diff --git a/.changeset/add-bedrock-provider-schema.md b/.changeset/add-bedrock-provider-schema.md
new file mode 100644
index 000000000..775df01da
--- /dev/null
+++ b/.changeset/add-bedrock-provider-schema.md
@@ -0,0 +1,6 @@
+---
+"@browserbasehq/stagehand": patch
+"@browserbasehq/stagehand-server-v3": patch
+---
+
+Add bedrock to the provider enum in model configuration schemas and regenerate OpenAPI spec.
diff --git a/.changeset/cool-doors-open.md b/.changeset/cool-doors-open.md
new file mode 100644
index 000000000..18350f076
--- /dev/null
+++ b/.changeset/cool-doors-open.md
@@ -0,0 +1,5 @@
+---
+"@browserbasehq/stagehand": minor
+---
+
+feat: add `cdpHeaders` option to `localBrowserLaunchOptions` for passing custom HTTP headers when connecting to an existing browser via CDP URL
diff --git a/.changeset/fix-cli-env-mode.md b/.changeset/fix-cli-env-mode.md
new file mode 100644
index 000000000..7763987d2
--- /dev/null
+++ b/.changeset/fix-cli-env-mode.md
@@ -0,0 +1,5 @@
+---
+"@browserbasehq/browse-cli": patch
+---
+
+Fix `browse env` showing stale mode after `browse env remote`
diff --git a/.changeset/flat-mice-cheer.md b/.changeset/flat-mice-cheer.md
new file mode 100644
index 000000000..53e42c3a1
--- /dev/null
+++ b/.changeset/flat-mice-cheer.md
@@ -0,0 +1,5 @@
+---
+"@browserbasehq/stagehand": patch
+---
+
+Expose `headers` in `GoogleVertexProviderSettings` so model configs can pass custom provider headers (for example `X-Goog-Priority`) without TypeScript errors.
diff --git a/.changeset/open-source-browse-cli.md b/.changeset/open-source-browse-cli.md
new file mode 100644
index 000000000..9c225011e
--- /dev/null
+++ b/.changeset/open-source-browse-cli.md
@@ -0,0 +1,5 @@
+---
+"@browserbasehq/browse-cli": minor
+---
+
+Initial release of browse CLI - browser automation for AI agents
diff --git a/.changeset/optional-project-id.md b/.changeset/optional-project-id.md
new file mode 100644
index 000000000..74919ca30
--- /dev/null
+++ b/.changeset/optional-project-id.md
@@ -0,0 +1,5 @@
+---
+"@browserbasehq/stagehand": patch
+---
+
+Make projectId optional for Browserbase sessions — only BROWSERBASE_API_KEY is required
diff --git a/.changeset/floppy-experts-wash.md b/.changeset/public-results-mate.md
similarity index 50%
rename from .changeset/floppy-experts-wash.md
rename to .changeset/public-results-mate.md
index 79a30b391..fb85f5394 100644
--- a/.changeset/floppy-experts-wash.md
+++ b/.changeset/public-results-mate.md
@@ -2,4 +2,4 @@
 "@browserbasehq/stagehand": patch
 ---
 
-remove unnecessary log
+Add configurable timeout to tools in agent
diff --git a/.changeset/real-cameras-grin.md b/.changeset/real-cameras-grin.md
new file mode 100644
index 000000000..22a326e00
--- /dev/null
+++ b/.changeset/real-cameras-grin.md
@@ -0,0 +1,5 @@
+---
+"@browserbasehq/stagehand": patch
+---
+
+When connecting to a browser session that has zero open tabs, Stagehand now automatically creates an initial `about:blank` tab so the connection can continue.
diff --git a/.changeset/solid-rice-admire.md b/.changeset/solid-rice-admire.md
deleted file mode 100644
index 2f0291d02..000000000
--- a/.changeset/solid-rice-admire.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"@browserbasehq/stagehand": minor
----
-
-Added Gemini 2.5 Flash to Google supported models
diff --git a/.changeset/some-parrots-wave.md b/.changeset/some-parrots-wave.md
new file mode 100644
index 000000000..1cd697972
--- /dev/null
+++ b/.changeset/some-parrots-wave.md
@@ -0,0 +1,5 @@
+---
+"@browserbasehq/stagehand": patch
+---
+
+fix issue where handlePossibleNavigation was producing unnecessary error logs on clicks that trigger page close
diff --git a/.changeset/fifty-cats-sell.md b/.changeset/twelve-breads-yawn.md
similarity index 50%
rename from .changeset/fifty-cats-sell.md
rename to .changeset/twelve-breads-yawn.md
index dfc981460..b89270c3c 100644
--- a/.changeset/fifty-cats-sell.md
+++ b/.changeset/twelve-breads-yawn.md
@@ -2,4 +2,4 @@
 "@browserbasehq/stagehand": minor
 ---
 
-extract links
+add new page.setExtraHTTPHeaders() method
diff --git a/.changeset/vast-vans-crash.md b/.changeset/vast-vans-crash.md
deleted file mode 100644
index 3fdc06f83..000000000
--- a/.changeset/vast-vans-crash.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"@browserbasehq/stagehand": patch
----
-
-Fixes a redundant unnecessary log
diff --git a/.cursorrules b/.cursorrules
index fe68bca7b..fee9b45c2 100644
--- a/.cursorrules
+++ b/.cursorrules
@@ -1,140 +1,263 @@
 # Stagehand Project
 
-This is a project that uses Stagehand, which amplifies Playwright with `act`, `extract`, and `observe` added to the Page class.
+This is a project that uses Stagehand V3, a browser automation framework with AI-powered `act`, `extract`, `observe`, and `agent` methods.
 
-`Stagehand` is a class that provides config, a `StagehandPage` object via `stagehand.page`, and a `StagehandContext` object via `stagehand.context`.
+The main class can be imported as `Stagehand` from `@browserbasehq/stagehand`.
 
-`Page` is a class that extends the Playwright `Page` class and adds `act`, `extract`, and `observe` methods.
-`Context` is a class that extends the Playwright `BrowserContext` class.
+**Key Classes:**
 
-Use the following rules to write code for this project.
+- `Stagehand`: Main orchestrator class providing `act`, `extract`, `observe`, and `agent` methods
+- `context`: A `V3Context` object that manages browser contexts and pages
+- `page`: Individual page objects accessed via `stagehand.context.pages()[i]` or created with `stagehand.context.newPage()`
 
-- To take an action on the page like "click the sign in button", use Stagehand `act` like this:
+## Initialize
 
 ```typescript
-await page.act("Click the sign in button");
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL", // or "BROWSERBASE"
+  verbose: 2, // 0, 1, or 2
+  model: "openai/gpt-4.1-mini", // or any supported model
+});
+
+await stagehand.init();
+
+// Access the browser context and pages
+const page = stagehand.context.pages()[0];
+const context = stagehand.context;
+
+// Create new pages if needed
+const page2 = await stagehand.context.newPage();
 ```
 
-- To plan an instruction before taking an action, use Stagehand `observe` to get the action to execute.
+## Act
+
+Actions are called on the `stagehand` instance (not the page). Use atomic, specific instructions:
 
 ```typescript
-const [action] = await page.observe("Click the sign in button");
+// Act on the current active page
+await stagehand.act("click the sign in button");
+
+// Act on a specific page (when you need to target a page that isn't currently active)
+await stagehand.act("click the sign in button", { page: page2 });
 ```
 
-- The result of `observe` is an array of `ObserveResult` objects that can directly be used as params for `act` like this:
+**Important:** Act instructions should be atomic and specific:
 
-  ```typescript
-  const [action] = await page.observe("Click the sign in button");
-  await page.act(action);
-  ```
+- ✅ Good: "Click the sign in button" or "Type 'hello' into the search input"
+- ❌ Bad: "Order me pizza" or "Type in the search bar and hit enter" (multi-step)
 
-- When writing code that needs to extract data from the page, use Stagehand `extract`. Explicitly pass the following params by default:
+### Observe + Act Pattern (Recommended)
+
+Cache the results of `observe` to avoid unexpected DOM changes:
+
+```typescript
+const instruction = "Click the sign in button";
+
+// Get candidate actions
+const actions = await stagehand.observe(instruction);
+
+// Execute the first action
+await stagehand.act(actions[0]);
+```
+
+To target a specific page:
 
 ```typescript
-const { someValue } = await page.extract({
-  instruction: the instruction to execute,
-  schema: z.object({
-    someValue: z.string(),
-  }), // The schema to extract
+const actions = await stagehand.observe("select blue as the favorite color", {
+  page: page2,
 });
+await stagehand.act(actions[0], { page: page2 });
 ```
 
-## Initialize
+## Extract
+
+Extract data from pages using natural language instructions. The `extract` method is called on the `stagehand` instance.
+
+### Basic Extraction (with schema)
 
 ```typescript
-import { Stagehand } from "@browserbasehq/stagehand";
-import StagehandConfig from "./stagehand.config";
+import { z } from "zod";
+
+// Extract with explicit schema
+const data = await stagehand.extract(
+  "extract all apartment listings with prices and addresses",
+  z.object({
+    listings: z.array(
+      z.object({
+        price: z.string(),
+        address: z.string(),
+      }),
+    ),
+  }),
+);
 
-const stagehand = new Stagehand(StagehandConfig);
-await stagehand.init();
+console.log(data.listings);
+```
+
+### Simple Extraction (without schema)
+
+```typescript
+// Extract returns a default object with 'extraction' field
+const result = await stagehand.extract("extract the sign in button text");
+
+console.log(result);
+// Output: { extraction: "Sign in" }
 
-const page = stagehand.page; // Playwright Page with act, extract, and observe methods
-const context = stagehand.context; // Playwright BrowserContext
+// Or destructure directly
+const { extraction } = await stagehand.extract(
+  "extract the sign in button text",
+);
+console.log(extraction); // "Sign in"
 ```
 
-## Act
+### Targeted Extraction
 
-You can cache the results of `observe` and use them as params for `act` like this:
+Extract data from a specific element using a selector:
 
 ```typescript
-const instruction = "Click the sign in button";
-const cachedAction = await getCache(instruction);
+const reason = await stagehand.extract(
+  "extract the reason why script injection fails",
+  z.string(),
+  { selector: "/html/body/div[2]/div[3]/iframe/html/body/p[2]" },
+);
+```
 
-if (cachedAction) {
-  await page.act(cachedAction);
-} else {
-  try {
-    const results = await page.observe(instruction);
-    await setCache(instruction, results);
-    await page.act(results[0]);
-  } catch (error) {
-    await page.act(instruction); // If the action is not cached, execute the instruction directly
-  }
-}
+### URL Extraction
+
+When extracting links or URLs, use `z.string().url()`:
+
+```typescript
+const { links } = await stagehand.extract(
+  "extract all navigation links",
+  z.object({
+    links: z.array(z.string().url()),
+  }),
+);
 ```
 
-Be sure to cache the results of `observe` and use them as params for `act` to avoid unexpected DOM changes. Using `act` without caching will result in more unpredictable behavior.
+### Extracting from a Specific Page
 
-Act `action` should be as atomic and specific as possible, i.e. "Click the sign in button" or "Type 'hello' into the search input".
-AVOID actions that are more than one step, i.e. "Order me pizza" or "Type in the search bar and hit enter".
+```typescript
+// Extract from a specific page (when you need to target a page that isn't currently active)
+const data = await stagehand.extract(
+  "extract the placeholder text on the name field",
+  { page: page2 },
+);
+```
 
-## Extract
+## Observe
 
-If you are writing code that needs to extract data from the page, use Stagehand `extract`.
+Plan actions before executing them. Returns an array of candidate actions:
 
 ```typescript
-const signInButtonText = await page.extract("extract the sign in button text");
+// Get candidate actions on the current active page
+const [action] = await stagehand.observe("Click the sign in button");
+
+// Execute the action
+await stagehand.act(action);
 ```
 
-You can also pass in params like an output schema in Zod, and a flag to use text extraction:
+Observing on a specific page:
 
 ```typescript
-const data = await page.extract({
-  instruction: "extract the sign in button text",
-  schema: z.object({
-    text: z.string(),
-  }),
+// Target a specific page (when you need to target a page that isn't currently active)
+const actions = await stagehand.observe("find the next page button", {
+  page: page2,
 });
+await stagehand.act(actions[0], { page: page2 });
 ```
 
-`schema` is a Zod schema that describes the data you want to extract. To extract an array, make sure to pass in a single object that contains the array, as follows:
+## Agent
+
+Use the `agent` method to autonomously execute complex, multi-step tasks.
+
+### Basic Agent Usage
 
 ```typescript
-const data = await page.extract({
-  instruction: "extract the text inside all buttons",
-  schema: z.object({
-    text: z.array(z.string()),
-  }),
-  useTextExtract: true, // Set true for larger-scale extractions (multiple paragraphs), or set false for small extractions (name, birthday, etc)
+const page = stagehand.context.pages()[0];
+await page.goto("https://www.google.com");
+
+const agent = stagehand.agent({
+  model: "google/gemini-2.0-flash",
+  executionModel: "google/gemini-2.0-flash",
+});
+
+const result = await agent.execute({
+  instruction: "Search for the stock price of NVDA",
+  maxSteps: 20,
 });
+
+console.log(result.message);
 ```
 
-## Agent
+### Computer Use Agent (CUA)
 
-Use the `agent` method to automonously execute larger tasks like "Get the stock price of NVDA"
+For more advanced scenarios using computer-use models:
 
 ```typescript
-// Navigate to a website
-await stagehand.page.goto("https://www.google.com");
+const agent = stagehand.agent({
+  mode: "cua", // Enable Computer Use Agent mode
+  model: "anthropic/claude-sonnet-4-20250514",
+  // or "google/gemini-2.5-computer-use-preview-10-2025"
+  systemPrompt: `You are a helpful assistant that can use a web browser.
+    Do not ask follow up questions, the user will trust your judgement.`,
+});
+
+await agent.execute({
+  instruction: "Apply for a library card at the San Francisco Public Library",
+  maxSteps: 30,
+});
+```
 
+### Agent with Custom Model Configuration
+
+```typescript
 const agent = stagehand.agent({
-  // You can use either OpenAI or Anthropic
-  provider: "openai",
-  // The model to use (claude-3-7-sonnet-20250219 or claude-3-5-sonnet-20240620 for Anthropic)
-  model: "computer-use-preview",
-
-  // Customize the system prompt
-  instructions: `You are a helpful assistant that can use a web browser.
-	Do not ask follow up questions, the user will trust your judgement.`,
-
-  // Customize the API key
-  options: {
-    apiKey: process.env.OPENAI_API_KEY,
+  model: {
+    modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+    apiKey: process.env.GEMINI_API_KEY,
   },
+  systemPrompt: `You are a helpful assistant.`,
 });
+```
 
-// Execute the agent
-await agent.execute(
-  "Apply for a library card at the San Francisco Public Library"
-);
+### Agent with Integrations (MCP/External Tools)
+
+```typescript
+const agent = stagehand.agent({
+  integrations: [`https://mcp.exa.ai/mcp?exaApiKey=${process.env.EXA_API_KEY}`],
+  systemPrompt: `You have access to the Exa search tool.`,
+});
+```
+
+## Advanced Features
+
+### DeepLocator (XPath Targeting)
+
+Target specific elements across shadow DOM and iframes:
+
+```typescript
+await page
+  .deepLocator("/html/body/div[2]/div[3]/iframe/html/body/p")
+  .highlight({
+    durationMs: 5000,
+    contentColor: { r: 255, g: 0, b: 0 },
+  });
+```
+
+### Multi-Page Workflows
+
+```typescript
+const page1 = stagehand.context.pages()[0];
+await page1.goto("https://example.com");
+
+const page2 = await stagehand.context.newPage();
+await page2.goto("https://example2.com");
+
+// Act/extract/observe operate on the current active page by default
+// Pass { page } option to target a specific page
+await stagehand.act("click button", { page: page1 });
+await stagehand.extract("get title", { page: page2 });
 ```
diff --git a/.env.example b/.env.example
index f7b468d6f..eb08f00ee 100644
--- a/.env.example
+++ b/.env.example
@@ -6,7 +6,7 @@ BRAINTRUST_API_KEY=""
 ANTHROPIC_API_KEY=""
 HEADLESS=false
 ENABLE_CACHING=false
-EVAL_MODELS="gpt-4o,claude-3-5-sonnet-latest"
-EXPERIMENTAL_EVAL_MODELS="gpt-4o,claude-3-5-sonnet-latest,o1-mini,o1-preview"
+EVAL_MODELS="gpt-4o,claude-sonnet-4-6"
+EXPERIMENTAL_EVAL_MODELS="gpt-4o,claude-sonnet-4-6,o1-mini,o1-preview"
 EVAL_CATEGORIES="observe,act,combination,extract,experimental"
-STAGEHAND_API_URL="http://localhost:80"
+AGENT_EVAL_MAX_STEPS=50
\ No newline at end of file
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 000000000..7cc4db16c
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,76 @@
+---
+name: Bug report
+about: Detailed descriptions help us resolve faster
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Before submitting an issue, please:**
+
+- [ ]  Check the [documentation](https://docs.stagehand.dev/) for relevant information
+- [ ]  Search existing [issues](https://github.com/browserbase/stagehand/issues) to avoid duplicates
+
+## Environment Information
+
+Please provide the following information to help us reproduce and resolve your issue:
+
+**Stagehand:**
+
+- Language/SDK: [TypeScript, Python, MCP…]
+- Stagehand version: [e.g., 1.0.0]
+
+**AI Provider:**
+
+- Provider: [e.g., OpenAI, Anthropic, Azure OpenAI]
+- Model: [e.g., gpt-4o, claude-sonnet-4-6]
+
+## Issue Description
+
+```
+[Describe the current behavior here]
+
+```
+
+### Steps to Reproduce
+
+1. 
+2. 
+3. 
+
+### Minimal Reproduction Code
+
+```tsx
+// Your minimal reproduction code here
+import { Stagehand } from '@browserbase/stagehand';
+
+const stagehand = new Stagehand({
+  // IMPORTANT: include your stagehand config
+});
+
+// Steps that reproduce the issue
+
+```
+
+### Error Messages / Log trace
+
+```
+[Paste error messages/logs here]
+
+```
+
+### Screenshots / Videos
+
+```
+[Attach screenshots or videos here]
+
+```
+
+### Related Issues
+
+Are there any related issues or PRs?
+
+- Related to: #[issue number]
+- Duplicate of: #[issue number]
+- Blocks: #[issue number]
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 000000000..75889eb82
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,23 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Are you willing to contribute to implementing this feature or fix?**
+
+- [ ]  Yes, I can submit a PR
+- [ ]  Yes, but I need guidance
+- [ ]  No, I cannot contribute at this time
diff --git a/.github/actions/select-browserbase-region/action.yml b/.github/actions/select-browserbase-region/action.yml
new file mode 100644
index 000000000..e5ccbd13e
--- /dev/null
+++ b/.github/actions/select-browserbase-region/action.yml
@@ -0,0 +1,67 @@
+name: Select Browserbase region
+description: Select a Browserbase region based on a weighted distribution.
+inputs:
+  distribution:
+    description: Comma-separated region=weight list (e.g. us-west-2=40,us-east-1=20).
+    required: true
+outputs:
+  region:
+    description: Selected region.
+    value: ${{ steps.select.outputs.region }}
+runs:
+  using: composite
+  steps:
+    - id: select
+      shell: bash
+      run: |
+        dist="${{ inputs.distribution }}"
+        if [ -z "$dist" ]; then
+          echo "BROWSERBASE_REGION_DISTRIBUTION is empty"
+          exit 1
+        fi
+        IFS=',' read -r -a entries <<< "$dist"
+        total=0
+        regions=()
+        weights=()
+        for entry in "${entries[@]}"; do
+          region="${entry%%=*}"
+          weight="${entry#*=}"
+          region="$(printf '%s' "$region" | tr -d '[:space:]')"
+          weight="$(printf '%s' "$weight" | tr -d '[:space:]')"
+          if [ -z "$region" ] || [ -z "$weight" ]; then
+            echo "Invalid region distribution entry: $entry"
+            exit 1
+          fi
+          if ! [[ "$region" =~ ^[A-Za-z0-9-]+$ ]]; then
+            echo "Invalid region value: $region"
+            exit 1
+          fi
+          if ! [[ "$weight" =~ ^[0-9]+$ ]]; then
+            echo "Invalid weight for region $region: $weight"
+            exit 1
+          fi
+          regions+=("$region")
+          weights+=("$weight")
+          total=$((total + weight))
+        done
+        if [ "$total" -le 0 ]; then
+          echo "Invalid total weight: $total"
+          exit 1
+        fi
+        roll=$((RANDOM % total))
+        cumulative=0
+        chosen=""
+        for i in "${!regions[@]}"; do
+          cumulative=$((cumulative + weights[i]))
+          if [ "$roll" -lt "$cumulative" ]; then
+            chosen="${regions[i]}"
+            break
+          fi
+        done
+        if [ -z "$chosen" ]; then
+          echo "Failed to choose Browserbase region"
+          exit 1
+        fi
+        echo "Selected Browserbase region: $chosen"
+        echo "region=$chosen" >> "$GITHUB_OUTPUT"
+        echo "BROWSERBASE_REGION=$chosen" >> "$GITHUB_ENV"
diff --git a/.github/actions/setup-node-pnpm-turbo/action.yml b/.github/actions/setup-node-pnpm-turbo/action.yml
new file mode 100644
index 000000000..e20cc9766
--- /dev/null
+++ b/.github/actions/setup-node-pnpm-turbo/action.yml
@@ -0,0 +1,56 @@
+name: Setup Node, pnpm, and Turbo cache
+description: Configure pnpm and Node.js with caching, restore Turbo cache, and install dependencies.
+inputs:
+  node-version:
+    description: Node.js version to use.
+    required: false
+    default: "20.x"
+  use-prebuilt-artifacts:
+    description: Whether to download pre-built package from build artifacts.
+    required: false
+    default: "true"
+  restore-turbo-cache:
+    description: Whether to restore the local .turbo cache.
+    required: false
+    default: "true"
+
+runs:
+  using: composite
+  steps:
+    - uses: pnpm/action-setup@v4
+
+    - name: Set up Node.js
+      uses: actions/setup-node@v6
+      with:
+        node-version: ${{ inputs.node-version }}
+        cache: 'pnpm'
+        cache-dependency-path: '**/pnpm-lock.yaml'
+
+    - name: Restore Turbo cache
+      if: ${{ inputs.restore-turbo-cache == 'true' }}
+      uses: actions/cache/restore@v4
+      with:
+        path: .turbo
+        key: ${{ runner.os }}-turbo-${{ hashFiles('pnpm-lock.yaml', 'pnpm-workspace.yaml', 'package.json', 'turbo.json') }}-${{ github.sha }}
+        restore-keys: |
+          ${{ runner.os }}-turbo-${{ hashFiles('pnpm-lock.yaml', 'pnpm-workspace.yaml', 'package.json', 'turbo.json') }}-
+
+    - name: Install dependencies
+      shell: bash
+      run: pnpm install --frozen-lockfile --prefer-offline
+  
+    - name: Download build artifacts
+      if: ${{ inputs.use-prebuilt-artifacts == 'true' }}
+      uses: actions/download-artifact@v4
+      with:
+        name: build-artifacts
+        path: .
+        merge-multiple: true
+
+    - name: Prepare test output directories
+      shell: bash
+      run: |
+        mkdir -p "${GITHUB_WORKSPACE}/ctrf"
+        if [ -n "${NODE_V8_COVERAGE:-}" ]; then
+          mkdir -p "$NODE_V8_COVERAGE"
+        fi
diff --git a/.github/actions/upload-ctrf-report/action.yml b/.github/actions/upload-ctrf-report/action.yml
new file mode 100644
index 000000000..40ac37175
--- /dev/null
+++ b/.github/actions/upload-ctrf-report/action.yml
@@ -0,0 +1,34 @@
+name: Upload CTRF report
+description: Upload CTRF report artifact.
+inputs:
+  name:
+    description: Report path (used as artifact name when sanitized).
+    required: true
+  path:
+    description: Optional explicit path (defaults to name).
+    required: false
+    default: ""
+
+runs:
+  using: composite
+  steps:
+    - name: Normalize inputs
+      id: normalize
+      shell: bash
+      run: |
+        name="${{ inputs.name }}"
+        echo "name=${name//\//-}" >> "$GITHUB_OUTPUT"
+        if [ -n "${{ inputs.path }}" ]; then
+          echo "path=${{ inputs.path }}" >> "$GITHUB_OUTPUT"
+        else
+          echo "path=${{ inputs.name }}" >> "$GITHUB_OUTPUT"
+        fi
+
+    - name: Upload CTRF report artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: ${{ steps.normalize.outputs.name }}
+        # package.json anchors uploaded paths to the repository root.
+        path: |
+          package.json
+          ${{ steps.normalize.outputs.path }}
diff --git a/.github/actions/upload-v8-coverage/action.yml b/.github/actions/upload-v8-coverage/action.yml
new file mode 100644
index 000000000..11f8257dd
--- /dev/null
+++ b/.github/actions/upload-v8-coverage/action.yml
@@ -0,0 +1,34 @@
+name: Upload V8 coverage
+description: Upload V8 coverage artifacts.
+inputs:
+  name:
+    description: Artifact name.
+    required: true
+  path:
+    description: Coverage path to upload (defaults to name).
+    required: false
+    default: ""
+
+runs:
+  using: composite
+  steps:
+    - name: Normalize artifact name
+      id: normalize
+      shell: bash
+      run: |
+        name="${{ inputs.name }}"
+        echo "name=${name//\//-}" >> "$GITHUB_OUTPUT"
+        if [ -n "${{ inputs.path }}" ]; then
+          echo "path=${{ inputs.path }}" >> "$GITHUB_OUTPUT"
+        else
+          echo "path=${{ inputs.name }}" >> "$GITHUB_OUTPUT"
+        fi
+
+    - name: Upload coverage artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: ${{ steps.normalize.outputs.name }}
+        # package.json anchors uploaded paths to the repository root.
+        path: |
+          package.json
+          ${{ steps.normalize.outputs.path }}
diff --git a/.github/actions/verify-chromium-launch/action.yml b/.github/actions/verify-chromium-launch/action.yml
new file mode 100644
index 000000000..e8be8fdcb
--- /dev/null
+++ b/.github/actions/verify-chromium-launch/action.yml
@@ -0,0 +1,223 @@
+name: Verify Chromium launch
+description: Validate that Chromium can start, connect to CDP, and read the page title.
+inputs:
+  chrome-path:
+    description: Path to Chromium/Chrome binary.
+    required: false
+    default: "/usr/bin/chromium"
+  max-attempts:
+    description: Number of launch attempts before failing.
+    required: false
+    default: "3"
+  timeout-ms:
+    description: Milliseconds to wait for DevTools and CDP per attempt.
+    required: false
+    default: "30000"
+runs:
+  using: composite
+  steps:
+    - shell: bash
+      run: |
+        set -euo pipefail
+        max_attempts="${{ inputs.max-attempts }}"
+        attempt=1
+        while [ "$attempt" -le "$max_attempts" ]; do
+          if [ -n "${{ inputs.chrome-path }}" ]; then
+            pkill -f "${{ inputs.chrome-path }}" >/dev/null 2>&1 || true
+          fi
+          if node - <<'NODE'
+        const { spawn } = require("node:child_process");
+        const workspace = process.env.GITHUB_WORKSPACE;
+        if (workspace) {
+          process.chdir(workspace);
+        }
+
+        const chrome = "${{ inputs.chrome-path }}";
+
+        const timeoutMs = Number("${{ inputs.timeout-ms }}");
+        const wsPrefix = "DevTools listening on ";
+        const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+        let proc;
+        let wsUrl;
+
+        const waitForWsUrl = async () => {
+          const deadline = Date.now() + timeoutMs;
+          while (!wsUrl) {
+            if (Date.now() > deadline) {
+              throw new Error(
+                `❌ Chromium did not expose CDP WS URL within timeout (${timeoutMs}ms)`,
+              );
+            }
+            await sleep(250);
+          }
+          return wsUrl;
+        };
+
+        const cleanup = () => {
+          if (proc && !proc.killed) {
+            proc.kill("SIGKILL");
+          }
+        };
+
+        (async () => {
+          try {
+            const startTime = Date.now();
+            const args = [
+              '--ash-no-nudges',
+              '--block-new-web-contents',
+              '--deny-permission-prompts',
+              '--disable-breakpad',
+              '--disable-client-side-phishing-detection',
+              '--disable-component-update',
+              '--disable-components=AcceptCHFrame,OptimizationHints,ProcessPerSiteUpToMainFrameThreshold,InterestFeedContentSuggestions,CalculateNativeWinOcclusion,BackForwardCache,HeavyAdPrivacyMitigations,LazyFrameLoading,ImprovedCookieControls,PrivacySandboxSettings4,AutofillServerCommunication,CertificateTransparencyComponentUpdater,DestroyProfileOnBrowserClose,CrashReporting,OverscrollHistoryNavigation,InfiniteSessionRestore',
+              '--disable-datasaver-prompt',
+              '--disable-default-apps',
+              '--disable-desktop-notifications',
+              '--disable-domain-reliability',
+              '--disable-external-intent-requests',
+              '--disable-hang-monitor',
+              '--disable-infobars',
+              '--disable-notifications',
+              '--disable-popup-blocking',
+              '--disable-print-preview',
+              '--disable-prompt-on-repost',
+              '--disable-search-engine-choice-screen',
+              '--disable-session-crashed-bubble',
+              '--disable-speech-api',
+              '--disable-speech-synthesis-api',
+              '--hide-crash-restore-bubble',
+              '--metrics-recording-only',
+              '--no-default-browser-check',
+              '--no-first-run',
+              '--no-pings',
+              '--noerrdialogs',
+              '--safebrowsing-disable-auto-update',
+              '--silent-debugger-extension-api',
+              '--simulate-outdated-no-au="Tue, 31 Dec 2099 23:59:59 GMT"',
+              '--suppress-message-center-popups',
+              "--disable-background-networking",
+              "--disable-default-apps",
+              "--disable-dev-shm-usage",
+              "--disable-extensions",
+              "--disable-notifications",
+              "--disable-setuid-sandbox",
+              "--disable-site-isolation-trials",
+              "--disable-sync",
+              "--disable-web-security",
+              "--headless=new",
+              "--no-default-browser-check",
+              "--no-first-run",
+              "--no-sandbox",
+              "--no-zygote",
+              "--password-store=basic",
+              "--remote-debugging-port=0",
+              "--test-type=gpu",
+              "--use-mock-keychain",
+              "about:blank",
+            ];
+            proc = spawn(chrome, args, { stdio: ["ignore", "pipe", "pipe"] });
+            const lineBuffers = { stdout: "", stderr: "" };
+            const onData = (stream) => (data) => {
+              const text = data.toString();
+              if (stream === "stderr") {
+                process.stderr.write(text);
+              } else {
+                process.stdout.write(text);
+              }
+              lineBuffers[stream] += text;
+              const lines = lineBuffers[stream].split(/\r?\n/);
+              lineBuffers[stream] = lines.pop() ?? "";
+              for (const line of lines) {
+                const idx = line.indexOf(wsPrefix);
+                if (idx === -1) continue;
+                const rest = line.slice(idx + wsPrefix.length).trim();
+                const candidate = rest.split(/\s+/)[0];
+                if (
+                  candidate.startsWith("ws://") ||
+                  candidate.startsWith("wss://")
+                ) {
+                  wsUrl = candidate;
+                }
+              }
+            };
+            proc.stdout.on("data", onData("stdout"));
+            proc.stderr.on("data", onData("stderr"));
+
+            const url = await waitForWsUrl();
+            const wsFoundMs = Date.now() - startTime;
+            const wsFoundSec = (wsFoundMs / 1000).toFixed(2);
+            const connectStart = Date.now();
+            const path = require("node:path");
+            const workspaceRoot = process.env.GITHUB_WORKSPACE || process.cwd();
+            const playwrightPath = path.join(
+              workspaceRoot,
+              "packages/core/node_modules/playwright",
+            );
+            console.log(
+              `✅ CDP Url found after ${wsFoundSec}s, connecting with playwright...`,
+            );
+            const { chromium } = require(playwrightPath);
+            const browser = await chromium.connectOverCDP(url, {
+              timeout: timeoutMs,
+            });
+            const context = browser.contexts()[0];
+            if (!context) {
+              throw new Error("❌ No browser context available after CDP connect");
+            }
+            const page = context.pages()[0];
+            if (!page) {
+              throw new Error("❌ No page available after CDP connect");
+            }
+            const remainingMs = timeoutMs - (Date.now() - connectStart);
+            if (remainingMs <= 0) {
+              throw new Error(
+                `❌ CDP connect + verify timed out after ${timeoutMs}ms`,
+              );
+            }
+            const sum = await Promise.race([
+              page.evaluate("1 + 1"),
+              new Promise((_, reject) =>
+                setTimeout(
+                  () =>
+                    reject(
+                      new Error(
+                        `❌ CDP connect + verify timed out after ${timeoutMs}ms`,
+                      ),
+                    ),
+                  remainingMs,
+                ),
+              ),
+            ]);
+            if (sum !== 2) {
+              throw new Error(`❌ Unexpected eval result: ${sum}`);
+            }
+            const totalMs = Date.now() - startTime;
+            const connectMs = Date.now() - connectStart;
+            const totalSec = (totalMs / 1000).toFixed(2);
+            const connectSec = (connectMs / 1000).toFixed(2);
+            console.log(
+              `✅ Chromium launched in ${wsFoundSec}s and CDP connected in ${connectSec}s (total: ${totalSec}s)`,
+            );
+            await browser.close();
+            cleanup();
+            process.exit(0);
+          } catch (err) {
+            cleanup();
+            console.error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+          }
+        })();
+        NODE
+          then
+            if [ "$attempt" -gt 1 ]; then
+              echo "⚠️ Chromium launch succeeded after ${attempt} attempts; GitHub Actions runner may be constrained."
+            fi
+            exit 0
+          fi
+          echo "⚠️ Chromium launch attempt ${attempt} failed."
+          attempt=$((attempt + 1))
+          sleep 2
+        done
+        echo "❌ Failed to launch Chromium before running Stagehand; GitHub Actions runner is likely overloaded."
+        exit 1
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 66fdc2dd8..a12848b1a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,4 +1,4 @@
-name: Evals
+name: Tests
 
 on:
   pull_request:
@@ -7,659 +7,821 @@ on:
       - synchronize
       - labeled
       - unlabeled
+    paths-ignore:
+      - "packages/docs/**"
+
+permissions:
+  contents: read
+  actions: write
 
 env:
-  EVAL_MODELS: "gpt-4o,gpt-4o-mini,claude-3-5-sonnet-latest"
-  EVAL_CATEGORIES: "observe,act,combination,extract,text_extract,targeted_extract"
+  LLM_MAX_MS: "15000"
+  EVAL_MODELS: "openai/gpt-4.1,google/gemini-2.0-flash,anthropic/claude-haiku-4-5"
+  EVAL_AGENT_MODELS: "computer-use-preview-2025-03-11,claude-sonnet-4-6"
+  EVAL_CATEGORIES: "observe,act,combination,extract,targeted_extract,agent"
+  EVAL_MAX_CONCURRENCY: 25
+  EVAL_TRIAL_COUNT: 3
+  LOCAL_SESSION_LIMIT_PER_E2E_TEST: 2
+  BROWSERBASE_SESSION_LIMIT_PER_E2E_TEST: 3
+  BROWSERBASE_REGION_DISTRIBUTION: "us-west-2=30,us-east-1=30,eu-central-1=20,ap-southeast-1=20"  # percentage of load for each region when running e2e tests against prod
+  CHROME_PATH: /usr/bin/chromium # GitHub Actions runners ship with stable Chromium by default
+  BROWSERBASE_CDP_CONNECT_MAX_MS: "10000"
+  BROWSERBASE_SESSION_CREATE_MAX_MS: "60000"
+  PUPPETEER_SKIP_DOWNLOAD: "1"
+  PLAYWRIGHT_SKIP_DOWNLOAD: "1"
+  TURBO_TELEMETRY_DISABLED: "1"
 
 concurrency:
-  group: ${{ github.ref }}
+  group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
 jobs:
+  determine-changes:
+    runs-on: ubuntu-latest
+    outputs:
+      core: ${{ steps.filter.outputs.core }}
+      cli: ${{ steps.filter.outputs.cli }}
+      evals: ${{ steps.filter.outputs.evals }}
+      server: ${{ steps.filter.outputs.server }}
+      docs-only: ${{ steps.filter.outputs.docs-only }}
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+
+      - name: Log GitHub API rate limit
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          headers_file=$(mktemp)
+          body_file=$(mktemp)
+          curl -sSL \
+            -D "$headers_file" \
+            -o "$body_file" \
+            -H "Accept: application/vnd.github+json" \
+            -H "X-GitHub-Api-Version: 2022-11-28" \
+            -H "Authorization: Bearer $GITHUB_TOKEN" \
+            https://api.github.com/rate_limit
+          cat "$headers_file"
+          echo ""
+          cat "$body_file"
+          remaining=$(jq -r '.rate.remaining' "$body_file")
+          if [ "$remaining" -eq 0 ]; then
+            reset_epoch=$(jq -r '.rate.reset' "$body_file")
+            reset_utc=$(date -u -d "@$reset_epoch" +"%Y-%m-%d %H:%M:%S")
+            reset_pacific=$(TZ=America/Los_Angeles date -d "@$reset_epoch" +"%Y-%m-%d %H:%M:%S %Z")
+            echo "Github API rate limited until: ${reset_pacific} (${reset_utc} UTC)" >> "$GITHUB_STEP_SUMMARY"
+            echo "GitHub API rate limit exhausted."
+            exit 1
+          fi
+
+      - uses: dorny/paths-filter@v3
+        id: filter
+        with:
+          filters: |
+            core:
+              - '.github/workflows/ci.yml'
+              - 'packages/core/**'
+              - 'package.json'
+              - 'pnpm-lock.yaml'
+              - 'turbo.json'
+            cli:
+              - 'packages/cli/**'
+              - 'packages/core/**'
+              - 'package.json'
+              - 'pnpm-lock.yaml'
+            evals:
+              - 'packages/evals/**'
+              - 'package.json'
+              - 'pnpm-lock.yaml'
+            server:
+              - 'packages/server-v3/**'
+              - 'packages/server-v4/**'
+              - 'packages/core/**'
+              - 'package.json'
+              - 'pnpm-lock.yaml'
+              - 'pnpm-workspace.yaml'
+              - '.github/workflows/ci.yml'
+            docs-only:
+              - '**/*.md'
+              - 'examples/**'
+              - '!packages/**/*.md'
+
   determine-evals:
+    needs: [determine-changes]
     runs-on: ubuntu-latest
     outputs:
-      run-combination: ${{ steps.check-labels.outputs.run-combination }}
-      run-extract: ${{ steps.check-labels.outputs.run-extract }}
-      run-act: ${{ steps.check-labels.outputs.run-act }}
-      run-observe: ${{ steps.check-labels.outputs.run-observe }}
-      run-text-extract: ${{ steps.check-labels.outputs.run-text-extract }}
-      run-targeted-extract: ${{ steps.check-labels.outputs.run-targeted-extract }}
+      skip-all-evals: ${{ steps.check-labels.outputs.skip-all-evals }}
+      eval-categories: ${{ steps.check-labels.outputs.eval-categories }}
     steps:
       - id: check-labels
         run: |
-          # Default to running all tests on main branch
-          if [[ "${{ github.ref }}" == "refs/heads/main" ]]; then
-            echo "Running all tests for main branch"
-            echo "run-combination=true" >> $GITHUB_OUTPUT
-            echo "run-extract=true" >> $GITHUB_OUTPUT
-            echo "run-act=true" >> $GITHUB_OUTPUT
-            echo "run-observe=true" >> $GITHUB_OUTPUT
-            echo "run-text-extract=true" >> $GITHUB_OUTPUT
-            echo "run-targeted-extract=true" >> $GITHUB_OUTPUT
+          categories=()
+          declare -A seen
+          add_category() {
+            local category="$1"
+            if [[ -z "${seen[$category]:-}" ]]; then
+              categories+=("$category")
+              seen["$category"]=1
+            fi
+          }
+
+          emit_categories() {
+            local json="["
+            for category in "${categories[@]}"; do
+              json+="\"${category}\","
+            done
+            json="${json%,}"
+            json+="]"
+            echo "eval-categories=$json" >> $GITHUB_OUTPUT
+          }
+
+          # Check if skip-evals label is present
+          if [[ "${{ contains(github.event.pull_request.labels.*.name, 'skip-evals') }}" == "true" ]]; then
+            echo "skip-evals label found - skipping all evals"
+            echo "skip-all-evals=true" >> $GITHUB_OUTPUT
+            emit_categories
             exit 0
           fi
 
-          # Check for specific labels
-          echo "run-combination=${{ contains(github.event.pull_request.labels.*.name, 'combination') }}" >> $GITHUB_OUTPUT
-          echo "run-extract=${{ contains(github.event.pull_request.labels.*.name, 'extract') }}" >> $GITHUB_OUTPUT
-          echo "run-act=${{ contains(github.event.pull_request.labels.*.name, 'act') }}" >> $GITHUB_OUTPUT
-          echo "run-observe=${{ contains(github.event.pull_request.labels.*.name, 'observe') }}" >> $GITHUB_OUTPUT
-          echo "run-text-extract=${{ contains(github.event.pull_request.labels.*.name, 'text-extract') }}" >> $GITHUB_OUTPUT
-          echo "run-targeted-extract=${{ contains(github.event.pull_request.labels.*.name, 'targeted-extract') }}" >> $GITHUB_OUTPUT
+          # Skip evals if only docs/examples changed
+          if [[ "${{ needs.determine-changes.outputs.docs-only }}" == "true" && "${{ needs.determine-changes.outputs.core }}" == "false" && "${{ needs.determine-changes.outputs.evals }}" == "false" ]]; then
+            echo "Only docs/examples changed - skipping evals"
+            echo "skip-all-evals=true" >> $GITHUB_OUTPUT
+            emit_categories
+            exit 0
+          fi
 
+          # Check for skip-regression-evals label
+          if [[ "${{ contains(github.event.pull_request.labels.*.name, 'skip-regression-evals') }}" == "true" ]]; then
+            echo "skip-regression-evals label found - regression evals will be skipped"
+          else
+            echo "Regression evals will run by default"
+            add_category "regression"
+          fi
+
+          # Check for specific labels
+          echo "skip-all-evals=false" >> $GITHUB_OUTPUT
+          if [[ "${{ contains(github.event.pull_request.labels.*.name, 'combination') }}" == "true" ]]; then
+            add_category "combination"
+          fi
+          if [[ "${{ contains(github.event.pull_request.labels.*.name, 'extract') }}" == "true" ]]; then
+            add_category "extract"
+          fi
+          if [[ "${{ contains(github.event.pull_request.labels.*.name, 'act') }}" == "true" ]]; then
+            add_category "act"
+          fi
+          if [[ "${{ contains(github.event.pull_request.labels.*.name, 'observe') }}" == "true" ]]; then
+            add_category "observe"
+          fi
+          if [[ "${{ contains(github.event.pull_request.labels.*.name, 'targeted-extract') }}" == "true" ]]; then
+            add_category "targeted_extract"
+          fi
+          if [[ "${{ contains(github.event.pull_request.labels.*.name, 'agent') }}" == "true" ]]; then
+            add_category "agent"
+          fi
+          emit_categories
+      
   run-lint:
+    name: Lint
     runs-on: ubuntu-latest
+    needs: [run-build]
     steps:
       - name: Check out repository code
         uses: actions/checkout@v4
 
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
+      - uses: ./.github/actions/setup-node-pnpm-turbo
         with:
-          node-version: "20"
-
-      - name: Install dependencies
-        run: |
-          rm -rf node_modules
-          rm -f package-lock.json
-          npm install
+          use-prebuilt-artifacts: "true"
+          restore-turbo-cache: "false"
+          node-version: 20.x
 
       - name: Run Lint
-        run: npm run lint
+        run: pnpm exec turbo run lint
 
-  run-build:
+  cancel-after-lint-failure:
+    name: Cancel after lint failure
     runs-on: ubuntu-latest
+    needs: [run-lint]
+    if: ${{ always() && needs.run-lint.result == 'failure' }}
+    continue-on-error: true
     steps:
-      - name: Check out repository code
-        uses: actions/checkout@v4
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "20"
-
-      - name: Install dependencies
+      - name: Cancel workflow run
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          rm -rf node_modules
-          rm -f package-lock.json
-          npm install
-
-      - name: Run Build
-        run: npm run build
+          curl -sSfL -X POST \
+            -H "Authorization: Bearer ${GITHUB_TOKEN}" \
+            -H "Accept: application/vnd.github+json" \
+            -H "X-GitHub-Api-Version: 2022-11-28" \
+            "https://api.github.com/repos/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}/cancel"
 
-  run-e2e-tests:
-    needs: [run-lint, run-build]
+  run-build:
+    name: Build
     runs-on: ubuntu-latest
-    timeout-minutes: 50
-    env:
-      HEADLESS: true
     steps:
       - name: Check out repository code
         uses: actions/checkout@v4
 
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
+      - uses: ./.github/actions/setup-node-pnpm-turbo
         with:
-          node-version: "20"
-
-      - name: Install dependencies
-        run: |
-          rm -rf node_modules
-          rm -f package-lock.json
-          npm install
+          use-prebuilt-artifacts: "false"
+          node-version: 20.x
 
-      - name: Install Playwright browsers
-        run: npm exec playwright install --with-deps
-
-      - name: Build Stagehand
-        run: npm run build
+      - name: Run Build
+        run: pnpm exec turbo run build
 
-      - name: Run E2E Tests (Deterministic Playwright)
-        run: npm run e2e
+      - name: Save Turbo cache
+        if: always()
+        uses: actions/cache/save@v4
+        with:
+          path: .turbo
+          key: ${{ runner.os }}-turbo-${{ hashFiles('pnpm-lock.yaml', 'pnpm-workspace.yaml', 'package.json', 'turbo.json') }}-${{ github.sha }}
 
-  run-e2e-local-tests:
-    needs: [run-lint, run-build]
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: build-artifacts
+          include-hidden-files: true
+          # package.json is included to anchor artifact paths at repo root.
+          path: |
+            package.json
+            packages/core/dist/**
+            packages/core/lib/version.ts
+            packages/core/lib/dom/build/**
+            packages/core/lib/v3/dom/build/**
+            packages/cli/dist/**
+            packages/evals/dist/**
+            packages/server-v3/dist/**
+            packages/server-v3/openapi.v3.yaml
+            packages/server-v4/dist/**
+            packages/server-v4/openapi.v4.yaml
+          retention-days: 1
+
+  discover-core-tests:
     runs-on: ubuntu-latest
-    timeout-minutes: 50
-    env:
-      HEADLESS: true
+    needs: [determine-changes]
+    if: needs.determine-changes.outputs.core == 'true'
+    outputs:
+      core-tests: ${{ steps.set-matrix.outputs.core-tests }}
+      has-core-tests: ${{ steps.set-matrix.outputs.has-core-tests }}
+
     steps:
-      - name: Check out repository code
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
 
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
+      - uses: ./.github/actions/setup-node-pnpm-turbo
         with:
-          node-version: "20"
+          use-prebuilt-artifacts: "false"
+          restore-turbo-cache: "false"
 
-      - name: Install dependencies
+      - name: Discover core test files
+        id: set-matrix
         run: |
-          rm -rf node_modules
-          rm -f package-lock.json
-          npm install
-
-      - name: Install Playwright browsers
-        run: npm exec playwright install --with-deps
+          core_json=$(pnpm --filter @browserbasehq/stagehand --silent run test:core -- --list)
+          echo "core-tests=$core_json" >> $GITHUB_OUTPUT
 
-      - name: Build Stagehand
-        run: npm run build
+          if [ "$core_json" = "[]" ]; then
+            echo "has-core-tests=false" >> $GITHUB_OUTPUT
+          else
+            echo "has-core-tests=true" >> $GITHUB_OUTPUT
+          fi
 
-      - name: Run local E2E Tests (Deterministic Playwright)
-        run: npm run e2e:local
+          echo "Found core tests: $core_json"
 
-  run-e2e-bb-tests:
-    needs: [run-lint, run-build]
+  core-unit-tests:
+    name: core/${{ matrix.test.name }}
     runs-on: ubuntu-latest
-    timeout-minutes: 50
-    if: >
-      github.event_name == 'push' ||
-      (github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository)
+    needs: [run-build, discover-core-tests]
+    if: needs.discover-core-tests.outputs.has-core-tests == 'true'
     env:
-      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-      ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-      BROWSERBASE_API_KEY: ${{ secrets.BROWSERBASE_API_KEY }}
-      BROWSERBASE_PROJECT_ID: ${{ secrets.BROWSERBASE_PROJECT_ID }}
-      HEADLESS: true
+      STAGEHAND_BROWSER_TARGET: local
+      STAGEHAND_SERVER_TARGET: local
+
+    strategy:
+      fail-fast: false
+      max-parallel: 100
+      matrix:
+        test: ${{ fromJson(needs.discover-core-tests.outputs.core-tests) }}
+
     steps:
-      - name: Check out repository code
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
 
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
+      - uses: ./.github/actions/setup-node-pnpm-turbo
         with:
-          node-version: "20"
+          use-prebuilt-artifacts: "true"
+          restore-turbo-cache: "false"
 
-      - name: Install dependencies
+      - name: Run Vitest - ${{ matrix.test.name }}
         run: |
-          rm -rf node_modules
-          rm -f package-lock.json
-          npm install
-
-      - name: Install Playwright browsers
-        run: npm exec playwright install --with-deps
+          pnpm exec turbo run test:core --only --filter=@browserbasehq/stagehand -- "${{ matrix.test.path }}"
 
-      - name: Build Stagehand
-        run: npm run build
+      - uses: ./.github/actions/upload-ctrf-report
+        if: always()
+        with:
+          name: ctrf/core-unit/${{ matrix.test.name }}.json
 
-      - name: Run E2E Tests (browserbase)
-        run: npm run e2e:bb
+      - uses: ./.github/actions/upload-v8-coverage
+        if: always()
+        with:
+          name: coverage/core-unit/${{ matrix.test.name }}
 
-  run-regression-evals:
-    needs:
-      [run-e2e-bb-tests, run-e2e-tests, run-e2e-local-tests, determine-evals]
+  discover-server-tests:
     runs-on: ubuntu-latest
-    timeout-minutes: 9
+    needs: [determine-changes]
+    if: needs.determine-changes.outputs.server == 'true'
     outputs:
-      regression_score: ${{ steps.set-regression-score.outputs.regression_score }}
-    env:
-      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-      ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-      BRAINTRUST_API_KEY: ${{ secrets.BRAINTRUST_API_KEY }}
-      BROWSERBASE_API_KEY: ${{ secrets.BROWSERBASE_API_KEY }}
-      BROWSERBASE_PROJECT_ID: ${{ secrets.BROWSERBASE_PROJECT_ID }}
-      HEADLESS: true
-      EVAL_ENV: browserbase
+      integration-tests: ${{ steps.set-matrix.outputs.integration-tests }}
+      has-integration-tests: ${{ steps.set-matrix.outputs.has-integration-tests }}
+
     steps:
-      - name: Check out repository code
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
 
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
+      - uses: ./.github/actions/setup-node-pnpm-turbo
         with:
-          node-version: "20"
+          use-prebuilt-artifacts: "false"
+          restore-turbo-cache: "false"
 
-      - name: Install dependencies
+      - name: Discover server test files
+        id: set-matrix
         run: |
-          rm -rf node_modules
-          rm -f package-lock.json
-          npm install
-
-      - name: Build Stagehand
-        run: npm run build
-
-      - name: Install Playwright browsers
-        run: npm exec playwright install --with-deps
+          int_json=$(pnpm --filter @browserbasehq/stagehand-server-v3 --silent run test:server -- --list integration)
+          echo "integration-tests=$int_json" >> $GITHUB_OUTPUT
 
-      - name: Run Regression Evals
-        run: npm run evals category regression trials=2 concurrency=20 env=BROWSERBASE
-
-      - name: Log Regression Evals Performance
-        run: |
-          experimentName=$(jq -r '.experimentName' eval-summary.json)
-          echo "View results at https://www.braintrust.dev/app/Browserbase/p/stagehand/experiments/${experimentName}"
-          if [ -f eval-summary.json ]; then
-            regression_score=$(jq '.categories.regression' eval-summary.json)
-            echo "Regression category score: $regression_score%"
-            if (( $(echo "$regression_score < 90" | bc -l) )); then
-              echo "Regression category score is below 90%. Failing CI."
-              exit 1
-            fi
+          if [ "$int_json" = "[]" ]; then
+            echo "has-integration-tests=false" >> $GITHUB_OUTPUT
           else
-            echo "Eval summary not found for regression category. Failing CI."
-            exit 1
+            echo "has-integration-tests=true" >> $GITHUB_OUTPUT
           fi
 
-  run-combination-evals:
-    needs: [run-regression-evals, determine-evals]
+          echo "Found server integration tests: $int_json"
+
+  build-server-sea:
+    name: Build SEA binary (tests, v3)
+    uses: ./.github/workflows/stagehand-server-v3-sea-build.yml
+    needs: [run-build]
+    with:
+      matrix: |
+        [
+          {"os":"ubuntu-latest","platform":"linux","arch":"x64","binary_name":"stagehand-server-v3-linux-x64","include_sourcemaps":false},
+          {"os":"ubuntu-24.04-arm","platform":"linux","arch":"arm64","binary_name":"stagehand-server-v3-linux-arm64","include_sourcemaps":false},
+          {"os":"macos-15","platform":"darwin","arch":"arm64","binary_name":"stagehand-server-v3-darwin-arm64","include_sourcemaps":false},
+          {"os":"macos-15-intel","platform":"darwin","arch":"x64","binary_name":"stagehand-server-v3-darwin-x64","include_sourcemaps":false},
+          {"os":"windows-latest","platform":"win32","arch":"x64","binary_name":"stagehand-server-v3-win32-x64.exe","include_sourcemaps":false},
+          {"os":"windows-11-arm","platform":"win32","arch":"arm64","binary_name":"stagehand-server-v3-win32-arm64.exe","include_sourcemaps":false},
+          {"os":"ubuntu-latest","platform":"linux","arch":"x64","binary_name":"stagehand-server-v3-linux-x64-sourcemap","include_sourcemaps":true}
+        ]
+      use-prebuilt-artifacts: "true"
+      restore-turbo-cache: "false"
+      node-version: "20.x"
+      upload-only-binary: stagehand-server-v3-linux-x64-sourcemap
+
+  server-integration-tests:
+    name: server/v3/integration/${{ matrix.test.name }}
     runs-on: ubuntu-latest
-    timeout-minutes: 40
+    needs: [build-server-sea, discover-server-tests, run-build]
+    if: needs.discover-server-tests.outputs.has-integration-tests == 'true'
+
+    strategy:
+      fail-fast: false
+      matrix:
+        test: ${{ fromJson(needs.discover-server-tests.outputs.integration-tests) }}
+
     env:
+      BB_ENV: local
+      STAGEHAND_BASE_URL: http://stagehand-api.localhost:3107
+      STAGEHAND_BROWSER_TARGET: local
+      STAGEHAND_SERVER_TARGET: sea
       OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+      GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
       ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-      BRAINTRUST_API_KEY: ${{ secrets.BRAINTRUST_API_KEY }}
+      # Used only for testing /start with env: BROWSERBASE remote browser
       BROWSERBASE_API_KEY: ${{ secrets.BROWSERBASE_API_KEY }}
       BROWSERBASE_PROJECT_ID: ${{ secrets.BROWSERBASE_PROJECT_ID }}
-      HEADLESS: true
-      EVAL_ENV: browserbase
+
     steps:
-      - name: Check out repository code
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
 
-      - name: Check for 'combination' label
-        id: label-check
-        run: |
-          if [ "${{ needs.determine-evals.outputs.run-combination }}" != "true" ]; then
-            echo "has_label=false" >> $GITHUB_OUTPUT
-            echo "No label for COMBINATION. Exiting with success."
-          else
-            echo "has_label=true" >> $GITHUB_OUTPUT
-          fi
+      - uses: ./.github/actions/setup-node-pnpm-turbo
+        with:
+          use-prebuilt-artifacts: "true"
+          restore-turbo-cache: "false"
 
-      - name: Set up Node.js
-        if: needs.determine-evals.outputs.run-combination == 'true'
-        uses: actions/setup-node@v4
+      - name: Download SEA binary
+        uses: actions/download-artifact@v4
         with:
-          node-version: "20"
+          name: stagehand-server-v3-linux-x64-sourcemap
+          path: .
 
-      - name: Install dependencies
-        if: needs.determine-evals.outputs.run-combination == 'true'
+      - name: Ensure SEA binary is present and executable
+        shell: bash
         run: |
-          rm -rf node_modules
-          rm -f package-lock.json
-          npm install
-
-      - name: Build Stagehand
-        if: needs.determine-evals.outputs.run-combination == 'true'
-        run: npm run build
+          set -euo pipefail
+          test -f packages/server-v3/dist/sea/stagehand-server-v3-linux-x64-sourcemap
+          chmod +x packages/server-v3/dist/sea/stagehand-server-v3-linux-x64-sourcemap
 
-      - name: Install Playwright browsers
-        if: needs.determine-evals.outputs.run-combination == 'true'
-        run: npm exec playwright install --with-deps
+      - name: Run server integration test - ${{ matrix.test.name }}
+        env:
+          SEA_BINARY_NAME: stagehand-server-v3-linux-x64-sourcemap
+        run: |
+          pnpm exec turbo run test:server --only --filter=@browserbasehq/stagehand-server-v3 -- "${{ matrix.test.path }}"
 
-      - name: Run Combination Evals
-        if: needs.determine-evals.outputs.run-combination == 'true'
-        run: npm run evals category combination
+      - uses: ./.github/actions/upload-ctrf-report
+        if: always()
+        with:
+          name: ctrf/server-v3-integration/${{ matrix.test.name }}.json
 
-      - name: Log Combination Evals Performance
-        if: needs.determine-evals.outputs.run-combination == 'true'
-        run: |
-          experimentName=$(jq -r '.experimentName' eval-summary.json)
-          echo "View results at https://www.braintrust.dev/app/Browserbase/p/stagehand/experiments/${experimentName}"
-          if [ -f eval-summary.json ]; then
-            combination_score=$(jq '.categories.combination' eval-summary.json)
-            echo "Combination category score: $combination_score%"
-            exit 0
-          else
-            echo "Eval summary not found for combination category. Failing CI."
-            exit 1
-          fi
+      - uses: ./.github/actions/upload-v8-coverage
+        if: always()
+        with:
+          name: coverage/server-v3-integration/${{ matrix.test.name }}
 
-  run-act-evals:
-    needs: [run-combination-evals, determine-evals]
+  discover-e2e-tests:
     runs-on: ubuntu-latest
-    timeout-minutes: 25
-    env:
-      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-      ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-      BRAINTRUST_API_KEY: ${{ secrets.BRAINTRUST_API_KEY }}
-      BROWSERBASE_API_KEY: ${{ secrets.BROWSERBASE_API_KEY }}
-      BROWSERBASE_PROJECT_ID: ${{ secrets.BROWSERBASE_PROJECT_ID }}
-      HEADLESS: true
-      EVAL_ENV: browserbase
-    steps:
-      - name: Check out repository code
-        uses: actions/checkout@v4
+    needs: [determine-changes]
+    if: needs.determine-changes.outputs.core == 'true'
+    outputs:
+      e2e-tests: ${{ steps.set-matrix.outputs.e2e-tests }}
+      has-e2e-tests: ${{ steps.set-matrix.outputs.has-e2e-tests }}
 
-      - name: Check for 'act' label
-        id: label-check
-        run: |
-          if [ "${{ needs.determine-evals.outputs.run-act }}" != "true" ]; then
-            echo "has_label=false" >> $GITHUB_OUTPUT
-            echo "No label for ACT. Exiting with success."
-          else
-            echo "has_label=true" >> $GITHUB_OUTPUT
-          fi
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
 
-      - name: Set up Node.js
-        if: needs.determine-evals.outputs.run-act == 'true'
-        uses: actions/setup-node@v4
+      - uses: ./.github/actions/setup-node-pnpm-turbo
         with:
-          node-version: "20"
+          use-prebuilt-artifacts: "false"
+          restore-turbo-cache: "false"
 
-      - name: Install dependencies
-        if: needs.determine-evals.outputs.run-act == 'true'
+      - name: Discover e2e test files
+        id: set-matrix
         run: |
-          rm -rf node_modules
-          rm -f package-lock.json
-          npm install
-
-      - name: Build Stagehand
-        if: needs.determine-evals.outputs.run-act == 'true'
-        run: npm run build
+          e2e_json=$(pnpm --filter @browserbasehq/stagehand --silent run test:e2e -- --list)
+          echo "e2e-tests=$e2e_json" >> $GITHUB_OUTPUT
 
-      - name: Install Playwright browsers
-        if: needs.determine-evals.outputs.run-act == 'true'
-        run: npm exec playwright install --with-deps
-
-      - name: Run Act Evals
-        if: needs.determine-evals.outputs.run-act == 'true'
-        run: npm run evals category act
-
-      - name: Log Act Evals Performance
-        if: needs.determine-evals.outputs.run-act == 'true'
-        run: |
-          experimentName=$(jq -r '.experimentName' eval-summary.json)
-          echo "View results at https://www.braintrust.dev/app/Browserbase/p/stagehand/experiments/${experimentName}"
-          if [ -f eval-summary.json ]; then
-            act_score=$(jq '.categories.act' eval-summary.json)
-            echo "Act category score: $act_score%"
-            if (( $(echo "$act_score < 80" | bc -l) )); then
-              echo "Act category score is below 80%. Failing CI."
-              exit 1
-            fi
+          if [ "$e2e_json" = "[]" ]; then
+            echo "has-e2e-tests=false" >> $GITHUB_OUTPUT
           else
-            echo "Eval summary not found for act category. Failing CI."
-            exit 1
+            echo "has-e2e-tests=true" >> $GITHUB_OUTPUT
           fi
 
-  run-extract-evals:
-    needs: [run-act-evals, determine-evals]
+          echo "Found e2e tests: $e2e_json"
+
+  run-e2e-local-tests:
+    name: e2e/local/${{ matrix.test.name }}
+    needs: [run-build, discover-e2e-tests]
     runs-on: ubuntu-latest
     timeout-minutes: 50
+    if: >
+      needs.discover-e2e-tests.outputs.has-e2e-tests == 'true' &&
+      github.event.pull_request.head.repo.full_name == github.repository
     env:
       OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
       ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-      BRAINTRUST_API_KEY: ${{ secrets.BRAINTRUST_API_KEY }}
+      GOOGLE_GENERATIVE_AI_API_KEY: ${{ secrets.GOOGLE_GENERATIVE_AI_API_KEY }}
       BROWSERBASE_API_KEY: ${{ secrets.BROWSERBASE_API_KEY }}
       BROWSERBASE_PROJECT_ID: ${{ secrets.BROWSERBASE_PROJECT_ID }}
       HEADLESS: true
-      EVAL_ENV: browserbase
+      STAGEHAND_BROWSER_TARGET: local
+      STAGEHAND_SERVER_TARGET: local
+    strategy:
+      fail-fast: false
+      max-parallel: 20
+      matrix:
+        test: ${{ fromJson(needs.discover-e2e-tests.outputs.e2e-tests) }}
     steps:
       - name: Check out repository code
         uses: actions/checkout@v4
 
-      - name: Check for 'extract' label
-        id: label-check
+      - uses: ./.github/actions/setup-node-pnpm-turbo
+        with:
+          use-prebuilt-artifacts: "true"
+          restore-turbo-cache: "false"
+
+      - uses: ./.github/actions/verify-chromium-launch
+
+      - name: Run local E2E Tests - ${{ matrix.test.name }}
         run: |
-          if [ "${{ needs.determine-evals.outputs.run-extract }}" != "true" ]; then
-            echo "has_label=false" >> $GITHUB_OUTPUT
-            echo "No label for EXTRACT. Exiting with success."
-          else
-            echo "has_label=true" >> $GITHUB_OUTPUT
-          fi
+          pnpm exec turbo run test:e2e --only --filter=@browserbasehq/stagehand -- "${{ matrix.test.path }}"
 
-      - name: Set up Node.js
-        if: needs.determine-evals.outputs.run-extract == 'true'
-        uses: actions/setup-node@v4
+      - uses: ./.github/actions/upload-ctrf-report
+        if: always()
         with:
-          node-version: "20"
+          name: ctrf/e2e-local/${{ matrix.test.name }}.json
 
-      - name: Install dependencies
-        if: needs.determine-evals.outputs.run-extract == 'true'
-        run: |
-          rm -rf node_modules
-          rm -f package-lock.json
-          npm install
-
-      - name: Build Stagehand
-        if: needs.determine-evals.outputs.run-extract == 'true'
-        run: npm run build
-
-      - name: Install Playwright browsers
-        if: needs.determine-evals.outputs.run-extract == 'true'
-        run: npm exec playwright install --with-deps
-
-      # 1. Run extract category with domExtract
-      - name: Run Extract Evals (domExtract)
-        if: needs.determine-evals.outputs.run-extract == 'true'
-        run: npm run evals category extract -- --extract-method=domExtract
-
-      - name: Save Extract Dom Results
-        if: needs.determine-evals.outputs.run-extract == 'true'
-        run: mv eval-summary.json eval-summary-extract-dom.json
-
-      # 2. Then run extract category with textExtract
-      - name: Run Extract Evals (textExtract)
-        if: needs.determine-evals.outputs.run-extract == 'true'
-        run: npm run evals category extract -- --extract-method=textExtract
-
-      - name: Save Extract Text Results
-        if: needs.determine-evals.outputs.run-extract == 'true'
-        run: mv eval-summary.json eval-summary-extract-text.json
-
-      # 3. Log and Compare Extract Evals Performance
-      - name: Log and Compare Extract Evals Performance
-        if: needs.determine-evals.outputs.run-extract == 'true'
-        run: |
-          experimentNameDom=$(jq -r '.experimentName' eval-summary-extract-dom.json)
-          dom_score=$(jq '.categories.extract' eval-summary-extract-dom.json)
-          echo "DomExtract Extract category score: $dom_score%"
-          echo "View domExtract results: https://www.braintrust.dev/app/Browserbase/p/stagehand/experiments/${experimentNameDom}"
-
-          experimentNameText=$(jq -r '.experimentName' eval-summary-extract-text.json)
-          text_score=$(jq '.categories.extract' eval-summary-extract-text.json)
-          echo "TextExtract Extract category score: $text_score%"
-          echo "View textExtract results: https://www.braintrust.dev/app/Browserbase/p/stagehand/experiments/${experimentNameText}"
-
-          # If domExtract <80% fail CI
-          if (( $(echo "$dom_score < 80" | bc -l) )); then
-            echo "DomExtract extract category score is below 80%. Failing CI."
-            exit 1
-          fi
+      - uses: ./.github/actions/upload-v8-coverage
+        if: always()
+        with:
+          name: coverage/e2e-local/${{ matrix.test.name }}
 
-  run-text-extract-evals:
-    needs: [run-extract-evals, determine-evals]
+  run-e2e-bb-tests:
+    name: e2e/bb/${{ matrix.test.name }}
+    needs: [run-build, discover-e2e-tests]
     runs-on: ubuntu-latest
-    timeout-minutes: 120
+    timeout-minutes: 50
+    if: >
+      needs.discover-e2e-tests.outputs.has-e2e-tests == 'true' &&
+      github.event.pull_request.head.repo.full_name == github.repository
     env:
       OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
       ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-      BRAINTRUST_API_KEY: ${{ secrets.BRAINTRUST_API_KEY }}
+      GOOGLE_GENERATIVE_AI_API_KEY: ${{ secrets.GOOGLE_GENERATIVE_AI_API_KEY }}
       BROWSERBASE_API_KEY: ${{ secrets.BROWSERBASE_API_KEY }}
       BROWSERBASE_PROJECT_ID: ${{ secrets.BROWSERBASE_PROJECT_ID }}
       HEADLESS: true
-      EVAL_ENV: browserbase
+      STAGEHAND_BROWSER_TARGET: browserbase
+      STAGEHAND_SERVER_TARGET: local
+    strategy:
+      fail-fast: false
+      max-parallel: 100
+      matrix:
+        test: ${{ fromJson(needs.discover-e2e-tests.outputs.e2e-tests) }}
     steps:
       - name: Check out repository code
         uses: actions/checkout@v4
 
-      - name: Check for 'text-extract' label
-        id: label-check
-        run: |
-          if [ "${{ needs.determine-evals.outputs.run-text-extract }}" != "true" ]; then
-            echo "has_label=false" >> $GITHUB_OUTPUT
-            echo "No label for TEXT-EXTRACT. Exiting with success."
-          else
-            echo "has_label=true" >> $GITHUB_OUTPUT
-          fi
+      - uses: ./.github/actions/setup-node-pnpm-turbo
+        with:
+          use-prebuilt-artifacts: "true"
+          restore-turbo-cache: "false"
 
-      - name: Set up Node.js
-        if: needs.determine-evals.outputs.run-text-extract == 'true'
-        uses: actions/setup-node@v4
+      - name: Select Browserbase region
+        uses: ./.github/actions/select-browserbase-region
         with:
-          node-version: "20"
+          distribution: ${{ env.BROWSERBASE_REGION_DISTRIBUTION }}
 
-      - name: Install dependencies
-        if: needs.determine-evals.outputs.run-text-extract == 'true'
+      - name: Run E2E Tests (browserbase) - ${{ matrix.test.name }}
         run: |
-          rm -rf node_modules
-          rm -f package-lock.json
-          npm install
+          pnpm exec turbo run test:e2e --only --filter=@browserbasehq/stagehand -- "${{ matrix.test.path }}"
 
-      - name: Install Playwright browsers
-        if: needs.determine-evals.outputs.run-text-extract == 'true'
-        run: npm exec playwright install --with-deps
-
-      - name: Build Stagehand
-        if: needs.determine-evals.outputs.run-text-extract == 'true'
-        run: npm run build
-
-      - name: Run text_extract Evals (textExtract)
-        if: needs.determine-evals.outputs.run-text-extract == 'true'
-        run: npm run evals category text_extract -- --extract-method=textExtract
-
-      - name: Save text_extract Results
-        if: needs.determine-evals.outputs.run-text-extract == 'true'
-        run: mv eval-summary.json eval-summary-text_extract-text.json
-
-      - name: Log text_extract Evals Performance
-        if: needs.determine-evals.outputs.run-text-extract == 'true'
-        run: |
-          experimentNameText=$(jq -r '.experimentName' eval-summary-text_extract-text.json)
-          text_score=$(jq '.categories.text_extract' eval-summary-text_extract-text.json)
-          echo "TextExtract text_extract category score: $text_score%"
-          echo "View textExtract results: https://www.braintrust.dev/app/Browserbase/p/stagehand/experiments/${experimentNameText}"
-
-          # If text_score <80% fail CI
-          if (( $(echo "$text_score < 80" | bc -l) )); then
-            echo "textExtract text_extract category score is below 80%. Failing CI."
-            exit 1
-          fi
+      - uses: ./.github/actions/upload-ctrf-report
+        if: always()
+        with:
+          name: ctrf/e2e-bb/${{ matrix.test.name }}.json
 
-  run-observe-evals:
-    needs: [run-text-extract-evals, determine-evals]
+      - uses: ./.github/actions/upload-v8-coverage
+        if: always()
+        with:
+          name: coverage/e2e-bb/${{ matrix.test.name }}
+
+  run-evals:
+    name: evals/${{ matrix.category }}
+    needs: [run-build, determine-evals, run-e2e-bb-tests]
+    if: >-
+      ${{
+        always() &&
+        needs.run-build.result == 'success' &&
+        needs.determine-evals.result == 'success' &&
+        needs.run-e2e-bb-tests.result != 'failure' &&
+        needs.run-e2e-bb-tests.result != 'cancelled' &&
+        needs.determine-evals.outputs.skip-all-evals != 'true' &&
+        needs.determine-evals.outputs.eval-categories != '[]'
+      }}
     runs-on: ubuntu-latest
-    timeout-minutes: 60
+    timeout-minutes: 90
+    strategy:
+      fail-fast: false
+      matrix:
+        category: ${{ fromJson(needs.determine-evals.outputs.eval-categories) }}
     env:
       OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
       ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+      GOOGLE_GENERATIVE_AI_API_KEY: ${{ secrets.GOOGLE_GENERATIVE_AI_API_KEY }}
       BRAINTRUST_API_KEY: ${{ secrets.BRAINTRUST_API_KEY }}
       BROWSERBASE_API_KEY: ${{ secrets.BROWSERBASE_API_KEY }}
       BROWSERBASE_PROJECT_ID: ${{ secrets.BROWSERBASE_PROJECT_ID }}
-      HEADLESS: true
-      EVAL_ENV: browserbase
+      STAGEHAND_BROWSER_TARGET: browserbase
+      STAGEHAND_SERVER_TARGET: local
     steps:
       - name: Check out repository code
         uses: actions/checkout@v4
 
-      - name: Check for 'observe' label
-        id: label-check
-        run: |
-          if [ "${{ needs.determine-evals.outputs.run-observe }}" != "true" ]; then
-            echo "has_label=false" >> $GITHUB_OUTPUT
-            echo "No label for OBSERVE. Exiting with success."
-          else
-            echo "has_label=true" >> $GITHUB_OUTPUT
-          fi
+      - uses: ./.github/actions/setup-node-pnpm-turbo
+        with:
+          use-prebuilt-artifacts: "true"
+          restore-turbo-cache: "false"
 
-      - name: Set up Node.js
-        if: needs.determine-evals.outputs.run-observe == 'true'
-        uses: actions/setup-node@v4
+      - name: Select Browserbase region
+        uses: ./.github/actions/select-browserbase-region
         with:
-          node-version: "20"
+          distribution: ${{ env.BROWSERBASE_REGION_DISTRIBUTION }}
 
-      - name: Install dependencies
-        if: needs.determine-evals.outputs.run-observe == 'true'
+      - name: Run Evals - ${{ matrix.category }}
+        id: run-evals
+        env:
+          NODE_V8_COVERAGE: coverage/evals/${{ matrix.category }}
         run: |
-          rm -rf node_modules
-          rm -f package-lock.json
-          npm install
-
-      - name: Install Playwright browsers
-        if: needs.determine-evals.outputs.run-observe == 'true'
-        run: npm exec playwright install --with-deps
-
-      - name: Build Stagehand
-        if: needs.determine-evals.outputs.run-observe == 'true'
-        run: npm run build
+          log_file="$(mktemp)"
+          set +e
+          pnpm exec turbo run test:evals --only --filter=@browserbasehq/stagehand-evals -- "${{ matrix.category }}" -t "${EVAL_TRIAL_COUNT}" -c "${EVAL_MAX_CONCURRENCY}" 2>&1 | tee "$log_file"
+          eval_status=${PIPESTATUS[0]}
+          set -e
+
+          summary_block="$(
+            awk '
+              /^=========================SUMMARY=========================$/ { capture=1 }
+              capture { print }
+              /^Evaluation summary written to / { capture=0 }
+            ' "$log_file"
+          )"
+
+          if [ -n "$summary_block" ]; then
+            {
+              echo "summary_text<<EOF"
+              echo "$summary_block"
+              echo "EOF"
+            } >> "$GITHUB_OUTPUT"
+          fi
 
-      - name: Run Observe Evals
-        if: needs.determine-evals.outputs.run-observe == 'true'
-        run: npm run evals category observe
+          exit "$eval_status"
 
-      - name: Log Observe Evals Performance
-        if: needs.determine-evals.outputs.run-observe == 'true'
+      - name: Log Evals Performance - ${{ matrix.category }}
+        env:
+          EVAL_STDOUT_SUMMARY: ${{ steps.run-evals.outputs.summary_text }}
         run: |
+          if [ -n "${EVAL_STDOUT_SUMMARY:-}" ]; then
+            echo "### Evals Summary (${{ matrix.category }})" >> "$GITHUB_STEP_SUMMARY"
+            echo '```' >> "$GITHUB_STEP_SUMMARY"
+            printf '%s\n' "$EVAL_STDOUT_SUMMARY" >> "$GITHUB_STEP_SUMMARY"
+            echo '```' >> "$GITHUB_STEP_SUMMARY"
+          fi
           experimentName=$(jq -r '.experimentName' eval-summary.json)
           echo "View results at https://www.braintrust.dev/app/Browserbase/p/stagehand/experiments/${experimentName}"
           if [ -f eval-summary.json ]; then
-            observe_score=$(jq '.categories.observe' eval-summary.json)
-            echo "Observe category score: $observe_score%"
-            if (( $(echo "$observe_score < 80" | bc -l) )); then
-              echo "Observe category score is below 80%. Failing CI."
+            category_score=$(jq ".categories[\"${{ matrix.category }}\"]" eval-summary.json)
+            echo "${{ matrix.category }} category score: $category_score%"
+            if (( $(echo "$category_score < 80" | bc -l) )); then
+              echo "${{ matrix.category }} category score is below 80%. Failing CI."
               exit 1
             fi
           else
-            echo "Eval summary not found for observe category. Failing CI."
+            echo "Eval summary not found for ${{ matrix.category }} category. Failing CI."
             exit 1
           fi
 
-  run-targeted-extract-evals:
-    needs: [run-observe-evals, determine-evals]
+      - uses: ./.github/actions/upload-ctrf-report
+        if: always()
+        with:
+          name: ctrf/evals/${{ matrix.category }}.json
+
+      - uses: ./.github/actions/upload-v8-coverage
+        if: always()
+        with:
+          name: coverage/evals/${{ matrix.category }}
+
+  merge-coverage:
+    name: Code Coverage Report
     runs-on: ubuntu-latest
-    timeout-minutes: 60
-    env:
-      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-      ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-      BRAINTRUST_API_KEY: ${{ secrets.BRAINTRUST_API_KEY }}
-      BROWSERBASE_API_KEY: ${{ secrets.BROWSERBASE_API_KEY }}
-      BROWSERBASE_PROJECT_ID: ${{ secrets.BROWSERBASE_PROJECT_ID }}
-      HEADLESS: true
-      EVAL_ENV: browserbase
+    needs:
+      - core-unit-tests
+      - run-e2e-local-tests
+      - run-e2e-bb-tests
+      - run-evals
+      - server-integration-tests
+    # if: always()
+    if: false
     steps:
-      - name: Check out repository code
-        uses: actions/checkout@v4
-
-      - name: Check for 'targeted-extract' label
-        id: label-check
-        run: |
-          if [ "${{ needs.determine-evals.outputs.run-targeted-extract }}" != "true" ]; then
-            echo "has_label=false" >> $GITHUB_OUTPUT
-            echo "No label for TARGETED-EXTRACT. Exiting with success."
-          else
-            echo "has_label=true" >> $GITHUB_OUTPUT
-          fi
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
 
-      - name: Set up Node.js
-        if: needs.determine-evals.outputs.run-targeted-extract == 'true'
-        uses: actions/setup-node@v4
+      - uses: ./.github/actions/setup-node-pnpm-turbo
         with:
-          node-version: "20"
+          use-prebuilt-artifacts: "true"
+          restore-turbo-cache: "false"
 
-      - name: Install dependencies
-        if: needs.determine-evals.outputs.run-targeted-extract == 'true'
-        run: |
-          rm -rf node_modules
-          rm -f package-lock.json
-          npm install
+      - name: Download V8 coverage artifacts
+        uses: actions/download-artifact@v4
+        continue-on-error: true
+        with:
+          pattern: coverage-*
+          path: .
+          merge-multiple: true
 
-      - name: Install Playwright browsers
-        if: needs.determine-evals.outputs.run-targeted-extract == 'true'
-        run: npm exec playwright install --with-deps
+      - name: Download CTRF artifacts
+        uses: actions/download-artifact@v4
+        continue-on-error: true
+        with:
+          pattern: ctrf-*
+          path: .
+          merge-multiple: true
 
-      - name: Build Stagehand
-        if: needs.determine-evals.outputs.run-targeted-extract == 'true'
-        run: npm run build
+      - name: Generate merged coverage report
+        run: |
+          pnpm run coverage:merge
 
-      - name: Run targeted extract Evals
-        if: needs.determine-evals.outputs.run-targeted-extract == 'true'
-        run: npm run evals category targeted_extract -- --extract-method=textExtract
+      - name: Upload merged coverage report
+        if: always()
+        id: upload-coverage-artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-merged
+          # package.json is included to anchor artifact paths at repo root.
+          path: |
+            package.json
+            coverage/merged
+
+      - name: Add coverage summary to job summary
+        if: always()
+        shell: bash
+        run: |
+          echo "### Code Coverage" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          if [ -f coverage/merged/coverage-summary.txt ]; then
+            echo '```' >> "$GITHUB_STEP_SUMMARY"
+            cat coverage/merged/coverage-summary.txt >> "$GITHUB_STEP_SUMMARY"
+            echo '```' >> "$GITHUB_STEP_SUMMARY"
+          else
+            echo "Coverage summary not available." >> "$GITHUB_STEP_SUMMARY"
+          fi
+          if [ -n "${{ steps.upload-coverage-artifact.outputs.artifact-url }}" ]; then
+            echo "" >> "$GITHUB_STEP_SUMMARY"
+            echo "[Download full HTML coverage report](${{ steps.upload-coverage-artifact.outputs.artifact-url }})" >> "$GITHUB_STEP_SUMMARY"
+          fi
 
-      - name: Log targeted extract Evals Performance
-        if: needs.determine-evals.outputs.run-targeted-extract == 'true'
+      - name: Publish merged CTRF report
+        if: always()
+        uses: ctrf-io/github-test-reporter@v1
+        with:
+          report-path: './ctrf/**/*.json'
+          summary: true
+          summary-report: false
+          summary-delta-report: true
+          test-report: false
+          failed-report: false
+          insights-report: true
+          flaky-rate-report: true
+          fail-rate-report: true
+          slowest-report: true
+          previous-results-report: true
+          fetch-previous-results: true
+          baseline: 1
+          previous-results-max: 1
+          max-workflow-runs-to-check: 5
+          max-previous-runs-to-fetch: 1
+          upload-artifact: true
+          artifact-name: ctrf-report-merged
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Compute coverage status metrics
+        if: always()
+        id: coverage-status
+        shell: bash
         run: |
-          experimentName=$(jq -r '.experimentName' eval-summary.json)
-          echo "View results at https://www.braintrust.dev/app/Browserbase/p/stagehand/experiments/${experimentName}"
-          if [ -f eval-summary.json ]; then
-            targeted_extract_score=$(jq '.categories.targeted_extract' eval-summary.json)
-            echo "Targeted extract category score: $targeted_extract_score%"
-            if (( $(echo "$targeted_extract_score < 80" | bc -l) )); then
-              echo "Targeted extract score is below 80%. Failing CI."
-              exit 1
-            fi
+          set -euo pipefail
+          shopt -s globstar nullglob
+          tests_failed=0
+          ctrf_files=(ctrf/**/*.json)
+          if [ "${#ctrf_files[@]}" -gt 0 ]; then
+            tests_failed=$(jq -s '[.[].results.summary.failed // 0] | add' "${ctrf_files[@]}")
+          fi
+          total_coverage=0
+          if [ -f coverage/merged/coverage-summary.txt ]; then
+            total_coverage=$(awk '/^Lines/ {gsub(/%/,"",$3); print $3}' coverage/merged/coverage-summary.txt)
+          fi
+          echo "tests_failed=${tests_failed}" >> "$GITHUB_OUTPUT"
+          echo "total_coverage=${total_coverage}" >> "$GITHUB_OUTPUT"
+
+      - name: Set coverage status
+        if: always()
+        continue-on-error: true
+        shell: bash
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          RUN_ID: ${{ github.run_id }}
+          PULL_NUMBER: ${{ github.event.pull_request.number }}
+          TESTS_FAILED: ${{ steps.coverage-status.outputs.tests_failed }}
+          TOTAL_COVERAGE: ${{ steps.coverage-status.outputs.total_coverage }}
+        run: |
+          set -euo pipefail
+          repo="${GITHUB_REPOSITORY}"
+          sha="${GITHUB_SHA}"
+          tests_failed="${TESTS_FAILED:-0}"
+          total_coverage="${TOTAL_COVERAGE:-0}"
+          state="success"
+          if [ -n "${PULL_NUMBER:-}" ]; then
+            target_url="https://github.com/${repo}/pull/${PULL_NUMBER}/checks?check_run_id=${RUN_ID}"
           else
-            echo "Eval summary not found for targeted_extract category. Failing CI."
-            exit 1
+            target_url="https://github.com/${repo}/actions/runs/${RUN_ID}"
           fi
+          description="non-blocking report: ${tests_failed} tests failed. ${total_coverage}% coverage"
+          payload=$(jq -n \
+            --arg state "$state" \
+            --arg target_url "$target_url" \
+            --arg description "$description" \
+            --arg context "Measured coverage" \
+            '{state: $state, target_url: $target_url, description: $description, context: $context}')
+          curl -sSfL -X POST \
+            -H "Authorization: Bearer ${GITHUB_TOKEN}" \
+            -H "Accept: application/vnd.github+json" \
+            -H "X-GitHub-Api-Version: 2022-11-28" \
+            "https://api.github.com/repos/${repo}/statuses/${sha}" \
+            -d "$payload"
diff --git a/.github/workflows/claude.yml b/.github/workflows/claude.yml
new file mode 100644
index 000000000..d51e7c4c5
--- /dev/null
+++ b/.github/workflows/claude.yml
@@ -0,0 +1,50 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+      issues: write
+      id-token: write
+      actions: read # Required for Claude to read CI results on PRs
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+
+          # This is an optional setting that allows Claude to read CI results on PRs
+          additional_permissions: |
+            actions: read
+
+          # Optional: Give a custom prompt to Claude. If this is not specified, Claude will perform the instructions specified in the comment that tagged it.
+          # prompt: 'Update the pull request description to include a summary of changes.'
+
+          # Optional: Add claude_args to customize behavior and configuration
+          # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md
+          # or https://code.claude.com/docs/en/cli-reference for available options
+          # claude_args: '--allowed-tools Bash(gh pr:*)'
+
diff --git a/.github/workflows/feature-parity.yml b/.github/workflows/feature-parity.yml
new file mode 100644
index 000000000..9a40db33e
--- /dev/null
+++ b/.github/workflows/feature-parity.yml
@@ -0,0 +1,147 @@
+name: Feature Parity
+
+on:
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - labeled
+      - unlabeled
+    paths-ignore:
+      - "packages/docs/**"
+
+jobs:
+  check-parity-label:
+    runs-on: ubuntu-latest
+    if: github.event.action == 'labeled' && github.event.label.name == 'parity'
+    permissions:
+      contents: read
+      pull-requests: write
+      issues: write
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+
+      - name: Check user permissions
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const { data: permission } = await github.rest.repos.getCollaboratorPermissionLevel({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              username: context.actor
+            });
+
+            const hasWriteAccess = ['admin', 'write'].includes(permission.permission);
+
+            if (!hasWriteAccess) {
+              // Remove the parity label if user doesn't have write access
+              await github.rest.issues.removeLabel({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.issue.number,
+                name: 'parity'
+              });
+
+              // Add a comment explaining why the label was removed
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.issue.number,
+                body: `❌ **Parity Label Removed**\n\n@${context.actor}, you do not have sufficient permissions to add the 'parity' label. Only users with write access can trigger feature parity issues.\n\nIf you believe this feature should be implemented in the Python SDK, please ask a maintainer to add the label.`
+              });
+
+              throw new Error(`User ${context.actor} does not have write access to add parity label`);
+            }
+
+            console.log(`User ${context.actor} has ${permission.permission} access - proceeding with parity workflow`);
+
+      - name: Generate GitHub App token
+        id: generate-token
+        uses: actions/create-github-app-token@v1
+        with:
+          app-id: ${{ secrets.PARITY_APP_ID }}
+          private-key: ${{ secrets.PARITY_APP_PRIVATE_KEY }}
+          owner: browserbase
+          repositories: stagehand
+
+      - name: Create issue in Python SDK repository
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ steps.generate-token.outputs.token }}
+          script: |
+            const { data: pullRequest } = await github.rest.pulls.get({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: context.issue.number,
+            });
+
+            // Get PR comments for additional context
+            const { data: comments } = await github.rest.issues.listComments({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+            });
+
+            // Format comments for the issue description
+            let commentsSection = '';
+            if (comments.length > 0) {
+              commentsSection = '\n\n## Recent Comments\n\n';
+              comments.slice(-3).forEach(comment => {
+                commentsSection += `**@${comment.user.login}** commented:\n`;
+                commentsSection += `${comment.body.substring(0, 500)}${comment.body.length > 500 ? '...' : ''}\n\n`;
+              });
+            }
+
+            // Get list of changed files for context
+            const { data: files } = await github.rest.pulls.listFiles({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: context.issue.number,
+            });
+
+            const changedFiles = files.map(file => `- \`${file.filename}\``).join('\n');
+
+            const issueTitle = `[Feature Parity] ${pullRequest.title}`;
+            const issueBody = `## Feature Parity Request
+
+            This issue was automatically created from a pull request in the TypeScript Stagehand repository that was labeled with 'parity'.
+
+            ### Original PR Details
+            - **PR**: #${context.issue.number} - ${pullRequest.title}
+            - **Author**: @${pullRequest.user.login}
+            - **Link**: ${pullRequest.html_url}
+
+            ### Description
+            ${pullRequest.body || 'No description provided.'}
+
+            ### Changed Files
+            ${changedFiles}
+
+            ${commentsSection}
+
+            ### Action Required
+            Please review the changes in the original PR and implement equivalent functionality in the Python SDK if applicable.
+
+            ---
+            *This issue was automatically generated by the Feature Parity workflow.*`;
+
+            // Create the issue in the Python repository
+            const { data: issue } = await github.rest.issues.create({
+              owner: 'browserbase',
+              repo: 'stagehand-python',
+              title: issueTitle,
+              body: issueBody,
+              labels: ['parity']
+            });
+
+            console.log(`Created issue: ${issue.html_url}`);
+
+            // Add a comment to the original PR confirming the issue was created
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+              body: `🔄 **Feature Parity Issue Created**\n\nAn issue has been automatically created in the Python SDK repository to track parity implementation:\n${issue.html_url}`
+            });
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 00975f83a..f3347e72c 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -8,6 +8,7 @@ on:
 permissions:
   contents: write
   pull-requests: write
+  id-token: write
 
 concurrency: ${{ github.workflow }}-${{ github.ref }}
 
@@ -17,38 +18,38 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - uses: ./.github/actions/setup-node-pnpm-turbo
+        with:
+          use-prebuilt-artifacts: "false"
 
-      - name: Setup Node.js 20.x
-        uses: actions/setup-node@v3
+      - name: Configure npm registry for Trusted Publishing
+        uses: actions/setup-node@v6
         with:
           node-version: 20.x
           registry-url: "https://registry.npmjs.org"
 
-      - name: Install dependencies
-        run: |
-          rm -rf node_modules
-          rm -f package-lock.json
-          npm install
+      - name: Update npm for Trusted Publishing
+        run: npm install -g npm@latest
 
-      - name: Build
-        run: npm run build
+      - name: Run Lint & Build
+        run: pnpm exec turbo run lint && pnpm exec turbo run build
 
       - name: Create Release Pull Request or Publish to npm
         id: changesets
         uses: changesets/action@v1
         with:
-          publish: npm run release
+          publish: pnpm run release
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
 
       - name: Publish Canary
         if: github.ref == 'refs/heads/main'
         run: |
-          npm config set //registry.npmjs.org/:_authToken=${NODE_AUTH_TOKEN}
           git checkout main
-          npm run release-canary
+          pnpm run release-canary
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
diff --git a/.github/workflows/stagehand-server-v3-release.yml b/.github/workflows/stagehand-server-v3-release.yml
new file mode 100644
index 000000000..6f13b774d
--- /dev/null
+++ b/.github/workflows/stagehand-server-v3-release.yml
@@ -0,0 +1,186 @@
+name: Release stagehand/server-v3
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - .changeset/**
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+
+env:
+  OAS_PATH: packages/server-v3/openapi.v3.yaml
+
+jobs:
+  detect:
+    name: Detect server-v3 release (changesets)
+    runs-on: ubuntu-latest
+    outputs:
+      release: ${{ steps.meta.outputs.release }}
+      version: ${{ steps.meta.outputs.version }}
+      tag: ${{ steps.meta.outputs.tag }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+          fetch-tags: true
+
+      - uses: ./.github/actions/setup-node-pnpm-turbo
+        env:
+          PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: "1"
+        with:
+          use-prebuilt-artifacts: "false"
+
+      - name: Determine release metadata
+        id: meta
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          latest_tag="$(git tag -l 'stagehand-server-v3/v*' --sort=-v:refname | head -n 1 || true)"
+          rm -f changeset-status.json
+          if [ -n "${latest_tag}" ]; then
+            pnpm changeset status --since "${latest_tag}" --output changeset-status.json
+          else
+            pnpm changeset status --output changeset-status.json
+          fi
+
+          node <<'NODE'
+          const fs = require('fs');
+
+          const status = JSON.parse(fs.readFileSync('changeset-status.json', 'utf8'));
+          const changesets = Array.isArray(status.changesets) ? status.changesets : [];
+          const releases = Array.isArray(status.releases) ? status.releases : [];
+
+          const shouldRelease = changesets.some((cs) =>
+            (cs.releases || []).some((r) => r?.name === '@browserbasehq/stagehand-server-v3')
+          );
+
+          const serverRelease = releases.find((r) => r?.name === '@browserbasehq/stagehand-server-v3');
+          if (shouldRelease && !serverRelease?.newVersion) {
+            throw new Error(
+              'Expected @browserbasehq/stagehand-server-v3 to have a computed newVersion in changeset-status.json.'
+            );
+          }
+
+          const release = shouldRelease ? 'true' : 'false';
+          const version = shouldRelease ? serverRelease.newVersion : '';
+          const tag = `stagehand-server-v3/v${version}`;
+
+          const out = process.env.GITHUB_OUTPUT;
+          fs.appendFileSync(out, `release=${release}\n`);
+          fs.appendFileSync(out, `version=${version}\n`);
+          fs.appendFileSync(out, `tag=${tag}\n`);
+          NODE
+
+      - name: Create stagehand/server-v3 tag
+        if: steps.meta.outputs.release == 'true'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          TAG="${{ steps.meta.outputs.tag }}"
+          VERSION="${{ steps.meta.outputs.version }}"
+          TARGET_SHA="${{ github.sha }}"
+
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+
+          # Try to fetch the tag if it exists on remote; ignore failure for new tags
+          git fetch --force origin "refs/tags/${TAG}:refs/tags/${TAG}" 2>/dev/null || true
+          if git rev-parse -q --verify "refs/tags/${TAG}" >/dev/null; then
+            echo "Tag already exists: ${TAG}"
+            exit 0
+          fi
+
+          git tag -a "${TAG}" "${TARGET_SHA}" -m "stagehand/server-v3 v${VERSION}"
+          git push origin "${TAG}"
+
+  build_binaries:
+    name: Build SEA binaries
+    needs: detect
+    if: needs.detect.outputs.release == 'true'
+    uses: ./.github/workflows/stagehand-server-v3-sea-build.yml
+    with:
+      matrix: |
+        [
+          {"os":"ubuntu-latest","platform":"linux","arch":"x64","binary_name":"stagehand-server-v3-linux-x64","include_sourcemaps":false},
+          {"os":"ubuntu-24.04-arm","platform":"linux","arch":"arm64","binary_name":"stagehand-server-v3-linux-arm64","include_sourcemaps":false},
+          {"os":"macos-15","platform":"darwin","arch":"arm64","binary_name":"stagehand-server-v3-darwin-arm64","include_sourcemaps":false},
+          {"os":"macos-15-intel","platform":"darwin","arch":"x64","binary_name":"stagehand-server-v3-darwin-x64","include_sourcemaps":false},
+          {"os":"windows-latest","platform":"win32","arch":"x64","binary_name":"stagehand-server-v3-win32-x64.exe","include_sourcemaps":false},
+          {"os":"windows-11-arm","platform":"win32","arch":"arm64","binary_name":"stagehand-server-v3-win32-arm64.exe","include_sourcemaps":false}
+        ]
+
+  release:
+    name: Publish GitHub Release
+    needs: [detect, build_binaries]
+    if: needs.detect.outputs.release == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+          fetch-tags: false
+
+      - name: Prepare release assets directory
+        run: mkdir -p release-assets
+
+      - name: Prepare stagehand/server-v3 release assets
+        run: |
+          set -euo pipefail
+          cp "${{ env.OAS_PATH }}" "release-assets/openapi.v3.stagehand-server-v3-${{ needs.detect.outputs.version }}.yaml"
+
+      - name: Download SEA binary artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: stagehand-server-v3-*
+          path: .
+          merge-multiple: true
+
+      - name: Collect SEA binaries
+        shell: bash
+        run: |
+          set -euo pipefail
+          shopt -s nullglob
+          for f in packages/server-v3/dist/sea/stagehand-server-v3-*; do
+            cp "$f" release-assets/
+          done
+
+      - name: Create checksums
+        shell: bash
+        run: |
+          set -euo pipefail
+          cd release-assets
+          # Only checksum binaries (exclude openapi yaml). Avoid failing if no matches.
+          shopt -s nullglob
+          files=(stagehand-server-v3-*)
+          bins=()
+          for f in "${files[@]}"; do
+            [[ "$f" == *openapi* ]] && continue
+            [[ -f "$f" ]] && bins+=("$f")
+          done
+          : > checksums.sha256
+          if [ "${#bins[@]}" -gt 0 ]; then
+            shasum -a 256 "${bins[@]}" > checksums.sha256
+          fi
+
+      - name: Publish stagehand/server-v3 GitHub release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.detect.outputs.tag }}
+          name: stagehand/server-v3 v${{ needs.detect.outputs.version }}
+          generate_release_notes: true
+          files: |
+            release-assets/openapi.v3.stagehand-server-v3-${{ needs.detect.outputs.version }}.yaml
+            release-assets/stagehand-server-v3-*
+            release-assets/checksums.sha256
diff --git a/.github/workflows/stagehand-server-v3-sea-build.yml b/.github/workflows/stagehand-server-v3-sea-build.yml
new file mode 100644
index 000000000..39ad9fe1a
--- /dev/null
+++ b/.github/workflows/stagehand-server-v3-sea-build.yml
@@ -0,0 +1,180 @@
+name: Stagehand Server v3 SEA Build
+
+on:
+  workflow_call:
+    inputs:
+      matrix:
+        description: "JSON matrix include list for SEA binaries."
+        required: false
+        type: string
+        default: |
+          [
+            {"os":"ubuntu-latest","platform":"linux","arch":"x64","binary_name":"stagehand-server-v3-linux-x64","include_sourcemaps":false},
+            {"os":"ubuntu-24.04-arm","platform":"linux","arch":"arm64","binary_name":"stagehand-server-v3-linux-arm64","include_sourcemaps":false},
+            {"os":"macos-15","platform":"darwin","arch":"arm64","binary_name":"stagehand-server-v3-darwin-arm64","include_sourcemaps":false},
+            {"os":"macos-15-intel","platform":"darwin","arch":"x64","binary_name":"stagehand-server-v3-darwin-x64","include_sourcemaps":false},
+            {"os":"windows-latest","platform":"win32","arch":"x64","binary_name":"stagehand-server-v3-win32-x64.exe","include_sourcemaps":false},
+            {"os":"windows-11-arm","platform":"win32","arch":"arm64","binary_name":"stagehand-server-v3-win32-arm64.exe","include_sourcemaps":false}
+          ]
+      use-prebuilt-artifacts:
+        description: "Whether to download pre-built package artifacts."
+        required: false
+        type: string
+        default: "false"
+      restore-turbo-cache:
+        description: "Whether to restore local .turbo cache."
+        required: false
+        type: string
+        default: "true"
+      node-version:
+        description: "Node.js version for setup."
+        required: false
+        type: string
+        default: "20.x"
+      upload-only-binary:
+        description: "Upload only this binary (empty => upload all)."
+        required: false
+        type: string
+        default: ""
+  workflow_dispatch:
+    inputs:
+      matrix:
+        description: "JSON matrix include list for SEA binaries."
+        required: false
+        default: |
+          [
+            {"os":"ubuntu-latest","platform":"linux","arch":"x64","binary_name":"stagehand-server-v3-linux-x64","include_sourcemaps":false},
+            {"os":"ubuntu-24.04-arm","platform":"linux","arch":"arm64","binary_name":"stagehand-server-v3-linux-arm64","include_sourcemaps":false},
+            {"os":"macos-15","platform":"darwin","arch":"arm64","binary_name":"stagehand-server-v3-darwin-arm64","include_sourcemaps":false},
+            {"os":"macos-15-intel","platform":"darwin","arch":"x64","binary_name":"stagehand-server-v3-darwin-x64","include_sourcemaps":false},
+            {"os":"windows-latest","platform":"win32","arch":"x64","binary_name":"stagehand-server-v3-win32-x64.exe","include_sourcemaps":false},
+            {"os":"windows-11-arm","platform":"win32","arch":"arm64","binary_name":"stagehand-server-v3-win32-arm64.exe","include_sourcemaps":false}
+          ]
+      use-prebuilt-artifacts:
+        description: "Whether to download pre-built package artifacts."
+        required: false
+        type: string
+        default: "false"
+      restore-turbo-cache:
+        description: "Whether to restore local .turbo cache."
+        required: false
+        type: string
+        default: "true"
+      node-version:
+        description: "Node.js version for setup."
+        required: false
+        type: string
+        default: "20.x"
+      upload-only-binary:
+        description: "Upload only this binary (empty => upload all)."
+        required: false
+        type: string
+        default: ""
+
+jobs:
+  build_binaries:
+    name: Build SEA binaries (${{ matrix.binary_name }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include: ${{ fromJson(inputs.matrix) }}
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 1
+          fetch-tags: false
+
+      - uses: ./.github/actions/setup-node-pnpm-turbo
+        env:
+          PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: "1"
+          PLAYWRIGHT_SKIP_DOWNLOAD: "1"
+          PUPPETEER_SKIP_DOWNLOAD: "1"
+        with:
+          use-prebuilt-artifacts: ${{ inputs.use-prebuilt-artifacts }}
+          restore-turbo-cache: ${{ inputs.restore-turbo-cache }}
+          node-version: ${{ inputs.node-version }}
+
+      - name: Build SEA binary (ESM)
+        env:
+          SEA_TARGET_PLATFORM: ${{ matrix.platform }}
+          SEA_TARGET_ARCH: ${{ matrix.arch }}
+          SEA_BINARY_NAME: ${{ matrix.binary_name }}
+          SEA_INCLUDE_SOURCEMAPS: ${{ matrix.include_sourcemaps && '1' || '0' }}
+        run: pnpm exec turbo run build:sea:esm --filter=@browserbasehq/stagehand-server-v3
+
+      - name: Verify SEA binary exists
+        shell: bash
+        run: |
+          test -f "packages/server-v3/dist/sea/${{ matrix.binary_name }}"
+
+      - name: Verify SEA binary launches cleanly
+        shell: bash
+        env:
+          RUNNER_ARCH: ${{ runner.arch }}
+        run: |
+          set -euo pipefail
+
+          binary="packages/server-v3/dist/sea/${{ matrix.binary_name }}"
+          matrix_arch="${{ matrix.arch }}"
+          runner_arch="$(echo "${RUNNER_ARCH}" | tr '[:upper:]' '[:lower:]')"
+
+          if [[ "${matrix_arch}" != "${runner_arch}" ]]; then
+            echo "Runner arch (${runner_arch}) does not match matrix arch (${matrix_arch})."
+            echo "Launch verification must run on same-arch runners."
+            exit 1
+          fi
+
+          if [[ "${{ matrix.platform }}" != "win32" ]]; then
+            chmod +x "${binary}"
+          fi
+
+          port="$((30000 + RANDOM % 10000))"
+          log_file="$(mktemp)"
+          launched="false"
+
+          cleanup() {
+            if [[ -n "${pid:-}" ]] && kill -0 "${pid}" 2>/dev/null; then
+              kill "${pid}" 2>/dev/null || true
+              wait "${pid}" 2>/dev/null || true
+            fi
+          }
+          trap cleanup EXIT
+
+          PORT="${port}" "${binary}" >"${log_file}" 2>&1 &
+          pid=$!
+
+          for _ in {1..30}; do
+            if ! kill -0 "${pid}" 2>/dev/null; then
+              wait "${pid}" 2>/dev/null || true
+              echo "SEA binary exited before becoming healthy."
+              cat "${log_file}"
+              exit 1
+            fi
+
+            if curl --silent --show-error --fail "http://127.0.0.1:${port}/healthz" >/dev/null; then
+              launched="true"
+              break
+            fi
+
+            sleep 1
+          done
+
+          if [[ "${launched}" != "true" ]]; then
+            echo "SEA binary did not become healthy within 30 seconds."
+            cat "${log_file}"
+            exit 1
+          fi
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        if: ${{ inputs.upload-only-binary == '' || matrix.binary_name == inputs.upload-only-binary }}
+        with:
+          name: ${{ matrix.binary_name }}
+          # package.json is included to anchor artifact paths at repo root.
+          path: |
+            package.json
+            packages/server-v3/dist/sea/${{ matrix.binary_name }}
+          retention-days: 7
diff --git a/.github/workflows/stagehand-server-v4-release.yml b/.github/workflows/stagehand-server-v4-release.yml
new file mode 100644
index 000000000..d2a978662
--- /dev/null
+++ b/.github/workflows/stagehand-server-v4-release.yml
@@ -0,0 +1,186 @@
+name: Release stagehand/server-v4
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - .changeset/**
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+
+env:
+  OAS_PATH: packages/server-v4/openapi.v4.yaml
+
+jobs:
+  detect:
+    name: Detect server-v4 release (changesets)
+    runs-on: ubuntu-latest
+    outputs:
+      release: ${{ steps.meta.outputs.release }}
+      version: ${{ steps.meta.outputs.version }}
+      tag: ${{ steps.meta.outputs.tag }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+          fetch-tags: true
+
+      - uses: ./.github/actions/setup-node-pnpm-turbo
+        env:
+          PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: "1"
+        with:
+          use-prebuilt-artifacts: "false"
+
+      - name: Determine release metadata
+        id: meta
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          latest_tag="$(git tag -l 'stagehand-server-v4/v*' --sort=-v:refname | head -n 1 || true)"
+          rm -f changeset-status.json
+          if [ -n "${latest_tag}" ]; then
+            pnpm changeset status --since "${latest_tag}" --output changeset-status.json
+          else
+            pnpm changeset status --output changeset-status.json
+          fi
+
+          node <<'NODE'
+          const fs = require('fs');
+
+          const status = JSON.parse(fs.readFileSync('changeset-status.json', 'utf8'));
+          const changesets = Array.isArray(status.changesets) ? status.changesets : [];
+          const releases = Array.isArray(status.releases) ? status.releases : [];
+
+          const shouldRelease = changesets.some((cs) =>
+            (cs.releases || []).some((r) => r?.name === '@browserbasehq/stagehand-server-v4')
+          );
+
+          const serverRelease = releases.find((r) => r?.name === '@browserbasehq/stagehand-server-v4');
+          if (shouldRelease && !serverRelease?.newVersion) {
+            throw new Error(
+              'Expected @browserbasehq/stagehand-server-v4 to have a computed newVersion in changeset-status.json.'
+            );
+          }
+
+          const release = shouldRelease ? 'true' : 'false';
+          const version = shouldRelease ? serverRelease.newVersion : '';
+          const tag = `stagehand-server-v4/v${version}`;
+
+          const out = process.env.GITHUB_OUTPUT;
+          fs.appendFileSync(out, `release=${release}\n`);
+          fs.appendFileSync(out, `version=${version}\n`);
+          fs.appendFileSync(out, `tag=${tag}\n`);
+          NODE
+
+      - name: Create stagehand/server-v4 tag
+        if: steps.meta.outputs.release == 'true'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          TAG="${{ steps.meta.outputs.tag }}"
+          VERSION="${{ steps.meta.outputs.version }}"
+          TARGET_SHA="${{ github.sha }}"
+
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+
+          # Try to fetch the tag if it exists on remote; ignore failure for new tags
+          git fetch --force origin "refs/tags/${TAG}:refs/tags/${TAG}" 2>/dev/null || true
+          if git rev-parse -q --verify "refs/tags/${TAG}" >/dev/null; then
+            echo "Tag already exists: ${TAG}"
+            exit 0
+          fi
+
+          git tag -a "${TAG}" "${TARGET_SHA}" -m "stagehand/server-v4 v${VERSION}"
+          git push origin "${TAG}"
+
+  build_binaries:
+    name: Build SEA binaries
+    needs: detect
+    if: needs.detect.outputs.release == 'true'
+    uses: ./.github/workflows/stagehand-server-v4-sea-build.yml
+    with:
+      matrix: |
+        [
+          {"os":"ubuntu-latest","platform":"linux","arch":"x64","binary_name":"stagehand-server-v4-linux-x64","include_sourcemaps":false},
+          {"os":"ubuntu-24.04-arm","platform":"linux","arch":"arm64","binary_name":"stagehand-server-v4-linux-arm64","include_sourcemaps":false},
+          {"os":"macos-15","platform":"darwin","arch":"arm64","binary_name":"stagehand-server-v4-darwin-arm64","include_sourcemaps":false},
+          {"os":"macos-15-intel","platform":"darwin","arch":"x64","binary_name":"stagehand-server-v4-darwin-x64","include_sourcemaps":false},
+          {"os":"windows-latest","platform":"win32","arch":"x64","binary_name":"stagehand-server-v4-win32-x64.exe","include_sourcemaps":false},
+          {"os":"windows-11-arm","platform":"win32","arch":"arm64","binary_name":"stagehand-server-v4-win32-arm64.exe","include_sourcemaps":false}
+        ]
+
+  release:
+    name: Publish GitHub Release
+    needs: [detect, build_binaries]
+    if: needs.detect.outputs.release == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+          fetch-tags: false
+
+      - name: Prepare release assets directory
+        run: mkdir -p release-assets
+
+      - name: Prepare stagehand/server-v4 release assets
+        run: |
+          set -euo pipefail
+          cp "${{ env.OAS_PATH }}" "release-assets/openapi.v4.stagehand-server-v4-${{ needs.detect.outputs.version }}.yaml"
+
+      - name: Download SEA binary artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: stagehand-server-v4-*
+          path: .
+          merge-multiple: true
+
+      - name: Collect SEA binaries
+        shell: bash
+        run: |
+          set -euo pipefail
+          shopt -s nullglob
+          for f in packages/server-v4/dist/sea/stagehand-server-v4-*; do
+            cp "$f" release-assets/
+          done
+
+      - name: Create checksums
+        shell: bash
+        run: |
+          set -euo pipefail
+          cd release-assets
+          # Only checksum binaries (exclude openapi yaml). Avoid failing if no matches.
+          shopt -s nullglob
+          files=(stagehand-server-v4-*)
+          bins=()
+          for f in "${files[@]}"; do
+            [[ "$f" == *openapi* ]] && continue
+            [[ -f "$f" ]] && bins+=("$f")
+          done
+          : > checksums.sha256
+          if [ "${#bins[@]}" -gt 0 ]; then
+            shasum -a 256 "${bins[@]}" > checksums.sha256
+          fi
+
+      - name: Publish stagehand/server-v4 GitHub release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.detect.outputs.tag }}
+          name: stagehand/server-v4 v${{ needs.detect.outputs.version }}
+          generate_release_notes: true
+          files: |
+            release-assets/openapi.v4.stagehand-server-v4-${{ needs.detect.outputs.version }}.yaml
+            release-assets/stagehand-server-v4-*
+            release-assets/checksums.sha256
diff --git a/.github/workflows/stagehand-server-v4-sea-build.yml b/.github/workflows/stagehand-server-v4-sea-build.yml
new file mode 100644
index 000000000..3ad278dc5
--- /dev/null
+++ b/.github/workflows/stagehand-server-v4-sea-build.yml
@@ -0,0 +1,180 @@
+name: Stagehand Server v4 SEA Build
+
+on:
+  workflow_call:
+    inputs:
+      matrix:
+        description: "JSON matrix include list for SEA binaries."
+        required: false
+        type: string
+        default: |
+          [
+            {"os":"ubuntu-latest","platform":"linux","arch":"x64","binary_name":"stagehand-server-v4-linux-x64","include_sourcemaps":false},
+            {"os":"ubuntu-24.04-arm","platform":"linux","arch":"arm64","binary_name":"stagehand-server-v4-linux-arm64","include_sourcemaps":false},
+            {"os":"macos-15","platform":"darwin","arch":"arm64","binary_name":"stagehand-server-v4-darwin-arm64","include_sourcemaps":false},
+            {"os":"macos-15-intel","platform":"darwin","arch":"x64","binary_name":"stagehand-server-v4-darwin-x64","include_sourcemaps":false},
+            {"os":"windows-latest","platform":"win32","arch":"x64","binary_name":"stagehand-server-v4-win32-x64.exe","include_sourcemaps":false},
+            {"os":"windows-11-arm","platform":"win32","arch":"arm64","binary_name":"stagehand-server-v4-win32-arm64.exe","include_sourcemaps":false}
+          ]
+      use-prebuilt-artifacts:
+        description: "Whether to download pre-built package artifacts."
+        required: false
+        type: string
+        default: "false"
+      restore-turbo-cache:
+        description: "Whether to restore local .turbo cache."
+        required: false
+        type: string
+        default: "true"
+      node-version:
+        description: "Node.js version for setup."
+        required: false
+        type: string
+        default: "20.x"
+      upload-only-binary:
+        description: "Upload only this binary (empty => upload all)."
+        required: false
+        type: string
+        default: ""
+  workflow_dispatch:
+    inputs:
+      matrix:
+        description: "JSON matrix include list for SEA binaries."
+        required: false
+        default: |
+          [
+            {"os":"ubuntu-latest","platform":"linux","arch":"x64","binary_name":"stagehand-server-v4-linux-x64","include_sourcemaps":false},
+            {"os":"ubuntu-24.04-arm","platform":"linux","arch":"arm64","binary_name":"stagehand-server-v4-linux-arm64","include_sourcemaps":false},
+            {"os":"macos-15","platform":"darwin","arch":"arm64","binary_name":"stagehand-server-v4-darwin-arm64","include_sourcemaps":false},
+            {"os":"macos-15-intel","platform":"darwin","arch":"x64","binary_name":"stagehand-server-v4-darwin-x64","include_sourcemaps":false},
+            {"os":"windows-latest","platform":"win32","arch":"x64","binary_name":"stagehand-server-v4-win32-x64.exe","include_sourcemaps":false},
+            {"os":"windows-11-arm","platform":"win32","arch":"arm64","binary_name":"stagehand-server-v4-win32-arm64.exe","include_sourcemaps":false}
+          ]
+      use-prebuilt-artifacts:
+        description: "Whether to download pre-built package artifacts."
+        required: false
+        type: string
+        default: "false"
+      restore-turbo-cache:
+        description: "Whether to restore local .turbo cache."
+        required: false
+        type: string
+        default: "true"
+      node-version:
+        description: "Node.js version for setup."
+        required: false
+        type: string
+        default: "20.x"
+      upload-only-binary:
+        description: "Upload only this binary (empty => upload all)."
+        required: false
+        type: string
+        default: ""
+
+jobs:
+  build_binaries:
+    name: Build SEA binaries (${{ matrix.binary_name }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include: ${{ fromJson(inputs.matrix) }}
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 1
+          fetch-tags: false
+
+      - uses: ./.github/actions/setup-node-pnpm-turbo
+        env:
+          PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: "1"
+          PLAYWRIGHT_SKIP_DOWNLOAD: "1"
+          PUPPETEER_SKIP_DOWNLOAD: "1"
+        with:
+          use-prebuilt-artifacts: ${{ inputs.use-prebuilt-artifacts }}
+          restore-turbo-cache: ${{ inputs.restore-turbo-cache }}
+          node-version: ${{ inputs.node-version }}
+
+      - name: Build SEA binary (ESM)
+        env:
+          SEA_TARGET_PLATFORM: ${{ matrix.platform }}
+          SEA_TARGET_ARCH: ${{ matrix.arch }}
+          SEA_BINARY_NAME: ${{ matrix.binary_name }}
+          SEA_INCLUDE_SOURCEMAPS: ${{ matrix.include_sourcemaps && '1' || '0' }}
+        run: pnpm exec turbo run build:sea:esm --filter=@browserbasehq/stagehand-server-v4
+
+      - name: Verify SEA binary exists
+        shell: bash
+        run: |
+          test -f "packages/server-v4/dist/sea/${{ matrix.binary_name }}"
+
+      - name: Verify SEA binary launches cleanly
+        shell: bash
+        env:
+          RUNNER_ARCH: ${{ runner.arch }}
+        run: |
+          set -euo pipefail
+
+          binary="packages/server-v4/dist/sea/${{ matrix.binary_name }}"
+          matrix_arch="${{ matrix.arch }}"
+          runner_arch="$(echo "${RUNNER_ARCH}" | tr '[:upper:]' '[:lower:]')"
+
+          if [[ "${matrix_arch}" != "${runner_arch}" ]]; then
+            echo "Runner arch (${runner_arch}) does not match matrix arch (${matrix_arch})."
+            echo "Launch verification must run on same-arch runners."
+            exit 1
+          fi
+
+          if [[ "${{ matrix.platform }}" != "win32" ]]; then
+            chmod +x "${binary}"
+          fi
+
+          port="$((30000 + RANDOM % 10000))"
+          log_file="$(mktemp)"
+          launched="false"
+
+          cleanup() {
+            if [[ -n "${pid:-}" ]] && kill -0 "${pid}" 2>/dev/null; then
+              kill "${pid}" 2>/dev/null || true
+              wait "${pid}" 2>/dev/null || true
+            fi
+          }
+          trap cleanup EXIT
+
+          PORT="${port}" "${binary}" >"${log_file}" 2>&1 &
+          pid=$!
+
+          for _ in {1..30}; do
+            if ! kill -0 "${pid}" 2>/dev/null; then
+              wait "${pid}" 2>/dev/null || true
+              echo "SEA binary exited before becoming healthy."
+              cat "${log_file}"
+              exit 1
+            fi
+
+            if curl --silent --show-error --fail "http://127.0.0.1:${port}/healthz" >/dev/null; then
+              launched="true"
+              break
+            fi
+
+            sleep 1
+          done
+
+          if [[ "${launched}" != "true" ]]; then
+            echo "SEA binary did not become healthy within 30 seconds."
+            cat "${log_file}"
+            exit 1
+          fi
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        if: ${{ inputs.upload-only-binary == '' || matrix.binary_name == inputs.upload-only-binary }}
+        with:
+          name: ${{ matrix.binary_name }}
+          # package.json is included to anchor artifact paths at repo root.
+          path: |
+            package.json
+            packages/server-v4/dist/sea/${{ matrix.binary_name }}
+          retention-days: 7
diff --git a/.github/workflows/stainless.yml b/.github/workflows/stainless.yml
new file mode 100644
index 000000000..0f8d69be8
--- /dev/null
+++ b/.github/workflows/stainless.yml
@@ -0,0 +1,60 @@
+name: Build SDKs for pull request
+
+on:
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
+      - closed
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+env:
+  STAINLESS_ORG: ${{ vars.STAINLESS_ORG }}
+  STAINLESS_PROJECT: ${{ vars.STAINLESS_PROJECT }}
+  OAS_PATH: packages/server-v3/openapi.v3.yaml
+
+jobs:
+  preview:
+    if: github.event.action != 'closed'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+
+      - name: Run preview builds
+        uses: stainless-api/upload-openapi-spec-action/preview@v1
+        with:
+          stainless_api_key: ${{ secrets.STAINLESS_API_KEY }}
+          org: ${{ env.STAINLESS_ORG }}
+          project: ${{ env.STAINLESS_PROJECT }}
+          oas_path: ${{ env.OAS_PATH }}
+          config_path: stainless.yml
+
+  merge:
+    if: github.event.action == 'closed' && github.event.pull_request.merged == true && github.event.pull_request.base.ref == 'main'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+      - name: Run merge build
+        uses: stainless-api/upload-openapi-spec-action/merge@v1
+        with:
+          stainless_api_key: ${{ secrets.STAINLESS_API_KEY }}
+          org: ${{ env.STAINLESS_ORG }}
+          project: ${{ env.STAINLESS_PROJECT }}
+          oas_path: ${{ env.OAS_PATH }}
+          config_path: stainless.yml
diff --git a/.gitignore b/.gitignore
index e5ea06bbe..2f22d2ad3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,12 +9,23 @@ screenshot.png
 .env
 downloads/
 dist/
-evals/**/public
-lib/dom/build/
-evals/public
+.browserbase/
+packages/evals/**/public
+packages/core/lib/dom/build/
+packages/core/lib/v3/dom/build/
+packages/evals/public
 *.tgz
 evals/playground.ts
 tmp/
 eval-summary.json
-pnpm-lock.yaml
+package-lock.json
 evals/deterministic/tests/BrowserContext/tmp-test.har
+packages/core/lib/version.ts
+packages/core/test-results/
+/examples/inference_summary
+/inference_summary
+.turbo
+.idea
+coverage/
+ctrf/
+.stagehand-sea/
diff --git a/.prettierignore b/.prettierignore
index 9581fb07d..c4cf4cc5d 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -1,3 +1,21 @@
 pnpm-lock.yaml
 README.md
-**/*.json
\ No newline at end of file
+**/*.json
+docs/
+.github/
+dist/
+node_modules/
+lib/dom/build/
+lib/v3/dom/build/
+packages/core/dist/
+packages/core/lib/dom/build/
+packages/core/lib/v3/dom/build/
+packages/evals/dist/
+packages/docs/
+*.min.js
+.browserbase/
+.browserbase/**
+**/.browserbase/
+**/.browserbase/**
+stainless.yml
+openapi.*.yaml
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2b34a6abc..b37ce4d87 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,222 @@
 # @browserbasehq/stagehand
 
+## 3.0.0
+
+### Major Changes
+
+- Removes internal Playwright dependency
+- A generous 20-40% speed increase across `act`, `extract`, & `observe` calls
+- Compatibility with Playwright, Puppeteer, and Patchright
+- Automatic action caching (agent, stagehand.act). Go from CUA → deterministic scripts w/o inference
+- A suite of non AI primitives:
+  - `page`
+  - `locator` (built in closed mode shadow root traversal, with xpaths & css selectors)
+  - `frameLocator`
+  - `deepLocator` (crosses iframes & shadow roots)
+- bun compatibility
+- Simplified extract schemas
+- CSS selector support (id-based support coming soon)
+- Targeted extract and observe across iframes & shadow roots
+- More intuitive type names (observeResult is now action, act accepts an instruction string instead of an action string, solidified ModelConfiguration)
+
+Check the [migration guide](https://docs.stagehand.dev/v3/migrations/v2) for more information
+
+## 2.5.0
+
+### Minor Changes
+
+- [#981](https://github.com/browserbase/stagehand/pull/981) [`8244ab2`](https://github.com/browserbase/stagehand/commit/8244ab247cd679962685ae2f7c54e874ce1fa614) Thanks [@sameelarif](https://github.com/sameelarif)! - Added support for `stagehand.agent` to interact with MCP servers as well as custom tools to be passed in. For more information, reference the [MCP integrations documentation](https://docs.stagehand.dev/best-practices/mcp-integrations)
+
+### Patch Changes
+
+- [#959](https://github.com/browserbase/stagehand/pull/959) [`09b5e1e`](https://github.com/browserbase/stagehand/commit/09b5e1e9c23c845903686db6665cc968ac34efbb) Thanks [@filip-michalsky](https://github.com/filip-michalsky)! - add webvoyager evals
+
+- [#1049](https://github.com/browserbase/stagehand/pull/1049) [`e3734b9`](https://github.com/browserbase/stagehand/commit/e3734b9c98352d5f0a4eca49791b0bbf2130ab41) Thanks [@miguelg719](https://github.com/miguelg719)! - Support local MCP server connections
+
+- [#1025](https://github.com/browserbase/stagehand/pull/1025) [`be85b19`](https://github.com/browserbase/stagehand/commit/be85b19679a826f19702e00f0aae72fce1118ec8) Thanks [@tkattkat](https://github.com/tkattkat)! - add support for custom baseUrl within openai provider
+
+- [#1040](https://github.com/browserbase/stagehand/pull/1040) [`88d1565`](https://github.com/browserbase/stagehand/commit/88d1565c65bb65a104fea2d5f5e862bbbda69677) Thanks [@miguelg719](https://github.com/miguelg719)! - Allow OpenAI CUA to take in an optional baseURL
+
+- [#1046](https://github.com/browserbase/stagehand/pull/1046) [`ab5d6ed`](https://github.com/browserbase/stagehand/commit/ab5d6ede19aabc059badc4247f1cb2c6c9e71bae) Thanks [@tkattkat](https://github.com/tkattkat)! - Add support for gpt-5 in operator agent
+
+## 2.4.4
+
+### Patch Changes
+
+- [#1012](https://github.com/browserbase/stagehand/pull/1012) [`9e8c173`](https://github.com/browserbase/stagehand/commit/9e8c17374fdc8fbe7f26e6cf802c36bd14f11039) Thanks [@miguelg719](https://github.com/miguelg719)! - Fix disabling api validation whenever a customLLM client is provided
+
+## 2.4.3
+
+### Patch Changes
+
+- [#951](https://github.com/browserbase/stagehand/pull/951) [`f45afdc`](https://github.com/browserbase/stagehand/commit/f45afdccc8680650755fee66ffbeac32b41e075d) Thanks [@miguelg719](https://github.com/miguelg719)! - Patch GPT-5 new api format
+
+- [#954](https://github.com/browserbase/stagehand/pull/954) [`261bba4`](https://github.com/browserbase/stagehand/commit/261bba43fa79ac3af95328e673ef3e9fced3279b) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - add support for shadow DOMs (open & closed mode) when experimental: true
+
+- [#944](https://github.com/browserbase/stagehand/pull/944) [`8de7bd8`](https://github.com/browserbase/stagehand/commit/8de7bd8635c2051cd8025e365c6c8aa83d81c7e7) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - Bump zod version compatibility and add pathing spec
+
+- [#919](https://github.com/browserbase/stagehand/pull/919) [`3d80421`](https://github.com/browserbase/stagehand/commit/3d804210a106a6828c7fa50f8b765b10afd4cc6a) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - enable scrolling inside of iframes
+
+- [#963](https://github.com/browserbase/stagehand/pull/963) [`0ead63d`](https://github.com/browserbase/stagehand/commit/0ead63d6526f6c286362b74b6407c8bebc900e69) Thanks [@tkattkat](https://github.com/tkattkat)! - Properly handle images in evaluator + clean up response parsing logic
+
+- [#961](https://github.com/browserbase/stagehand/pull/961) [`8422828`](https://github.com/browserbase/stagehand/commit/8422828c4cd5fd5ebcf348cfbdb40c768bb76dd9) Thanks [@tkattkat](https://github.com/tkattkat)! - Add more evals for stagehand agent
+
+- [#946](https://github.com/browserbase/stagehand/pull/946) [`b769206`](https://github.com/browserbase/stagehand/commit/b7692060f98a2f49aeeefb90d8789ed034b08ec2) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: unable to act on/get content from some same process iframes
+
+- [#962](https://github.com/browserbase/stagehand/pull/962) [`72d2683`](https://github.com/browserbase/stagehand/commit/72d2683202af7e578d98367893964b33e0828de5) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - handle namespaced elements in xpath build step
+
+## 2.4.2
+
+### Patch Changes
+
+- [#865](https://github.com/browserbase/stagehand/pull/865) [`6b4e6e3`](https://github.com/browserbase/stagehand/commit/6b4e6e3f31d5496cf15728e9018eddeb04839542) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - improve type safety for trimTrailingTextNode
+
+- [#897](https://github.com/browserbase/stagehand/pull/897) [`e77d018`](https://github.com/browserbase/stagehand/commit/e77d0188683ebf596dfb78dfafbbca1dc32993f0) Thanks [@miguelg719](https://github.com/miguelg719)! - Fix selfHeal to remember intially received arguments
+
+- [#920](https://github.com/browserbase/stagehand/pull/920) [`c20adb9`](https://github.com/browserbase/stagehand/commit/c20adb95539fed8c56a4aa413262a9c65a8e6474) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: tab handling on API
+
+- [#882](https://github.com/browserbase/stagehand/pull/882) [`b86df93`](https://github.com/browserbase/stagehand/commit/b86df93b9136aae96292121a29c25f3d74d84bf7) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - remove elements that don't have xpaths from observe response
+
+- [#905](https://github.com/browserbase/stagehand/pull/905) [`023c2c2`](https://github.com/browserbase/stagehand/commit/023c2c273b46d3792d7e5d3c902089487b16b531) Thanks [@tkattkat](https://github.com/tkattkat)! - Delete old images from anthropic cua client
+
+- [#925](https://github.com/browserbase/stagehand/pull/925) [`8c28647`](https://github.com/browserbase/stagehand/commit/8c2864755ecd05c8f7de235d4198deec0dd5f78e) Thanks [@miguelg719](https://github.com/miguelg719)! - Remove \_refreshPageFromApi()
+
+- [#887](https://github.com/browserbase/stagehand/pull/887) [`87e09c6`](https://github.com/browserbase/stagehand/commit/87e09c618940f364ec8af00455a19a17ec63cbd3) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: allow xpaths with prepended 'xpath=' for targeted extract
+
+- [#864](https://github.com/browserbase/stagehand/pull/864) [`a611115`](https://github.com/browserbase/stagehand/commit/a61111525d70b450bdfc43f112380f44899c9e97) Thanks [@miguelg719](https://github.com/miguelg719)! - Temporarily patch custom clients serialization error on api
+
+- [#881](https://github.com/browserbase/stagehand/pull/881) [`69913fe`](https://github.com/browserbase/stagehand/commit/69913fe1dfb8201ae2aeffa5f049fb46ab02cbc2) Thanks [@miguelg719](https://github.com/miguelg719)! - Pass sdk version number to API for debugging
+
+- [#913](https://github.com/browserbase/stagehand/pull/913) [`b1b83a1`](https://github.com/browserbase/stagehand/commit/b1b83a1d334fe76e5f5f9dd32dc92c16b7d40ce6) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - move iframe out of 'experimental'
+
+- [#891](https://github.com/browserbase/stagehand/pull/891) [`be8497c`](https://github.com/browserbase/stagehand/commit/be8497cb6b142cc893cea9692b8c47bd19514c60) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: nested iframe xpath bug
+
+- [#883](https://github.com/browserbase/stagehand/pull/883) [`98704c9`](https://github.com/browserbase/stagehand/commit/98704c9ed225ca25bbde4bb3dc286936e9c54471) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - add timeout for JS click
+
+- [#907](https://github.com/browserbase/stagehand/pull/907) [`04978bd`](https://github.com/browserbase/stagehand/commit/04978bdd30d2edcbc69eb9fd91358a16975ea2eb) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - store mapping of CDP frame ID -> page
+
+## 2.4.1
+
+### Patch Changes
+
+- [#856](https://github.com/browserbase/stagehand/pull/856) [`8a43c5a`](https://github.com/browserbase/stagehand/commit/8a43c5a86d4da40cfaedd9cf2e42186928bdf946) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - set download behaviour by default
+
+- [#857](https://github.com/browserbase/stagehand/pull/857) [`890ffcc`](https://github.com/browserbase/stagehand/commit/890ffccac5e0a60ade64a46eb550c981ffb3e84a) Thanks [@miguelg719](https://github.com/miguelg719)! - return "not-supported" for elements inside the shadow-dom
+
+- [#844](https://github.com/browserbase/stagehand/pull/844) [`64c1072`](https://github.com/browserbase/stagehand/commit/64c10727bda50470483a3eb175c02842db0923a1) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - don't automatically close tabs
+
+- [#860](https://github.com/browserbase/stagehand/pull/860) [`b077d3f`](https://github.com/browserbase/stagehand/commit/b077d3f48a97f47a71ccc79ae39b41e7f07f9c04) Thanks [@miguelg719](https://github.com/miguelg719)! - Set default schema on extract options with no schema
+
+- [#842](https://github.com/browserbase/stagehand/pull/842) [`8bcb5d7`](https://github.com/browserbase/stagehand/commit/8bcb5d77debf6bf7601fd5c090efd7fde75c5d5e) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - improved handling for OS level dropdowns
+
+- [#846](https://github.com/browserbase/stagehand/pull/846) [`7bf10c5`](https://github.com/browserbase/stagehand/commit/7bf10c55b267078fe847c1d7f7a60d604f9c7c94) Thanks [@miguelg719](https://github.com/miguelg719)! - Filter attaching to target worker / shared_worker
+
+## 2.4.0
+
+### Minor Changes
+
+- [#819](https://github.com/browserbase/stagehand/pull/819) [`6a18c1e`](https://github.com/browserbase/stagehand/commit/6a18c1ee1e46d55c6e90c4d5572e17ed8daa140c) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - try playwright click and fall back to JS click event
+
+### Patch Changes
+
+- [#826](https://github.com/browserbase/stagehand/pull/826) [`124e0d3`](https://github.com/browserbase/stagehand/commit/124e0d3bb54ddb6738ede6d7aa99a945ef1cacd1) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix issue where we are unable to take actions on text nodes
+
+- [#818](https://github.com/browserbase/stagehand/pull/818) [`1660751`](https://github.com/browserbase/stagehand/commit/1660751cd14cb5b27d44f8167216afb8d1c3c45c) Thanks [@miguelg719](https://github.com/miguelg719)! - Added CUA support for Claude 4 models
+
+- [#821](https://github.com/browserbase/stagehand/pull/821) [`cadac9d`](https://github.com/browserbase/stagehand/commit/cadac9da09123d12e5d496a0e8b12660964c1b33) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - use playwright instead of playwright test
+
+- [#832](https://github.com/browserbase/stagehand/pull/832) [`759da55`](https://github.com/browserbase/stagehand/commit/759da55775eb2df81d56ae18c0f386fd9b02a9f0) Thanks [@miguelg719](https://github.com/miguelg719)! - Fix \_refreshPageFromAPI to use parametrized apiKey
+
+- [#810](https://github.com/browserbase/stagehand/pull/810) [`a175a51`](https://github.com/browserbase/stagehand/commit/a175a519b8c14300db6f1ed30709e113d18e99db) Thanks [@miguelg719](https://github.com/miguelg719)! - Update logos
+
+- [#822](https://github.com/browserbase/stagehand/pull/822) [`8527a80`](https://github.com/browserbase/stagehand/commit/8527a80522c3eedb9516a6caa1a0e4e4be981a3d) Thanks [@miguelg719](https://github.com/miguelg719)! - Add model with date tag for OpenAI CUA
+
+- [#833](https://github.com/browserbase/stagehand/pull/833) [`55fca2f`](https://github.com/browserbase/stagehand/commit/55fca2f7da63cc0ef6e27b45a33f63c666cdce7e) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - adjust stagehandLogger.warn() level to be 1 instead of 0
+
+## 2.3.1
+
+### Patch Changes
+
+- [#796](https://github.com/browserbase/stagehand/pull/796) [`12a99b3`](https://github.com/browserbase/stagehand/commit/12a99b398d8a4c3eea3ca69a3cf793faaaf4aea3) Thanks [@miguelg719](https://github.com/miguelg719)! - Added a experimental flag to enable the newest and most experimental features
+
+- [#807](https://github.com/browserbase/stagehand/pull/807) [`2451797`](https://github.com/browserbase/stagehand/commit/2451797f64c0efa4a72fd70265110003c8d0a6cd) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - include version number in StagehandDefaultError message
+
+- [#803](https://github.com/browserbase/stagehand/pull/803) [`1d631a5`](https://github.com/browserbase/stagehand/commit/1d631a57a197390f672b718ae5199991ab27cfb1) Thanks [@miguelg719](https://github.com/miguelg719)! - Enable session affinity for cache optimization
+
+- [#804](https://github.com/browserbase/stagehand/pull/804) [`9c398bb`](https://github.com/browserbase/stagehand/commit/9c398bb9ec2d10bdb53ad5aa7e3b58cce24fdb2b) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - update operatorResponseSchema based on new openai spec
+
+- [#786](https://github.com/browserbase/stagehand/pull/786) [`c19ad7f`](https://github.com/browserbase/stagehand/commit/c19ad7f1e082e91fdeaa9c2ef63767a5a2b3a195) Thanks [@miguelg719](https://github.com/miguelg719)! - Handle reroute to account for rollout
+
+## 2.3.0
+
+### Minor Changes
+
+- [#737](https://github.com/browserbase/stagehand/pull/737) [`6ef6073`](https://github.com/browserbase/stagehand/commit/6ef60730cab0ad9025f44b6eeb2c83751d1dcd35) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - deprecate useTextExtract and remove functionality
+
+### Patch Changes
+
+- [#741](https://github.com/browserbase/stagehand/pull/741) [`5680d25`](https://github.com/browserbase/stagehand/commit/5680d2509352c383ad502c9f4fabde01fa638833) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - use safeparse for zod validation
+
+- [#783](https://github.com/browserbase/stagehand/pull/783) [`4de92a8`](https://github.com/browserbase/stagehand/commit/4de92a8af461fc95063faf39feee1d49259f58ba) Thanks [@miguelg719](https://github.com/miguelg719)! - Fix the readme logo link
+
+## 2.2.1
+
+### Patch Changes
+
+- [#721](https://github.com/browserbase/stagehand/pull/721) [`be8652e`](https://github.com/browserbase/stagehand/commit/be8652e770b57fdb3299fa0b2efa4eb0e816434e) Thanks [@miguelg719](https://github.com/miguelg719)! - Fix stagehand.close() functionality to include calling browser.close()
+
+- [#724](https://github.com/browserbase/stagehand/pull/724) [`6b413b7`](https://github.com/browserbase/stagehand/commit/6b413b7ad00b13ca0bd53ee2e7393023821408b6) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - rm refine step in extract
+
+- [#712](https://github.com/browserbase/stagehand/pull/712) [`7eafbd9`](https://github.com/browserbase/stagehand/commit/7eafbd9b1a73b37effa444929767df7c592caf02) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - deprecated `onlyVisible` param and remove its functionality
+
+- [#725](https://github.com/browserbase/stagehand/pull/725) [`1b50aa6`](https://github.com/browserbase/stagehand/commit/1b50aa61cf0a429dd6cb2760a08f7f698a50454b) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - dont overwrite .describe() when user defines a zod schema with z.string().url().describe()
+
+- [#717](https://github.com/browserbase/stagehand/pull/717) [`f2b7f1f`](https://github.com/browserbase/stagehand/commit/f2b7f1f284eef1f96753319b66c7d0b273a6f8cd) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - don't publish uncompiled ts to npm
+
+- [#719](https://github.com/browserbase/stagehand/pull/719) [`c8d672f`](https://github.com/browserbase/stagehand/commit/c8d672f7c410c256defbc2e87ead99239837aa28) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix `Invalid schema for response_format` error when extracting links
+
+- [#722](https://github.com/browserbase/stagehand/pull/722) [`bebf204`](https://github.com/browserbase/stagehand/commit/bebf2044502333c694743078c5b0c9deae11fb79) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - replace NBSP with regular space & remove special characters from dom+a11y tree
+
+- [#714](https://github.com/browserbase/stagehand/pull/714) [`37d6810`](https://github.com/browserbase/stagehand/commit/37d6810a704773d0383a86f98f5f17c7d5b21975) Thanks [@miguelg719](https://github.com/miguelg719)! - Fix the native AI SDK client implementation to optionally take in an API key
+
+## 2.2.0
+
+### Minor Changes
+
+- [#655](https://github.com/browserbase/stagehand/pull/655) [`8814af9`](https://github.com/browserbase/stagehand/commit/8814af9ece99fddc3dd9fb32671d0513a3a00c67) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - extract links
+
+- [#675](https://github.com/browserbase/stagehand/pull/675) [`35c55eb`](https://github.com/browserbase/stagehand/commit/35c55ebf6c2867801a0a6f6988a883c8cb90cf9a) Thanks [@tkattkat](https://github.com/tkattkat)! - Added Gemini 2.5 Flash to Google supported models
+
+- [#668](https://github.com/browserbase/stagehand/pull/668) [`5c6d2cf`](https://github.com/browserbase/stagehand/commit/5c6d2cf89c9fbf198485506ed9ed75e07aec5cd4) Thanks [@miguelg719](https://github.com/miguelg719)! - Added a new class - Stagehand Evaluator - that wraps around a Stagehand object to determine whether a task is successful or not. Currently used for agent evals
+
+### Patch Changes
+
+- [#706](https://github.com/browserbase/stagehand/pull/706) [`18ac6fb`](https://github.com/browserbase/stagehand/commit/18ac6fba30f45b7557cecb890f4e84c75de8383c) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - remove unused fillInVariables fn
+
+- [#692](https://github.com/browserbase/stagehand/pull/692) [`6b95248`](https://github.com/browserbase/stagehand/commit/6b95248d6e02e5304ce4dd60499e31fc42af57eb) Thanks [@miguelg719](https://github.com/miguelg719)! - Updated the list of OpenAI models (4.1, o3...)
+
+- [#688](https://github.com/browserbase/stagehand/pull/688) [`7d81b3c`](https://github.com/browserbase/stagehand/commit/7d81b3c951c1f3dfc46845aefcc26ff175299bca) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - wrap page.evaluate to make sure we have injected browser side scripts before calling them
+
+- [#664](https://github.com/browserbase/stagehand/pull/664) [`b5ca00a`](https://github.com/browserbase/stagehand/commit/b5ca00a25ad0c33a5f4d3198e1bc59edb9956e7c) Thanks [@miguelg719](https://github.com/miguelg719)! - remove unnecessary log
+
+- [#683](https://github.com/browserbase/stagehand/pull/683) [`8f0f97b`](https://github.com/browserbase/stagehand/commit/8f0f97bc491e23ff0078c802aaf509fd04173c37) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - use javsacript click instead of playwright
+
+- [#705](https://github.com/browserbase/stagehand/pull/705) [`346ef5d`](https://github.com/browserbase/stagehand/commit/346ef5d0132dc1418dac18d26640a8df0435af57) Thanks [@miguelg719](https://github.com/miguelg719)! - Fixed removing a hanging observation map that is no longer used
+
+- [#698](https://github.com/browserbase/stagehand/pull/698) [`c145bc1`](https://github.com/browserbase/stagehand/commit/c145bc1d90ffd0d71c412de3af1c26c121e0b101) Thanks [@sameelarif](https://github.com/sameelarif)! - Fixing LLM client support to natively integrate with AI SDK
+
+- [#687](https://github.com/browserbase/stagehand/pull/687) [`edd6d3f`](https://github.com/browserbase/stagehand/commit/edd6d3feb47aac9f312a5edad78bf850ae1541db) Thanks [@miguelg719](https://github.com/miguelg719)! - Fixed the schema input for Gemini's response model
+
+- [#678](https://github.com/browserbase/stagehand/pull/678) [`5ec43d8`](https://github.com/browserbase/stagehand/commit/5ec43d8b9568c0f86b3e24bd83d1826c837656ed) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - allow form filling when form is not top-most element
+
+- [#694](https://github.com/browserbase/stagehand/pull/694) [`b8cc164`](https://github.com/browserbase/stagehand/commit/b8cc16405b712064a54c8cd591750368a47f35ea) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - add telemetry for cua agents to stagehand.metrics
+
+- [#699](https://github.com/browserbase/stagehand/pull/699) [`d9f4243`](https://github.com/browserbase/stagehand/commit/d9f4243f6a8c8d4f3003ad6589f7eb4da6d23d0f) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - rm deprecated primitives from stagehand object
+
+- [#710](https://github.com/browserbase/stagehand/pull/710) [`9f4ab76`](https://github.com/browserbase/stagehand/commit/9f4ab76a0c1f0c2171290765c48c3bcea5b50e0f) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - support targeted extract for domExtract
+
+- [#677](https://github.com/browserbase/stagehand/pull/677) [`bc5a731`](https://github.com/browserbase/stagehand/commit/bc5a731241f7f4c5040dd672d8e3787555766421) Thanks [@miguelg719](https://github.com/miguelg719)! - Fixes a redundant unnecessary log
+
 ## 2.1.0
 
 ### Minor Changes
diff --git a/README.md b/README.md
index 788d6c073..56dda5f6d 100644
--- a/README.md
+++ b/README.md
@@ -1,30 +1,29 @@
-<div id="toc" align="center">
-  <ul style="list-style: none">
+<div id="toc" align="center" style="margin-bottom: 0;">
+  <ul style="list-style: none; margin: 0; padding: 0;">
     <a href="https://stagehand.dev">
       <picture>
-        <source media="(prefers-color-scheme: dark)" srcset="https://stagehand.dev/logo-dark.svg" />
-        <img alt="Stagehand" src="https://stagehand.dev/logo-light.svg" />
+        <source media="(prefers-color-scheme: dark)" srcset="media/dark_logo.png" />
+        <img alt="Stagehand" src="media/light_logo.png" width="200" style="margin-right: 30px;" />
       </picture>
     </a>
   </ul>
 </div>
-
 <p align="center">
-  The production-ready framework for AI browser automations.<br>
+  <strong>The AI Browser Automation Framework</strong><br>
   <a href="https://docs.stagehand.dev">Read the Docs</a>
 </p>
 
 <p align="center">
   <a href="https://github.com/browserbase/stagehand/tree/main?tab=MIT-1-ov-file#MIT-1-ov-file">
     <picture>
-      <source media="(prefers-color-scheme: dark)" srcset="https://stagehand.dev/api/assets/license?mode=dark" />
-      <img alt="MIT License" src="https://stagehand.dev/api/assets/license?mode=light" />
+      <source media="(prefers-color-scheme: dark)" srcset="media/dark_license.svg" />
+      <img alt="MIT License" src="media/light_license.svg" />
     </picture>
   </a>
-  <a href="https://stagehand.dev/slack">
+  <a href="https://stagehand.dev/discord">
     <picture>
-      <source media="(prefers-color-scheme: dark)" srcset="https://stagehand.dev/api/assets/slack?mode=dark" />
-      <img alt="Slack Community" src="https://stagehand.dev/api/assets/slack?mode=light" />
+      <source media="(prefers-color-scheme: dark)" srcset="media/dark_discord.svg" />
+      <img alt="Discord Community" src="media/light_discord.svg" />
     </picture>
   </a>
 </p>
@@ -33,81 +32,90 @@
 	<a href="https://trendshift.io/repositories/12122" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12122" alt="browserbase%2Fstagehand | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
 </p>
 
+<p align="center">
+  <a href="https://deepwiki.com/browserbase/stagehand">
+    <img alt="Ask DeepWiki" src="https://deepwiki.com/badge.svg" />
+  </a>
+</p>
+
+<p align="center">
+If you're looking for the Python implementation, you can find it 
+<a href="https://github.com/browserbase/stagehand-python"> here</a>
+</p>
+
+<div align="center" style="display: flex; align-items: center; justify-content: center; gap: 4px; margin-bottom: 0;">
+  <b>Vibe code</b>
+  <span style="font-size: 1.05em;"> Stagehand with </span>
+  <a href="https://director.ai" style="display: flex; align-items: center;">
+    <span>Director</span>
+  </a>
+  <span> </span>
+  <picture>
+    <img alt="Director" src="media/director_icon.svg" width="25" />
+  </picture>
+</div>
+
+## What is Stagehand?
+
+Stagehand is a browser automation framework used to control web browsers with natural language and code. By combining the power of AI with the precision of code, Stagehand makes web automation flexible, maintainable, and actually reliable.
+
 ## Why Stagehand?
 
-Most existing browser automation tools either require you to write low-level code in a framework like Selenium, Playwright, or Puppeteer, or use high-level agents that can be unpredictable in production. By letting developers choose what to write in code vs. natural language, Stagehand is the natural choice for browser automations in production.
+Most existing browser automation tools either require you to write low-level code in a framework like Selenium, Playwright, or Puppeteer, or use high-level agents that can be unpredictable in production. By letting developers choose what to write in code vs. natural language (and bridging the gap between the two) Stagehand is the natural choice for browser automations in production.
+
+1. **Choose when to write code vs. natural language**: use AI when you want to navigate unfamiliar pages, and use code when you know exactly what you want to do.
+
+2. **Go from AI-driven to repeatable workflows**: Stagehand lets you preview AI actions before running them, and also helps you easily cache repeatable actions to save time and tokens.
 
-1. **Choose when to write code vs. natural language**: use AI when you want to navigate unfamiliar pages, and use code ([Playwright](https://playwright.dev/)) when you know exactly what you want to do.
+3. **Write once, run forever**: Stagehand's auto-caching combined with self-healing remembers previous actions, runs without LLM inference, and knows when to involve AI whenever the website changes and your automation breaks. 
 
-2. **Preview and cache actions**: Stagehand lets you preview AI actions before running them, and also helps you easily cache repeatable actions to save time and tokens.
+## Getting Started
+
+Start with Stagehand with one line of code, or check out our [Quickstart Guide](https://docs.stagehand.dev/v3/first-steps/quickstart) for more information:
 
-3. **Computer use models with one line of code**: Stagehand lets you integrate SOTA computer use models from OpenAI and Anthropic into the browser with one line of code.
+```bash
+npx create-browser-app
+```
 
 ## Example
 
 Here's how to build a sample browser automation with Stagehand:
 
-<div align="center">
-  <div style="max-width:300px;">
-    <img src="/media/github_demo.gif" alt="See Stagehand in Action">
-  </div>
-</div>
-
 ```typescript
-// Use Playwright functions on the page object
-const page = stagehand.page;
+// Stagehand's CDP engine provides an optimized, low level interface to the browser built for automation
+const page = stagehand.context.pages()[0];
 await page.goto("https://github.com/browserbase");
 
 // Use act() to execute individual actions
-await page.act("click on the stagehand repo");
+await stagehand.act("click on the stagehand repo");
 
-// Use Computer Use agents for larger actions
-const agent = stagehand.agent({
-    provider: "openai",
-    model: "computer-use-preview",
-});
+// Use agent() for multi-step tasks
+const agent = stagehand.agent();
 await agent.execute("Get to the latest PR");
 
-// Use extract() to read data from the page
-const { author, title } = await page.extract({
-  instruction: "extract the author and title of the PR",
-  schema: z.object({
+// Use extract() to get structured data from the page
+const { author, title } = await stagehand.extract(
+  "extract the author and title of the PR",
+  z.object({
     author: z.string().describe("The username of the PR author"),
     title: z.string().describe("The title of the PR"),
   }),
-});
+);
 ```
 
 ## Documentation
 
 Visit [docs.stagehand.dev](https://docs.stagehand.dev) to view the full documentation.
 
-## Getting Started
-
-Start with Stagehand with one line of code, or check out our [Quickstart Guide](https://docs.stagehand.dev/get_started/quickstart) for more information:
-
-```bash
-npx create-browser-app
-```
-
-<div align="center">
-    <a href="https://www.loom.com/share/f5107f86d8c94fa0a8b4b1e89740f7a7">
-      <p>Watch Anirudh demo create-browser-app to create a Stagehand project!</p>
-    </a>
-    <a href="https://www.loom.com/share/f5107f86d8c94fa0a8b4b1e89740f7a7">
-      <img style="max-width:300px;" src="https://cdn.loom.com/sessions/thumbnails/f5107f86d8c94fa0a8b4b1e89740f7a7-ec3f428b6775ceeb-full-play.gif">
-    </a>
-  </div>
 
 ### Build and Run from Source
 
 ```bash
 git clone https://github.com/browserbase/stagehand.git
 cd stagehand
-npm install
-npx playwright install
-npm run build
-npm run example # run the blank script at ./examples/example.ts
+pnpm install
+pnpm run build
+pnpm run example # run the blank script at ./examples/example.ts
 ```
 
 Stagehand is best when you have an API key for an LLM provider and Browserbase credentials. To add these to your project, run:
@@ -117,26 +125,35 @@ cp .env.example .env
 nano .env # Edit the .env file to add API keys
 ```
 
+### Installing from a branch
+
+You can install and build Stagehand directly from a github branch using [gitpkg](https://github.com/EqualMa/gitpkg)
+
+In your project's `package.json` set:
+```json
+"@browserbasehq/stagehand": "https://gitpkg.now.sh/browserbase/stagehand/packages/core?<branchName>",
+```
+
+
 ## Contributing
 
-> [!NOTE]  
-> We highly value contributions to Stagehand! For questions or support, please join our [Slack community](https://stagehand.dev/slack).
+> [!NOTE]
+> We highly value contributions to Stagehand! For questions or support, please join our [Discord community](https://stagehand.dev/discord).
 
-At a high level, we're focused on improving reliability, speed, and cost in that order of priority. If you're interested in contributing, we strongly recommend reaching out to [Anirudh Kamath](https://x.com/kamathematic) or [Paul Klein](https://x.com/pk_iv) in our [Slack community](https://stagehand.dev/slack) before starting to ensure that your contribution aligns with our goals.
+At a high level, we're focused on improving reliability, extensibility, speed, and cost in that order of priority. If you're interested in contributing, **bug fixes and small improvements are the best way to get started**. For more involved features, we strongly recommend reaching out to [Miguel Gonzalez](https://x.com/miguel_gonzf) or [Paul Klein](https://x.com/pk_iv) in our [Discord community](https://stagehand.dev/discord) before starting to ensure that your contribution aligns with our goals.
 
-For more information, please see our [Contributing Guide](https://docs.stagehand.dev/contributions/contributing).
+<!-- For more information, please see our [Contributing Guide](https://docs.stagehand.dev/examples/contributing). -->
 
 ## Acknowledgements
 
-This project heavily relies on [Playwright](https://playwright.dev/) as a resilient backbone to automate the web. It also would not be possible without the awesome techniques and discoveries made by [tarsier](https://github.com/reworkd/tarsier), and [fuji-web](https://github.com/normal-computing/fuji-web).
-
 We'd like to thank the following people for their major contributions to Stagehand:
 - [Paul Klein](https://github.com/pkiv)
-- [Anirudh Kamath](https://github.com/kamath)
 - [Sean McGuire](https://github.com/seanmcguire12)
 - [Miguel Gonzalez](https://github.com/miguelg719)
 - [Sameel Arif](https://github.com/sameelarif)
+- [Thomas Katwan](https://github.com/tkattkat)
 - [Filip Michalsky](https://github.com/filip-michalsky)
+- [Anirudh Kamath](https://github.com/kamath)
 - [Jeremy Press](https://x.com/jeremypress)
 - [Navid Pour](https://github.com/navidpour)
 
diff --git a/claude.md b/claude.md
new file mode 100644
index 000000000..fcffa95b4
--- /dev/null
+++ b/claude.md
@@ -0,0 +1,297 @@
+# Stagehand Project
+
+This is a project that uses Stagehand V3, a browser automation framework with AI-powered `act`, `extract`, `observe`, and `agent` methods.
+
+The main class can be imported as `Stagehand` from `@browserbasehq/stagehand`.
+
+**Key Classes:**
+
+- `Stagehand`: Main orchestrator class providing `act`, `extract`, `observe`, and `agent` methods
+- `context`: A `V3Context` object that manages browser contexts and pages
+- `page`: Individual page objects accessed via `stagehand.context.pages()[i]` or created with `stagehand.context.newPage()`
+
+## Initialize
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL", // or "BROWSERBASE"
+  verbose: 2, // 0, 1, or 2
+  model: "openai/gpt-4.1-mini", // or any supported model
+});
+
+await stagehand.init();
+
+// Access the browser context and pages
+const page = stagehand.context.pages()[0];
+const context = stagehand.context;
+
+// Create new pages if needed
+const page2 = await stagehand.context.newPage();
+```
+
+## Act
+
+Actions are called on the `stagehand` instance (not the page). Use atomic, specific instructions:
+
+```typescript
+// Act on the current active page
+await stagehand.act("click the sign in button");
+
+// Act on a specific page (when you need to target a page that isn't currently active)
+await stagehand.act("click the sign in button", { page: page2 });
+```
+
+**Important:** Act instructions should be atomic and specific:
+
+- ✅ Good: "Click the sign in button" or "Type 'hello' into the search input"
+- ❌ Bad: "Order me pizza" or "Type in the search bar and hit enter" (multi-step)
+
+### Observe + Act Pattern (Recommended)
+
+Cache the results of `observe` to avoid unexpected DOM changes:
+
+```typescript
+const instruction = "Click the sign in button";
+
+// Get candidate actions
+const actions = await stagehand.observe(instruction);
+
+// Execute the first action
+await stagehand.act(actions[0]);
+```
+
+To target a specific page:
+
+```typescript
+const actions = await stagehand.observe("select blue as the favorite color", {
+  page: page2,
+});
+await stagehand.act(actions[0], { page: page2 });
+```
+
+## Extract
+
+Extract data from pages using natural language instructions. The `extract` method is called on the `stagehand` instance.
+
+### Basic Extraction (with schema)
+
+```typescript
+import { z } from "zod";
+
+// Extract with explicit schema
+const data = await stagehand.extract(
+  "extract all apartment listings with prices and addresses",
+  z.object({
+    listings: z.array(
+      z.object({
+        price: z.string(),
+        address: z.string(),
+      }),
+    ),
+  }),
+);
+
+console.log(data.listings);
+```
+
+### Simple Extraction (without schema)
+
+```typescript
+// Extract returns a default object with 'extraction' field
+const result = await stagehand.extract("extract the sign in button text");
+
+console.log(result);
+// Output: { extraction: "Sign in" }
+
+// Or destructure directly
+const { extraction } = await stagehand.extract(
+  "extract the sign in button text",
+);
+console.log(extraction); // "Sign in"
+```
+
+### Targeted Extraction
+
+Extract data from a specific element using a selector:
+
+```typescript
+const reason = await stagehand.extract(
+  "extract the reason why script injection fails",
+  z.string(),
+  { selector: "/html/body/div[2]/div[3]/iframe/html/body/p[2]" },
+);
+```
+
+### URL Extraction
+
+When extracting links or URLs, use `z.string().url()`:
+
+```typescript
+const { links } = await stagehand.extract(
+  "extract all navigation links",
+  z.object({
+    links: z.array(z.string().url()),
+  }),
+);
+```
+
+### Extracting from a Specific Page
+
+```typescript
+// Extract from a specific page (when you need to target a page that isn't currently active)
+const data = await stagehand.extract(
+  "extract the placeholder text on the name field",
+  { page: page2 },
+);
+```
+
+## Observe
+
+Plan actions before executing them. Returns an array of candidate actions:
+
+```typescript
+// Get candidate actions on the current active page
+const [action] = await stagehand.observe("Click the sign in button");
+
+// Execute the action
+await stagehand.act(action);
+```
+
+Observing on a specific page:
+
+```typescript
+// Target a specific page (when you need to target a page that isn't currently active)
+const actions = await stagehand.observe("find the next page button", {
+  page: page2,
+});
+await stagehand.act(actions[0], { page: page2 });
+```
+
+## Agent
+
+Use the `agent` method to autonomously execute complex, multi-step tasks.
+
+### Basic Agent Usage
+
+```typescript
+const page = stagehand.context.pages()[0];
+await page.goto("https://www.google.com");
+
+const agent = stagehand.agent({
+  model: "google/gemini-2.0-flash",
+  executionModel: "google/gemini-2.0-flash",
+});
+
+const result = await agent.execute({
+  instruction: "Search for the stock price of NVDA",
+  maxSteps: 20,
+});
+
+console.log(result.message);
+```
+
+### Computer Use Agent (CUA)
+
+For more advanced scenarios using computer-use models:
+
+```typescript
+const agent = stagehand.agent({
+  mode: "cua", // Enable Computer Use Agent mode
+  model: "anthropic/claude-sonnet-4-20250514",
+  // or "google/gemini-2.5-computer-use-preview-10-2025"
+  systemPrompt: `You are a helpful assistant that can use a web browser.
+    Do not ask follow up questions, the user will trust your judgement.`,
+});
+
+await agent.execute({
+  instruction: "Apply for a library card at the San Francisco Public Library",
+  maxSteps: 30,
+});
+```
+
+### Agent with Custom Model Configuration
+
+```typescript
+const agent = stagehand.agent({
+  model: {
+    modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+    apiKey: process.env.GEMINI_API_KEY,
+  },
+  systemPrompt: `You are a helpful assistant.`,
+});
+```
+
+### Agent with Integrations (MCP/External Tools)
+
+```typescript
+const agent = stagehand.agent({
+  integrations: [`https://mcp.exa.ai/mcp?exaApiKey=${process.env.EXA_API_KEY}`],
+  systemPrompt: `You have access to the Exa search tool.`,
+});
+```
+
+### Agent Hybrid Mode
+
+Hybrid mode uses both DOM-based and coordinate-based tools (act, click, type, dragAndDrop) for visual interactions. This requires `experimental: true` and models that support reliable coordinate-based actions.
+
+**Recommended models for hybrid mode:**
+
+- `google/gemini-3-flash-preview`
+- `anthropic/claude-sonnet-4-20250514`, `anthropic/claude-sonnet-4-5-20250929`, `anthropic/claude-haiku-4-5-20251001`
+
+```typescript
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  experimental: true, // Required for hybrid mode
+});
+await stagehand.init();
+
+const agent = stagehand.agent({
+  mode: "hybrid",
+  model: "google/gemini-3-flash-preview",
+});
+
+await agent.execute({
+  instruction: "Click the submit button and fill the form",
+  maxSteps: 20,
+  highlightCursor: true, // Enabled by default in hybrid mode
+});
+```
+
+**Agent modes:**
+
+- `"dom"` (default): Uses DOM-based tools (act, fillForm) - works with any model
+- `"hybrid"`: Uses both DOM-based and coordinate-based tools (act, click, type, dragAndDrop) - requires grounding-capable models
+- `"cua"`: Uses Computer Use Agent providers
+
+## Advanced Features
+
+### DeepLocator (XPath Targeting)
+
+Target specific elements across shadow DOM and iframes:
+
+```typescript
+await page
+  .deepLocator("/html/body/div[2]/div[3]/iframe/html/body/p")
+  .highlight({
+    durationMs: 5000,
+    contentColor: { r: 255, g: 0, b: 0 },
+  });
+```
+
+### Multi-Page Workflows
+
+```typescript
+const page1 = stagehand.context.pages()[0];
+await page1.goto("https://example.com");
+
+const page2 = await stagehand.context.newPage();
+await page2.goto("https://example2.com");
+
+// Act/extract/observe operate on the current active page by default
+// Pass { page } option to target a specific page
+await stagehand.act("click button", { page: page1 });
+await stagehand.extract("get title", { page: page2 });
+```
diff --git a/docs/logging.md b/docs/logging.md
deleted file mode 100644
index fa73482c1..000000000
--- a/docs/logging.md
+++ /dev/null
@@ -1,184 +0,0 @@
-# Stagehand Logging System
-
-The Stagehand logging system uses [Pino](https://getpino.io/) to provide structured, efficient, and configurable logging.
-
-## Log Levels
-
-Stagehand uses three primary log levels:
-
-| Level | Name  | Description                             |
-| ----- | ----- | --------------------------------------- |
-| 0     | error | Critical errors and important warnings  |
-| 1     | info  | Standard information messages (default) |
-| 2     | debug | Detailed information for debugging      |
-
-The verbosity of logging is controlled by the `verbose` option when creating a Stagehand instance:
-
-```typescript
-const stagehand = new Stagehand({
-  verbose: 2, // Show all logs up to debug level
-  // other options...
-});
-```
-
-## Using the Logger
-
-The logging system is automatically initialized with your Stagehand instance. You can access it directly via:
-
-```typescript
-// Log an error
-stagehand.log({
-  message: "An error occurred",
-  level: 0,
-  category: "error",
-});
-
-// Log info (level 1 is default)
-stagehand.log({
-  message: "Operation completed",
-  category: "operation",
-});
-
-// Log debug information
-stagehand.log({
-  message: "Debug details",
-  level: 2,
-  category: "debug",
-  auxiliary: {
-    details: {
-      value: JSON.stringify({ key: "value" }),
-      type: "object",
-    },
-  },
-});
-```
-
-## Inference Logging
-
-For detailed logging of inference operations (act, extract, observe), Stagehand provides specialized logging:
-
-```typescript
-// Enable inference logging to file
-const stagehand = new Stagehand({
-  logInferenceToFile: true,
-  // other options...
-});
-```
-
-When enabled, inference logs are written to the `inference_summary` directory in your project.
-
-## Pretty Printing
-
-By default, logs in development are formatted with colors and readable timestamps using Pino's pretty formatting. For production environments or when sending logs to external systems, you can disable pretty printing.
-
-## Customizing Logging
-
-### Using Your Own Logger
-
-You can provide your own custom logger when creating a Stagehand instance:
-
-```typescript
-const stagehand = new Stagehand({
-  logger: (logLine) => {
-    // Your custom logging logic here
-    console.log(`[${logLine.category}] ${logLine.message}`);
-  },
-  // other options...
-});
-```
-
-When you provide a custom logger, Stagehand will automatically disable its internal Pino logger to prevent duplicate logging. Your logger will receive all log events directly.
-
-### Configuring Pino
-
-If you want to use Pino but with custom configuration:
-
-```typescript
-import { StagehandLogger } from "@browserbasehq/stagehand/lib/logger";
-
-// Create a custom configured logger
-const customLogger = new StagehandLogger({
-  pretty: true,
-  level: "debug",
-  // Other Pino options...
-});
-
-// Pass it to Stagehand
-const stagehand = new Stagehand({
-  logger: (logLine) => customLogger.log(logLine),
-  // other options...
-});
-```
-
-## Advanced Usage
-
-### Creating a New StagehandLogger Instance
-
-You can create a standalone logger for use in your application:
-
-```typescript
-import { StagehandLogger } from "@browserbasehq/stagehand/lib/logger";
-
-const logger = new StagehandLogger({
-  pretty: true,
-  level: "debug",
-});
-
-logger.info("Information message");
-logger.debug("Debug message", { details: "some data" });
-logger.error("Error message", { error: "details" });
-```
-
-### Configuring Log Output
-
-You can direct logs to a file or other destination:
-
-```typescript
-import fs from "fs";
-import { StagehandLogger } from "@browserbasehq/stagehand/lib/logger";
-
-const fileStream = fs.createWriteStream("./logs/application.log", {
-  flags: "a",
-});
-
-const logger = new StagehandLogger({
-  destination: fileStream,
-});
-```
-
-### Disabling Pino Explicitly
-
-If you want to handle all logging yourself without using Pino:
-
-```typescript
-import { StagehandLogger } from "@browserbasehq/stagehand/lib/logger";
-
-const logger = new StagehandLogger(
-  {
-    usePino: false,
-  },
-  (logLine) => {
-    // Your custom logging logic
-    console.log(`[${logLine.level}] ${logLine.message}`);
-  },
-);
-```
-
-## Troubleshooting
-
-If you're not seeing logs:
-
-1. Check your `verbose` setting - it may be too low for the log levels you're trying to see
-2. Verify that your log messages have the correct level set
-3. If using a custom logger, ensure it's correctly handling the log messages
-
-If you're seeing duplicate logs:
-
-1. Make sure you're not creating multiple instances of StagehandLogger that log to the same output
-2. If providing a custom logger to Stagehand, it will automatically disable the internal Pino logger
-
-If logs are not being written to files:
-
-1. Ensure you have write permissions to the target directory
-2. Check that the `logInferenceToFile` option is enabled
-3. Verify that the destination path exists or can be created
diff --git a/docs/release.md b/docs/release.md
deleted file mode 100644
index 2a0402a1a..000000000
--- a/docs/release.md
+++ /dev/null
@@ -1,117 +0,0 @@
-# Releasing
-
-We use [Changesets](https://github.com/changesets/changesets) to version and release our packages.
-
-When we merge to main, the release workflow will:
-
-1. Create a release pull request with:
-   - A version bump for the package calculated by the changesets.
-   - A changelog entry summarizing the changes in the release.
-1. Create an `alpha` version of the package with whatever is merged to main, and you can install it with `npm install @browserbasehq/stagehand@alpha`. This is useful for testing the release before it's published to the `latest` tag.
-
-When the pull request is merged, the release workflow will publish the package to npm with the version calculated by the changesets.
-
-For more information on how changesets work, see the [changesets docs](https://github.com/changesets/changesets) and our [release.yml file](/.github/workflows/release.yml).
-
-# Manually Releasing
-
-> [!WARNING]
-> You should not need to manually release unless absolutely necessary. Our automated release workflow handles this for you when changes are merged to main.
-
-When you're ready to cut a release, start by versioning the packages:
-
-```
-npx changeset version
-```
-
-This will consume the changesets in [`.changeset`](../.changeset) and update the [changelog](../CHANGELOG.md) and [`package.json`](../package.json):
-
-```
-% git status --short
- M CHANGELOG.md
- M package.json
-```
-
-Based on the versions implications declared by the changesets, the package version will be updated to the next patch, minor, or major:
-
-```diff
-   "name": "@browserbasehq/stagehand",
--  "version": "1.3.0",
-+  "version": "1.3.1",
-```
-
-Since we updated the `package.json`, we should also update the lockfile ([`package-lock.json`](../package-lock.json)) for tidiness:
-
-```
-npm install
-```
-
-Now the lockfile should be updated:
-
-```
-% git status --short
- M CHANGELOG.md
- M package-lock.json
- M package.json
-```
-
-The diff will look something like this:
-
-```diff
- {
-   "name": "@browserbasehq/stagehand",
--  "version": "1.3.0",
-+  "version": "1.3.1",
-   "lockfileVersion": 3,
-   "requires": true,
-   "packages": {
-     "": {
-       "name": "@browserbasehq/stagehand",
--      "version": "1.3.0",
-+      "version": "1.3.1",
-```
-
-At this point we're ready to commit our changes.
-It's probably a good idea to have some consistency around the name of this commit message:
-
-```
-git commit -am 'Version Packages'
-```
-
-Ok, now it's time to publish the release.
-Before we do, we have to build the artifacts that comprise the tarball.
-Let's clean our working directory first so that we don't accidentally include anything in the tarball that shouldn't be there:
-
-```
-% git clean -fxd -e .env
-Removing dist/
-Removing lib/dom/build/
-Removing node_modules/
-```
-
-Let's reinstall dependencies and build the artifacts:
-
-```
-npm install && npm run build
-```
-
-Now we're ready to publish to NPM. You have to be logged in via the `npm` CLI and have to be part of the `@browserbasehq` org:
-
-```
-npx changeset publish
-```
-
-Congratulations! You just published a new version of `@browserbasehq/stagehand`. 🤘
-
-In the process of publishing, Changesets created an [annotated git tag](https://git-scm.com/book/en/v2/Git-Basics-Tagging):
-
-```
-🦋  Creating git tag...
-🦋  New tag:  v1.3.1
-```
-
-Let's push the commit and tag to GitHub for posterity:
-
-```
-git push --follow-tags
-```
diff --git a/eslint.config.mjs b/eslint.config.mjs
index c0d192cde..f525029b1 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -1,12 +1,76 @@
 import globals from "globals";
 import pluginJs from "@eslint/js";
 import tseslint from "typescript-eslint";
+import security from "eslint-plugin-security";
 
 /** @type {import('eslint').Linter.Config[]} */
 export default [
   { files: ["**/*.{js,mjs,cjs,ts}"] },
   { languageOptions: { globals: globals.browser } },
-  { ignores: ["**/dist/**", "lib/dom/build/**"] },
+  {
+    files: ["packages/core/scripts/**/*.{js,cjs,mjs}"],
+    languageOptions: { globals: globals.node },
+  },
+  {
+    files: [
+      "packages/server-v3/scripts/**/*.{js,cjs,mjs,ts}",
+      "packages/server-v4/scripts/**/*.{js,cjs,mjs,ts}",
+    ],
+    languageOptions: { globals: globals.node },
+  },
+  {
+    ignores: [
+      "**/dist/**",
+      "**/node_modules/**",
+      "packages/core/lib/dom/build/**",
+      "packages/core/lib/v3/dom/build/**",
+      "packages/core/lib/v4/dom/build/**",
+      "packages/core/scripts/prepare.js",
+      "**/*.config.js",
+      "**/*.config.mjs",
+      ".browserbase/**",
+      "**/.browserbase/**",
+      "**/*.json",
+      "stainless.yml",
+      "packages/server-v3/openapi.v3.yaml",
+      "packages/server-v4/openapi.v4.yaml",
+    ],
+  },
   pluginJs.configs.recommended,
   ...tseslint.configs.recommended,
+  {
+    plugins: {
+      security,
+    },
+    rules: {
+      "no-eval": "error",
+      "no-implied-eval": "error",
+      "no-new-func": "error",
+      "security/detect-eval-with-expression": "error",
+      "preserve-caught-error": "error",
+      "no-restricted-syntax": [
+        "error",
+        {
+          selector: "CallExpression[callee.name='Function']",
+          message: "Dynamic function construction is prohibited.",
+        },
+        {
+          selector: "NewExpression[callee.name='Function']",
+          message: "Dynamic function construction is prohibited.",
+        },
+        {
+          selector:
+            "CallExpression[callee.object.name='window'][callee.property.name='Function']",
+          message:
+            "Dynamic function construction via window.Function is prohibited.",
+        },
+        {
+          selector:
+            "CallExpression[callee.object.name='globalThis'][callee.property.name='Function']",
+          message:
+            "Dynamic function construction via globalThis.Function is prohibited.",
+        },
+      ],
+    },
+  },
 ];
diff --git a/evals/args.ts b/evals/args.ts
deleted file mode 100644
index 4c2f748fc..000000000
--- a/evals/args.ts
+++ /dev/null
@@ -1,110 +0,0 @@
-import process from "process";
-import { EvalCategorySchema } from "@/types/evals";
-
-const rawArgs = process.argv.slice(2);
-
-const parsedArgs: {
-  env?: string;
-  trials?: number;
-  concurrency?: number;
-  extractMethod?: string;
-  provider?: string;
-  leftover: string[];
-} = {
-  leftover: [],
-};
-
-for (const arg of rawArgs) {
-  if (arg.startsWith("env=")) {
-    parsedArgs.env = arg.split("=")[1]?.toLowerCase();
-  } else if (arg.startsWith("trials=")) {
-    const val = parseInt(arg.split("=")[1], 10);
-    if (!isNaN(val)) {
-      parsedArgs.trials = val;
-    }
-  } else if (arg.startsWith("concurrency=")) {
-    const val = parseInt(arg.split("=")[1], 10);
-    if (!isNaN(val)) {
-      parsedArgs.concurrency = val;
-    }
-  } else if (arg.startsWith("--extract-method=")) {
-    parsedArgs.extractMethod = arg.split("=")[1];
-  } else if (arg.startsWith("provider=")) {
-    parsedArgs.provider = arg.split("=")[1]?.toLowerCase();
-  } else {
-    parsedArgs.leftover.push(arg);
-  }
-}
-
-/** Apply environment defaults or overrides */
-if (parsedArgs.env === "browserbase") {
-  process.env.EVAL_ENV = "BROWSERBASE";
-} else if (parsedArgs.env === "local") {
-  process.env.EVAL_ENV = "LOCAL";
-}
-
-if (parsedArgs.trials !== undefined) {
-  process.env.EVAL_TRIAL_COUNT = String(parsedArgs.trials);
-}
-if (parsedArgs.concurrency !== undefined) {
-  process.env.EVAL_MAX_CONCURRENCY = String(parsedArgs.concurrency);
-}
-
-const extractMethod = parsedArgs.extractMethod || "domExtract";
-process.env.EXTRACT_METHOD = extractMethod;
-
-const useTextExtract = extractMethod === "textExtract";
-const useAccessibilityTree = extractMethod === "accessibilityTree";
-
-const DEFAULT_EVAL_CATEGORIES = process.env.EVAL_CATEGORIES
-  ? process.env.EVAL_CATEGORIES.split(",")
-  : [
-      "observe",
-      "act",
-      "combination",
-      "extract",
-      "experimental",
-      "text_extract",
-      "targeted_extract",
-      "regression_llm_providers",
-      "regression",
-      "llm_clients",
-    ];
-
-// Finally, interpret leftover arguments to see if user typed "category X" or a single eval name
-let filterByCategory: string | null = null;
-let filterByEvalName: string | null = null;
-
-if (parsedArgs.leftover.length > 0) {
-  if (parsedArgs.leftover[0].toLowerCase() === "category") {
-    filterByCategory = parsedArgs.leftover[1];
-    if (!filterByCategory) {
-      console.error("Error: Category name not specified.");
-      process.exit(1);
-    }
-    try {
-      EvalCategorySchema.parse(filterByCategory);
-    } catch {
-      console.error(
-        `Error: Invalid category "${filterByCategory}". Valid categories are: ${DEFAULT_EVAL_CATEGORIES.join(", ")}`,
-      );
-      process.exit(1);
-    }
-  } else {
-    // If leftover[0] is not "category", interpret it as a task/eval name
-    filterByEvalName = parsedArgs.leftover[0];
-  }
-}
-
-if (parsedArgs.provider !== undefined) {
-  process.env.EVAL_PROVIDER = parsedArgs.provider;
-}
-
-export {
-  filterByCategory,
-  filterByEvalName,
-  useTextExtract,
-  useAccessibilityTree,
-  DEFAULT_EVAL_CATEGORIES,
-  parsedArgs,
-};
diff --git a/evals/deterministic/auxiliary/logo.png b/evals/deterministic/auxiliary/logo.png
deleted file mode 100644
index 7ae5d4850..000000000
Binary files a/evals/deterministic/auxiliary/logo.png and /dev/null differ
diff --git a/evals/deterministic/bb.playwright.config.ts b/evals/deterministic/bb.playwright.config.ts
deleted file mode 100644
index cea358f55..000000000
--- a/evals/deterministic/bb.playwright.config.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import { defineConfig, devices } from "@playwright/test";
-
-/**
- * See https://playwright.dev/docs/test-configuration.
- */
-export default defineConfig({
-  testDir: "./tests/browserbase",
-
-  /* Fail the build on CI if you accidentally left test.only in the source code. */
-  /* Run tests in files in parallel */
-  fullyParallel: true,
-  /* Reporter to use. See https://playwright.dev/docs/test-reporters */
-  //   reporter: "html",
-  reporter: "line",
-  /* Retry on CI only */
-  retries: 2,
-
-  /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
-  use: {
-    /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
-    trace: "on-first-retry",
-  },
-
-  /* Configure projects for major browsers */
-  projects: [
-    {
-      name: "chromium",
-      use: { ...devices["Desktop Chrome"] },
-    },
-  ],
-});
diff --git a/evals/deterministic/e2e.playwright.config.ts b/evals/deterministic/e2e.playwright.config.ts
deleted file mode 100644
index 4ed3c2594..000000000
--- a/evals/deterministic/e2e.playwright.config.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import { defineConfig, devices } from "@playwright/test";
-
-/**
- * See https://playwright.dev/docs/test-configuration.
- */
-export default defineConfig({
-  // Look in "tests" for test files...
-  testDir: "./tests",
-  // ...but ignore anything in "tests/browserbase & "tests/local"
-  testIgnore: ["**/browserbase/**", "**/local/**"],
-
-  /* Fail the build on CI if you accidentally left test.only in the source code. */
-  /* Run tests in files in parallel */
-  fullyParallel: true,
-  /* Reporter to use. See https://playwright.dev/docs/test-reporters */
-  //   reporter: "html",
-  reporter: "line",
-  retries: 2,
-
-  /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
-  use: {
-    /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
-    trace: "on-first-retry",
-  },
-
-  /* Configure projects for major browsers */
-  projects: [
-    {
-      name: "chromium",
-      use: { ...devices["Desktop Chrome"] },
-    },
-  ],
-});
diff --git a/evals/deterministic/local.playwright.config.ts b/evals/deterministic/local.playwright.config.ts
deleted file mode 100644
index 3c309ff70..000000000
--- a/evals/deterministic/local.playwright.config.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { defineConfig, devices } from "@playwright/test";
-
-/**
- * See https://playwright.dev/docs/test-configuration.
- */
-export default defineConfig({
-  testDir: "./tests/local",
-
-  /* Maximum time one test can run for. */
-  timeout: 30 * 1000,
-
-  /* Fail the build on CI if you accidentally left test.only in the source code. */
-  forbidOnly: !!process.env.CI,
-
-  /* Run tests in files in parallel */
-  fullyParallel: false,
-
-  /* Reporter to use */
-  reporter: "line",
-
-  /* Retry on CI only */
-  retries: process.env.CI ? 2 : 0,
-
-  /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
-  use: {
-    /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
-    trace: "on-first-retry",
-  },
-
-  /* Configure projects for major browsers */
-  projects: [
-    {
-      name: "chromium",
-      use: { ...devices["Desktop Chrome"] },
-    },
-  ],
-});
diff --git a/evals/deterministic/stagehand.config.ts b/evals/deterministic/stagehand.config.ts
deleted file mode 100644
index a7bcbb644..000000000
--- a/evals/deterministic/stagehand.config.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import { default as DefaultStagehandConfig } from "@/stagehand.config";
-import type { ConstructorParams } from "@/dist";
-import dotenv from "dotenv";
-dotenv.config({ path: "../../.env" });
-
-const StagehandConfig: ConstructorParams = {
-  ...DefaultStagehandConfig,
-  env: "LOCAL" /* Environment to run Stagehand in */,
-  verbose: 1 /* Logging verbosity level (0=quiet, 1=normal, 2=verbose) */,
-  browserbaseSessionCreateParams: {
-    projectId: process.env.BROWSERBASE_PROJECT_ID,
-  },
-  enableCaching: false /* Enable caching functionality */,
-  localBrowserLaunchOptions: {
-    headless: true /* Run browser in headless mode */,
-  },
-};
-export default StagehandConfig;
diff --git a/evals/deterministic/tests/BrowserContext/addInitScript.test.ts b/evals/deterministic/tests/BrowserContext/addInitScript.test.ts
deleted file mode 100644
index cf78933c2..000000000
--- a/evals/deterministic/tests/BrowserContext/addInitScript.test.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-test.describe("StagehandContext - addInitScript", () => {
-  test("should inject a script on the context before pages load", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const context = stagehand.context;
-
-    await context.addInitScript(() => {
-      const w = window as typeof window & {
-        __testContextScriptVar?: string;
-      };
-      w.__testContextScriptVar = "Hello from context.initScript!";
-    });
-
-    const pageA = await context.newPage();
-    await pageA.goto("https://example.com");
-
-    const resultA = await pageA.evaluate(() => {
-      const w = window as typeof window & {
-        __testContextScriptVar?: string;
-      };
-      return w.__testContextScriptVar;
-    });
-    expect(resultA).toBe("Hello from context.initScript!");
-
-    const pageB = await context.newPage();
-    await pageB.goto("https://docs.browserbase.com");
-
-    const resultB = await pageB.evaluate(() => {
-      const w = window as typeof window & {
-        __testContextScriptVar?: string;
-      };
-      return w.__testContextScriptVar;
-    });
-    expect(resultB).toBe("Hello from context.initScript!");
-
-    await stagehand.close();
-  });
-});
diff --git a/evals/deterministic/tests/BrowserContext/cookies.test.ts b/evals/deterministic/tests/BrowserContext/cookies.test.ts
deleted file mode 100644
index b42c04507..000000000
--- a/evals/deterministic/tests/BrowserContext/cookies.test.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-test.describe("StagehandContext - Cookies", () => {
-  let stagehand: Stagehand;
-
-  test.beforeEach(async () => {
-    stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-  });
-
-  test.afterEach(async () => {
-    await stagehand.close();
-  });
-
-  test("should add cookies and retrieve them", async () => {
-    const context = stagehand.context; // This is the wrapped BrowserContext
-    const url = "https://example.com";
-
-    await context.addCookies([
-      {
-        name: "myCookie",
-        value: "myValue",
-        domain: "example.com",
-        path: "/",
-        expires: Math.floor(Date.now() / 1000) + 3600,
-        httpOnly: false,
-        secure: false,
-        sameSite: "Lax",
-      },
-    ]);
-
-    const cookies = await context.cookies(url);
-    expect(cookies.length).toBeGreaterThan(0);
-
-    const myCookie = cookies.find((c) => c.name === "myCookie");
-    expect(myCookie).toBeDefined();
-    expect(myCookie?.value).toBe("myValue");
-  });
-
-  test("should clear all cookies", async () => {
-    const context = stagehand.context;
-    const url = "https://example.com";
-
-    await context.addCookies([
-      {
-        name: "myOtherCookie",
-        value: "anotherValue",
-        domain: "example.com",
-        path: "/",
-        expires: Math.floor(Date.now() / 1000) + 3600,
-        httpOnly: false,
-        secure: false,
-        sameSite: "Lax",
-      },
-    ]);
-
-    const cookiesBefore = await context.cookies(url);
-    const found = cookiesBefore.some((c) => c.name === "myOtherCookie");
-    expect(found).toBe(true);
-
-    await context.clearCookies();
-
-    const cookiesAfter = await context.cookies(url);
-    const stillFound = cookiesAfter.some((c) => c.name === "myOtherCookie");
-    expect(stillFound).toBe(false);
-  });
-});
diff --git a/evals/deterministic/tests/BrowserContext/multiPage.test.ts b/evals/deterministic/tests/BrowserContext/multiPage.test.ts
deleted file mode 100644
index b0b38cdf0..000000000
--- a/evals/deterministic/tests/BrowserContext/multiPage.test.ts
+++ /dev/null
@@ -1,209 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-import { Page } from "@/dist";
-
-import http from "http";
-import express from "express";
-import { Server as WebSocketServer } from "ws";
-
-test.describe("StagehandContext - Multi-page Support", () => {
-  let stagehand: Stagehand;
-  let server: http.Server;
-  let wss: WebSocketServer;
-  let serverPort: number;
-
-  test.beforeAll(async () => {
-    // Set up a local Express server
-    const app = express();
-
-    // Serve test pages
-    app.get("/page1", (_req, res) => {
-      res.set("Content-Type", "text/html");
-      res.end(`
-        <html>
-          <head><title>Page 1</title></head>
-          <body>
-            <h1>Page 1 Content</h1>
-            <button id="popupBtn" onclick="window.open('/page2', '_blank')">Open Page 2</button>
-          </body>
-        </html>
-      `);
-    });
-
-    app.get("/page2", (_req, res) => {
-      res.set("Content-Type", "text/html");
-      res.end(`
-        <html>
-          <head><title>Page 2</title></head>
-          <body>
-            <h1>Page 2 Content</h1>
-          </body>
-        </html>
-      `);
-    });
-
-    // Create the server on a random free port
-    server = http.createServer(app);
-    await new Promise<void>((resolve) => {
-      server.listen(0, () => resolve());
-    });
-    const address = server.address();
-    if (typeof address === "object" && address !== null) {
-      serverPort = address.port;
-    } else {
-      throw new Error("Failed to get server port");
-    }
-
-    // Set up WebSocket for future tests
-    wss = new WebSocketServer({ server, path: "/socket" });
-    wss.on("connection", (ws) => {
-      console.log("WebSocket client connected");
-      ws.send("Hello from server WebSocket");
-    });
-  });
-
-  test.beforeEach(async () => {
-    stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-  });
-
-  test.afterEach(async () => {
-    await stagehand.close();
-  });
-
-  test.afterAll(async () => {
-    wss?.close();
-    server?.close();
-  });
-
-  /**
-   * Test enhanced page capabilities
-   */
-  test("should provide enhanced capabilities for new pages", async () => {
-    const context = stagehand.context;
-    const newPage = await context.newPage();
-
-    // Verify enhanced methods
-    expect(typeof newPage.act).toBe("function");
-    expect(typeof newPage.extract).toBe("function");
-    expect(typeof newPage.observe).toBe("function");
-
-    // Verify basic Playwright functionality
-    expect(typeof newPage.goto).toBe("function");
-    expect(typeof newPage.click).toBe("function");
-
-    // Test navigation maintains capabilities
-    await newPage.goto(`http://localhost:${serverPort}/page1`);
-    expect(typeof newPage.act).toBe("function");
-    expect(await newPage.title()).toBe("Page 1");
-  });
-
-  /**
-   * Test context.pages() functionality
-   */
-  test("should return array of enhanced pages via context.pages()", async () => {
-    const context = stagehand.context;
-
-    // Create multiple pages
-    const page1 = await context.newPage();
-    const page2 = await context.newPage();
-
-    await page1.goto(`http://localhost:${serverPort}/page1`);
-    await page2.goto(`http://localhost:${serverPort}/page2`);
-
-    const pages = context.pages();
-    expect(pages).toContain(page1);
-    expect(pages).toContain(page2);
-
-    // Verify all pages have enhanced capabilities
-    for (const page of pages) {
-      expect(typeof page.act).toBe("function");
-      expect(typeof page.extract).toBe("function");
-      expect(typeof page.observe).toBe("function");
-    }
-  });
-
-  /**
-   * Test popup handling
-   */
-  test("should handle popups with enhanced capabilities", async () => {
-    const mainPage = stagehand.page;
-    let popupPage: Page | null = null;
-
-    mainPage.on("popup", (page: Page) => {
-      popupPage = page;
-    });
-
-    await mainPage.goto(`http://localhost:${serverPort}/page1`);
-    await mainPage.click("#popupBtn");
-
-    // Verify popup has enhanced capabilities
-    expect(popupPage).not.toBeNull();
-    expect(typeof popupPage.act).toBe("function");
-    expect(typeof popupPage.extract).toBe("function");
-    expect(typeof popupPage.observe).toBe("function");
-
-    if (popupPage) {
-      await popupPage.waitForLoadState();
-      expect(await popupPage.title()).toBe("Page 2");
-    }
-  });
-
-  /**
-   * Test page tracking and cleanup
-   */
-  test("should properly track and cleanup pages", async () => {
-    const context = stagehand.context;
-    const initialPages = context.pages().length;
-
-    const newPage = await context.newPage();
-    await newPage.goto(`http://localhost:${serverPort}/page1`);
-
-    expect(context.pages().length).toBe(initialPages + 1);
-    await newPage.close();
-    expect(context.pages().length).toBe(initialPages);
-  });
-
-  /**
-   * Test enhanced methods across pages
-   */
-  test("should support enhanced methods across all pages", async () => {
-    const page1 = await stagehand.context.newPage();
-    const page2 = await stagehand.context.newPage();
-
-    await page1.goto(`http://localhost:${serverPort}/page1`);
-    await page2.goto(`http://localhost:${serverPort}/page2`);
-
-    // Verify both pages have enhanced capabilities
-    expect(typeof page1.act).toBe("function");
-    expect(typeof page1.extract).toBe("function");
-    expect(typeof page1.observe).toBe("function");
-
-    expect(typeof page2.act).toBe("function");
-    expect(typeof page2.extract).toBe("function");
-    expect(typeof page2.observe).toBe("function");
-  });
-
-  /**
-   * Test active page tracking
-   */
-  test("should update stagehand.page when creating new pages", async () => {
-    const initialPage = stagehand.page;
-
-    // Create a new page and verify it becomes active
-    const newPage = await stagehand.context.newPage();
-    expect(stagehand.page).toBe(newPage);
-    expect(stagehand.page).not.toBe(initialPage);
-
-    // Navigate and verify it's still the active page
-    await newPage.goto(`http://localhost:${serverPort}/page1`);
-    expect(stagehand.page).toBe(newPage);
-    expect(await stagehand.page.title()).toBe("Page 1");
-
-    // Create another page and verify it becomes active
-    const anotherPage = await stagehand.context.newPage();
-    expect(stagehand.page).toBe(anotherPage);
-    expect(stagehand.page).not.toBe(newPage);
-  });
-});
diff --git a/evals/deterministic/tests/BrowserContext/page.test.ts b/evals/deterministic/tests/BrowserContext/page.test.ts
deleted file mode 100644
index f6c7aca58..000000000
--- a/evals/deterministic/tests/BrowserContext/page.test.ts
+++ /dev/null
@@ -1,100 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-import http from "http";
-import express from "express";
-import { Server as WebSocketServer } from "ws";
-
-test.describe("StagehandContext - pages and newPage", () => {
-  let stagehand: Stagehand;
-  let server: http.Server;
-  let wss: WebSocketServer;
-  let serverPort: number;
-
-  test.beforeAll(async () => {
-    // 1. Spin up a local Express server
-    const app = express();
-
-    // Serve a single page at "/"
-    app.get("/", (_req, res) => {
-      res.set("Content-Type", "text/html");
-      res.end(`
-        <html>
-          <head>
-            <title>Test Page</title>
-          </head>
-          <body>
-            <h1>Hello from local server</h1>
-            <script>
-              // Optionally register a service worker if you want it for demo:
-              if ('serviceWorker' in navigator) {
-                navigator.serviceWorker.register('/sw.js')
-                  .then(() => console.log('SW registered'))
-                  .catch(e => console.error('SW failed', e));
-              }
-            </script>
-          </body>
-        </html>
-      `);
-    });
-
-    // Create the server on a random free port
-    server = http.createServer(app);
-    await new Promise<void>((resolve) => {
-      server.listen(0, () => resolve());
-    });
-    const address = server.address();
-    if (typeof address === "object" && address !== null) {
-      serverPort = address.port;
-    } else {
-      throw new Error("Failed to get server port");
-    }
-
-    // Optionally set up a WebSocket for future tests
-    wss = new WebSocketServer({ server, path: "/socket" });
-    wss.on("connection", (ws) => {
-      console.log("WebSocket client connected");
-      ws.send("Hello from server WebSocket");
-    });
-  });
-
-  test.beforeEach(async () => {
-    // 2. Create & init Stagehand for each test
-    stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-  });
-
-  test.afterEach(async () => {
-    await stagehand.close();
-  });
-
-  test.afterAll(async () => {
-    // Shut down local server
-    wss?.close();
-    server?.close();
-  });
-
-  /**
-   * Test context.newPage() and context.pages()
-   */
-  test("should create multiple pages and list them via context.pages()", async () => {
-    const context = stagehand.context;
-
-    // Create multiple pages
-    const page1 = await context.newPage();
-    const page2 = await context.newPage();
-
-    // Confirm context.pages() sees them
-    const allPages = context.pages();
-
-    // We expect at least these 2 pages. If a default blank page existed, total might be more.
-    // The key is that page1 & page2 are in the array:
-    expect(allPages).toContain(page1);
-    expect(allPages).toContain(page2);
-
-    // Navigate page1 to the local server
-    await page1.goto(`http://localhost:${serverPort}`);
-    expect(await page1.title()).toBe("Test Page");
-  });
-});
diff --git a/evals/deterministic/tests/BrowserContext/routing.test.ts b/evals/deterministic/tests/BrowserContext/routing.test.ts
deleted file mode 100644
index 1dd53664d..000000000
--- a/evals/deterministic/tests/BrowserContext/routing.test.ts
+++ /dev/null
@@ -1,236 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-import http from "http";
-import express from "express";
-import { Server as WebSocketServer } from "ws";
-import fs from "fs";
-import path from "path";
-
-const HAR_CONTENT = `{
-  "log": {
-    "version": "1.2",
-    "creator": { "name": "PlaywrightTest", "version": "1.0" },
-    "entries": [
-      {
-        "startedDateTime": "2023-01-01T00:00:00.000Z",
-        "time": 5,
-        "request": {
-          "method": "GET",
-          "url": "http://localhost/har-example.json",
-          "httpVersion": "HTTP/1.1",
-          "cookies": [],
-          "headers": [],
-          "queryString": [],
-          "headersSize": -1,
-          "bodySize": 0
-        },
-        "response": {
-          "status": 200,
-          "statusText": "OK",
-          "httpVersion": "HTTP/1.1",
-          "cookies": [],
-          "headers": [{"name":"Content-Type","value":"application/json"}],
-          "content": {
-            "size": 27,
-            "mimeType": "application/json",
-            "text": "{\\"harKey\\":\\"harValue\\"}"
-          },
-          "redirectURL": "",
-          "headersSize": -1,
-          "bodySize": 0
-        },
-        "cache": {},
-        "timings": { "send": 0, "wait": 5, "receive": 0 }
-      }
-    ]
-  }
-}`;
-
-test.describe("StagehandContext - Routing APIs with dynamic setup", () => {
-  let stagehand: Stagehand;
-  let server: http.Server;
-  let wss: WebSocketServer;
-  let serverPort: number;
-
-  test.beforeAll(async () => {
-    const app = express();
-
-    app.get("/example.json", (_req, res) => {
-      res.json({ original: "server-data" });
-    });
-
-    app.get("/har-example.json", (_req, res) => {
-      res.json({
-        fromServer:
-          "This should be replaced by HAR if routeFromHar is in effect",
-      });
-    });
-
-    server = http.createServer(app);
-    await new Promise<void>((resolve) => {
-      server.listen(0, () => resolve());
-    });
-    const address = server.address();
-    if (typeof address === "object" && address !== null) {
-      serverPort = address.port;
-    } else {
-      throw new Error("Failed to get server port");
-    }
-
-    // Set up a WebSocket endpoint at "/socket"
-    wss = new WebSocketServer({ server, path: "/socket" });
-    wss.on("connection", (ws) => {
-      console.log("WebSocket client connected");
-      ws.send("Hello from server WebSocket");
-
-      // Echo messages back
-      ws.on("message", (message) => {
-        console.log("Server received WS message:", message);
-        ws.send(`Server echo: ${message}`);
-      });
-    });
-  });
-
-  test.beforeEach(async () => {
-    stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-  });
-
-  test.afterEach(async () => {
-    await stagehand.close();
-  });
-
-  test.afterAll(async () => {
-    wss?.close();
-    server?.close();
-  });
-
-  test("should intercept requests, mock the response, handle websockets, and unroute them", async () => {
-    const context = stagehand.context;
-    const baseURL = `http://localhost:${serverPort}`;
-
-    // 1. route: intercept "/example.json" and fulfill with a mock response
-    await context.route("**/example.json", async (route) => {
-      console.log("[route] Intercepting:", route.request().url());
-
-      // Mock the response entirely:
-      await route.fulfill({
-        status: 200,
-        contentType: "application/json",
-        body: JSON.stringify({ mockedData: 1234 }),
-      });
-    });
-
-    // 2. routeWebSocket: intercept "/socket"
-    await context.routeWebSocket("**/socket", async (pageSideRoute) => {
-      console.log("Intercepting WebSocket at:", pageSideRoute.url());
-
-      // Connect to the real server
-      const serverSideRoute = pageSideRoute.connectToServer();
-
-      // Page -> Server
-      pageSideRoute.onMessage((msg) => {
-        console.log("Page -> Server message:", msg);
-        // Forward to server side
-        serverSideRoute.send(msg);
-      });
-
-      // Server -> Page
-      serverSideRoute.onMessage((msg) => {
-        console.log("Server -> Page message:", msg);
-        pageSideRoute.send(msg);
-      });
-    });
-
-    // 3. Open a page and fetch /example.json
-    const page = await context.newPage();
-    await page.goto(baseURL);
-
-    const fetchResult = await page.evaluate(async () => {
-      const res = await fetch("/example.json");
-      return res.json();
-    });
-    // We should get the mocked data from our route, not the real 'server-data'
-    expect(fetchResult.mockedData).toBe(1234);
-
-    // 4. Test the WebSocket
-    // We'll store messages from the server in an array so we can assert them
-    const wsMessages: string[] = [];
-    page.on("console", (msg) => {
-      // We'll parse out the console logs we used for WebSocket
-      if (msg.type() === "log") {
-        wsMessages.push(msg.text());
-      }
-    });
-
-    // Create a WS from the page
-    await page.evaluate((port) => {
-      const ws = new WebSocket(`ws://localhost:${port}/socket`);
-      ws.onmessage = (evt) => {
-        console.log(`WS message from server: ${evt.data}`);
-      };
-      setTimeout(() => {
-        // send a message from the page side
-        ws.send("Hello from the client");
-      }, 1000);
-    }, serverPort);
-
-    // Wait a moment for messages
-    await page.waitForTimeout(3000);
-
-    // We expect the server to have initially sent "Hello from server WebSocket"
-    // And also an echo of "Hello from the client" => "Server echo: Hello from the client"
-    const initialHello = wsMessages.find((m) =>
-      m.includes("Hello from server WebSocket"),
-    );
-    expect(initialHello).toBeTruthy();
-
-    const echoMessage = wsMessages.find((m) =>
-      m.includes("Server echo: Hello from the client"),
-    );
-    expect(echoMessage).toBeTruthy();
-
-    // 5. unroute the JSON route
-    await context.unroute("**/example.json");
-
-    // 6. confirm the WebSocket route is still active
-    // do a second fetch -> This time it won't be mocked
-    const fetchResult2 = await page.evaluate(async () => {
-      const res = await fetch("/example.json");
-      return res.json();
-    });
-    // The real server returns { original: "server-data" }
-    expect(fetchResult2.original).toBe("server-data");
-
-    // 7. unrouteAll
-    await context.unrouteAll();
-  });
-
-  test("should demonstrate routeFromHar usage", async () => {
-    const harPath = path.join(__dirname, "tmp-test.har");
-
-    const dynamicHar = HAR_CONTENT.replace(
-      "http://localhost/har-example.json",
-      `http://localhost:${serverPort}/har-example.json`,
-    );
-
-    fs.writeFileSync(harPath, dynamicHar, "utf-8");
-
-    const context = stagehand.context;
-
-    await context.routeFromHAR(harPath, { update: false });
-
-    const page = await context.newPage();
-    await page.goto(`http://localhost:${serverPort}/har-example.json`);
-
-    const bodyText = await page.evaluate(() => document.body.innerText);
-    console.log("HAR-based body text:", bodyText);
-    expect(bodyText).toContain("harKey");
-    expect(bodyText).toContain("harValue");
-
-    await context.unrouteAll();
-    fs.unlinkSync(harPath);
-  });
-});
diff --git a/evals/deterministic/tests/Errors/apiKeyError.test.ts b/evals/deterministic/tests/Errors/apiKeyError.test.ts
deleted file mode 100644
index 2cdc6656f..000000000
--- a/evals/deterministic/tests/Errors/apiKeyError.test.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-import { z } from "zod";
-
-test.describe("API key/LLMClient error", () => {
-  test("Should confirm that we get an error if we call extract without LLM API key or LLMClient", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-    await stagehand.page.goto("https://docs.browserbase.com/introduction");
-
-    let errorThrown: Error | null = null;
-
-    try {
-      await stagehand.page.extract({
-        instruction:
-          "From the introduction page, extract the explanation of what Browserbase is.",
-        schema: z.object({
-          stars: z.string().describe("the explanation of what Browserbase is"),
-        }),
-      });
-    } catch (error) {
-      errorThrown = error as Error;
-    }
-
-    expect(errorThrown).toBeInstanceOf(Error);
-    expect(errorThrown?.message).toContain(
-      "No LLM API key or LLM Client configured",
-    );
-
-    await stagehand.close();
-  });
-
-  test("Should confirm that we get an error if we call act without LLM API key or LLMClient", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-    await stagehand.page.goto("https://docs.browserbase.com/introduction");
-
-    let errorThrown: Error | null = null;
-
-    try {
-      await stagehand.page.act({
-        action: "Click on the 'Quickstart' section",
-      });
-    } catch (error) {
-      errorThrown = error as Error;
-    }
-
-    expect(errorThrown).toBeInstanceOf(Error);
-    expect(errorThrown?.message).toContain(
-      "No LLM API key or LLM Client configured",
-    );
-
-    await stagehand.close();
-  });
-
-  test("Should confirm that we get an error if we call observe without LLM API key or LLMClient", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-    await stagehand.page.goto("https://docs.browserbase.com/introduction");
-
-    let errorThrown: Error | null = null;
-
-    try {
-      await stagehand.page.observe();
-    } catch (error) {
-      errorThrown = error as Error;
-    }
-
-    expect(errorThrown).toBeInstanceOf(Error);
-    expect(errorThrown?.message).toContain(
-      "No LLM API key or LLM Client configured",
-    );
-
-    await stagehand.close();
-  });
-});
diff --git a/evals/deterministic/tests/browserbase/contexts.test.ts b/evals/deterministic/tests/browserbase/contexts.test.ts
deleted file mode 100644
index 0f8ecea9c..000000000
--- a/evals/deterministic/tests/browserbase/contexts.test.ts
+++ /dev/null
@@ -1,145 +0,0 @@
-import Browserbase from "@browserbasehq/sdk";
-import { expect, test } from "@playwright/test";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-import { Stagehand } from "@/dist";
-
-// Configuration
-const CONTEXT_TEST_URL = "https://docs.browserbase.com";
-const BROWSERBASE_PROJECT_ID = process.env.BROWSERBASE_PROJECT_ID!;
-const BROWSERBASE_API_KEY = process.env.BROWSERBASE_API_KEY!;
-
-const bb = new Browserbase({
-  apiKey: BROWSERBASE_API_KEY,
-});
-
-// Helper functions
-function addHour(date: Date): number {
-  const SECOND = 1000;
-  return new Date(date.getTime() + 60 * 60 * 1000).getTime() / SECOND;
-}
-
-async function findCookie(stagehand: Stagehand, name: string) {
-  const defaultContext = stagehand.context;
-  const cookies = await defaultContext?.cookies();
-  return cookies?.find((cookie) => cookie.name === name);
-}
-
-async function createContext() {
-  console.log("Creating a new context...");
-  const context = await bb.contexts.create({
-    projectId: BROWSERBASE_PROJECT_ID,
-  });
-  const contextId = context.id;
-  console.log(`Context created with ID: ${contextId}`);
-  return contextId;
-}
-
-async function setRandomCookie(contextId: string, stagehand: Stagehand) {
-  console.log(
-    `Populating context ${contextId} during session ${stagehand.browserbaseSessionID}`,
-  );
-  const page = stagehand.page;
-
-  await page.goto(CONTEXT_TEST_URL, { waitUntil: "domcontentloaded" });
-
-  const now = new Date();
-  const testCookieName = `bb_${now.getTime().toString()}`;
-  const testCookieValue = now.toISOString();
-
-  await stagehand.context.addCookies([
-    {
-      domain: `.${new URL(CONTEXT_TEST_URL).hostname}`,
-      expires: addHour(now),
-      name: testCookieName,
-      path: "/",
-      value: testCookieValue,
-    },
-  ]);
-
-  expect(findCookie(stagehand, testCookieName)).toBeDefined();
-  console.log(`Set test cookie: ${testCookieName}=${testCookieValue}`);
-  return { testCookieName, testCookieValue };
-}
-
-test.describe("Contexts", () => {
-  test("Persists and re-uses a context", async () => {
-    let contextId: string;
-    let testCookieName: string;
-    let testCookieValue: string;
-    let stagehand: Stagehand;
-
-    await test.step("Create a context", async () => {
-      contextId = await createContext();
-    });
-
-    await test.step("Instantiate Stagehand with the context to persist", async () => {
-      // We will be adding cookies to the context in this session, so we need mark persist=true
-      stagehand = new Stagehand({
-        ...StagehandConfig,
-        browserbaseSessionCreateParams: {
-          projectId: BROWSERBASE_PROJECT_ID,
-          browserSettings: {
-            context: {
-              id: contextId,
-              persist: true,
-            },
-          },
-        },
-      });
-      await stagehand.init();
-    });
-
-    await test.step("Set a random cookie on the page", async () => {
-      ({ testCookieName } = await setRandomCookie(contextId, stagehand));
-
-      const page = stagehand.page;
-      await page.goto("https://www.google.com", {
-        waitUntil: "domcontentloaded",
-      });
-      await page.goBack();
-    });
-
-    await test.step("Validate cookie persistence between pages", async () => {
-      const cookie = await findCookie(stagehand, testCookieName);
-      const found = !!cookie;
-      expect(found).toBe(true);
-      console.log("Cookie persisted between pages:", found);
-
-      await stagehand.close();
-      // Wait for context to persist
-      console.log("Waiting for context to persist...");
-      await new Promise((resolve) => setTimeout(resolve, 5000));
-    });
-
-    await test.step("Create another session with the same context", async () => {
-      // We don't need to persist cookies in this session, so we can mark persist=false
-      const newStagehand = new Stagehand({
-        ...StagehandConfig,
-        browserbaseSessionCreateParams: {
-          projectId: BROWSERBASE_PROJECT_ID,
-          browserSettings: {
-            context: {
-              id: contextId,
-              persist: false,
-            },
-          },
-        },
-      });
-      await newStagehand.init();
-      console.log(
-        `Reusing context ${contextId} during session ${newStagehand.browserbaseSessionID}`,
-      );
-      const newPage = newStagehand.page;
-      await newPage.goto(CONTEXT_TEST_URL, { waitUntil: "domcontentloaded" });
-
-      const foundCookie = await findCookie(newStagehand, testCookieName);
-      console.log("Cookie found in new session:", !!foundCookie);
-      console.log(
-        "Cookie value matches:",
-        foundCookie?.value === testCookieValue,
-      );
-
-      await newStagehand.close();
-    });
-  });
-});
diff --git a/evals/deterministic/tests/browserbase/downloads.test.ts b/evals/deterministic/tests/browserbase/downloads.test.ts
deleted file mode 100644
index 10366b6cd..000000000
--- a/evals/deterministic/tests/browserbase/downloads.test.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-import { test, expect } from "@playwright/test";
-import AdmZip from "adm-zip";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-import { Stagehand } from "@/dist";
-import Browserbase from "@browserbasehq/sdk";
-
-const downloadRe = /sandstorm-(\d{13})+\.mp3/;
-
-test("Downloads", async () => {
-  const stagehand = new Stagehand(StagehandConfig);
-  await stagehand.init();
-  const page = stagehand.page;
-  const context = stagehand.context;
-
-  const client = await context.newCDPSession(page);
-  await client.send("Browser.setDownloadBehavior", {
-    behavior: "allow",
-    // `downloadPath` gets appended to the browser's default download directory.
-    // set to "downloads", it ends up being "/app/apps/browser/downloads/<file>".
-    downloadPath: "downloads",
-    eventsEnabled: true,
-  });
-
-  await page.goto("https://browser-tests-alpha.vercel.app/api/download-test");
-
-  const [download] = await Promise.all([
-    page.waitForEvent("download"),
-    page.locator("#download").click(),
-  ]);
-
-  const downloadError = await download.failure();
-
-  await stagehand.close();
-
-  if (downloadError !== null) {
-    throw new Error(
-      `Download for session ${stagehand.browserbaseSessionID} failed: ${downloadError}`,
-    );
-  }
-
-  expect(async () => {
-    const bb = new Browserbase();
-    const zipBuffer = await bb.sessions.downloads.list(
-      stagehand.browserbaseSessionID,
-    );
-    if (!zipBuffer) {
-      throw new Error(
-        `Download buffer is empty for session ${stagehand.browserbaseSessionID}`,
-      );
-    }
-
-    const zip = new AdmZip(Buffer.from(await zipBuffer.arrayBuffer()));
-    const zipEntries = zip.getEntries();
-    const mp3Entry = zipEntries.find((entry) =>
-      downloadRe.test(entry.entryName),
-    );
-
-    if (!mp3Entry) {
-      throw new Error(
-        `Session ${stagehand.browserbaseSessionID} is missing a file matching "${downloadRe.toString()}" in its zip entries: ${JSON.stringify(zipEntries.map((entry) => entry.entryName))}`,
-      );
-    }
-
-    const expectedFileSize = 6137541;
-    expect(mp3Entry.header.size).toBe(expectedFileSize);
-  }).toPass({
-    timeout: 30_000,
-  });
-});
diff --git a/evals/deterministic/tests/browserbase/sessions.test.ts b/evals/deterministic/tests/browserbase/sessions.test.ts
deleted file mode 100644
index 67c97659c..000000000
--- a/evals/deterministic/tests/browserbase/sessions.test.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-import Browserbase from "@browserbasehq/sdk";
-
-test.describe("Browserbase Sessions", () => {
-  let browserbase: Browserbase;
-  let sessionId: string;
-  let bigStagehand: Stagehand;
-
-  test.beforeAll(async () => {
-    browserbase = new Browserbase({
-      apiKey: process.env.BROWSERBASE_API_KEY,
-    });
-    bigStagehand = new Stagehand({
-      ...StagehandConfig,
-      env: "BROWSERBASE",
-      browserbaseSessionCreateParams: {
-        projectId: process.env.BROWSERBASE_PROJECT_ID,
-        keepAlive: true,
-      },
-    });
-    await bigStagehand.init();
-    await bigStagehand.page.goto(
-      "https://docs.stagehand.dev/get_started/introduction",
-    );
-    sessionId = bigStagehand.browserbaseSessionID;
-    if (!sessionId) {
-      throw new Error("Failed to get browserbase session ID");
-    }
-  });
-  test.afterAll(async () => {
-    await bigStagehand.close();
-  });
-  test("resumes a session via sessionId", async () => {
-    const stagehand = new Stagehand({
-      ...StagehandConfig,
-      env: "BROWSERBASE",
-      browserbaseSessionID: sessionId,
-    });
-    await stagehand.init();
-
-    const page = stagehand.page;
-
-    expect(page.url()).toBe(
-      "https://docs.stagehand.dev/get_started/introduction",
-    );
-    await stagehand.close();
-  });
-  test("resumes a session via CDP URL", async () => {
-    const session = await browserbase.sessions.retrieve(sessionId);
-    const stagehand = new Stagehand({
-      ...StagehandConfig,
-      env: "LOCAL",
-      localBrowserLaunchOptions: {
-        headless: true,
-        cdpUrl: session.connectUrl,
-      },
-    });
-    await stagehand.init();
-    const page = stagehand.page;
-
-    expect(page.url()).toBe(
-      "https://docs.stagehand.dev/get_started/introduction",
-    );
-  });
-});
diff --git a/evals/deterministic/tests/browserbase/uploads.test.ts b/evals/deterministic/tests/browserbase/uploads.test.ts
deleted file mode 100644
index 06b724423..000000000
--- a/evals/deterministic/tests/browserbase/uploads.test.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { join } from "node:path";
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-test.describe("Playwright Upload", () => {
-  let stagehand: Stagehand;
-
-  test.beforeAll(async () => {
-    stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-  });
-
-  test.afterAll(async () => {
-    await stagehand.close();
-  });
-
-  test("uploads a file", async () => {
-    const page = stagehand.page;
-    await page.goto("https://browser-tests-alpha.vercel.app/api/upload-test");
-
-    const fileInput = page.locator("#fileUpload");
-    await fileInput.setInputFiles(
-      join(__dirname, "../..", "auxiliary", "logo.png"),
-    );
-
-    const fileNameSpan = page.locator("#fileName");
-    const fileName = await fileNameSpan.innerText();
-
-    const fileSizeSpan = page.locator("#fileSize");
-    const fileSize = Number(await fileSizeSpan.innerText());
-
-    expect(fileName).toBe("logo.png");
-    expect(fileSize).toBeGreaterThan(0);
-  });
-});
diff --git a/evals/deterministic/tests/local/create.test.ts b/evals/deterministic/tests/local/create.test.ts
deleted file mode 100644
index 48f78f4cb..000000000
--- a/evals/deterministic/tests/local/create.test.ts
+++ /dev/null
@@ -1,185 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import path from "path";
-import fs from "fs";
-import os from "os";
-import type { Cookie } from "@playwright/test";
-import StagehandConfig from "../../stagehand.config";
-
-test.describe("Local browser launch options", () => {
-  test("launches with default options when no localBrowserLaunchOptions provided", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const context = stagehand.context;
-    expect(context.browser()).toBeDefined();
-    expect(context.pages().length).toBe(1);
-
-    await stagehand.close();
-  });
-
-  test("respects custom userDataDir", async () => {
-    const customUserDataDir = path.join(os.tmpdir(), "custom-user-data");
-
-    const stagehand = new Stagehand({
-      ...StagehandConfig,
-      localBrowserLaunchOptions: {
-        userDataDir: customUserDataDir,
-        headless: true,
-      },
-    });
-    await stagehand.init();
-
-    expect(fs.existsSync(customUserDataDir)).toBeTruthy();
-
-    await stagehand.close();
-
-    // Cleanup
-    fs.rmSync(customUserDataDir, { recursive: true, force: true });
-  });
-
-  test("applies custom viewport settings", async () => {
-    const customViewport = { width: 1920, height: 1080 };
-
-    const stagehand = new Stagehand({
-      ...StagehandConfig,
-      localBrowserLaunchOptions: {
-        ...StagehandConfig.localBrowserLaunchOptions,
-        viewport: customViewport,
-      },
-    });
-    await stagehand.init();
-
-    const page = await stagehand.context.newPage();
-    const viewport = page.viewportSize();
-
-    expect(viewport).toEqual(customViewport);
-
-    await stagehand.close();
-  });
-
-  test("applies custom cookies", async () => {
-    const testCookies: Cookie[] = [
-      {
-        name: "testCookie",
-        value: "testValue",
-        domain: "example.com",
-        path: "/",
-        expires: -1,
-        httpOnly: false,
-        secure: false,
-        sameSite: "Lax" as const,
-      },
-    ];
-
-    const stagehand = new Stagehand({
-      ...StagehandConfig,
-      localBrowserLaunchOptions: {
-        ...StagehandConfig.localBrowserLaunchOptions,
-        cookies: testCookies,
-      },
-    });
-    await stagehand.init();
-
-    const page = await stagehand.context.newPage();
-    await page.goto("https://example.com");
-    const cookies = await stagehand.context.cookies();
-
-    expect(cookies[0]).toMatchObject(
-      testCookies[0] as unknown as Record<string, unknown>,
-    );
-
-    await stagehand.close();
-  });
-
-  test("applies custom geolocation settings", async () => {
-    const customGeolocation = {
-      latitude: 40.7128,
-      longitude: -74.006,
-    };
-
-    const stagehand = new Stagehand({
-      ...StagehandConfig,
-      localBrowserLaunchOptions: {
-        ...StagehandConfig.localBrowserLaunchOptions,
-        geolocation: customGeolocation,
-        permissions: ["geolocation"],
-      },
-    });
-    await stagehand.init();
-
-    const page = await stagehand.context.newPage();
-    await page.goto("https://example.com");
-
-    const location = await page.evaluate(() => {
-      return new Promise((resolve) => {
-        navigator.geolocation.getCurrentPosition(
-          (position) => {
-            resolve({
-              latitude: position.coords.latitude,
-              longitude: position.coords.longitude,
-            });
-          },
-          () => resolve(null),
-        );
-      });
-    });
-
-    expect(location).toEqual(customGeolocation);
-
-    await stagehand.close();
-  });
-
-  test("applies custom timezone and locale", async () => {
-    const stagehand = new Stagehand({
-      ...StagehandConfig,
-      localBrowserLaunchOptions: {
-        ...StagehandConfig.localBrowserLaunchOptions,
-        locale: "ja-JP",
-        timezoneId: "Asia/Tokyo",
-      },
-    });
-    await stagehand.init();
-
-    const page = await stagehand.context.newPage();
-    await page.goto("https://example.com");
-
-    const { locale, timezone } = await page.evaluate(() => ({
-      locale: navigator.language,
-      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-    }));
-
-    expect(locale).toBe("ja-JP");
-    expect(timezone).toBe("Asia/Tokyo");
-
-    await stagehand.close();
-  });
-
-  test("records video when enabled", async () => {
-    const videoDir = path.join(os.tmpdir(), "test-videos");
-    fs.mkdirSync(videoDir, { recursive: true });
-
-    const stagehand = new Stagehand({
-      ...StagehandConfig,
-      localBrowserLaunchOptions: {
-        ...StagehandConfig.localBrowserLaunchOptions,
-        recordVideo: {
-          dir: videoDir,
-          size: { width: 800, height: 600 },
-        },
-      },
-    });
-    await stagehand.init();
-
-    const page = await stagehand.context.newPage();
-    await page.goto("https://example.com");
-    await stagehand.close();
-
-    const videos = fs.readdirSync(videoDir);
-    expect(videos.length).toBeGreaterThan(0);
-    expect(videos[0]).toMatch(/\.webm$/);
-
-    // Cleanup
-    fs.rmSync(videoDir, { recursive: true, force: true });
-  });
-});
diff --git a/evals/deterministic/tests/page/addInitScript.test.ts b/evals/deterministic/tests/page/addInitScript.test.ts
deleted file mode 100644
index 56be8ef41..000000000
--- a/evals/deterministic/tests/page/addInitScript.test.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-test.describe("StagehandPage - addInitScript", () => {
-  test("should inject a script before the page loads", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-
-    await page.addInitScript(() => {
-      const w = window as typeof window & {
-        __testInitScriptVar?: string;
-      };
-      w.__testInitScriptVar = "Hello from init script!";
-    });
-
-    await page.goto("https://example.com");
-
-    const result = await page.evaluate(() => {
-      const w = window as typeof window & {
-        __testInitScriptVar?: string;
-      };
-      return w.__testInitScriptVar;
-    });
-    expect(result).toBe("Hello from init script!");
-
-    await page.goto("https://docs.browserbase.com/");
-    const resultAfterNavigation = await page.evaluate(() => {
-      const w = window as typeof window & {
-        __testInitScriptVar?: string;
-      };
-      return w.__testInitScriptVar;
-    });
-    expect(resultAfterNavigation).toBe("Hello from init script!");
-
-    await stagehand.close();
-  });
-});
diff --git a/evals/deterministic/tests/page/addRemoveLocatorHandler.test.ts b/evals/deterministic/tests/page/addRemoveLocatorHandler.test.ts
deleted file mode 100644
index a46abc92d..000000000
--- a/evals/deterministic/tests/page/addRemoveLocatorHandler.test.ts
+++ /dev/null
@@ -1,93 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-test.describe("StagehandPage - addLocatorHandler and removeLocatorHandler", () => {
-  // This HTML snippet is reused by both tests.
-  // The "Sign up to the newsletter" overlay appears after 2 seconds.
-  // The "No thanks" button hides it.
-  const overlayHTML = `
-    <html>
-      <body>
-        <button id="cta">Start here</button>
-        <div id="overlay" style="display: none;">
-          <p>Sign up to the newsletter</p>
-          <button id="no-thanks">No thanks</button>
-        </div>
-        <script>
-          // Show the overlay after 2 seconds
-          setTimeout(() => {
-            document.getElementById('overlay').style.display = 'block';
-          }, 2000);
-
-          // Hide the overlay when "No thanks" is clicked
-          document.getElementById('no-thanks').addEventListener('click', () => {
-            document.getElementById('overlay').style.display = 'none';
-          });
-        </script>
-      </body>
-    </html>
-  `;
-
-  test("should use a custom locator handler to dismiss the overlay", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const { page } = stagehand;
-
-    await page.addLocatorHandler(
-      page.getByText("Sign up to the newsletter"),
-      async () => {
-        console.log("Overlay detected. Clicking 'No thanks' to remove it...");
-        await page.getByRole("button", { name: "No thanks" }).click();
-      },
-    );
-
-    await page.goto("https://example.com");
-    await page.setContent(overlayHTML);
-
-    await page.waitForTimeout(5000);
-
-    await page.getByRole("button", { name: "Start here" }).click();
-
-    const isOverlayVisible = await page
-      .getByText("Sign up to the newsletter")
-      .isVisible()
-      .catch(() => false);
-
-    await stagehand.close();
-
-    expect(isOverlayVisible).toBeFalsy();
-  });
-
-  test("should remove a custom locator handler so overlay stays visible", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const { page } = stagehand;
-
-    const locator = page.getByText("Sign up to the newsletter");
-    await page.addLocatorHandler(locator, async () => {
-      console.log("Overlay detected. Clicking 'No thanks' to remove it...");
-      await page.getByRole("button", { name: "No thanks" }).click();
-    });
-
-    await page.removeLocatorHandler(locator);
-    console.log("Locator handler removed — overlay will not be dismissed now.");
-
-    await page.goto("https://example.com");
-    await page.setContent(overlayHTML);
-
-    await page.waitForTimeout(5000);
-
-    await page.getByRole("button", { name: "Start here" }).click();
-
-    const isOverlayVisible = await page
-      .getByText("Sign up to the newsletter")
-      .isVisible()
-      .catch(() => false);
-
-    await stagehand.close();
-    expect(isOverlayVisible).toBe(true);
-  });
-});
diff --git a/evals/deterministic/tests/page/addTags.test.ts b/evals/deterministic/tests/page/addTags.test.ts
deleted file mode 100644
index 463d109a2..000000000
--- a/evals/deterministic/tests/page/addTags.test.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-test.describe("StagehandPage - addScriptTag and addStyleTag", () => {
-  let stagehand: Stagehand;
-
-  test.beforeAll(async () => {
-    stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-  });
-
-  test.afterAll(async () => {
-    await stagehand.close();
-  });
-
-  test("should inject a script tag and have access to the defined function", async () => {
-    const { page } = stagehand;
-
-    await page.setContent(`
-      <html>
-      <body>
-        <h1 id="greeting">Hello, world!</h1>
-      </body>
-      </html>
-    `);
-
-    await page.addScriptTag({
-      content: `
-        window.sayHello = function() {
-          document.getElementById("greeting").textContent = "Hello from injected script!";
-        }
-      `,
-    });
-
-    await page.evaluate(() => {
-      const w = window as typeof window & {
-        sayHello?: () => void;
-      };
-      w.sayHello?.();
-    });
-
-    const text = await page.locator("#greeting").textContent();
-    expect(text).toBe("Hello from injected script!");
-  });
-
-  test("should inject a style tag and apply styles", async () => {
-    const { page } = stagehand;
-
-    await page.setContent(`
-      <html>
-      <body>
-        <div id="styledDiv">Some text</div>
-      </body>
-      </html>
-    `);
-
-    await page.addStyleTag({
-      content: `
-        #styledDiv {
-          color: red;
-          font-weight: bold;
-        }
-      `,
-    });
-
-    const color = await page.evaluate(() => {
-      const el = document.getElementById("styledDiv");
-      return window.getComputedStyle(el!).color;
-    });
-    expect(color).toBe("rgb(255, 0, 0)");
-
-    const fontWeight = await page.evaluate(() => {
-      const el = document.getElementById("styledDiv");
-      return window.getComputedStyle(el!).fontWeight;
-    });
-    expect(["bold", "700"]).toContain(fontWeight);
-  });
-});
diff --git a/evals/deterministic/tests/page/bringToFront.test.ts b/evals/deterministic/tests/page/bringToFront.test.ts
deleted file mode 100644
index d25ddb6c3..000000000
--- a/evals/deterministic/tests/page/bringToFront.test.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-test.describe("StagehandPage - bringToFront", () => {
-  test("should bring a background page to the front and allow further actions", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const { page: page1 } = stagehand;
-
-    const page2 = await stagehand.context.newPage();
-    await page2.goto("https://example.com");
-    const page2Title = await page2.title();
-    console.log("Page2 Title:", page2Title);
-
-    await page1.goto("https://www.google.com");
-    const page1TitleBefore = await page1.title();
-    console.log("Page1 Title before:", page1TitleBefore);
-
-    await page1.bringToFront();
-
-    await page1.goto("https://docs.browserbase.com");
-    const page1TitleAfter = await page1.title();
-    console.log("Page1 Title after:", page1TitleAfter);
-
-    await page2.bringToFront();
-    const page2URLBefore = page2.url();
-    console.log("Page2 URL before navigation:", page2URLBefore);
-
-    await stagehand.close();
-
-    expect(page1TitleBefore).toContain("Google");
-    expect(page1TitleAfter).toContain("Browserbase");
-    expect(page2Title).toContain("Example Domain");
-  });
-});
diff --git a/evals/deterministic/tests/page/content.test.ts b/evals/deterministic/tests/page/content.test.ts
deleted file mode 100644
index fe95aae69..000000000
--- a/evals/deterministic/tests/page/content.test.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-test.describe("StagehandPage - content", () => {
-  test("should retrieve the full HTML content of the page", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-    await page.goto("https://example.com");
-    const html = await page.content();
-    expect(html).toContain("<title>Example Domain</title>");
-    expect(html).toContain("<h1>Example Domain</h1>");
-
-    await stagehand.close();
-  });
-});
diff --git a/evals/deterministic/tests/page/evaluate.test.ts b/evals/deterministic/tests/page/evaluate.test.ts
deleted file mode 100644
index 2610735be..000000000
--- a/evals/deterministic/tests/page/evaluate.test.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-test.describe("StagehandPage - JavaScript Evaluation", () => {
-  test("can evaluate JavaScript in the page context", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-
-    await page.goto("https://example.com");
-
-    const sum = await page.evaluate(() => 2 + 2);
-    expect(sum).toBe(4);
-
-    const pageTitle = await page.evaluate(() => document.title);
-    expect(pageTitle).toMatch(/example/i);
-
-    const obj = await page.evaluate(() => {
-      return {
-        message: "Hello from the browser",
-        userAgent: navigator.userAgent,
-      };
-    });
-    expect(obj).toHaveProperty("message", "Hello from the browser");
-    expect(obj.userAgent).toBeDefined();
-
-    await stagehand.close();
-  });
-});
diff --git a/evals/deterministic/tests/page/expose.test.ts b/evals/deterministic/tests/page/expose.test.ts
deleted file mode 100644
index 9572b39c0..000000000
--- a/evals/deterministic/tests/page/expose.test.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-test.describe("StagehandPage - evaluateHandle, exposeBinding, exposeFunction", () => {
-  let stagehand: Stagehand;
-
-  test.beforeAll(async () => {
-    stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-  });
-
-  test.afterAll(async () => {
-    await stagehand.close();
-  });
-
-  test("demonstrates evaluateHandle, exposeBinding, and exposeFunction", async () => {
-    const { page } = stagehand;
-
-    await page.setContent(`
-      <html>
-        <body>
-          <div id="myDiv">Initial Text</div>
-        </body>
-      </html>
-    `);
-
-    const divHandle = await page.evaluateHandle(() => {
-      return document.getElementById("myDiv");
-    });
-    await divHandle.evaluate((div, newText) => {
-      div.textContent = newText;
-    }, "Text updated via evaluateHandle");
-
-    const text = await page.locator("#myDiv").textContent();
-    expect(text).toBe("Text updated via evaluateHandle");
-
-    await page.exposeBinding("myBinding", async (source, arg: string) => {
-      console.log("myBinding called from page with arg:", arg);
-      return `Node responded with: I got your message: "${arg}"`;
-    });
-
-    const responseFromBinding = await page.evaluate(async () => {
-      const w = window as typeof window & {
-        myBinding?: (arg: string) => Promise<string>;
-      };
-      return w.myBinding?.("Hello from the browser");
-    });
-    expect(responseFromBinding).toMatch(/I got your message/);
-
-    await page.exposeFunction("addNumbers", (a: number, b: number) => {
-      return a + b;
-    });
-
-    const sum = await page.evaluate(async () => {
-      const w = window as typeof window & {
-        addNumbers?: (a: number, b: number) => number;
-      };
-      return w.addNumbers?.(3, 7);
-    });
-    expect(sum).toBe(10);
-  });
-});
diff --git a/evals/deterministic/tests/page/frames.test.ts b/evals/deterministic/tests/page/frames.test.ts
deleted file mode 100644
index 18c50942c..000000000
--- a/evals/deterministic/tests/page/frames.test.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-test.describe("StagehandPage - frame operations", () => {
-  let stagehand: Stagehand;
-
-  test.beforeAll(async () => {
-    stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-  });
-
-  test.afterAll(async () => {
-    await stagehand.close();
-  });
-
-  test("should use page.mainFrame(), page.frames(), page.frame(), and page.frameLocator()", async () => {
-    const { page } = stagehand;
-
-    await page.setContent(`
-      <html>
-        <body>
-          <iframe
-            name="frame-one"
-            srcdoc="<html><body><h1>Hello from Frame 1</h1></body></html>">
-          </iframe>
-
-          <iframe
-            name="frame-two"
-            srcdoc="<html><body><h1>Hello from Frame 2</h1></body></html>">
-          </iframe>
-        </body>
-      </html>
-    `);
-
-    await page.waitForSelector('iframe[name="frame-one"]');
-    await page.waitForSelector('iframe[name="frame-two"]');
-
-    const frames = page.frames();
-    console.log(
-      "All frames found:",
-      frames.map((f) => f.name()),
-    );
-    expect(frames).toHaveLength(3);
-
-    const mainFrame = page.mainFrame();
-    console.log("Main frame name:", mainFrame.name());
-    expect(mainFrame.name()).toBe("");
-
-    const frameOne = page.frame({ name: "frame-one" });
-    expect(frameOne).not.toBeNull();
-
-    const frameOneText = await frameOne?.locator("h1").textContent();
-    expect(frameOneText).toBe("Hello from Frame 1");
-
-    const frameTwoLocator = page.frameLocator("iframe[name='frame-two']");
-    const frameTwoText = await frameTwoLocator.locator("h1").textContent();
-    expect(frameTwoText).toBe("Hello from Frame 2");
-
-    const frameTwo = page.frame({ name: "frame-two" });
-    expect(frameTwo).not.toBeNull();
-
-    const frameTwoTextAgain = await frameTwo?.locator("h1").textContent();
-    expect(frameTwoTextAgain).toBe("Hello from Frame 2");
-  });
-});
diff --git a/evals/deterministic/tests/page/getBy.test.ts b/evals/deterministic/tests/page/getBy.test.ts
deleted file mode 100644
index 5da3a3976..000000000
--- a/evals/deterministic/tests/page/getBy.test.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-test.describe("StagehandPage - Built-in locators", () => {
-  let stagehand: Stagehand;
-
-  test.beforeAll(async () => {
-    stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-  });
-
-  test.afterAll(async () => {
-    await stagehand.close();
-  });
-
-  test("demonstrates getByAltText, getByLabel, getByPlaceholder, getByRole, getByTestId, getByText, getByTitle", async () => {
-    const { page } = stagehand;
-    await page.setContent(`
-      <html>
-        <body>
-          <img src="avatar.png" alt="Profile picture" />
-          <label for="username">Username</label>
-          <input id="username" type="text" />
-          <input placeholder="Enter your email" type="email" />
-          <button>Sign in</button>
-          <div data-testid="greeting">Hello World!</div>
-          <p>This is some descriptive text on the page.</p>
-          <h1 title="A heading for the page">Site Title</h1>
-        </body>
-      </html>
-    `);
-    const image = page.getByAltText("Profile picture");
-    await expect(image).toBeVisible();
-    const usernameInput = page.getByLabel("Username");
-    await expect(usernameInput).toBeVisible();
-    const emailInput = page.getByPlaceholder("Enter your email");
-    await expect(emailInput).toBeVisible();
-    const signInButton = page.getByRole("button", { name: "Sign in" });
-    await expect(signInButton).toBeVisible();
-    const greetingDiv = page.getByTestId("greeting");
-    await expect(greetingDiv).toHaveText("Hello World!");
-    const descriptiveText = page.getByText(
-      "This is some descriptive text on the page.",
-    );
-    await expect(descriptiveText).toBeVisible();
-    const heading = page.getByTitle("A heading for the page");
-    await expect(heading).toHaveText("Site Title");
-  });
-});
diff --git a/evals/deterministic/tests/page/navigation.test.ts b/evals/deterministic/tests/page/navigation.test.ts
deleted file mode 100644
index e9acb7a7c..000000000
--- a/evals/deterministic/tests/page/navigation.test.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-test.describe("StagehandPage - Navigation", () => {
-  test("should navigate back and forward between pages", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-
-    await page.goto("https://example.com");
-    expect(page.url()).toBe("https://example.com/");
-
-    await page.goto("https://docs.browserbase.com/introduction");
-    expect(page.url()).toBe("https://docs.browserbase.com/introduction");
-
-    await page.goBack();
-    expect(page.url()).toBe("https://example.com/");
-
-    await page.goForward();
-    expect(page.url()).toBe("https://docs.browserbase.com/introduction");
-
-    await stagehand.close();
-  });
-});
diff --git a/evals/deterministic/tests/page/on.test.ts b/evals/deterministic/tests/page/on.test.ts
deleted file mode 100644
index 97ec5bbfe..000000000
--- a/evals/deterministic/tests/page/on.test.ts
+++ /dev/null
@@ -1,134 +0,0 @@
-import { expect, test } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-test.describe("StagehandPage - page.on()", () => {
-  test("should click on the crewAI blog tab", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-    await page.goto(
-      "https://docs.browserbase.com/integrations/crew-ai/introduction",
-    );
-
-    let clickPromise: Promise<void>;
-
-    page.on("popup", async (newPage) => {
-      clickPromise = newPage.click(
-        "body > div.page-wrapper > div.navbar-2.w-nav > div.padding-global.top-bot > div > div.navigation-left > nav > a:nth-child(7)",
-      );
-    });
-
-    await page.goto(
-      "https://docs.browserbase.com/integrations/crew-ai/introduction",
-    );
-
-    await page.click(
-      "#content-area > div.relative.mt-8.prose.prose-gray.dark\\:prose-invert > p:nth-child(2) > a",
-    );
-
-    await clickPromise;
-
-    await stagehand.close();
-  });
-
-  test("should close the new tab and navigate to it on the existing page", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-    await page.goto(
-      "https://docs.browserbase.com/integrations/crew-ai/introduction",
-    );
-
-    let navigatePromise: Promise<unknown>;
-
-    page.on("popup", async (newPage) => {
-      navigatePromise = Promise.allSettled([
-        newPage.close(),
-        page.goto(newPage.url(), { waitUntil: "domcontentloaded" }),
-      ]);
-    });
-
-    // Click on the crewAI blog tab
-    await page.click(
-      "#content-area > div.relative.mt-8.prose.prose-gray.dark\\:prose-invert > p:nth-child(2) > a",
-    );
-
-    await navigatePromise;
-
-    await page.click(
-      "body > div.page-wrapper > div.navbar-2.w-nav > div.padding-global.top-bot > div > div.navigation-left > nav > a:nth-child(3)",
-    );
-
-    await page.waitForLoadState("domcontentloaded");
-
-    const currentUrl = page.url();
-    expect(currentUrl).toBe("https://www.crewai.com/open-source");
-
-    await stagehand.close();
-  });
-
-  test("should handle console events", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-    await page.goto("https://example.com");
-
-    const messages: string[] = [];
-    page.on("console", (msg) => {
-      messages.push(msg.text());
-    });
-
-    await page.evaluate(() => console.log("Test console log"));
-
-    expect(messages).toContain("Test console log");
-
-    await stagehand.close();
-  });
-
-  test("should handle dialog events", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-    await page.goto("https://example.com");
-
-    page.on("dialog", async (dialog) => {
-      expect(dialog.message()).toBe("Test alert");
-      await dialog.dismiss();
-    });
-
-    await page.evaluate(() => alert("Test alert"));
-
-    await stagehand.close();
-  });
-
-  test("should handle request and response events", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-    await page.goto("https://example.com");
-
-    const requests: string[] = [];
-    const responses: string[] = [];
-
-    page.on("request", (request) => {
-      requests.push(request.url());
-    });
-
-    page.on("response", (response) => {
-      responses.push(response.url());
-    });
-
-    await page.goto("https://example.com");
-
-    expect(requests).toContain("https://example.com/");
-    expect(responses).toContain("https://example.com/");
-
-    await stagehand.close();
-  });
-});
diff --git a/evals/deterministic/tests/page/pageContext.test.ts b/evals/deterministic/tests/page/pageContext.test.ts
deleted file mode 100644
index a0f36911c..000000000
--- a/evals/deterministic/tests/page/pageContext.test.ts
+++ /dev/null
@@ -1,59 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-test.describe("StagehandPage - page.context()", () => {
-  let stagehand: Stagehand;
-
-  test.beforeEach(async () => {
-    stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-  });
-
-  test.afterEach(async () => {
-    if (stagehand) {
-      try {
-        await stagehand.close();
-      } catch (error) {
-        console.error("[afterEach] Error during stagehand.close():", error);
-      }
-    } else {
-      console.log("[afterEach] Stagehand was not defined, skipping close().");
-    }
-  });
-
-  test("should confirm page.context() and stagehand.context share state", async () => {
-    const page = stagehand.page;
-    const stagehandContext = stagehand.context;
-    const pageContext = page.context();
-
-    await pageContext.addCookies([
-      {
-        name: "stagehandTestCookie",
-        value: "hello-stagehand",
-        domain: "example.com",
-        path: "/",
-        expires: Math.floor(Date.now() / 1000) + 3600, // 1 hour
-        httpOnly: false,
-        secure: false,
-        sameSite: "Lax",
-      },
-    ]);
-
-    const cookies = await stagehandContext.cookies("https://example.com");
-
-    const testCookie = cookies.find((c) => c.name === "stagehandTestCookie");
-    expect(testCookie).toBeDefined();
-    expect(testCookie?.value).toBe("hello-stagehand");
-
-    const extraPage = await pageContext.newPage();
-    await extraPage.goto("https://example.com");
-    const contextPages = stagehandContext.pages();
-
-    // The newly created page should be recognized by stagehandContext as well.
-    const foundExtraPage = contextPages.find(
-      (p) => p.url() === "https://example.com/",
-    );
-    expect(foundExtraPage).toBeDefined();
-  });
-});
diff --git a/evals/deterministic/tests/page/reload.test.ts b/evals/deterministic/tests/page/reload.test.ts
deleted file mode 100644
index 31518a747..000000000
--- a/evals/deterministic/tests/page/reload.test.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-test.describe("StagehandPage - Reload", () => {
-  test("should reload the page and reset page state", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-    await page.goto("https://docs.browserbase.com/");
-
-    await page.evaluate(() => {
-      const w = window as typeof window & {
-        __testReloadMarker?: string;
-      };
-      w.__testReloadMarker = "Hello Reload!";
-    });
-
-    const markerBeforeReload = await page.evaluate(() => {
-      const w = window as typeof window & {
-        __testReloadMarker?: string;
-      };
-      return w.__testReloadMarker;
-    });
-    expect(markerBeforeReload).toBe("Hello Reload!");
-
-    await page.reload();
-
-    const markerAfterReload = await page.evaluate(() => {
-      const w = window as typeof window & {
-        __testReloadMarker?: string;
-      };
-      return w.__testReloadMarker;
-    });
-    expect(markerAfterReload).toBeUndefined();
-
-    await stagehand.close();
-  });
-});
diff --git a/evals/deterministic/tests/page/waitFor.test.ts b/evals/deterministic/tests/page/waitFor.test.ts
deleted file mode 100644
index e42dd3b58..000000000
--- a/evals/deterministic/tests/page/waitFor.test.ts
+++ /dev/null
@@ -1,165 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/evals/deterministic/stagehand.config";
-
-test.describe("StagehandPage - waitFor", () => {
-  test("should wait for an element to become visible", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-    await page.goto("https://docs.browserbase.com/introduction");
-    const dynamicElement = page.locator(
-      "div.grid:nth-child(1) > a:nth-child(1) > div:nth-child(1)",
-    );
-
-    const isVisibleBefore = await dynamicElement.isVisible();
-    expect(isVisibleBefore).toBe(false);
-
-    const clickableElement = page.locator(
-      "div.not-prose:nth-child(2) > a:nth-child(1) > div:nth-child(1)",
-    );
-    await clickableElement.click();
-
-    await dynamicElement.waitFor({ state: "visible" });
-
-    const isVisibleAfter = await dynamicElement.isVisible();
-    expect(isVisibleAfter).toBe(true);
-
-    await stagehand.close();
-  });
-
-  test("should wait for an element to be detached", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-    await page.goto("https://docs.browserbase.com/introduction");
-
-    const disappearingElement = page.locator(
-      "div.not-prose:nth-child(2) > a:nth-child(1) > div:nth-child(1)",
-    );
-
-    await disappearingElement.click();
-    await disappearingElement.waitFor({ state: "detached" });
-
-    const isAttachedAfter = await disappearingElement.isVisible();
-    expect(isAttachedAfter).toBe(false);
-
-    await stagehand.close();
-  });
-
-  test("should wait for a specific event (waitForEvent)", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-    await page.goto("https://docs.browserbase.com/introduction");
-
-    const consolePromise = page.waitForEvent("console");
-    await page.evaluate(() => {
-      console.log("Hello from the browser console!");
-    });
-    const consoleMessage = await consolePromise;
-    expect(consoleMessage.text()).toBe("Hello from the browser console!");
-
-    await stagehand.close();
-  });
-
-  test("should wait for a function to return true (waitForFunction)", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-    await page.goto("https://docs.browserbase.com/introduction");
-
-    await page.evaluate(() => {
-      setTimeout(() => {
-        const w = window as typeof window & {
-          __stagehandFlag?: boolean;
-        };
-        w.__stagehandFlag = true;
-      }, 1000);
-    });
-
-    await page.waitForFunction(() => {
-      const w = window as typeof window & {
-        __stagehandFlag?: boolean;
-      };
-      return w.__stagehandFlag === true;
-    });
-
-    const value = await page.evaluate(() => {
-      const w = window as typeof window & {
-        __stagehandFlag?: boolean;
-      };
-      return w.__stagehandFlag;
-    });
-    expect(value).toBe(true);
-
-    await stagehand.close();
-  });
-
-  test("should wait for the load state (waitForLoadState)", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-    await page.goto("https://docs.browserbase.com/introduction");
-    await page.waitForLoadState("networkidle");
-    const heroTitle = page.locator("h1");
-    await expect(heroTitle).toHaveText(/Documentation/i);
-
-    await stagehand.close();
-  });
-
-  test("should wait for a specific request (waitForRequest)", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-    const requestPromise = page.waitForRequest((req) =>
-      req.url().includes("mintlify"),
-    );
-
-    await page.goto("https://docs.browserbase.com/introduction");
-    const matchingRequest = await requestPromise;
-    expect(matchingRequest.url()).toContain("mintlify");
-
-    await stagehand.close();
-  });
-
-  test("should wait for a specific response (waitForResponse)", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-    const responsePromise = page.waitForResponse(
-      (res) => res.url().includes("introduction") && res.status() === 200,
-    );
-
-    await page.goto("https://docs.browserbase.com/introduction");
-    const matchingResponse = await responsePromise;
-    expect(await matchingResponse.text()).toContain("Browserbase");
-
-    await stagehand.close();
-  });
-
-  test("should wait for a URL (waitForURL)", async () => {
-    const stagehand = new Stagehand(StagehandConfig);
-    await stagehand.init();
-
-    const page = stagehand.page;
-    await page.goto("https://docs.browserbase.com");
-
-    const getStartedLink = page.locator(
-      "div.not-prose:nth-child(3) > a:nth-child(1) > div:nth-child(1)",
-    );
-    await getStartedLink.click();
-
-    await page.waitForURL(/.*getting-started.*/);
-    expect(page.url()).toContain("/getting-started");
-
-    await stagehand.close();
-  });
-});
diff --git a/evals/env.ts b/evals/env.ts
deleted file mode 100644
index 45f877bd1..000000000
--- a/evals/env.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-/**
- * Determine the current environment in which the evaluations are running:
- * - BROWSERBASE or LOCAL
- *
- * The environment is read from the EVAL_ENV environment variable.
- */
-export const env: "BROWSERBASE" | "LOCAL" =
-  process.env.EVAL_ENV?.toLowerCase() === "browserbase"
-    ? "BROWSERBASE"
-    : "LOCAL";
-
-/**
- * Enable or disable caching based on the EVAL_ENABLE_CACHING environment variable.
- * Caching may improve performance by not re-fetching or re-computing certain results.
- * By default, caching is disabled unless explicitly enabled.
- */
-export const enableCaching =
-  process.env.EVAL_ENABLE_CACHING?.toLowerCase() === "true";
diff --git a/evals/evals.config.json b/evals/evals.config.json
deleted file mode 100644
index ade809c32..000000000
--- a/evals/evals.config.json
+++ /dev/null
@@ -1,322 +0,0 @@
-{
-  "tasks": [
-    {
-      "name": "history",
-      "categories": ["combination"]
-    },
-    {
-      "name": "expect_act_timeout",
-      "categories": ["regression"]
-    },
-    {
-      "name": "extract_repo_name",
-      "categories": ["extract"]
-    },
-    {
-      "name": "amazon_add_to_cart",
-      "categories": ["act"]
-    },
-    {
-      "name": "instructions",
-      "categories": ["regression", "combination"]
-    },
-    {
-      "name": "bidnet",
-      "categories": ["act"]
-    },
-    {
-      "name": "ionwave",
-      "categories": ["act", "regression"],
-      "extract_method": "domExtract"
-    },
-    {
-      "name": "nonsense_action",
-      "categories": ["act"]
-    },
-    {
-      "name": "peeler_simple",
-      "categories": ["act"]
-    },
-    {
-      "name": "simple_google_search",
-      "categories": ["act"]
-    },
-    {
-      "name": "vantechjournal",
-      "categories": ["act"]
-    },
-    {
-      "name": "wikipedia",
-      "categories": ["act"]
-    },
-
-    {
-      "name": "allrecipes",
-      "categories": ["combination"]
-    },
-    {
-      "name": "arxiv",
-      "categories": ["combination"]
-    },
-    {
-      "name": "extract_collaborators",
-      "categories": ["combination"]
-    },
-    {
-      "name": "extract_github_commits",
-      "categories": ["combination"]
-    },
-    {
-      "name": "imdb_movie_details",
-      "categories": ["combination"]
-    },
-    {
-      "name": "peeler_complex",
-      "categories": ["combination"]
-    },
-    {
-      "name": "sciquest",
-      "categories": ["combination"]
-    },
-    {
-      "name": "wichita",
-      "categories": ["combination", "regression"],
-      "extract_method": "domExtract"
-    },
-    {
-      "name": "hn_aisdk",
-      "categories": ["llm_clients"]
-    },
-    {
-      "name": "hn_langchain",
-      "categories": ["llm_clients"]
-    },
-    {
-      "name": "hn_customOpenAI",
-      "categories": ["llm_clients"]
-    },
-    {
-      "name": "apple",
-      "categories": ["experimental"]
-    },
-    {
-      "name": "combination_sauce",
-      "categories": ["experimental"]
-    },
-    {
-      "name": "costar",
-      "categories": ["experimental"]
-    },
-    {
-      "name": "expedia",
-      "categories": ["experimental"]
-    },
-    {
-      "name": "expedia_search",
-      "categories": ["experimental"]
-    },
-    {
-      "name": "extract_aigrant_companies",
-      "categories": ["text_extract", "regression"],
-      "extract_method": "textExtract"
-    },
-    {
-      "name": "extract_capacitor_info",
-      "categories": ["experimental", "text_extract"]
-    },
-    {
-      "name": "extract_partners",
-      "categories": ["experimental"]
-    },
-    {
-      "name": "extract_press_releases",
-      "categories": ["experimental", "text_extract"]
-    },
-    {
-      "name": "extract_snowshoeing_destinations",
-      "categories": ["experimental", "text_extract"]
-    },
-    {
-      "name": "google_jobs",
-      "categories": ["experimental"]
-    },
-    {
-      "name": "homedepot",
-      "categories": ["experimental"]
-    },
-    {
-      "name": "rakuten_jp",
-      "categories": ["experimental"]
-    },
-    {
-      "name": "stock_x",
-      "categories": ["experimental"]
-    },
-    {
-      "name": "ted_talk",
-      "categories": ["experimental"]
-    },
-
-    {
-      "name": "extract_baptist_health",
-      "categories": ["extract"]
-    },
-    {
-      "name": "extract_github_stars",
-      "categories": ["extract"]
-    },
-    {
-      "name": "extract_memorial_healthcare",
-      "categories": ["extract", "regression"],
-      "extract_method": "domExtract"
-    },
-    {
-      "name": "extract_nhl_stats",
-      "categories": ["extract"]
-    },
-    {
-      "name": "extract_professional_info",
-      "categories": ["extract"]
-    },
-    {
-      "name": "extract_csa",
-      "categories": ["text_extract"]
-    },
-    {
-      "name": "extract_resistor_info",
-      "categories": ["extract"]
-    },
-    {
-      "name": "extract_rockauto",
-      "categories": ["extract"]
-    },
-    {
-      "name": "extract_staff_members",
-      "categories": ["extract"]
-    },
-
-    {
-      "name": "ionwave_observe",
-      "categories": ["observe"]
-    },
-    {
-      "name": "panamcs",
-      "categories": ["observe"]
-    },
-    {
-      "name": "vanta_h",
-      "categories": ["experimental"]
-    },
-    {
-      "name": "extract_area_codes",
-      "categories": ["text_extract"]
-    },
-    {
-      "name": "extract_public_notices",
-      "categories": ["text_extract"]
-    },
-    {
-      "name": "extract_jstor_news",
-      "categories": ["text_extract"]
-    },
-    {
-      "name": "extract_apartments",
-      "categories": ["text_extract"]
-    },
-    {
-      "name": "extract_zillow",
-      "categories": ["text_extract"]
-    },
-    {
-      "name": "observe_github",
-      "categories": ["observe", "regression"],
-      "extract_method": "textExtract"
-    },
-    {
-      "name": "observe_vantechjournal",
-      "categories": ["observe", "regression"],
-      "extract_method": "textExtract"
-    },
-    {
-      "name": "observe_amazon_add_to_cart",
-      "categories": ["observe"]
-    },
-    {
-      "name": "observe_simple_google_search",
-      "categories": ["observe"]
-    },
-    {
-      "name": "observe_yc_startup",
-      "categories": ["observe"]
-    },
-    {
-      "name": "observe_taxes",
-      "categories": ["observe"]
-    },
-    {
-      "name": "observe_iframes1",
-      "categories": ["regression", "observe"]
-    },
-    {
-      "name": "observe_iframes2",
-      "categories": ["regression", "observe"]
-    },
-    {
-      "name": "extract_hamilton_weather",
-      "categories": ["targeted_extract", "regression"],
-      "extract_method": "textExtract"
-    },
-    {
-      "name": "extract_regulations_table",
-      "categories": ["targeted_extract"]
-    },
-    {
-      "name": "extract_recipe",
-      "categories": ["targeted_extract"]
-    },
-    {
-      "name": "extract_aigrant_targeted",
-      "categories": ["targeted_extract"]
-    },
-    {
-      "name": "extract_aigrant_targeted_2",
-      "categories": ["targeted_extract"]
-    },
-    {
-      "name": "extract_geniusee",
-      "categories": ["targeted_extract"]
-    },
-    {
-      "name": "extract_geniusee_2",
-      "categories": ["targeted_extract"]
-    },
-    {
-      "name": "scroll_50",
-      "categories": ["regression", "act"]
-    },
-    {
-      "name": "scroll_75",
-      "categories": ["regression", "act"]
-    },
-    {
-      "name": "nextChunk",
-      "categories": ["regression", "act"]
-    },
-    {
-      "name": "prevChunk",
-      "categories": ["regression", "act"]
-    },
-    {
-      "name": "google_flights",
-      "categories": ["act"]
-    },
-    {
-      "name": "extract_jfk_links",
-      "categories": ["extract"]
-    },
-    {
-      "name": "extract_single_link",
-      "categories": ["extract"]
-    }
-  ]
-}
diff --git a/evals/index.eval.ts b/evals/index.eval.ts
deleted file mode 100644
index 617214e1e..000000000
--- a/evals/index.eval.ts
+++ /dev/null
@@ -1,390 +0,0 @@
-/**
- * This script orchestrates the running of evaluations against a set of tasks.
- * It uses Braintrust to run multiple testcases (each testcase representing a
- * given task-model combination) and then aggregates the results, producing
- * a summary of passes, failures, and categorized success rates.
- *
- * Overview:
- * - Reads a configuration file `evals.config.json` to determine what tasks (evaluations)
- *   are available and which categories they belong to.
- * - Supports filtering which tasks to run either by evaluation category or by specific task name.
- * - Supports multiple models, defaulting to certain sets of models depending on the category.
- * - Runs each selected task against each selected model in parallel, collecting results.
- * - Saves a summary of the evaluation results to `eval-summary.json`.
- */
-import fs from "fs";
-import path from "path";
-import process from "process";
-import {
-  DEFAULT_EVAL_CATEGORIES,
-  filterByCategory,
-  filterByEvalName,
-  useTextExtract,
-} from "./args";
-import { generateExperimentName } from "./utils";
-import { exactMatch, errorMatch } from "./scoring";
-import { tasksByName, MODELS, tasksConfig } from "./taskConfig";
-import { Eval, wrapAISDKModel, wrapOpenAI } from "braintrust";
-import { EvalFunction, SummaryResult, Testcase } from "@/types/evals";
-import { EvalLogger } from "./logger";
-import { AvailableModel, LLMClient } from "@/dist";
-import { env } from "./env";
-import dotenv from "dotenv";
-import { StagehandEvalError } from "@/types/stagehandErrors";
-import { CustomOpenAIClient } from "@/examples/external_clients/customOpenAI";
-import OpenAI from "openai";
-import { initStagehand } from "./initStagehand";
-import { AISdkClient } from "@/examples/external_clients/aisdk";
-import { google } from "@ai-sdk/google";
-import { anthropic } from "@ai-sdk/anthropic";
-import { groq } from "@ai-sdk/groq";
-import { cerebras } from "@ai-sdk/cerebras";
-dotenv.config();
-
-/**
- * Read max concurrency and trial count from environment variables set in args.ts.
- * Fallback to defaults (20 and 5) if they're not provided.
- */
-const MAX_CONCURRENCY = process.env.EVAL_MAX_CONCURRENCY
-  ? parseInt(process.env.EVAL_MAX_CONCURRENCY, 10)
-  : 3;
-
-const TRIAL_COUNT = process.env.EVAL_TRIAL_COUNT
-  ? parseInt(process.env.EVAL_TRIAL_COUNT, 10)
-  : 3;
-
-/**
- * generateSummary:
- * After all evaluations have finished, aggregate the results into a summary.
- * This summary includes:
- * - Which tasks passed or failed (with model and categories).
- * - Category-wise success percentages.
- * - Model-wise success percentages.
- *
- * The summary is written to `eval-summary.json` for further analysis.
- */
-const generateSummary = async (
-  results: SummaryResult[],
-  experimentName: string,
-) => {
-  // Determine passed testcases (those with _success: true)
-  const passed = results
-    .filter((r) => r.output._success)
-    .map((r) => ({
-      eval: r.input.name,
-      model: r.input.modelName,
-      categories: tasksByName[r.input.name].categories,
-    }));
-
-  // Determine failed testcases (those with _success: false)
-  const failed = results
-    .filter((r) => !r.output._success)
-    .map((r) => ({
-      eval: r.input.name,
-      model: r.input.modelName,
-      categories: tasksByName[r.input.name].categories,
-    }));
-
-  // Calculate success counts for each category
-  const categorySuccessCounts: Record<
-    string,
-    { total: number; success: number }
-  > = {};
-  for (const taskName of Object.keys(tasksByName)) {
-    const taskCategories = tasksByName[taskName].categories;
-    const taskResults = results.filter((r) => r.input.name === taskName);
-    const successCount = taskResults.filter((r) => r.output._success).length;
-
-    for (const cat of taskCategories) {
-      if (!categorySuccessCounts[cat]) {
-        categorySuccessCounts[cat] = { total: 0, success: 0 };
-      }
-      categorySuccessCounts[cat].total += taskResults.length;
-      categorySuccessCounts[cat].success += successCount;
-    }
-  }
-
-  // Compute percentage success per category
-  const categories: Record<string, number> = {};
-  for (const [cat, counts] of Object.entries(categorySuccessCounts)) {
-    categories[cat] = Math.round((counts.success / counts.total) * 100);
-  }
-
-  // Compute percentage success per model
-  const models: Record<string, number> = {};
-  const allModels = [...new Set(results.map((r) => r.input.modelName))];
-  for (const model of allModels) {
-    const modelResults = results.filter((r) => r.input.modelName === model);
-    const successCount = modelResults.filter((r) => r.output._success).length;
-    models[model] = Math.round((successCount / modelResults.length) * 100);
-  }
-
-  // Format and write the summary to a JSON file
-  const formattedSummary = {
-    experimentName,
-    passed,
-    failed,
-    categories,
-    models,
-  };
-
-  fs.writeFileSync(
-    "eval-summary.json",
-    JSON.stringify(formattedSummary, null, 2),
-  );
-  console.log("Evaluation summary written to eval-summary.json");
-};
-
-/**
- * generateFilteredTestcases:
- * Based on the chosen filters (category or specific eval name) and environment,
- * this function generates the set of testcases to run. Each testcase is a combination
- * of a task and a model.
- *
- * Steps:
- * - Start with all combinations of tasks (from `tasksByName`) and models (`MODELS`).
- * - Filter by category if a category filter was specified.
- * - Filter by evaluation name if specified.
- * - In the BROWSERBASE environment, exclude certain tasks that are not suitable.
- */
-const generateFilteredTestcases = (): Testcase[] => {
-  // Create a list of all testcases for each model-task combination.
-  let allTestcases = MODELS.flatMap((model) =>
-    Object.keys(tasksByName).map((testName) => ({
-      input: { name: testName, modelName: model },
-      name: testName,
-      tags: [
-        model,
-        testName,
-        ...(tasksConfig.find((t) => t.name === testName)?.categories || []).map(
-          (x) => `category/${x}`,
-        ),
-      ],
-      metadata: {
-        model,
-        test: testName,
-        categories: tasksConfig.find((t) => t.name === testName)?.categories,
-      },
-      expected: true,
-    })),
-  );
-
-  // Filter test cases to match default eval categories
-  allTestcases = allTestcases.filter((testcase) =>
-    DEFAULT_EVAL_CATEGORIES.some((category) =>
-      tasksByName[testcase.name].categories.includes(category),
-    ),
-  );
-
-  // Filter by category if a category is specified
-  if (filterByCategory) {
-    allTestcases = allTestcases.filter((testcase) =>
-      tasksByName[testcase.name].categories.includes(filterByCategory!),
-    );
-  }
-
-  // Filter by a specific evaluation (task) name if specified
-  if (filterByEvalName) {
-    allTestcases = allTestcases.filter(
-      (testcase) =>
-        testcase.name === filterByEvalName ||
-        testcase.input.name === filterByEvalName,
-    );
-  }
-
-  // If running in BROWSERBASE environment, exclude tasks that are not applicable.
-  if (env === "BROWSERBASE") {
-    allTestcases = allTestcases.filter(
-      (testcase) => !["peeler_simple", "stock_x"].includes(testcase.name),
-    );
-  }
-
-  console.log(
-    "All test cases:",
-    allTestcases
-      .map(
-        (t, i) =>
-          `${i}: ${t.name} (${t.input.modelName}): ${t.metadata.categories}`,
-      )
-      .join("\n"),
-  );
-
-  return allTestcases;
-};
-
-/**
- * Main execution block:
- * - Determine experiment name
- * - Determine the project name (braintrustProjectName) based on CI or dev environment
- * - Run the Eval function with the given configuration:
- *    * experimentName: A label for this run
- *    * data: A function that returns the testcases to run
- *    * task: A function that executes each task, given input specifying model and task name
- *    * scores: An array of scoring functions
- *    * maxConcurrency: Limit on parallel tasks
- *    * trialCount: Number of trials (retries) per task
- * - Collect and summarize results using `generateSummary`.
- */
-(async () => {
-  // Generate a unique name for the experiment
-  const experimentName: string = generateExperimentName({
-    evalName: filterByEvalName || undefined,
-    category: filterByCategory || undefined,
-    environment: env,
-  });
-
-  // Determine braintrust project name to use (stagehand in CI, stagehand-dev otherwise)
-  const braintrustProjectName =
-    process.env.CI === "true" ? "stagehand" : "stagehand-dev";
-
-  try {
-    // Run the evaluations with the braintrust Eval function
-    const evalResult = await Eval(braintrustProjectName, {
-      experimentName,
-      data: generateFilteredTestcases,
-      // Each test is a function that runs the corresponding task module
-      task: async (input: { name: string; modelName: AvailableModel }) => {
-        const logger = new EvalLogger();
-        try {
-          // Dynamically import the task based on its name
-          const taskModulePath = path.join(
-            __dirname,
-            "tasks",
-            `${input.name}.ts`,
-          );
-          const taskModule = (await import(taskModulePath)) as {
-            [key: string]: EvalFunction;
-          };
-          const taskFunction = taskModule[input.name];
-
-          if (typeof taskFunction !== "function") {
-            throw new StagehandEvalError(
-              `No Eval function found for task name: ${input.name}`,
-            );
-          }
-          let shouldUseTextExtract = useTextExtract;
-          const categories = tasksByName[input.name].categories || [];
-          const isRegression = categories.includes("regression");
-          const regressionExtractMethod = tasksByName[input.name].extractMethod;
-          if (isRegression) {
-            if (regressionExtractMethod) {
-              shouldUseTextExtract = regressionExtractMethod === "textExtract";
-            }
-          }
-
-          // Execute the task
-          let llmClient: LLMClient;
-          if (input.modelName.startsWith("gpt")) {
-            llmClient = new CustomOpenAIClient({
-              modelName: input.modelName as AvailableModel,
-              client: wrapOpenAI(
-                new OpenAI({
-                  apiKey: process.env.OPENAI_API_KEY,
-                }),
-              ),
-            });
-          } else if (input.modelName.startsWith("gemini")) {
-            llmClient = new AISdkClient({
-              model: wrapAISDKModel(google(input.modelName)),
-            });
-          } else if (input.modelName.startsWith("claude")) {
-            llmClient = new AISdkClient({
-              model: wrapAISDKModel(anthropic(input.modelName)),
-            });
-          } else if (input.modelName.includes("groq")) {
-            llmClient = new AISdkClient({
-              model: wrapAISDKModel(
-                groq(
-                  input.modelName.substring(input.modelName.indexOf("/") + 1),
-                ),
-              ),
-            });
-          } else if (input.modelName.includes("cerebras")) {
-            llmClient = new AISdkClient({
-              model: wrapAISDKModel(
-                cerebras(
-                  input.modelName.substring(input.modelName.indexOf("/") + 1),
-                ),
-              ),
-            });
-          } else if (input.modelName.includes("/")) {
-            llmClient = new CustomOpenAIClient({
-              modelName: input.modelName as AvailableModel,
-              client: wrapOpenAI(
-                new OpenAI({
-                  apiKey: process.env.TOGETHER_AI_API_KEY,
-                  baseURL: "https://api.together.xyz/v1",
-                }),
-              ),
-            });
-          }
-          const taskInput = await initStagehand({
-            logger,
-            llmClient,
-            useTextExtract: shouldUseTextExtract,
-          });
-          let result;
-          try {
-            result = await taskFunction(taskInput);
-            // Log result to console
-            if (result && result._success) {
-              console.log(`✅ ${input.name}: Passed`);
-            } else {
-              console.log(`❌ ${input.name}: Failed`);
-            }
-          } finally {
-            await taskInput.stagehand.close();
-          }
-          return result;
-        } catch (error) {
-          // Log any errors that occur during task execution
-          console.error(`❌ ${input.name}: Error - ${error}`);
-          logger.error({
-            message: `Error in task ${input.name}`,
-            level: 0,
-            auxiliary: {
-              error: {
-                value: error.message,
-                type: "string",
-              },
-              trace: {
-                value: error.stack,
-                type: "string",
-              },
-            },
-          });
-          return {
-            _success: false,
-            error: JSON.parse(JSON.stringify(error, null, 2)),
-            logs: logger.getLogs(),
-          };
-        }
-      },
-      // Use the scoring functions defined above
-      scores: [exactMatch, errorMatch],
-      maxConcurrency: MAX_CONCURRENCY,
-      trialCount: TRIAL_COUNT,
-    });
-
-    // Map results to the SummaryResult format
-    const summaryResults: SummaryResult[] = evalResult.results.map((result) => {
-      const output =
-        typeof result.output === "boolean"
-          ? { _success: result.output }
-          : result.output;
-
-      return {
-        input: result.input,
-        output,
-        name: result.input.name,
-        score: output._success ? 1 : 0,
-      };
-    });
-
-    // Generate and write the summary
-    await generateSummary(summaryResults, experimentName);
-  } catch (error) {
-    console.error("Error during evaluation run:", error);
-    process.exit(1);
-  }
-})();
diff --git a/evals/initStagehand.ts b/evals/initStagehand.ts
deleted file mode 100644
index 174778aea..000000000
--- a/evals/initStagehand.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-/**
- * This file provides a function to initialize a Stagehand instance for use in evaluations.
- * It configures the Stagehand environment and sets default options based on the current environment
- * (e.g., local or BROWSERBASE), caching preferences, and verbosity. It also establishes a logger for
- * capturing logs emitted by Stagehand.
- *
- * We create a central config object (`StagehandConfig`) that defines all parameters for Stagehand.
- *
- * The `initStagehand` function takes the model name, an optional DOM settling timeout, and an EvalLogger,
- * then uses these to override some default values before creating and initializing the Stagehand instance.
- */
-
-import { enableCaching, env } from "./env";
-import { ConstructorParams, LLMClient, Stagehand } from "@/dist";
-import { EvalLogger } from "./logger";
-import type { StagehandInitResult } from "@/types/evals";
-
-/**
- * StagehandConfig:
- * This configuration object follows a similar pattern to `examples/stagehand.config.ts`.
- * It sets the environment, verbosity, caching preferences, and other defaults. Some values,
- * like `apiKey` and `projectId`, can be defined via environment variables if needed.
- *
- * Adjust or remove fields as appropriate for your environment.
- */
-const StagehandConfig = {
-  env: env,
-  apiKey: process.env.BROWSERBASE_API_KEY,
-  projectId: process.env.BROWSERBASE_PROJECT_ID,
-  verbose: 2 as const,
-  debugDom: true,
-  headless: false,
-  enableCaching,
-  domSettleTimeoutMs: 30_000,
-  disablePino: true,
-};
-
-/**
- * Initializes a Stagehand instance for a given model:
- * - modelName: The model to use (overrides default in StagehandConfig)
- * - domSettleTimeoutMs: Optional timeout for DOM settling operations
- * - logger: An EvalLogger instance for capturing logs
- *
- * Returns:
- * - stagehand: The initialized Stagehand instance
- * - logger: The provided logger, associated with the Stagehand instance
- * - initResponse: Any response data returned by Stagehand initialization
- */
-export const initStagehand = async ({
-  llmClient,
-  domSettleTimeoutMs,
-  logger,
-  configOverrides,
-  actTimeoutMs,
-  useTextExtract,
-}: {
-  llmClient: LLMClient;
-  domSettleTimeoutMs?: number;
-  logger: EvalLogger;
-  configOverrides?: Partial<ConstructorParams>;
-  actTimeoutMs?: number;
-  useTextExtract?: boolean;
-}): Promise<StagehandInitResult> => {
-  const config = {
-    ...StagehandConfig,
-    llmClient,
-    ...(domSettleTimeoutMs && { domSettleTimeoutMs }),
-    actTimeoutMs,
-    ...configOverrides,
-    logger: logger.log.bind(logger),
-  };
-
-  const stagehand = new Stagehand(config);
-
-  // Associate the logger with the Stagehand instance
-  logger.init(stagehand);
-
-  const { debugUrl, sessionUrl } = await stagehand.init();
-  return {
-    stagehand,
-    stagehandConfig: config,
-    logger,
-    debugUrl,
-    sessionUrl,
-    useTextExtract,
-  };
-};
diff --git a/evals/llm_clients/hn_aisdk.ts b/evals/llm_clients/hn_aisdk.ts
deleted file mode 100644
index 51ab4937e..000000000
--- a/evals/llm_clients/hn_aisdk.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-import { Stagehand } from "@/dist";
-import { AISdkClient } from "@/examples/external_clients/aisdk";
-import { EvalFunction } from "@/types/evals";
-import { openai } from "@ai-sdk/openai/dist";
-import { z } from "zod";
-
-export const hn_aisdk: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehandConfig,
-  logger,
-}) => {
-  const stagehand = new Stagehand({
-    ...stagehandConfig,
-    llmClient: new AISdkClient({
-      model: openai("gpt-4o-mini"),
-    }),
-  });
-  await stagehand.init();
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/hackernews/",
-  );
-
-  let { story } = await stagehand.page.extract({
-    instruction: "extract the title of the top story on the page",
-    schema: z.object({
-      story: z.string().describe("the title of the top story on the page"),
-    }),
-  });
-  // remove the (url) part of the story title
-  story = story.split(" (")[0];
-
-  const expectedStoryElement = await stagehand.page.$(
-    "xpath=/html/body/center/table/tbody/tr[3]/td/table/tbody/tr[1]/td[3]/span/a",
-  );
-  // remove the (url) part of the story title
-  const expectedStory = (await expectedStoryElement?.textContent())?.split(
-    " (",
-  )?.[0];
-
-  if (!expectedStory) {
-    logger.error({
-      message: "Could not find expected story element",
-      level: 0,
-    });
-    return {
-      _success: false,
-      error: "Could not find expected story element",
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  if (story !== expectedStory) {
-    logger.error({
-      message: "Extracted story does not match expected story",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: expectedStory,
-          type: "string",
-        },
-        actual: {
-          value: story,
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Extracted story does not match expected story",
-      expectedStory,
-      actualStory: story,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  await stagehand.page.act("Click on the 'new' tab");
-
-  if (stagehand.page.url() !== "https://news.ycombinator.com/newest") {
-    logger.error({
-      message: "Page did not navigate to the 'new' tab",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: "https://news.ycombinator.com/newest",
-          type: "string",
-        },
-        actual: {
-          value: stagehand.page.url(),
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Page did not navigate to the 'new' tab",
-      expectedUrl: "https://news.ycombinator.com/newest",
-      actualUrl: stagehand.page.url(),
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  await stagehand.close();
-
-  return {
-    _success: true,
-    expectedStory,
-    actualStory: story,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/llm_clients/hn_customOpenAI.ts b/evals/llm_clients/hn_customOpenAI.ts
deleted file mode 100644
index 7b4f1f1e5..000000000
--- a/evals/llm_clients/hn_customOpenAI.ts
+++ /dev/null
@@ -1,124 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { z } from "zod";
-import { CustomOpenAIClient } from "@/examples/external_clients/customOpenAI";
-import OpenAI from "openai";
-import { Stagehand } from "@/dist";
-
-export const hn_customOpenAI: EvalFunction = async ({
-  logger,
-  stagehandConfig,
-  debugUrl,
-  sessionUrl,
-}) => {
-  const stagehand = new Stagehand({
-    ...stagehandConfig,
-    llmClient: new CustomOpenAIClient({
-      modelName: "gpt-4o-mini",
-      client: new OpenAI({
-        apiKey: process.env.OPENAI_API_KEY,
-      }),
-    }),
-  });
-
-  await stagehand.init();
-
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/hackernews/",
-  );
-
-  let { story } = await stagehand.page.extract({
-    instruction: "extract the title of the top story on the page",
-    schema: z.object({
-      story: z.string().describe("the title of the top story on the page"),
-    }),
-  });
-  // remove the (url) part of the story title
-  story = story.split(" (")[0];
-
-  const expectedStoryElement = await stagehand.page.$(
-    "xpath=/html/body/center/table/tbody/tr[3]/td/table/tbody/tr[1]/td[3]/span/a",
-  );
-  // remove the (url) part of the story title
-  const expectedStory = (await expectedStoryElement?.textContent())?.split(
-    " (",
-  )?.[0];
-
-  if (!expectedStory) {
-    logger.error({
-      message: "Could not find expected story element",
-      level: 0,
-    });
-    return {
-      _success: false,
-      error: "Could not find expected story element",
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  if (story !== expectedStory) {
-    logger.error({
-      message: "Extracted story does not match expected story",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: expectedStory,
-          type: "string",
-        },
-        actual: {
-          value: story,
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Extracted story does not match expected story",
-      expectedStory,
-      actualStory: story,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  await stagehand.page.act("Click on the 'new' tab");
-
-  if (stagehand.page.url() !== "https://news.ycombinator.com/newest") {
-    logger.error({
-      message: "Page did not navigate to the 'new' tab",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: "https://news.ycombinator.com/newest",
-          type: "string",
-        },
-        actual: {
-          value: stagehand.page.url(),
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Page did not navigate to the 'new' tab",
-      expectedUrl: "https://news.ycombinator.com/newest",
-      actualUrl: stagehand.page.url(),
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  await stagehand.close();
-
-  return {
-    _success: true,
-    expectedStory,
-    actualStory: story,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/llm_clients/hn_langchain.ts b/evals/llm_clients/hn_langchain.ts
deleted file mode 100644
index 35fc6b68d..000000000
--- a/evals/llm_clients/hn_langchain.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { z } from "zod";
-import { LangchainClient } from "@/examples/external_clients/langchain";
-import { ChatOpenAI } from "@langchain/openai";
-import { Stagehand } from "@/dist";
-
-export const hn_langchain: EvalFunction = async ({
-  logger,
-  stagehandConfig,
-  debugUrl,
-  sessionUrl,
-}) => {
-  const stagehand = new Stagehand({
-    ...stagehandConfig,
-    llmClient: new LangchainClient(
-      new ChatOpenAI({
-        model: "gpt-4o-mini",
-      }),
-    ),
-  });
-  await stagehand.init();
-
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/hackernews/",
-  );
-
-  let { story } = await stagehand.page.extract({
-    instruction: "extract the title of the top story on the page",
-    schema: z.object({
-      story: z.string().describe("the title of the top story on the page"),
-    }),
-  });
-  // remove the (url) part of the story title
-  story = story.split(" (")[0];
-
-  const expectedStoryElement = await stagehand.page.$(
-    "xpath=/html/body/center/table/tbody/tr[3]/td/table/tbody/tr[1]/td[3]/span/a",
-  );
-  // remove the (url) part of the story title
-  const expectedStory = (await expectedStoryElement?.textContent())?.split(
-    " (",
-  )?.[0];
-
-  if (!expectedStory) {
-    logger.error({
-      message: "Could not find expected story element",
-      level: 0,
-    });
-    return {
-      _success: false,
-      error: "Could not find expected story element",
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  if (story !== expectedStory) {
-    logger.error({
-      message: "Extracted story does not match expected story",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: expectedStory,
-          type: "string",
-        },
-        actual: {
-          value: story,
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Extracted story does not match expected story",
-      expectedStory,
-      actualStory: story,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  await stagehand.page.act("Click on the 'new' tab");
-
-  if (stagehand.page.url() !== "https://news.ycombinator.com/newest") {
-    logger.error({
-      message: "Page did not navigate to the 'new' tab",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: "https://news.ycombinator.com/newest",
-          type: "string",
-        },
-        actual: {
-          value: stagehand.page.url(),
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Page did not navigate to the 'new' tab",
-      expectedUrl: "https://news.ycombinator.com/newest",
-      actualUrl: stagehand.page.url(),
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  await stagehand.close();
-
-  return {
-    _success: true,
-    expectedStory,
-    actualStory: story,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/allrecipes.ts b/evals/tasks/allrecipes.ts
deleted file mode 100644
index e1b8a0c50..000000000
--- a/evals/tasks/allrecipes.ts
+++ /dev/null
@@ -1,92 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { z } from "zod";
-
-export const allrecipes: EvalFunction = async ({
-  logger,
-  useTextExtract,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  await stagehand.page.goto("https://www.allrecipes.com/", {
-    waitUntil: "domcontentloaded",
-  });
-
-  await stagehand.page.act({
-    action: 'Type "chocolate chip cookies" in the search bar',
-  });
-  await stagehand.page.act({
-    action: "press enter",
-  });
-
-  const recipeDetails = await stagehand.page.extract({
-    instruction:
-      "Extract the title of the first recipe and the total number of ratings it has received.",
-    schema: z.object({
-      title: z.string().describe("Title of the recipe"),
-      total_ratings: z
-        .string()
-        .describe("Total number of ratings for the recipe"),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-
-  const { title, total_ratings } = recipeDetails;
-  const expectedTitle = "Best Chocolate Chip Cookies";
-  const expectedRatings = 19164;
-
-  const extractedRatings = parseInt(total_ratings.replace(/[^\d]/g, ""), 10);
-  const isRatingsWithinRange =
-    extractedRatings >= expectedRatings - 1000 &&
-    extractedRatings <= expectedRatings + 1000;
-
-  if (title !== expectedTitle || !isRatingsWithinRange) {
-    const errors = [];
-    if (title !== expectedTitle) {
-      errors.push({
-        message: "Extracted title does not match the expected title",
-        expected: expectedTitle,
-        actual: title,
-      });
-    }
-    if (!isRatingsWithinRange) {
-      errors.push({
-        message: "Extracted ratings are not within the expected range",
-        expected: `${expectedRatings} ± 1000`,
-        actual: extractedRatings.toString(),
-      });
-    }
-
-    logger.error({
-      message: "Failed to extract correct recipe details",
-      level: 0,
-      auxiliary: {
-        errors: {
-          value: JSON.stringify(errors),
-          type: "object",
-        },
-      },
-    });
-
-    return {
-      _success: false,
-      error: "Recipe details extraction validation failed",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    recipeDetails: {
-      title,
-      total_ratings: extractedRatings,
-    },
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/amazon_add_to_cart.ts b/evals/tasks/amazon_add_to_cart.ts
deleted file mode 100644
index 64c410f8f..000000000
--- a/evals/tasks/amazon_add_to_cart.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const amazon_add_to_cart: EvalFunction = async ({
-  logger,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/amazon/",
-  );
-
-  await stagehand.page.waitForTimeout(5000);
-
-  await stagehand.page.act({
-    action: "click the 'Add to Cart' button",
-  });
-
-  await stagehand.page.waitForTimeout(2000);
-
-  await stagehand.page.act({
-    action: "click the 'Proceed to checkout' button",
-  });
-
-  await stagehand.page.waitForTimeout(2000);
-  const currentUrl = stagehand.page.url();
-  const expectedUrl =
-    "https://browserbase.github.io/stagehand-eval-sites/sites/amazon/sign-in.html";
-
-  await stagehand.close();
-
-  return {
-    _success: currentUrl === expectedUrl,
-    currentUrl,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/apple.ts b/evals/tasks/apple.ts
deleted file mode 100644
index 1926a1718..000000000
--- a/evals/tasks/apple.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const apple: EvalFunction = async ({
-  logger,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  await stagehand.page.goto("https://www.apple.com/iphone-16-pro/");
-
-  await stagehand.page.act({ action: "click on the buy button" });
-  await stagehand.page.act({ action: "select the Pro Max model" });
-  await stagehand.page.act({ action: "select the natural titanium color" });
-  await stagehand.page.act({ action: "select the 256GB storage option" });
-  await stagehand.page.act({
-    action: "click on the 'select a smartphone' trade-in option",
-  });
-
-  await stagehand.page.act({
-    action: "select the iPhone 13 mini model from the dropdown",
-  });
-  await stagehand.page.act({
-    action: "select the iPhone 13 mini is in good condition",
-  });
-
-  const successMessageLocator = stagehand.page.locator(
-    'text="Good News. Your iPhone 13 mini qualifies for credit."',
-  );
-  const isVisible = await successMessageLocator.isVisible();
-
-  await stagehand.close();
-
-  return {
-    _success: isVisible,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/bidnet.ts b/evals/tasks/bidnet.ts
deleted file mode 100644
index d73c83030..000000000
--- a/evals/tasks/bidnet.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const bidnet: EvalFunction = async ({
-  logger,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  await stagehand.page.goto("https://www.bidnetdirect.com/");
-
-  await stagehand.page.act({
-    action: 'Click on the "Construction" keyword',
-  });
-
-  const expectedUrl =
-    "https://www.bidnetdirect.com/public/solicitations/open?keywords=Construction";
-  const currentUrl = stagehand.page.url();
-
-  await stagehand.close();
-
-  return {
-    _success: currentUrl.startsWith(expectedUrl),
-    currentUrl,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/combination_sauce.ts b/evals/tasks/combination_sauce.ts
deleted file mode 100644
index fc8bfc32e..000000000
--- a/evals/tasks/combination_sauce.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { z } from "zod";
-
-export const combination_sauce: EvalFunction = async ({
-  logger,
-  useTextExtract,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  try {
-    await stagehand.page.goto("https://www.saucedemo.com/");
-
-    const { usernames, password } = await stagehand.page.extract({
-      instruction: "extract the accepted usernames and the password for login",
-      schema: z.object({
-        usernames: z.array(z.string()).describe("the accepted usernames"),
-        password: z.string().describe("the password for login"),
-      }),
-      useTextExtract,
-    });
-
-    await stagehand.page.act({
-      action: `enter username 'standard_user'`,
-    });
-
-    await stagehand.page.act({
-      action: `enter password '${password}'`,
-    });
-
-    await stagehand.page.act({
-      action: "click on 'login'",
-    });
-
-    const observations = await stagehand.page.observe({
-      instruction: "find all the 'add to cart' buttons",
-    });
-
-    console.log("observations", observations);
-    console.log("observations length", observations.length);
-
-    const url = await stagehand.page.url();
-
-    await stagehand.close();
-
-    const usernamesCheck = usernames.length === 6;
-    const urlCheck = url === "https://www.saucedemo.com/inventory.html";
-    const observationsCheck = observations.length === 6;
-
-    return {
-      _success: usernamesCheck && urlCheck && observationsCheck,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  } catch (error) {
-    console.error("Error or timeout occurred:", error);
-
-    await stagehand.close();
-
-    return {
-      _success: false,
-      error: JSON.parse(JSON.stringify(error, null, 2)),
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-};
diff --git a/evals/tasks/expect_act_timeout.ts b/evals/tasks/expect_act_timeout.ts
deleted file mode 100644
index 0a6f45170..000000000
--- a/evals/tasks/expect_act_timeout.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const expect_act_timeout: EvalFunction = async ({
-  logger,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  await stagehand.page.goto("https://docs.stagehand.dev");
-  const result = await stagehand.page.act({
-    action: "search for 'Stagehand'",
-    timeoutMs: 1_000,
-  });
-
-  await stagehand.close();
-
-  return {
-    _success: !result.success,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/expedia.ts b/evals/tasks/expedia.ts
deleted file mode 100644
index ac5645a5d..000000000
--- a/evals/tasks/expedia.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const expedia: EvalFunction = async ({
-  logger,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  try {
-    await stagehand.page.goto("https://www.expedia.com/flights");
-    await stagehand.page.act(
-      "find round-trip flights from San Francisco (SFO) to Toronto (YYZ) for Jan 1, 2025 (up to one to two weeks)",
-    );
-    await stagehand.page.act("Go to the first non-stop flight");
-    await stagehand.page.act("select the cheapest flight");
-    await stagehand.page.act("click on the first non-stop flight");
-    await stagehand.page.act("Take me to the checkout page");
-
-    const url = stagehand.page.url();
-    return {
-      _success: url.startsWith("https://www.expedia.com/Checkout/"),
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  } catch (error) {
-    logger.error({
-      message: "Error in expedia eval",
-      level: 0,
-      auxiliary: {
-        error: { value: error.message, type: "string" },
-        trace: { value: error.stack, type: "string" },
-      },
-    });
-
-    return {
-      _success: false,
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  } finally {
-    await stagehand.close();
-  }
-};
diff --git a/evals/tasks/expedia_search.ts b/evals/tasks/expedia_search.ts
deleted file mode 100644
index 592e553dd..000000000
--- a/evals/tasks/expedia_search.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const expedia_search: EvalFunction = async ({
-  logger,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  try {
-    await stagehand.page.goto("https://www.expedia.com/flights");
-    await stagehand.page.act({
-      action:
-        "find round-trip flights from San Francisco (SFO) to Toronto (YYZ) for Jan 1, 2025 (up to one to two weeks)",
-    });
-
-    await stagehand.page.act({ action: "Go to the first non-stop flight" });
-
-    await stagehand.page.act({ action: "select the cheapest flight" });
-
-    await stagehand.page.act({ action: "click on the first non-stop flight" });
-
-    await stagehand.page.act({
-      action: "Take me to the checkout page",
-    });
-
-    const url = stagehand.page.url();
-    return {
-      _success: url.startsWith("https://www.expedia.com/Checkout/"),
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  } catch (error) {
-    logger.error({
-      message: `error in expedia function`,
-      level: 0,
-      auxiliary: {
-        error: {
-          value: JSON.stringify(error, null, 2),
-          type: "object",
-        },
-        trace: {
-          value: error.stack,
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: JSON.parse(JSON.stringify(error, null, 2)),
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  } finally {
-    await stagehand.close();
-  }
-};
diff --git a/evals/tasks/extract_aigrant_companies.ts b/evals/tasks/extract_aigrant_companies.ts
deleted file mode 100644
index f3e1f19cb..000000000
--- a/evals/tasks/extract_aigrant_companies.ts
+++ /dev/null
@@ -1,127 +0,0 @@
-import { z } from "zod";
-import { EvalFunction } from "@/types/evals";
-
-export const extract_aigrant_companies: EvalFunction = async ({
-  logger,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  useTextExtract,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/aigrant/",
-  );
-  const companyList = await stagehand.page.extract({
-    instruction:
-      "Extract all companies that received the AI grant and group them with their batch numbers as an array of objects. Each object should contain the company name and its corresponding batch number.",
-    schema: z.object({
-      companies: z.array(
-        z.object({
-          company: z.string(),
-          batch: z.string(),
-        }),
-      ),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-  const companies = companyList.companies;
-  const expectedLength = 91;
-
-  const expectedFirstItem = {
-    company: "Goodfire",
-    batch: "4",
-  };
-
-  const expectedLastItem = {
-    company: "Forefront",
-    batch: "1",
-  };
-
-  if (companies.length !== expectedLength) {
-    logger.error({
-      message: "Incorrect number of companies extracted",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: expectedLength.toString(),
-          type: "integer",
-        },
-        actual: {
-          value: companies.length.toString(),
-          type: "integer",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Incorrect number of companies extracted",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-  const firstItemMatches =
-    companies[0].company === expectedFirstItem.company &&
-    companies[0].batch === expectedFirstItem.batch;
-
-  if (!firstItemMatches) {
-    logger.error({
-      message: "First company extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: JSON.stringify(expectedFirstItem),
-          type: "object",
-        },
-        actual: {
-          value: JSON.stringify(companies[0]),
-          type: "object",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "First company extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  const lastItemMatches =
-    companies[companies.length - 1].company === expectedLastItem.company &&
-    companies[companies.length - 1].batch === expectedLastItem.batch;
-
-  if (!lastItemMatches) {
-    logger.error({
-      message: "Last company extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: JSON.stringify(expectedLastItem),
-          type: "object",
-        },
-        actual: {
-          value: JSON.stringify(companies[companies.length - 1]),
-          type: "object",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Last company extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_aigrant_targeted.ts b/evals/tasks/extract_aigrant_targeted.ts
deleted file mode 100644
index d72328505..000000000
--- a/evals/tasks/extract_aigrant_targeted.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import { z } from "zod";
-import { EvalFunction } from "@/types/evals";
-
-export const extract_aigrant_targeted: EvalFunction = async ({
-  logger,
-  useTextExtract,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/aigrant/",
-  );
-  const selector = "/html/body/div/ul[5]/li[28]";
-  const company = await stagehand.page.extract({
-    instruction: "Extract the company name.",
-    schema: z.object({
-      company_name: z.string(),
-    }),
-    useTextExtract,
-    selector: selector,
-  });
-
-  await stagehand.close();
-  const companyName = company.company_name;
-
-  const expectedName = {
-    company_name: "Coframe",
-  };
-
-  const nameMatches = companyName == expectedName.company_name;
-
-  if (!nameMatches) {
-    logger.error({
-      message: "extracted company name does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: expectedName.company_name,
-          type: "string",
-        },
-        actual: {
-          value: companyName,
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Company name does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_aigrant_targeted_2.ts b/evals/tasks/extract_aigrant_targeted_2.ts
deleted file mode 100644
index 772d2f4a4..000000000
--- a/evals/tasks/extract_aigrant_targeted_2.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-import { z } from "zod";
-import { EvalFunction } from "@/types/evals";
-
-export const extract_aigrant_targeted_2: EvalFunction = async ({
-  logger,
-  useTextExtract,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/aigrant/",
-  );
-  const selector = "/html/body/div/ul[5]/li[28]";
-  const company = await stagehand.page.extract({
-    instruction: "Extract the name of the company that comes after 'Coframe'.",
-    schema: z.object({
-      company_name: z.string(),
-    }),
-    useTextExtract,
-    selector: selector,
-  });
-
-  await stagehand.close();
-  const companyName = company.company_name;
-
-  // nameWeShouldNotGet matches the name of the company that comes after
-  // CoFrame on the website. Since we are using targeted_extract here,
-  // and passing in a selector that does NOT contain the nameWeShouldNotGet,
-  // the LLM should have no visibility into what comes after 'CoFrame' if
-  // targeted_extract is performing correctly
-  const nameWeShouldNotGet = {
-    company_name: "OpusClip",
-  };
-
-  const nameMatches = companyName == nameWeShouldNotGet.company_name;
-
-  if (nameMatches) {
-    logger.error({
-      message:
-        "extracted company name matches the company name that we SHOULD NOT get",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: nameWeShouldNotGet.company_name,
-          type: "string",
-        },
-        actual: {
-          value: companyName,
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error:
-        "extracted company name matches the company name that we SHOULD NOT get",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_apartments.ts b/evals/tasks/extract_apartments.ts
deleted file mode 100644
index 96cfd06b7..000000000
--- a/evals/tasks/extract_apartments.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-import { z } from "zod";
-import { EvalFunction } from "../../types/evals";
-
-export const extract_apartments: EvalFunction = async ({
-  logger,
-  useTextExtract,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  await stagehand.page.goto(
-    "https://www.apartments.com/san-francisco-ca/2-bedrooms/",
-  );
-  const apartment_listings = await stagehand.page.extract({
-    instruction:
-      "Extract all the apartment listings with their prices and their addresses.",
-    schema: z.object({
-      listings: z.array(
-        z.object({
-          price: z.string().describe("The price of the listing"),
-          trails: z.string().describe("The address of the listing"),
-        }),
-      ),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-  const listings = apartment_listings.listings;
-  const expectedLength = 40;
-
-  if (listings.length < expectedLength) {
-    logger.error({
-      message: "Incorrect number of listings extracted",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: expectedLength.toString(),
-          type: "integer",
-        },
-        actual: {
-          value: listings.length.toString(),
-          type: "integer",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Incorrect number of listings extracted",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_area_codes.ts b/evals/tasks/extract_area_codes.ts
deleted file mode 100644
index 07f99ec32..000000000
--- a/evals/tasks/extract_area_codes.ts
+++ /dev/null
@@ -1,153 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { z } from "zod";
-
-export const extract_area_codes: EvalFunction = async ({
-  logger,
-  useTextExtract,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/ncc-area-codes/",
-    { waitUntil: "domcontentloaded" },
-  );
-
-  const result = await stagehand.page.extract({
-    instruction:
-      "Extract ALL the Primary Center names and their corresponding Area Code, and the name of their corresponding Zone.",
-    schema: z.object({
-      primary_center_list: z.array(
-        z.object({
-          zone_name: z
-            .string()
-            .describe(
-              "The name of the Zone that the Primary Center is in. For example, 'North Central Zone'.",
-            ),
-          primary_center_name: z
-            .string()
-            .describe(
-              "The name of the Primary Center. I.e., this is the name of the city or town.",
-            ),
-          area_code: z
-            .string()
-            .describe(
-              "The area code for the Primary Center. This will either be 2 or 3 digits.",
-            ),
-        }),
-      ),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-
-  const primaryCenterList = result.primary_center_list;
-  const expectedLength = 56;
-
-  const expectedFirstItem = {
-    zone_name: "Lagos Zone",
-    primary_center_name: "Lagos",
-    area_code: "01",
-  };
-
-  const expectedLastItem = {
-    zone_name: "South-East",
-    primary_center_name: "Yenagoa",
-    area_code: "089",
-  };
-
-  if (primaryCenterList.length !== expectedLength) {
-    logger.error({
-      message: "Incorrect number of primary centers extracted",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: expectedLength.toString(),
-          type: "integer",
-        },
-        actual: {
-          value: primaryCenterList.length.toString(),
-          type: "integer",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Incorrect number of primary centers extracted",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-  const firstItemMatches =
-    primaryCenterList[0].zone_name === expectedFirstItem.zone_name &&
-    primaryCenterList[0].primary_center_name ===
-      expectedFirstItem.primary_center_name &&
-    primaryCenterList[0].area_code === expectedFirstItem.area_code;
-
-  if (!firstItemMatches) {
-    logger.error({
-      message: "First primary center extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: JSON.stringify(expectedFirstItem),
-          type: "object",
-        },
-        actual: {
-          value: JSON.stringify(primaryCenterList[0]),
-          type: "object",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "First primary center extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  const lastItemMatches =
-    primaryCenterList[primaryCenterList.length - 1].zone_name ===
-      expectedLastItem.zone_name &&
-    primaryCenterList[primaryCenterList.length - 1].primary_center_name ===
-      expectedLastItem.primary_center_name &&
-    primaryCenterList[primaryCenterList.length - 1].area_code ===
-      expectedLastItem.area_code;
-
-  if (!lastItemMatches) {
-    logger.error({
-      message: "Last primary center extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: JSON.stringify(expectedLastItem),
-          type: "object",
-        },
-        actual: {
-          value: JSON.stringify(
-            primaryCenterList[primaryCenterList.length - 1],
-          ),
-          type: "object",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Last primary center extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_baptist_health.ts b/evals/tasks/extract_baptist_health.ts
deleted file mode 100644
index 1bb90d83e..000000000
--- a/evals/tasks/extract_baptist_health.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { compareStrings } from "@/evals/utils";
-import { z } from "zod";
-
-export const extract_baptist_health: EvalFunction = async ({
-  logger,
-  useTextExtract,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/baptist-health/",
-  );
-
-  const result = await stagehand.page.extract({
-    instruction:
-      "Extract the address, phone number, and fax number of the healthcare location.",
-    schema: z.object({
-      address: z.string(),
-      phone: z.string(),
-      fax: z.string(),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-
-  const { address, phone, fax } = result;
-  const expected = {
-    address: "2055 East South Blvd; Suite 908 Montgomery, AL 36116",
-    phone: "334-747-2273",
-    fax: "334-747-7501",
-  };
-
-  const similarityThreshold = 0.85;
-  const failedFields: Array<{
-    field: string;
-    similarity: number;
-    expected: string;
-    actual: string;
-  }> = [];
-
-  const compareField = (
-    actualVal: string,
-    expectedVal: string,
-    fieldName: string,
-  ) => {
-    const { similarity, meetsThreshold } = compareStrings(
-      actualVal,
-      expectedVal,
-      similarityThreshold,
-    );
-
-    if (!meetsThreshold) {
-      failedFields.push({
-        field: fieldName,
-        similarity,
-        expected: expectedVal,
-        actual: actualVal,
-      });
-      logger.error({
-        message: `${fieldName} extracted does not meet similarity threshold`,
-        level: 0,
-        auxiliary: {
-          field: { value: fieldName, type: "string" },
-          similarity: { value: similarity.toFixed(2), type: "string" },
-          expected: { value: expectedVal, type: "string" },
-          actual: { value: actualVal, type: "string" },
-        },
-      });
-    }
-
-    return meetsThreshold;
-  };
-
-  const addressOk = compareField(address, expected.address, "Address");
-  const phoneOk = compareField(phone, expected.phone, "Phone number");
-  const faxOk = compareField(fax, expected.fax, "Fax number");
-
-  if (!addressOk || !phoneOk || !faxOk) {
-    return {
-      _success: false,
-      error: "Some fields did not meet similarity threshold",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-      failedFields,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_capacitor_info.ts b/evals/tasks/extract_capacitor_info.ts
deleted file mode 100644
index f416b6a75..000000000
--- a/evals/tasks/extract_capacitor_info.ts
+++ /dev/null
@@ -1,112 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { normalizeString } from "@/evals/utils";
-import { z } from "zod";
-
-export const extract_capacitor_info: EvalFunction = async ({
-  logger,
-  useTextExtract,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/capacitor/",
-  );
-
-  const result = await stagehand.page.extract({
-    instruction: "Extract the ECCN Code, RoHS Status, and Impedance.",
-    schema: z.object({
-      ECCN_code: z.string(),
-      RoHS_Status: z.string(),
-      Impedance: z.string(),
-    }),
-    useTextExtract,
-  });
-
-  const { ECCN_code, RoHS_Status, Impedance } = result;
-
-  const expected = {
-    ECCN_code: "EAR99",
-    RoHS_Status: "RoHS Compliant",
-    Impedance: "12mOhm",
-  };
-
-  if (normalizeString(ECCN_code) !== normalizeString(expected.ECCN_code)) {
-    logger.error({
-      message: "ECCN code extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: normalizeString(expected.ECCN_code),
-          type: "string",
-        },
-        actual: {
-          value: normalizeString(ECCN_code),
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "ECCN code extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  if (normalizeString(RoHS_Status) !== normalizeString(expected.RoHS_Status)) {
-    logger.error({
-      message: "RoHS Status extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: normalizeString(expected.RoHS_Status),
-          type: "string",
-        },
-        actual: {
-          value: normalizeString(RoHS_Status),
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "RoHS Status extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  if (normalizeString(Impedance) !== normalizeString(expected.Impedance)) {
-    logger.error({
-      message: "Impedance extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: normalizeString(expected.Impedance),
-          type: "string",
-        },
-        actual: {
-          value: normalizeString(Impedance),
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Impedance extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_csa.ts b/evals/tasks/extract_csa.ts
deleted file mode 100644
index 9609d1d5d..000000000
--- a/evals/tasks/extract_csa.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { z } from "zod";
-
-export const extract_csa: EvalFunction = async ({
-  useTextExtract,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  const page = stagehand.page;
-  await page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/csa/",
-  );
-
-  const result = await page.extract({
-    instruction:
-      "Extract all the publications on the page including the publication date, session type, publication type, and annotation",
-    schema: z.object({
-      publications: z.array(
-        z.object({
-          publication_date: z.string(),
-          session_type: z.string(),
-          publication_type: z.string(),
-          annotation: z.string(),
-        }),
-      ),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-
-  const publications = result.publications;
-  const expectedLength = 14;
-
-  const expectedFirstItem = {
-    publication_date: "11-30-2024",
-    session_type: "Regular Session",
-    publication_type: "Assembly Weekly History",
-    annotation:
-      "2024 -- This publication includes the complete histories of second-year bills. The complete electronic history of all bills is always available at leginfo.legislature.ca.gov",
-  };
-
-  const expectedLastItem = {
-    publication_date: "11-30-2016",
-    session_type: "1st Extraordinary Session",
-    publication_type: "Assembly Weekly History",
-    annotation: "",
-  };
-
-  if (publications.length < expectedLength) {
-    logger.error({
-      message: "Incorrect number of publications extracted",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: `>= ${expectedLength}`,
-          type: "integer",
-        },
-        actual: {
-          value: publications.length.toString(),
-          type: "integer",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Incorrect number of publications extracted",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  const hasExpectedFirstItem = publications.some((publication) => {
-    return (
-      publication.publication_date === expectedFirstItem.publication_date &&
-      publication.session_type === expectedFirstItem.session_type &&
-      publication.publication_type === expectedFirstItem.publication_type &&
-      publication.annotation === expectedFirstItem.annotation
-    );
-  });
-
-  if (!hasExpectedFirstItem) {
-    logger.error({
-      message: "Expected 'first' item not found in publications",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: JSON.stringify(expectedFirstItem),
-          type: "object",
-        },
-        actual: {
-          value: JSON.stringify(publications),
-          type: "object",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Expected 'first' item not found in publications",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  const hasExpectedLastItem = publications.some((publication) => {
-    return (
-      publication.publication_date === expectedLastItem.publication_date &&
-      publication.session_type === expectedLastItem.session_type &&
-      publication.publication_type === expectedLastItem.publication_type &&
-      publication.annotation === expectedLastItem.annotation
-    );
-  });
-
-  if (!hasExpectedLastItem) {
-    logger.error({
-      message: "Expected 'last' item not found in publications",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: JSON.stringify(expectedLastItem),
-          type: "object",
-        },
-        actual: {
-          value: JSON.stringify(publications),
-          type: "object",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Expected 'last' item not found in publications",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_geniusee.ts b/evals/tasks/extract_geniusee.ts
deleted file mode 100644
index 18664ad6d..000000000
--- a/evals/tasks/extract_geniusee.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-import { z } from "zod";
-import { EvalFunction } from "@/types/evals";
-
-export const extract_geniusee: EvalFunction = async ({
-  logger,
-  useTextExtract,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/geniusee/",
-  );
-  const selector = "/html/body/main/div[2]/div[2]/div[2]/table";
-  const scalability = await stagehand.page.extract({
-    instruction:
-      "Extract the scalability comment in the table for Gemini (Google)",
-    schema: z.object({
-      scalability: z.string(),
-    }),
-    useTextExtract,
-    selector: selector,
-  });
-
-  await stagehand.close();
-  const scalabilityComment = scalability.scalability;
-
-  const expectedScalabilityComment = {
-    scalability: "Scalable architecture with API access",
-  };
-
-  const commentMatches =
-    scalabilityComment == expectedScalabilityComment.scalability;
-
-  if (!commentMatches) {
-    logger.error({
-      message: "extracted scalability comment does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: expectedScalabilityComment.scalability,
-          type: "string",
-        },
-        actual: {
-          value: scalabilityComment,
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "extracted scalability comment does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_geniusee_2.ts b/evals/tasks/extract_geniusee_2.ts
deleted file mode 100644
index 4a3f8006b..000000000
--- a/evals/tasks/extract_geniusee_2.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-import { z } from "zod";
-import { EvalFunction } from "@/types/evals";
-
-export const extract_geniusee_2: EvalFunction = async ({
-  logger,
-  useTextExtract,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/geniusee/",
-  );
-  const selector = "/html/body/main/div[2]/div[2]/div[2]/table/tbody/tr[9]";
-  const scalability = await stagehand.page.extract({
-    instruction:
-      "Extract the scalability comment in the table for Gemini (Google)",
-    schema: z.object({
-      scalability: z.string(),
-    }),
-    useTextExtract,
-    selector: selector,
-  });
-
-  await stagehand.close();
-  const scalabilityComment = scalability.scalability;
-
-  // scalabilityCommentWeShouldNotGet matches a scalability comment in the table,
-  // but since we are using targeted_extract here,
-  // and passing in a selector that does NOT contain the scalabilityCommentWeShouldNotGet,
-  // the LLM should have no visibility into scalabilityCommentWeShouldNotGet if
-  // targeted_extract is performing correctly
-  const scalabilityCommentWeShouldNotGet = {
-    scalability: "Scalable architecture with API access",
-  };
-
-  const commentMatches =
-    scalabilityComment == scalabilityCommentWeShouldNotGet.scalability;
-
-  if (commentMatches) {
-    logger.error({
-      message:
-        "extracted scalability comment matches the scalability comment that we SHOULD NOT get",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: scalabilityCommentWeShouldNotGet.scalability,
-          type: "string",
-        },
-        actual: {
-          value: scalabilityComment,
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error:
-        "scalability comment matches the scalability comment that we SHOULD NOT get",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_jstor_news.ts b/evals/tasks/extract_jstor_news.ts
deleted file mode 100644
index 4c5c690c9..000000000
--- a/evals/tasks/extract_jstor_news.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { z } from "zod";
-
-export const extract_jstor_news: EvalFunction = async ({
-  logger,
-  useTextExtract,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/jstor/",
-    {
-      waitUntil: "load",
-    },
-  );
-  await stagehand.page.act({ action: "close the cookie" });
-
-  const result = await stagehand.page.extract({
-    instruction: "Extract ALL the news report titles and their dates.",
-    schema: z.object({
-      reports: z.array(
-        z.object({
-          report_name: z
-            .string()
-            .describe("The name or title of the news report."),
-          publish_date: z
-            .string()
-            .describe("The date the news report was published."),
-        }),
-      ),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-
-  const reports = result.reports;
-  const expectedLength = 10;
-
-  const expectedFirstItem = {
-    report_name: "JSTOR retires Publisher Sales Service",
-    publish_date: "December 9, 2024",
-  };
-
-  const expectedLastItem = {
-    report_name: "Path to Open announces 2024 titles",
-    publish_date: "May 10, 2024",
-  };
-
-  if (reports.length !== expectedLength) {
-    logger.error({
-      message: "Incorrect number of reports extracted",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: expectedLength.toString(),
-          type: "integer",
-        },
-        actual: {
-          value: reports.length.toString(),
-          type: "integer",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Incorrect number of reports extracted",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-  const firstItemMatches =
-    reports[0].report_name === expectedFirstItem.report_name &&
-    reports[0].publish_date === expectedFirstItem.publish_date;
-
-  if (!firstItemMatches) {
-    logger.error({
-      message: "First report extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: JSON.stringify(expectedFirstItem),
-          type: "object",
-        },
-        actual: {
-          value: JSON.stringify(reports[0]),
-          type: "object",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "First report extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  const lastItemMatches =
-    reports[reports.length - 1].report_name === expectedLastItem.report_name &&
-    reports[reports.length - 1].publish_date === expectedLastItem.publish_date;
-
-  if (!lastItemMatches) {
-    logger.error({
-      message: "Last report extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: JSON.stringify(expectedLastItem),
-          type: "object",
-        },
-        actual: {
-          value: JSON.stringify(reports[reports.length - 1]),
-          type: "object",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Last report extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_memorial_healthcare.ts b/evals/tasks/extract_memorial_healthcare.ts
deleted file mode 100644
index c01dd5480..000000000
--- a/evals/tasks/extract_memorial_healthcare.ts
+++ /dev/null
@@ -1,185 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { z } from "zod";
-import { compareStrings } from "@/evals/utils";
-
-export const extract_memorial_healthcare: EvalFunction = async ({
-  logger,
-  useTextExtract,
-  debugUrl,
-  sessionUrl,
-  stagehand,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/mycmh/",
-  );
-
-  const result = await stagehand.page.extract({
-    instruction:
-      "extract a list of the first three healthcare centers on this page, with their name, full address, and phone number",
-    schema: z.object({
-      health_centers: z.array(
-        z.object({
-          name: z.string(),
-          phone_number: z.string(),
-          address: z.string(),
-        }),
-      ),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-
-  const health_centers: Array<
-    Partial<{ name: string; phone_number: string; address: string }>
-  > = result.health_centers;
-
-  const expectedLength = 3;
-  const similarityThreshold = 0.85;
-
-  const expectedFirstItem = {
-    name: "Community Memorial Breast Center",
-    phone_number: "805-948-5093",
-    address: "168 North Brent Street, Suite 401, Ventura, CA 93003",
-  };
-
-  const expectedLastItem = {
-    name: "Community Memorial Dermatology and Mohs Surgery",
-    phone_number: "805-948-6920",
-    address: "168 North Brent Street, Suite 403, Ventura, CA 93003",
-  };
-
-  if (health_centers.length !== expectedLength) {
-    logger.error({
-      message: "Incorrect number of health centers extracted",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: expectedLength.toString(),
-          type: "integer",
-        },
-        actual: {
-          value: health_centers.length.toString(),
-          type: "integer",
-        },
-      },
-    });
-
-    return {
-      _success: false,
-      error: "Incorrect number of health centers extracted",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  const validateHealthCenter = (
-    center: Partial<{ name: string; phone_number: string; address: string }>,
-  ): { name: string; phone_number: string; address: string } | null => {
-    if (center.name && center.phone_number && center.address) {
-      return center as { name: string; phone_number: string; address: string };
-    }
-    logger.error({
-      message: "Invalid health center data",
-      level: 0,
-      auxiliary: {
-        center: { value: JSON.stringify(center), type: "object" },
-      },
-    });
-    return null;
-  };
-
-  const validHealthCenters = health_centers
-    .map(validateHealthCenter)
-    .filter(Boolean) as Array<{
-    name: string;
-    phone_number: string;
-    address: string;
-  }>;
-
-  if (validHealthCenters.length < expectedLength) {
-    return {
-      _success: false,
-      error: "One or more health centers have missing fields",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  const compareField = (
-    actual: string,
-    expected: string,
-    fieldName: string,
-  ): boolean => {
-    const { similarity, meetsThreshold } = compareStrings(
-      actual,
-      expected,
-      similarityThreshold,
-    );
-
-    if (!meetsThreshold) {
-      logger.error({
-        message: `Field "${fieldName}" does not meet similarity threshold`,
-        level: 0,
-        auxiliary: {
-          field: { value: fieldName, type: "string" },
-          similarity: { value: similarity.toFixed(2), type: "float" },
-          expected: { value: expected, type: "string" },
-          actual: { value: actual, type: "string" },
-        },
-      });
-    }
-
-    return meetsThreshold;
-  };
-
-  const compareItem = (
-    actual: { name: string; phone_number: string; address: string },
-    expected: { name: string; phone_number: string; address: string },
-    position: string,
-  ): boolean => {
-    const fields = [
-      { field: "name", actual: actual.name, expected: expected.name },
-      {
-        field: "phone_number",
-        actual: actual.phone_number,
-        expected: expected.phone_number,
-      },
-      { field: "address", actual: actual.address, expected: expected.address },
-    ];
-
-    return fields.every(({ field, actual, expected }) =>
-      compareField(actual, expected, `${position} ${field}`),
-    );
-  };
-
-  const firstItemMatches = compareItem(
-    validHealthCenters[0],
-    expectedFirstItem,
-    "First",
-  );
-  const lastItemMatches = compareItem(
-    validHealthCenters[validHealthCenters.length - 1],
-    expectedLastItem,
-    "Last",
-  );
-
-  if (!firstItemMatches || !lastItemMatches) {
-    return {
-      _success: false,
-      error: "One or more fields do not match expected values",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_nhl_stats.ts b/evals/tasks/extract_nhl_stats.ts
deleted file mode 100644
index fb9e982ac..000000000
--- a/evals/tasks/extract_nhl_stats.ts
+++ /dev/null
@@ -1,118 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { normalizeString } from "@/evals/utils";
-import { z } from "zod";
-
-export const extract_nhl_stats: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-  useTextExtract,
-}) => {
-  await stagehand.page.goto(
-    "https://www.hockeydb.com/ihdb/stats/top_league.php?lid=nhl1927&sid=1990",
-    {
-      waitUntil: "domcontentloaded",
-    },
-  );
-
-  const result = await stagehand.page.extract({
-    instruction:
-      "Extract the name of the goal scoring leader, their number of goals they scored, and the team they played for.",
-    schema: z.object({
-      name: z.string(),
-      num_goals: z.string(),
-      team: z.string(),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-
-  const { name, num_goals, team } = result;
-
-  const expected = {
-    name: "Brett Hull",
-    num_goals: "72",
-    team: "St. Louis",
-  };
-
-  if (normalizeString(name) !== normalizeString(expected.name)) {
-    logger.error({
-      message: "Player name extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: normalizeString(expected.name),
-          type: "string",
-        },
-        actual: {
-          value: normalizeString(name),
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Player name extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  if (normalizeString(num_goals) !== normalizeString(expected.num_goals)) {
-    logger.error({
-      message: "Number of goals extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: normalizeString(expected.num_goals),
-          type: "string",
-        },
-        actual: {
-          value: normalizeString(num_goals),
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Number of goals extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  if (normalizeString(team) !== normalizeString(expected.team)) {
-    logger.error({
-      message: "Player team extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: normalizeString(expected.team),
-          type: "string",
-        },
-        actual: {
-          value: normalizeString(team),
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Player team extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_professional_info.ts b/evals/tasks/extract_professional_info.ts
deleted file mode 100644
index c77708f5c..000000000
--- a/evals/tasks/extract_professional_info.ts
+++ /dev/null
@@ -1,123 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { normalizeString } from "@/evals/utils";
-import { z } from "zod";
-
-export const extract_professional_info: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-  useTextExtract,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/professional-info/",
-  );
-
-  const result = await stagehand.page.extract({
-    instruction:
-      "Extract the list of Practices, phone number, and fax number of the professional.",
-    schema: z.object({
-      practices: z.array(z.string()),
-      phone: z.string(),
-      fax: z.string(),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-
-  const { practices, phone, fax } = result;
-
-  const expected = {
-    practices: [
-      "Restructuring",
-      "Finance",
-      "Hybrid Capital & Special Situations",
-      "Private Credit",
-    ],
-    phone: "+1-212-373-3262",
-    fax: "+1-212-492-0262",
-  };
-
-  if (
-    JSON.stringify(practices.map(normalizeString)) !==
-    JSON.stringify(expected.practices.map(normalizeString))
-  ) {
-    logger.error({
-      message: "Practices extracted do not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: JSON.stringify(expected.practices),
-          type: "object",
-        },
-        actual: {
-          value: JSON.stringify(practices),
-          type: "object",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Practices extracted do not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  if (normalizeString(phone) !== normalizeString(expected.phone)) {
-    logger.error({
-      message: "Phone number extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: normalizeString(expected.phone),
-          type: "string",
-        },
-        actual: {
-          value: normalizeString(phone),
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Phone number extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  if (normalizeString(fax) !== normalizeString(expected.fax)) {
-    logger.error({
-      message: "Fax number extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: normalizeString(expected.fax),
-          type: "string",
-        },
-        actual: {
-          value: normalizeString(fax),
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Fax number extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_public_notices.ts b/evals/tasks/extract_public_notices.ts
deleted file mode 100644
index 73a76864c..000000000
--- a/evals/tasks/extract_public_notices.ts
+++ /dev/null
@@ -1,172 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { z } from "zod";
-import { compareStrings } from "@/evals/utils";
-
-export const extract_public_notices: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-  useTextExtract,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/sars/",
-    { waitUntil: "load" },
-  );
-
-  const result = await stagehand.page.extract({
-    instruction:
-      "Extract ALL the public notice descriptions with their corresponding, GG number and publication date. Extract ALL notices from 2024 through 2020. Do not include the Notice number.",
-    schema: z.object({
-      public_notices: z.array(
-        z.object({
-          notice_description: z
-            .string()
-            .describe(
-              "the description of the notice. Do not include the Notice number",
-            ),
-          gg_number: z
-            .string()
-            .describe("the GG number of the notice. For example, GG 12345"),
-          publication_date: z
-            .string()
-            .describe(
-              "the publication date of the notice. For example, 8 December 2021",
-            ),
-        }),
-      ),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-
-  const publicNotices = result.public_notices;
-  const expectedLength = 24;
-
-  const expectedFirstItem = {
-    notice_description:
-      "Additional considerations in terms of section 80(2) in respect of which an application for a binding private ruling or a binding class ruling may be rejected",
-    gg_number: "GG 51526",
-    publication_date: "8 November 2024",
-  };
-
-  const expectedLastItem = {
-    notice_description:
-      "Notice in terms of section 25, read with section 66(1) of the Income Tax Act, 1962, for submission of 2020 income tax returns",
-    gg_number: "GG 43495",
-    publication_date: "3 July 2020",
-  };
-
-  if (publicNotices.length !== expectedLength) {
-    logger.error({
-      message: "Incorrect number of public notices extracted",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: expectedLength.toString(),
-          type: "integer",
-        },
-        actual: {
-          value: publicNotices.length.toString(),
-          type: "integer",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Incorrect number of public notices extracted",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-  const firstItemMatches =
-    compareStrings(
-      publicNotices[0].notice_description,
-      expectedFirstItem.notice_description,
-      0.9,
-    ) &&
-    compareStrings(
-      publicNotices[0].gg_number,
-      expectedFirstItem.gg_number,
-      0.9,
-    ) &&
-    compareStrings(
-      publicNotices[0].publication_date,
-      expectedFirstItem.publication_date,
-      0.9,
-    );
-
-  if (!firstItemMatches) {
-    logger.error({
-      message: "First public notice extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: JSON.stringify(expectedFirstItem),
-          type: "object",
-        },
-        actual: {
-          value: JSON.stringify(publicNotices[0]),
-          type: "object",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "First public notice extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  const lastItemMatches =
-    compareStrings(
-      publicNotices[publicNotices.length - 1].notice_description,
-      expectedLastItem.notice_description,
-      0.9,
-    ) &&
-    compareStrings(
-      publicNotices[publicNotices.length - 1].gg_number,
-      expectedLastItem.gg_number,
-      0.9,
-    ) &&
-    compareStrings(
-      publicNotices[publicNotices.length - 1].publication_date,
-      expectedLastItem.publication_date,
-      0.9,
-    );
-
-  if (!lastItemMatches) {
-    logger.error({
-      message: "Last public notice extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: JSON.stringify(expectedLastItem),
-          type: "object",
-        },
-        actual: {
-          value: JSON.stringify(publicNotices[publicNotices.length - 1]),
-          type: "object",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Last public notice extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_recipe.ts b/evals/tasks/extract_recipe.ts
deleted file mode 100644
index 1e5040688..000000000
--- a/evals/tasks/extract_recipe.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { z } from "zod";
-
-export const extract_recipe: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-  useTextExtract,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/allrecipes-extract/",
-    {
-      waitUntil: "domcontentloaded",
-    },
-  );
-
-  const selector = "/html/body/main/article/div[3]/div[3]/div[4]";
-  const recipeDetails = await stagehand.page.extract({
-    instruction:
-      "Extract the title of the number of tablespoons of olive oil needed for the steak, and the number of teaspoons of lemon juice needed for the mushroom pan sauce.",
-    schema: z.object({
-      tablespoons_olive_oil: z
-        .number()
-        .describe(
-          "the number of tablespoons of olive oil needed for the steak",
-        ),
-      teaspoons_lemon_juice: z
-        .number()
-        .describe(
-          "the number of teaspoons of lemon juice needed for the mushroom pan sauce",
-        ),
-    }),
-    useTextExtract,
-    selector: selector,
-  });
-
-  await stagehand.close();
-
-  const { tablespoons_olive_oil, teaspoons_lemon_juice } = recipeDetails;
-  const expectedTablespoons = 2;
-  const expectedTeaspoons = 2;
-
-  if (
-    tablespoons_olive_oil !== expectedTablespoons ||
-    teaspoons_lemon_juice !== expectedTeaspoons
-  ) {
-    const errors = [];
-    if (tablespoons_olive_oil !== expectedTablespoons) {
-      errors.push({
-        message:
-          "Extracted tablespoons of olive oil do not match the extracted tablespoons of olive oil",
-        expected: expectedTablespoons.toString(),
-        actual: tablespoons_olive_oil.toString(),
-      });
-    }
-    if (teaspoons_lemon_juice !== expectedTeaspoons) {
-      errors.push({
-        message:
-          "Extracted teaspoons of lemon juice do not match the extracted teaspoons of lemon juice",
-        expected: expectedTeaspoons.toString(),
-        actual: teaspoons_lemon_juice.toString(),
-      });
-    }
-
-    logger.error({
-      message: "Failed to extract correct recipe details",
-      level: 0,
-      auxiliary: {
-        errors: {
-          value: JSON.stringify(errors),
-          type: "object",
-        },
-      },
-    });
-
-    return {
-      _success: false,
-      error: "Recipe details extraction validation failed",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    recipeDetails: {
-      tablespoons_olive_oil: expectedTablespoons,
-      teaspoons_lemon_juice: expectedTeaspoons,
-    },
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_resistor_info.ts b/evals/tasks/extract_resistor_info.ts
deleted file mode 100644
index 4f4f0b265..000000000
--- a/evals/tasks/extract_resistor_info.ts
+++ /dev/null
@@ -1,157 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { normalizeString } from "@/evals/utils";
-import { z } from "zod";
-
-export const extract_resistor_info: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-  useTextExtract,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/resistor/",
-  );
-
-  const result = await stagehand.page.extract({
-    instruction:
-      "Extract the manufacturer standard lead time, tolerance percentage, resistance, and operating temperature range of the resistor.",
-    schema: z.object({
-      manufacturer_standard_lead_time: z.string(),
-      tolerance_percentage: z.string(),
-      resistance: z.string(),
-      operating_temperature_range: z.string(),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-
-  const {
-    manufacturer_standard_lead_time,
-    tolerance_percentage,
-    resistance,
-    operating_temperature_range,
-  } = result;
-
-  const expected = {
-    manufacturer_standard_lead_time: "11 Weeks",
-    tolerance_percentage: "±5",
-    resistance: "330 ohms",
-    operating_temperature_range: "-55°C ~ 155°C",
-  };
-
-  if (
-    normalizeString(manufacturer_standard_lead_time) !==
-    normalizeString(expected.manufacturer_standard_lead_time)
-  ) {
-    logger.error({
-      message:
-        "manufacturer standard lead time extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: normalizeString(expected.manufacturer_standard_lead_time),
-          type: "string",
-        },
-        actual: {
-          value: normalizeString(manufacturer_standard_lead_time),
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error:
-        "manufacturer standard lead time extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  if (
-    normalizeString(tolerance_percentage) !==
-    normalizeString(expected.tolerance_percentage)
-  ) {
-    logger.error({
-      message: "Tolerance percentage extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: normalizeString(expected.tolerance_percentage),
-          type: "string",
-        },
-        actual: {
-          value: normalizeString(tolerance_percentage),
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Tolerance percentage extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  if (normalizeString(resistance) !== normalizeString(expected.resistance)) {
-    logger.error({
-      message: "resistance extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: normalizeString(expected.resistance),
-          type: "string",
-        },
-        actual: {
-          value: normalizeString(resistance),
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "resistance extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  if (
-    normalizeString(operating_temperature_range) !==
-    normalizeString(expected.operating_temperature_range)
-  ) {
-    logger.error({
-      message: "Operating temperature range extracted does not match expected",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: normalizeString(expected.operating_temperature_range),
-          type: "string",
-        },
-        actual: {
-          value: normalizeString(operating_temperature_range),
-          type: "string",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Operating temperature range extracted does not match expected",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_rockauto.ts b/evals/tasks/extract_rockauto.ts
deleted file mode 100644
index f154790de..000000000
--- a/evals/tasks/extract_rockauto.ts
+++ /dev/null
@@ -1,100 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { z } from "zod";
-
-export const extract_rockauto: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-  useTextExtract,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/rockauto/",
-  );
-  await new Promise((resolve) => setTimeout(resolve, 5000));
-  const result = await stagehand.page.extract({
-    instruction:
-      "Extract the part number of all the coolant and antifreeze products in the 'economy' category. " +
-      "Do not include the manufacturer name. Do not include products from the premium category.",
-    schema: z.object({
-      coolant_products: z.array(
-        z.object({
-          part_number: z.string(),
-        }),
-      ),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-
-  const coolantProducts = result.coolant_products;
-  const expectedPartNumbers = [
-    "GREEN5050GAL",
-    "719009",
-    "AF3300",
-    "AF3100",
-    "MV5050GAL",
-  ];
-  const expectedLength = expectedPartNumbers.length;
-
-  if (coolantProducts.length !== expectedLength) {
-    logger.error({
-      message: "Incorrect number of coolant products extracted",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: expectedLength.toString(),
-          type: "integer",
-        },
-        actual: {
-          value: coolantProducts.length.toString(),
-          type: "integer",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Incorrect number of coolant products extracted",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  const missingParts = expectedPartNumbers.filter(
-    (expectedPart) =>
-      !coolantProducts.some((p) => p.part_number === expectedPart),
-  );
-
-  if (missingParts.length > 0) {
-    logger.error({
-      message: "Missing expected part number(s)",
-      level: 0,
-      auxiliary: {
-        missingParts: {
-          value: JSON.stringify(missingParts),
-          type: "object",
-        },
-        actualExtracted: {
-          value: JSON.stringify(coolantProducts),
-          type: "object",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: `One or more expected part numbers were not found: ${missingParts.join(", ")}`,
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_staff_members.ts b/evals/tasks/extract_staff_members.ts
deleted file mode 100644
index 7cf396773..000000000
--- a/evals/tasks/extract_staff_members.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-import { z } from "zod";
-import { EvalFunction } from "@/types/evals";
-
-export const extract_staff_members: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-  useTextExtract,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/panamcs/",
-  );
-
-  const result = await stagehand.page.extract({
-    instruction:
-      "extract a list of ALL the staff members on this page, with their name and their job title",
-    schema: z.object({
-      staff_members: z.array(
-        z.object({
-          name: z.string(),
-          job_title: z.string(),
-        }),
-      ),
-    }),
-    useTextExtract,
-  });
-
-  const staff_members = result.staff_members;
-  await stagehand.close();
-
-  const expectedLength = 50;
-
-  const expectedFirstItem = {
-    name: "Louis Alvarez",
-    job_title: "School Resource Officer",
-  };
-
-  const expectedLastItem = {
-    name: "Jessica Zipin",
-    job_title: "School Based Therapist",
-  };
-
-  if (staff_members.length !== expectedLength) {
-    logger.error({
-      message: "Incorrect number of items extracted",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: expectedLength.toString(),
-          type: "integer",
-        },
-        actual: {
-          value: staff_members.length.toString(),
-          type: "integer",
-        },
-      },
-    });
-
-    return {
-      _success: false,
-      error: "Incorrect number of staff members extracted",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  // Check for the presence of the expected items
-  const firstItemExists = staff_members.some(
-    (member) =>
-      member.name === expectedFirstItem.name &&
-      member.job_title === expectedFirstItem.job_title,
-  );
-
-  if (!firstItemExists) {
-    logger.error({
-      message: "Expected first staff member not found in extracted data",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: JSON.stringify(expectedFirstItem),
-          type: "object",
-        },
-        actual: {
-          value: JSON.stringify(staff_members),
-          type: "object",
-        },
-      },
-    });
-
-    await stagehand.close();
-
-    return {
-      _success: false,
-      error: "Expected first staff member not found in extracted data",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  const lastItemExists = staff_members.some(
-    (member) =>
-      member.name === expectedLastItem.name &&
-      member.job_title === expectedLastItem.job_title,
-  );
-
-  if (!lastItemExists) {
-    logger.error({
-      message: "Expected last staff member not found in extracted data",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: JSON.stringify(expectedLastItem),
-          type: "object",
-        },
-        actual: {
-          value: JSON.stringify(staff_members),
-          type: "object",
-        },
-      },
-    });
-
-    await stagehand.close();
-
-    return {
-      _success: false,
-      error: "Expected last staff member not found in extracted data",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  await stagehand.close();
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/extract_zillow.ts b/evals/tasks/extract_zillow.ts
deleted file mode 100644
index 1902f281f..000000000
--- a/evals/tasks/extract_zillow.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-import { z } from "zod";
-import { EvalFunction } from "../../types/evals";
-
-export const extract_zillow: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-  useTextExtract,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/zillow/",
-  );
-  // timeout for 5 seconds
-  await stagehand.page.waitForTimeout(5000);
-  const real_estate_listings = await stagehand.page.extract({
-    instruction:
-      "Extract EACH AND EVERY HOME PRICE AND ADDRESS ON THE PAGE. DO NOT MISS ANY OF THEM.",
-    schema: z.object({
-      listings: z.array(
-        z.object({
-          price: z.string().describe("The price of the home"),
-          trails: z.string().describe("The address of the home"),
-        }),
-      ),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-  const listings = real_estate_listings.listings;
-  const expectedLength = 38;
-
-  if (listings.length < expectedLength) {
-    logger.error({
-      message: "Incorrect number of listings extracted",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: expectedLength.toString(),
-          type: "integer",
-        },
-        actual: {
-          value: listings.length.toString(),
-          type: "integer",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Incorrect number of listings extracted",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/google_flights.ts b/evals/tasks/google_flights.ts
deleted file mode 100644
index 73654dc1e..000000000
--- a/evals/tasks/google_flights.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { ObserveResult } from "@/types/stagehand";
-
-/**
- * This eval attempts to click on an element that should not pass the playwright actionability check
- * which happens by default if you call locator.click (more information here:
- * https://playwright.dev/docs/actionability)
- *
- * If this eval passes, it means that we have correctly set {force: true} in performPlaywrightMethod,
- * and the click was successful even though the target element (found by the xpath) did not
- * pass the actionability check.
- */
-
-export const google_flights: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/google-flights/",
-  );
-
-  const observeResult: ObserveResult = {
-    selector:
-      "xpath=/html/body/c-wiz[2]/div/div[2]/c-wiz/div[1]/c-wiz/div[2]/div[2]/div[2]/div/div[2]/div[1]/ul/li[1]/div/div[1]",
-    description: "the first departing flight",
-    method: "click",
-    arguments: [],
-  };
-  await stagehand.page.act(observeResult);
-
-  const expectedUrl =
-    "https://browserbase.github.io/stagehand-eval-sites/sites/google-flights/return-flight.html";
-  const currentUrl = stagehand.page.url();
-
-  await stagehand.close();
-
-  if (currentUrl === expectedUrl) {
-    return {
-      _success: true,
-      currentUrl,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-  return {
-    _success: false,
-    error: "The current URL does not match expected.",
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/google_jobs.ts b/evals/tasks/google_jobs.ts
deleted file mode 100644
index a8e139988..000000000
--- a/evals/tasks/google_jobs.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { z } from "zod";
-
-export const google_jobs: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-  useTextExtract,
-}) => {
-  try {
-    await stagehand.page.goto("https://www.google.com/");
-    await stagehand.page.act("click on the about page");
-    await stagehand.page.act("click on the careers page");
-    await stagehand.page.act("input data scientist into role");
-    await stagehand.page.act("input new york city into location");
-    await stagehand.page.act("click on the search button");
-    await stagehand.page.act("click on the first job link");
-
-    const jobDetails = await stagehand.page.extract({
-      instruction:
-        "Extract the following details from the job posting: application deadline, minimum qualifications (degree and years of experience), and preferred qualifications (degree and years of experience)",
-      schema: z.object({
-        applicationDeadline: z
-          .string()
-          .describe("The date until which the application window will be open")
-          .nullable(),
-        minimumQualifications: z.object({
-          degree: z.string().describe("The minimum required degree").nullable(),
-          yearsOfExperience: z
-            .number()
-            .describe("The minimum required years of experience")
-            .nullable(),
-        }),
-        preferredQualifications: z.object({
-          degree: z.string().describe("The preferred degree").nullable(),
-          yearsOfExperience: z
-            .number()
-            .describe("The preferred years of experience")
-            .nullable(),
-        }),
-      }),
-      useTextExtract,
-    });
-
-    const isJobDetailsValid =
-      jobDetails &&
-      Object.values(jobDetails).every(
-        (value) =>
-          value !== null &&
-          value !== undefined &&
-          (typeof value !== "object" ||
-            Object.values(value).every(
-              (v) =>
-                v !== null &&
-                v !== undefined &&
-                (typeof v === "number" || typeof v === "string"),
-            )),
-      );
-
-    await stagehand.close();
-
-    return {
-      _success: isJobDetailsValid,
-      jobDetails,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  } catch (error) {
-    logger.error({
-      message: "error in google_jobs function",
-      level: 0,
-      auxiliary: {
-        error: {
-          value: error.message,
-          type: "string",
-        },
-        trace: {
-          value: error.stack,
-          type: "string",
-        },
-      },
-    });
-
-    await stagehand.close();
-
-    return {
-      _success: false,
-      debugUrl,
-      sessionUrl,
-      error: JSON.parse(JSON.stringify(error, null, 2)),
-      logs: logger.getLogs(),
-    };
-  }
-};
diff --git a/evals/tasks/history.ts b/evals/tasks/history.ts
deleted file mode 100644
index a41eb256b..000000000
--- a/evals/tasks/history.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const history: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto("https://docs.stagehand.dev");
-
-  await stagehand.page.act("click on the 'Quickstart' tab");
-
-  await stagehand.page.extract("Extract the title of the page");
-
-  await stagehand.page.observe("Find all links on the page");
-
-  const history = stagehand.history;
-
-  const hasCorrectNumberOfEntries = history.length === 4;
-
-  const hasNavigateEntry = history[0].method === "navigate";
-  const hasActEntry = history[1].method === "act";
-  const hasExtractEntry = history[2].method === "extract";
-  const hasObserveEntry = history[3].method === "observe";
-
-  const allEntriesHaveTimestamps = history.every(
-    (entry) =>
-      typeof entry.timestamp === "string" && entry.timestamp.length > 0,
-  );
-  const allEntriesHaveResults = history.every(
-    (entry) => entry.result !== undefined,
-  );
-
-  await stagehand.close();
-
-  const success =
-    hasCorrectNumberOfEntries &&
-    hasNavigateEntry &&
-    hasActEntry &&
-    hasExtractEntry &&
-    hasObserveEntry &&
-    allEntriesHaveTimestamps &&
-    allEntriesHaveResults;
-
-  return {
-    _success: success,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/homedepot.ts b/evals/tasks/homedepot.ts
deleted file mode 100644
index ca4b39b85..000000000
--- a/evals/tasks/homedepot.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { z } from "zod";
-
-export const homedepot: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-  useTextExtract,
-}) => {
-  try {
-    await stagehand.page.goto("https://www.homedepot.com/");
-    await stagehand.page.act("search for gas grills");
-    await stagehand.page.act("click on the best selling gas grill");
-    await stagehand.page.act("click on the Product Details");
-    await stagehand.page.act("find the Primary Burner BTU");
-
-    const productSpecs = await stagehand.page.extract({
-      instruction: "Extract the Primary exact Burner BTU of the product",
-      schema: z.object({
-        productSpecs: z
-          .array(
-            z.object({
-              burnerBTU: z.string().describe("Primary Burner BTU exact value"),
-            }),
-          )
-          .describe("Gas grill Primary Burner BTU exact value"),
-      }),
-      useTextExtract,
-    });
-
-    logger.log({
-      message: `gas grill primary burner BTU`,
-      level: 1,
-      auxiliary: {
-        productSpecs: {
-          value: JSON.stringify(productSpecs),
-          type: "object",
-        },
-      },
-    });
-
-    if (
-      !productSpecs ||
-      !productSpecs.productSpecs ||
-      productSpecs.productSpecs.length !== 1
-    ) {
-      await stagehand.close();
-
-      return {
-        _success: false,
-        productSpecs,
-        debugUrl,
-        sessionUrl,
-        logs: logger.getLogs(),
-      };
-    }
-
-    const hasFourZerosAndOne4 =
-      (productSpecs.productSpecs[0].burnerBTU.match(/0/g) || []).length === 4 &&
-      (productSpecs.productSpecs[0].burnerBTU.match(/4/g) || []).length === 1;
-
-    await stagehand.close();
-
-    return {
-      _success: hasFourZerosAndOne4,
-      productSpecs,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  } catch (error) {
-    logger.error({
-      message: "error in homedepot function",
-      level: 0,
-      auxiliary: {
-        error: {
-          value: error.message,
-          type: "string",
-        },
-        trace: {
-          value: error.stack,
-          type: "string",
-        },
-      },
-    });
-
-    await stagehand.close();
-
-    return {
-      _success: false,
-      error: JSON.parse(JSON.stringify(error, null, 2)),
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-};
diff --git a/evals/tasks/imdb_movie_details.ts b/evals/tasks/imdb_movie_details.ts
deleted file mode 100644
index 6e45bd2a0..000000000
--- a/evals/tasks/imdb_movie_details.ts
+++ /dev/null
@@ -1,99 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { z } from "zod";
-
-export const imdb_movie_details: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-  useTextExtract,
-}) => {
-  await stagehand.page.goto("https://www.imdb.com/title/tt0111161/", {
-    waitUntil: "domcontentloaded",
-  });
-  await stagehand.page.act({
-    action: "click on the movie ratings",
-  });
-
-  const movieDetails = await stagehand.page.extract({
-    instruction: "Extract the list of countries with the most ratings.",
-    schema: z.object({
-      countries: z
-        .array(z.string())
-        .describe("List of countries with the most ratings"),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-
-  const expectedCountries = [
-    "United States",
-    "United Kingdom",
-    "Turkey",
-    "India",
-    "Germany",
-  ];
-
-  if (!movieDetails.countries || movieDetails.countries.length !== 5) {
-    logger.error({
-      message: "Failed to extract exactly five countries",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: JSON.stringify(expectedCountries),
-          type: "object",
-        },
-        actual: {
-          value: JSON.stringify(movieDetails.countries || []),
-          type: "object",
-        },
-      },
-    });
-
-    return {
-      _success: false,
-      error: "Incorrect number of countries extracted",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  const missingCountries = expectedCountries.filter(
-    (country) => !movieDetails.countries.includes(country),
-  );
-
-  if (missingCountries.length > 0) {
-    logger.error({
-      message: "Extracted countries do not match expected countries",
-      level: 0,
-      auxiliary: {
-        missing: {
-          value: JSON.stringify(missingCountries),
-          type: "object",
-        },
-        extracted: {
-          value: JSON.stringify(movieDetails.countries),
-          type: "object",
-        },
-      },
-    });
-
-    return {
-      _success: false,
-      error: "Extracted countries do not match expected countries",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    countries: movieDetails.countries,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/ionwave.ts b/evals/tasks/ionwave.ts
deleted file mode 100644
index e4d4e200d..000000000
--- a/evals/tasks/ionwave.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const ionwave: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto("https://elpasotexas.ionwave.net/Login.aspx");
-
-  await stagehand.page.act({
-    action: 'Click on "Closed Bids"',
-  });
-
-  const expectedUrl =
-    "https://elpasotexas.ionwave.net/SourcingEvents.aspx?SourceType=2";
-  const currentUrl = stagehand.page.url();
-
-  await stagehand.close();
-
-  return {
-    _success: currentUrl.startsWith(expectedUrl),
-    currentUrl,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/ionwave_observe.ts b/evals/tasks/ionwave_observe.ts
deleted file mode 100644
index 8fa3197dc..000000000
--- a/evals/tasks/ionwave_observe.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const ionwave_observe: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto("https://elpasotexas.ionwave.net/Login.aspx");
-
-  const observations = await stagehand.page.observe({ onlyVisible: true });
-
-  if (observations.length === 0) {
-    await stagehand.close();
-    return {
-      _success: false,
-      observations,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  const expectedLocator = `div.rowLinks:nth-child(27) > div:nth-child(1) > a:nth-child(1)`;
-
-  const expectedResult = await stagehand.page
-    .locator(expectedLocator)
-    .first()
-    .innerText();
-
-  let foundMatch = false;
-  for (const observation of observations) {
-    try {
-      const observationResult = await stagehand.page
-        .locator(observation.selector)
-        .first()
-        .innerText();
-
-      if (observationResult === expectedResult) {
-        foundMatch = true;
-        break;
-      }
-    } catch (error) {
-      console.warn(
-        `Failed to check observation with selector ${observation.selector}:`,
-        error.message,
-      );
-      continue;
-    }
-  }
-
-  await stagehand.close();
-
-  return {
-    _success: foundMatch,
-    expected: expectedResult,
-    observations,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/nextChunk.ts b/evals/tasks/nextChunk.ts
deleted file mode 100644
index 6591cb8c5..000000000
--- a/evals/tasks/nextChunk.ts
+++ /dev/null
@@ -1,75 +0,0 @@
-import { Stagehand } from "@/dist";
-import { EvalFunction } from "@/types/evals";
-
-export const nextChunk: EvalFunction = async ({
-  logger,
-  stagehandConfig,
-  debugUrl,
-  sessionUrl,
-}) => {
-  const stagehand = new Stagehand({
-    ...stagehandConfig,
-    domSettleTimeoutMs: 3000,
-  });
-  await stagehand.init();
-
-  await stagehand.page.goto("https://www.apartments.com/san-francisco-ca/");
-  await stagehand.page.act({
-    action: "click on the all filters button",
-  });
-
-  const { initialScrollTop, chunkHeight } = await stagehand.page.evaluate(
-    () => {
-      const container = document.querySelector(
-        "#advancedFilters > div",
-      ) as HTMLElement;
-      if (!container) {
-        console.warn(
-          "Could not find #advancedFilters > div. Returning 0 for measurements.",
-        );
-        return { initialScrollTop: 0, chunkHeight: 0 };
-      }
-      return {
-        initialScrollTop: container.scrollTop,
-        chunkHeight: container.getBoundingClientRect().height,
-      };
-    },
-  );
-
-  await stagehand.page.act({
-    action: "scroll down one chunk on the filters modal",
-  });
-
-  await new Promise((resolve) => setTimeout(resolve, 2000));
-
-  const newScrollTop = await stagehand.page.evaluate(() => {
-    const container = document.querySelector(
-      "#advancedFilters > div",
-    ) as HTMLElement;
-    return container?.scrollTop ?? 0;
-  });
-
-  await stagehand.close();
-
-  const actualDiff = newScrollTop - initialScrollTop;
-  const threshold = 20; // allowable difference in px
-  const scrolledOneChunk = Math.abs(actualDiff - chunkHeight) <= threshold;
-
-  const evaluationResult = scrolledOneChunk
-    ? {
-        _success: true,
-        logs: logger.getLogs(),
-        debugUrl,
-        sessionUrl,
-        message: `Successfully scrolled ~one chunk: expected ~${chunkHeight}, got ${actualDiff}`,
-      }
-    : {
-        _success: false,
-        logs: logger.getLogs(),
-        debugUrl,
-        sessionUrl,
-        message: `Scroll difference expected ~${chunkHeight} but only scrolled ${actualDiff}.`,
-      };
-
-  return evaluationResult;
-};
diff --git a/evals/tasks/observe_amazon_add_to_cart.ts b/evals/tasks/observe_amazon_add_to_cart.ts
deleted file mode 100644
index a9b810380..000000000
--- a/evals/tasks/observe_amazon_add_to_cart.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const observe_amazon_add_to_cart: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/amazon/",
-  );
-
-  await stagehand.page.waitForTimeout(5000);
-
-  const observations1 = await stagehand.page.observe({
-    instruction: "Find and click the 'Add to Cart' button",
-    onlyVisible: false,
-    returnAction: true,
-  });
-
-  console.log(observations1);
-
-  // Example of using performPlaywrightMethod if you have the xpath
-  if (observations1.length > 0) {
-    const action1 = observations1[0];
-    await stagehand.page.act(action1);
-  }
-
-  await stagehand.page.waitForTimeout(2000);
-
-  const observations2 = await stagehand.page.observe({
-    instruction: "Find and click the 'Proceed to checkout' button",
-  });
-
-  // Example of using performPlaywrightMethod if you have the xpath
-  if (observations2.length > 0) {
-    const action2 = observations2[0];
-    await stagehand.page.act(action2);
-  }
-  await stagehand.page.waitForTimeout(2000);
-
-  const currentUrl = stagehand.page.url();
-  const expectedUrlPrefix =
-    "https://browserbase.github.io/stagehand-eval-sites/sites/amazon/sign-in.html";
-
-  await stagehand.close();
-
-  return {
-    _success: currentUrl.startsWith(expectedUrlPrefix),
-    currentUrl,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/observe_github.ts b/evals/tasks/observe_github.ts
deleted file mode 100644
index 036255f85..000000000
--- a/evals/tasks/observe_github.ts
+++ /dev/null
@@ -1,88 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const observe_github: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto("https://github.com/numpy/numpy/tree/main/numpy");
-
-  const observations = await stagehand.page.observe({
-    instruction: "find the scrollable element that holds the repos file tree.",
-  });
-
-  if (observations.length === 0) {
-    await stagehand.close();
-    return {
-      _success: false,
-      observations,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  const possibleLocators = [
-    `#repos-file-tree > div.Box-sc-g0xbh4-0.jbQqON > div > div > div > nav > ul`,
-    `#repos-file-tree > div.Box-sc-g0xbh4-0.jbQqON > div > div > div > nav`,
-    `#repos-file-tree > div.Box-sc-g0xbh4-0.jbQqON`,
-  ];
-
-  const possibleHandles = [];
-  for (const locatorStr of possibleLocators) {
-    const locator = stagehand.page.locator(locatorStr);
-    const handle = await locator.elementHandle();
-    if (handle) {
-      possibleHandles.push({ locatorStr, handle });
-    }
-  }
-
-  let foundMatch = false;
-  let matchedLocator: string | null = null;
-
-  for (const observation of observations) {
-    try {
-      const observationLocator = stagehand.page
-        .locator(observation.selector)
-        .first();
-      const observationHandle = await observationLocator.elementHandle();
-      if (!observationHandle) {
-        continue;
-      }
-
-      for (const { locatorStr, handle: candidateHandle } of possibleHandles) {
-        const isSameNode = await observationHandle.evaluate(
-          (node, otherNode) => node === otherNode,
-          candidateHandle,
-        );
-        if (isSameNode) {
-          foundMatch = true;
-          matchedLocator = locatorStr;
-          break;
-        }
-      }
-
-      if (foundMatch) {
-        break;
-      }
-    } catch (error) {
-      console.warn(
-        `Failed to check observation with selector ${observation.selector}:`,
-        error.message,
-      );
-      continue;
-    }
-  }
-
-  await stagehand.close();
-
-  return {
-    _success: foundMatch,
-    matchedLocator,
-    observations,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/observe_iframes1.ts b/evals/tasks/observe_iframes1.ts
deleted file mode 100644
index f1cbc68ee..000000000
--- a/evals/tasks/observe_iframes1.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const observe_iframes1: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto("https://tucowsdomains.com/abuse-form/phishing/");
-
-  const observations = await stagehand.page.observe({
-    instruction: "find the main header of the page",
-  });
-
-  if (observations.length === 0) {
-    await stagehand.close();
-    return {
-      _success: false,
-      observations,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  const possibleLocators = [
-    `#primary > div.singlePage > section > div > div > article > div > iframe`,
-    `#primary > div.heroBanner > section > div > h1`,
-  ];
-
-  const possibleHandles = [];
-  for (const locatorStr of possibleLocators) {
-    const locator = stagehand.page.locator(locatorStr);
-    const handle = await locator.elementHandle();
-    if (handle) {
-      possibleHandles.push({ locatorStr, handle });
-    }
-  }
-
-  let foundMatch = false;
-  let matchedLocator: string | null = null;
-
-  for (const observation of observations) {
-    try {
-      const observationLocator = stagehand.page
-        .locator(observation.selector)
-        .first();
-      const observationHandle = await observationLocator.elementHandle();
-      if (!observationHandle) {
-        continue;
-      }
-
-      for (const { locatorStr, handle: candidateHandle } of possibleHandles) {
-        const isSameNode = await observationHandle.evaluate(
-          (node, otherNode) => node === otherNode,
-          candidateHandle,
-        );
-        if (isSameNode) {
-          foundMatch = true;
-          matchedLocator = locatorStr;
-          break;
-        }
-      }
-
-      if (foundMatch) {
-        break;
-      }
-    } catch (error) {
-      console.warn(
-        `Failed to check observation with selector ${observation.selector}:`,
-        error.message,
-      );
-      continue;
-    }
-  }
-
-  await stagehand.close();
-
-  return {
-    _success: foundMatch,
-    matchedLocator,
-    observations,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/observe_iframes2.ts b/evals/tasks/observe_iframes2.ts
deleted file mode 100644
index e02ebc7ab..000000000
--- a/evals/tasks/observe_iframes2.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-import { Stagehand } from "@/dist";
-import { EvalFunction } from "@/types/evals";
-import { ObserveResult } from "@/types/stagehand";
-
-export const observe_iframes2: EvalFunction = async ({
-  logger,
-  stagehandConfig,
-  debugUrl,
-  sessionUrl,
-}) => {
-  const stagehand = new Stagehand({
-    ...stagehandConfig,
-  });
-  await stagehand.init();
-
-  await stagehand.page.goto(
-    "https://iframetester.com/?url=https://shopify.com",
-  );
-  await new Promise((resolve) => setTimeout(resolve, 5000));
-
-  let observations: ObserveResult[];
-  try {
-    observations = await stagehand.page.observe({
-      instruction: "find the main header of the page",
-    });
-  } catch (err) {
-    await stagehand.close();
-    return {
-      _success: false,
-      message: err.message,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  if (observations.length === 0) {
-    await stagehand.close();
-    return {
-      _success: false,
-      observations,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  const possibleLocators = [`#iframe-window`, `body > header > h1`];
-
-  const possibleHandles = [];
-  for (const locatorStr of possibleLocators) {
-    const locator = stagehand.page.locator(locatorStr);
-    const handle = await locator.elementHandle();
-    if (handle) {
-      possibleHandles.push({ locatorStr, handle });
-    }
-  }
-
-  let foundMatch = false;
-  let matchedLocator: string | null = null;
-
-  for (const observation of observations) {
-    try {
-      const observationLocator = stagehand.page
-        .locator(observation.selector)
-        .first();
-      const observationHandle = await observationLocator.elementHandle();
-      if (!observationHandle) {
-        continue;
-      }
-
-      for (const { locatorStr, handle: candidateHandle } of possibleHandles) {
-        const isSameNode = await observationHandle.evaluate(
-          (node, otherNode) => node === otherNode,
-          candidateHandle,
-        );
-        if (isSameNode) {
-          foundMatch = true;
-          matchedLocator = locatorStr;
-          break;
-        }
-      }
-
-      if (foundMatch) {
-        break;
-      }
-    } catch (error) {
-      console.warn(
-        `Failed to check observation with selector ${observation.selector}:`,
-        error.message,
-      );
-      continue;
-    }
-  }
-
-  await stagehand.close();
-
-  return {
-    _success: foundMatch,
-    matchedLocator,
-    observations,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/observe_simple_google_search.ts b/evals/tasks/observe_simple_google_search.ts
deleted file mode 100644
index 7e6fd1331..000000000
--- a/evals/tasks/observe_simple_google_search.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { performPlaywrightMethod } from "@/lib/a11y/utils";
-
-export const observe_simple_google_search: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto("https://www.google.com");
-
-  const observation1 = await stagehand.page.observe({
-    instruction: "Find the search bar and enter 'OpenAI'",
-    onlyVisible: false,
-    returnAction: true,
-  });
-  console.log(observation1);
-
-  if (observation1.length > 0) {
-    const action1 = observation1[0];
-    await performPlaywrightMethod(
-      stagehand.page,
-      stagehand.logger,
-      action1.method,
-      action1.arguments,
-      action1.selector.replace("xpath=", ""),
-    );
-  }
-  await stagehand.page.waitForTimeout(5000);
-  const observation2 = await stagehand.page.observe({
-    instruction: "Click the search button in the suggestions dropdown",
-    onlyVisible: false,
-    returnAction: true,
-  });
-  console.log(observation2);
-
-  if (observation2.length > 0) {
-    const action2 = observation2[0];
-    await performPlaywrightMethod(
-      stagehand.page,
-      stagehand.logger,
-      action2.method,
-      action2.arguments,
-      action2.selector.replace("xpath=", ""),
-    );
-  }
-  await stagehand.page.waitForTimeout(5000);
-
-  const expectedUrl = "https://www.google.com/search?q=OpenAI";
-  const currentUrl = stagehand.page.url();
-
-  await stagehand.close();
-
-  return {
-    _success: currentUrl.startsWith(expectedUrl),
-    currentUrl,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/observe_taxes.ts b/evals/tasks/observe_taxes.ts
deleted file mode 100644
index 3ba0b3676..000000000
--- a/evals/tasks/observe_taxes.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const observe_taxes: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto("https://file.1040.com/estimate/");
-
-  const observations = await stagehand.page.observe({
-    instruction: "Find all the form input elements under the 'Income' section",
-  });
-
-  if (observations.length === 0) {
-    await stagehand.close();
-    return {
-      _success: false,
-      observations,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  } else if (observations.length < 13) {
-    await stagehand.close();
-    return {
-      _success: false,
-      observations,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  const expectedLocator = `#tpWages`;
-
-  const expectedResult = await stagehand.page
-    .locator(expectedLocator)
-    .first()
-    .innerText();
-
-  let foundMatch = false;
-  for (const observation of observations) {
-    try {
-      const observationResult = await stagehand.page
-        .locator(observation.selector)
-        .first()
-        .innerText();
-
-      if (observationResult === expectedResult) {
-        foundMatch = true;
-        break;
-      }
-    } catch (error) {
-      console.warn(
-        `Failed to check observation with selector ${observation.selector}:`,
-        error.message,
-      );
-      continue;
-    }
-  }
-
-  await stagehand.close();
-
-  return {
-    _success: foundMatch,
-    expected: expectedResult,
-    observations,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/observe_vantechjournal.ts b/evals/tasks/observe_vantechjournal.ts
deleted file mode 100644
index c3eef6a71..000000000
--- a/evals/tasks/observe_vantechjournal.ts
+++ /dev/null
@@ -1,74 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const observe_vantechjournal: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto("https://vantechjournal.com/archive?page=8");
-  await stagehand.page.waitForTimeout(1000);
-
-  const observations = await stagehand.page.observe({
-    instruction: "find the button that takes us to the 11th page",
-  });
-
-  if (observations.length === 0) {
-    await stagehand.close();
-    return {
-      _success: false,
-      observations,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  const expectedLocator = `a.rounded-lg:nth-child(8)`;
-
-  const expectedResult = await stagehand.page.locator(expectedLocator);
-
-  let foundMatch = false;
-
-  for (const observation of observations) {
-    try {
-      const observationLocator = stagehand.page
-        .locator(observation.selector)
-        .first();
-      const observationHandle = await observationLocator.elementHandle();
-      const expectedHandle = await expectedResult.elementHandle();
-
-      if (!observationHandle || !expectedHandle) {
-        // Couldn’t get handles, skip
-        continue;
-      }
-
-      const isSameNode = await observationHandle.evaluate(
-        (node, otherNode) => node === otherNode,
-        expectedHandle,
-      );
-
-      if (isSameNode) {
-        foundMatch = true;
-        break;
-      }
-    } catch (error) {
-      console.warn(
-        `Failed to check observation with selector ${observation.selector}:`,
-        error.message,
-      );
-      continue;
-    }
-  }
-
-  await stagehand.close();
-
-  return {
-    _success: foundMatch,
-    expected: expectedResult,
-    observations,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/observe_yc_startup.ts b/evals/tasks/observe_yc_startup.ts
deleted file mode 100644
index bdc654da5..000000000
--- a/evals/tasks/observe_yc_startup.ts
+++ /dev/null
@@ -1,89 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const observe_yc_startup: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto("https://www.ycombinator.com/companies");
-  await stagehand.page.waitForLoadState("networkidle");
-
-  const observations = await stagehand.page.observe({
-    instruction:
-      "Click the container element that holds links to each of the startup companies. The companies each have a name, a description, and a link to their website.",
-  });
-
-  if (observations.length === 0) {
-    await stagehand.close();
-    return {
-      _success: false,
-      observations,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  const possibleLocators = [
-    `div._rightCol_i9oky_592`,
-    `div._section_i9oky_163._results_i9oky_343`,
-  ];
-
-  const possibleHandles = [];
-  for (const locatorStr of possibleLocators) {
-    const locator = stagehand.page.locator(locatorStr);
-    const handle = await locator.elementHandle();
-    if (handle) {
-      possibleHandles.push({ locatorStr, handle });
-    }
-  }
-
-  let foundMatch = false;
-  let matchedLocator: string | null = null;
-
-  for (const observation of observations) {
-    try {
-      const observationLocator = stagehand.page
-        .locator(observation.selector)
-        .first();
-      const observationHandle = await observationLocator.elementHandle();
-      if (!observationHandle) {
-        continue;
-      }
-
-      for (const { locatorStr, handle: candidateHandle } of possibleHandles) {
-        const isSameNode = await observationHandle.evaluate(
-          (node, otherNode) => node === otherNode,
-          candidateHandle,
-        );
-        if (isSameNode) {
-          foundMatch = true;
-          matchedLocator = locatorStr;
-          break;
-        }
-      }
-
-      if (foundMatch) {
-        break;
-      }
-    } catch (error) {
-      console.warn(
-        `Failed to check observation with selector ${observation.selector}:`,
-        error.message,
-      );
-      continue;
-    }
-  }
-
-  await stagehand.close();
-
-  return {
-    _success: foundMatch,
-    matchedLocator,
-    observations,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/panamcs.ts b/evals/tasks/panamcs.ts
deleted file mode 100644
index 2b68d096e..000000000
--- a/evals/tasks/panamcs.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const panamcs: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/panamcs/",
-  );
-
-  const observations = await stagehand.page.observe(
-    "click the 'about us' link",
-  );
-
-  if (observations.length === 0) {
-    await stagehand.close();
-    return {
-      _success: false,
-      observations,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  const expectedLocator = `#menu > li:nth-child(1) > a`;
-
-  const expectedResult = await stagehand.page
-    .locator(expectedLocator)
-    .first()
-    .innerText();
-
-  let foundMatch = false;
-  for (const observation of observations) {
-    try {
-      const observationResult = await stagehand.page
-        .locator(observation.selector)
-        .first()
-        .innerText();
-
-      if (observationResult === expectedResult) {
-        foundMatch = true;
-        break;
-      }
-    } catch (error) {
-      console.warn(
-        `Failed to check observation with selector ${observation.selector}:`,
-        error.message,
-      );
-      continue;
-    }
-  }
-
-  await stagehand.close();
-
-  return {
-    _success: foundMatch,
-    expected: expectedResult,
-    observations,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/peeler_simple.ts b/evals/tasks/peeler_simple.ts
deleted file mode 100644
index 12628c6fa..000000000
--- a/evals/tasks/peeler_simple.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { StagehandEnvironmentError } from "@/types/stagehandErrors";
-
-const env: "BROWSERBASE" | "LOCAL" =
-  process.env.EVAL_ENV?.toLowerCase() === "browserbase"
-    ? "BROWSERBASE"
-    : "LOCAL";
-
-export const peeler_simple: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  if (env === "BROWSERBASE") {
-    throw new StagehandEnvironmentError(
-      "BROWSERBASE",
-      "LOCAL",
-      "peeler_simple eval",
-    );
-  }
-
-  await stagehand.page.goto(`file://${process.cwd()}/evals/assets/peeler.html`);
-  await stagehand.page.act({ action: "add the peeler to cart" });
-
-  const successMessageLocator = stagehand.page.locator(
-    'text="Congratulations, you have 1 A in your cart"',
-  );
-  const isVisible = await successMessageLocator.isVisible();
-
-  await stagehand.close();
-
-  return {
-    _success: isVisible,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/prevChunk.ts b/evals/tasks/prevChunk.ts
deleted file mode 100644
index 0db2266bf..000000000
--- a/evals/tasks/prevChunk.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-import { Stagehand } from "@/dist";
-import { EvalFunction } from "@/types/evals";
-
-export const prevChunk: EvalFunction = async ({
-  logger,
-  stagehandConfig,
-  debugUrl,
-  sessionUrl,
-}) => {
-  const stagehand = new Stagehand({
-    ...stagehandConfig,
-    domSettleTimeoutMs: 3000,
-  });
-  await stagehand.init();
-
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/aigrant/",
-  );
-  await new Promise((resolve) => setTimeout(resolve, 2000));
-  const { initialScrollTop, chunkHeight } = await stagehand.page.evaluate(
-    () => {
-      const halfPage = document.body.scrollHeight / 2;
-
-      window.scrollTo({
-        top: halfPage,
-        left: 0,
-        behavior: "instant",
-      });
-
-      const chunk = window.innerHeight;
-
-      return {
-        initialScrollTop: window.scrollY,
-        chunkHeight: chunk,
-      };
-    },
-  );
-  await new Promise((resolve) => setTimeout(resolve, 2000));
-  await stagehand.page.act({
-    action: "scroll up one chunk",
-  });
-
-  await new Promise((resolve) => setTimeout(resolve, 5000));
-
-  const finalScrollTop = await stagehand.page.evaluate(() => window.scrollY);
-
-  await stagehand.close();
-
-  const actualDiff = initialScrollTop - finalScrollTop;
-  const threshold = 20; // px tolerance
-  const scrolledOneChunk = Math.abs(actualDiff - chunkHeight) <= threshold;
-
-  const evaluationResult = scrolledOneChunk
-    ? {
-        _success: true,
-        logs: logger.getLogs(),
-        debugUrl,
-        sessionUrl,
-        message: `Successfully scrolled ~one chunk UP: expected ~${chunkHeight}, got ${actualDiff}.`,
-      }
-    : {
-        _success: false,
-        logs: logger.getLogs(),
-        debugUrl,
-        sessionUrl,
-        message: `Scroll difference expected ~${chunkHeight} but only scrolled ${actualDiff}.`,
-      };
-
-  return evaluationResult;
-};
diff --git a/evals/tasks/rakuten_jp.ts b/evals/tasks/rakuten_jp.ts
deleted file mode 100644
index cf8ea55fe..000000000
--- a/evals/tasks/rakuten_jp.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const rakuten_jp: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto("https://www.rakuten.co.jp/");
-  await stagehand.page.act({ action: "click on online supermarket" });
-
-  await stagehand.page.act({ action: "if there is a popup, close it" });
-
-  await stagehand.page.act({
-    action: "navigate to Inageya Online Supermarket",
-  });
-  await stagehand.page.act({ action: "click the search bar input" });
-  await stagehand.page.act({ action: "search for '香菜'" });
-
-  const url = stagehand.page.url();
-  const successUrl =
-    "https://netsuper.rakuten.co.jp/inageya/search/?keyword=%E9%A6%99%E8%8F%9C";
-
-  await stagehand.close();
-
-  return {
-    _success: url === successUrl,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/sciquest.ts b/evals/tasks/sciquest.ts
deleted file mode 100644
index 42bc535d7..000000000
--- a/evals/tasks/sciquest.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { z } from "zod";
-
-export const sciquest: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-  useTextExtract,
-}) => {
-  await stagehand.page.goto(
-    "https://bids.sciquest.com/apps/Router/PublicEvent?tab=PHX_NAV_SourcingAllOpps&CustomerOrg=StateOfUtah",
-  );
-
-  await stagehand.page.act({
-    action: 'Click on the "Closed" tab',
-  });
-
-  const result = await stagehand.page.extract({
-    instruction:
-      "Extract the total number of results that the search produced. Not the number of results displayed on the page.",
-    schema: z.object({
-      total_results: z.string(),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-
-  const { total_results } = result;
-
-  const expectedNumber = 12637;
-  const extractedNumber = parseInt(total_results.replace(/[^\d]/g, ""), 10);
-
-  const isWithinRange =
-    extractedNumber >= expectedNumber - 1000 &&
-    extractedNumber <= expectedNumber + 1000;
-
-  if (!isWithinRange) {
-    logger.error({
-      message: "Total number of results is not within the expected range",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: `${expectedNumber} ± 1000`,
-          type: "string",
-        },
-        actual: {
-          value: extractedNumber.toString(),
-          type: "integer",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Total number of results is not within the expected range",
-      extractedNumber,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  return {
-    _success: true,
-    extractedNumber,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/scroll_50.ts b/evals/tasks/scroll_50.ts
deleted file mode 100644
index c6abb53c3..000000000
--- a/evals/tasks/scroll_50.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const scroll_50: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/aigrant/",
-  );
-  await stagehand.page.act({
-    action: "Scroll 50% down the page",
-  });
-
-  await new Promise((resolve) => setTimeout(resolve, 5000));
-
-  // Get the current scroll position and total scroll height
-  const scrollInfo = await stagehand.page.evaluate(() => {
-    return {
-      scrollTop: window.scrollY + window.innerHeight / 2,
-      scrollHeight: document.documentElement.scrollHeight,
-    };
-  });
-
-  await stagehand.close();
-
-  const halfwayScroll = scrollInfo.scrollHeight / 2;
-  const halfwayReached = Math.abs(scrollInfo.scrollTop - halfwayScroll) <= 200;
-  const evaluationResult = halfwayReached
-    ? {
-        _success: true,
-        logs: logger.getLogs(),
-        debugUrl,
-        sessionUrl,
-      }
-    : {
-        _success: false,
-        logs: logger.getLogs(),
-        debugUrl,
-        sessionUrl,
-        message: `Scroll position (${scrollInfo.scrollTop}px) is not halfway down the page (${halfwayScroll}px).`,
-      };
-
-  return evaluationResult;
-};
diff --git a/evals/tasks/scroll_75.ts b/evals/tasks/scroll_75.ts
deleted file mode 100644
index 3959837ca..000000000
--- a/evals/tasks/scroll_75.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import { Stagehand } from "@/dist";
-import { EvalFunction } from "@/types/evals";
-
-export const scroll_75: EvalFunction = async ({
-  logger,
-  stagehandConfig,
-  debugUrl,
-  sessionUrl,
-}) => {
-  const stagehand = new Stagehand({
-    ...stagehandConfig,
-    domSettleTimeoutMs: 3000,
-  });
-  await stagehand.init();
-
-  await stagehand.page.goto(
-    "https://browserbase.github.io/stagehand-eval-sites/sites/aigrant/",
-  );
-  await stagehand.page.act({
-    action: "Scroll 75% down the page",
-  });
-
-  await new Promise((resolve) => setTimeout(resolve, 5000));
-
-  // Get the current scroll position and total scroll height
-  const scrollInfo = await stagehand.page.evaluate(() => {
-    return {
-      scrollTop: window.scrollY + window.innerHeight * 0.75,
-      scrollHeight: document.documentElement.scrollHeight,
-    };
-  });
-
-  await stagehand.close();
-
-  const threeQuartersScroll = scrollInfo.scrollHeight * 0.75;
-  const threeQuartersReached =
-    Math.abs(scrollInfo.scrollTop - threeQuartersScroll) <= 200;
-  const evaluationResult = threeQuartersReached
-    ? {
-        _success: true,
-        logs: logger.getLogs(),
-        debugUrl,
-        sessionUrl,
-      }
-    : {
-        _success: false,
-        logs: logger.getLogs(),
-        debugUrl,
-        sessionUrl,
-        message: `Scroll position (${scrollInfo.scrollTop}px) is not three quarters down the page (${threeQuartersScroll}px).`,
-      };
-
-  return evaluationResult;
-};
diff --git a/evals/tasks/simple_google_search.ts b/evals/tasks/simple_google_search.ts
deleted file mode 100644
index e6a681200..000000000
--- a/evals/tasks/simple_google_search.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const simple_google_search: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto("https://www.google.com");
-
-  await stagehand.page.act({
-    action: 'type "OpenAI" into the search bar',
-  });
-
-  await stagehand.page.act("click the search button");
-
-  const expectedUrl = "https://www.google.com/search?q=OpenAI";
-  const currentUrl = stagehand.page.url();
-
-  await stagehand.close();
-
-  return {
-    _success: currentUrl.startsWith(expectedUrl),
-    currentUrl,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/stock_x.ts b/evals/tasks/stock_x.ts
deleted file mode 100644
index b1459b0a6..000000000
--- a/evals/tasks/stock_x.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const stock_x: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto(
-    "https://stockx.com/air-jordan-3-retro-black-cement-2024",
-  );
-
-  await stagehand.page.waitForTimeout(3000);
-
-  await stagehand.page.act({
-    action: "click on Jordan 3 Retro Crimson in the related products",
-  });
-
-  await stagehand.page.waitForTimeout(2000);
-  const currentUrl = stagehand.page.url();
-  const expectedUrlPrefix = "https://stockx.com/jordan-3-retro-crimson";
-
-  await stagehand.close();
-
-  return {
-    _success: currentUrl.startsWith(expectedUrlPrefix),
-    currentUrl,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/ted_talk.ts b/evals/tasks/ted_talk.ts
deleted file mode 100644
index d288df8f6..000000000
--- a/evals/tasks/ted_talk.ts
+++ /dev/null
@@ -1,114 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { normalizeString } from "@/evals/utils";
-import { z } from "zod";
-
-export const ted_talk: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-  useTextExtract,
-}) => {
-  await stagehand.page.goto(
-    "https://www.ted.com/talks/sir_ken_robinson_do_schools_kill_creativity",
-    {
-      waitUntil: "domcontentloaded",
-    },
-  );
-  await stagehand.page.act({
-    action:
-      "Click the link that takes you to the page about the 'Culture' topic",
-  });
-
-  const playlists = await stagehand.page.extract({
-    instruction:
-      "Extract the video playlist titles and the number of talks in each playlist. This info is in the Video Playlists about Culture section of the webpage.",
-    schema: z.object({
-      playlists: z
-        .array(
-          z.object({
-            title: z.string().describe("Title of the playlist"),
-            num_talks: z.number().describe("Number of talks in the playlist"),
-          }),
-        )
-        .describe("List of culture video playlists"),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-
-  const expectedPlaylists = [
-    {
-      title: "Talks that celebrate the boundless creativity of an open mind",
-      num_talks: 6,
-    },
-    {
-      title: "Little-known big history",
-      num_talks: 15,
-    },
-    {
-      title: "Extraordinary, larger-than-life art",
-      num_talks: 10,
-    },
-    {
-      title: "How perfectionism fails us",
-      num_talks: 4,
-    },
-  ];
-
-  if (!playlists.playlists || playlists.playlists.length === 0) {
-    logger.error({
-      message: "Failed to extract playlists on culture",
-      level: 0,
-    });
-
-    return {
-      _success: false,
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  const missingPlaylists = expectedPlaylists.filter((expected) =>
-    playlists.playlists.every(
-      (extracted) =>
-        normalizeString(extracted.title) !== normalizeString(expected.title) ||
-        extracted.num_talks !== expected.num_talks,
-    ),
-  );
-
-  if (missingPlaylists.length > 0) {
-    logger.error({
-      message: "Extracted playlists do not match expected playlists",
-      level: 0,
-      auxiliary: {
-        missing: {
-          value: JSON.stringify(missingPlaylists),
-          type: "object",
-        },
-        extracted: {
-          value: JSON.stringify(playlists.playlists),
-          type: "object",
-        },
-      },
-    });
-
-    return {
-      _success: false,
-      error: "Extracted playlists do not match expected playlists",
-      logs: logger.getLogs(),
-      debugUrl,
-      sessionUrl,
-    };
-  }
-
-  return {
-    _success: true,
-    playlists: playlists.playlists,
-    logs: logger.getLogs(),
-    debugUrl,
-    sessionUrl,
-  };
-};
diff --git a/evals/tasks/vanta_h.ts b/evals/tasks/vanta_h.ts
deleted file mode 100644
index dba21d303..000000000
--- a/evals/tasks/vanta_h.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const vanta_h: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto("https://www.vanta.com/");
-
-  const observations = await stagehand.page.observe(
-    "click the buy now button if it is available",
-  );
-
-  await stagehand.close();
-
-  // we should have no saved observation since the element shouldn't exist
-  return {
-    _success: observations.length === 0,
-    observations,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/vantechjournal.ts b/evals/tasks/vantechjournal.ts
deleted file mode 100644
index c176142b0..000000000
--- a/evals/tasks/vantechjournal.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const vantechjournal: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto("https://vantechjournal.com/");
-
-  await stagehand.page.act({
-    action: "click on page 8. do not click the next button",
-  });
-
-  const expectedUrl = "https://vantechjournal.com/archive?page=8";
-  const currentUrl = stagehand.page.url();
-
-  await stagehand.close();
-
-  return {
-    _success: currentUrl === expectedUrl,
-    currentUrl,
-    expectedUrl,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/wichita.ts b/evals/tasks/wichita.ts
deleted file mode 100644
index fe645b480..000000000
--- a/evals/tasks/wichita.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-import { z } from "zod";
-
-export const wichita: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-  useTextExtract,
-}) => {
-  await stagehand.page.goto("https://www.wichitafallstx.gov/Bids.aspx");
-
-  await stagehand.page.act({
-    action: 'Click on "Show Closed/Awarded/Cancelled bids"',
-  });
-
-  const result = await stagehand.page.extract({
-    instruction: "Extract the total number of bids that the search produced.",
-    schema: z.object({
-      total_results: z.string(),
-    }),
-    useTextExtract,
-  });
-
-  await stagehand.close();
-
-  const { total_results } = result;
-
-  const expectedNumber = 405;
-  const extractedNumber = parseInt(total_results.replace(/[^\d]/g, ""), 10);
-
-  const isWithinRange =
-    extractedNumber >= expectedNumber - 10 &&
-    extractedNumber <= expectedNumber + 10;
-
-  if (!isWithinRange) {
-    logger.error({
-      message: "Total number of results is not within the expected range",
-      level: 0,
-      auxiliary: {
-        expected: {
-          value: `${expectedNumber} ± 10`,
-          type: "string",
-        },
-        actual: {
-          value: extractedNumber.toString(),
-          type: "integer",
-        },
-      },
-    });
-    return {
-      _success: false,
-      error: "Total number of results is not within the expected range",
-      extractedNumber,
-      debugUrl,
-      sessionUrl,
-      logs: logger.getLogs(),
-    };
-  }
-
-  return {
-    _success: true,
-    extractedNumber,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/evals/tasks/wikipedia.ts b/evals/tasks/wikipedia.ts
deleted file mode 100644
index 5dad05d2f..000000000
--- a/evals/tasks/wikipedia.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { EvalFunction } from "@/types/evals";
-
-export const wikipedia: EvalFunction = async ({
-  debugUrl,
-  sessionUrl,
-  stagehand,
-  logger,
-}) => {
-  await stagehand.page.goto(`https://en.wikipedia.org/wiki/Baseball`);
-  await stagehand.page.act({
-    action: 'click the "hit and run" link in this article',
-    timeoutMs: 360_000,
-  });
-
-  const url = "https://en.wikipedia.org/wiki/Hit_and_run_(baseball)";
-  const currentUrl = stagehand.page.url();
-
-  await stagehand.close();
-
-  return {
-    _success: currentUrl === url,
-    expected: url,
-    actual: currentUrl,
-    debugUrl,
-    sessionUrl,
-    logs: logger.getLogs(),
-  };
-};
diff --git a/examples/actionable_observe_example.ts b/examples/actionable_observe_example.ts
deleted file mode 100644
index 5fa55d80c..000000000
--- a/examples/actionable_observe_example.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-/**
- * This file is meant to be used as a scratchpad for trying out actionable observe.
- * To create a Stagehand project with best practices and configuration, run:
- *
- * npx create-browser-app@latest my-browser-app
- */
-
-import { Stagehand } from "@/dist";
-import stagehandConfig from "@/stagehand.config";
-
-async function example() {
-  const stagehand = new Stagehand(stagehandConfig);
-  await stagehand.init();
-  await stagehand.page.goto("https://www.apartments.com/san-francisco-ca/");
-
-  await new Promise((resolve) => setTimeout(resolve, 3000));
-  const observations1 = await stagehand.page.observe({
-    instruction: "find the 'all filters' button",
-  });
-  await stagehand.page.act(observations1[0]);
-
-  await new Promise((resolve) => setTimeout(resolve, 3000));
-  const observations2 = await stagehand.page.observe({
-    instruction: "find the '1+' button in the 'beds' section",
-  });
-  await stagehand.page.act(observations2[0]);
-
-  await new Promise((resolve) => setTimeout(resolve, 3000));
-  const observations3 = await stagehand.page.observe({
-    instruction: "find the 'apartments' button in the 'home type' section",
-  });
-  await stagehand.page.act(observations3[0]);
-
-  await new Promise((resolve) => setTimeout(resolve, 3000));
-  const observations4 = await stagehand.page.observe({
-    instruction: "find the pet policy dropdown to click on.",
-  });
-  await stagehand.page.act(observations4[0]);
-
-  await new Promise((resolve) => setTimeout(resolve, 3000));
-  const observations5 = await stagehand.page.observe({
-    instruction: "find the 'Dog Friendly' option to click on",
-  });
-  await stagehand.page.act(observations5[0]);
-
-  await new Promise((resolve) => setTimeout(resolve, 3000));
-  const observations6 = await stagehand.page.observe({
-    instruction: "find the 'see results' section",
-  });
-  await stagehand.page.act(observations6[0]);
-
-  const currentUrl = await stagehand.page.url();
-  await stagehand.close();
-  if (
-    currentUrl.includes(
-      "https://www.apartments.com/apartments/san-francisco-ca/min-1-bedrooms-pet-friendly-dog/",
-    )
-  ) {
-    console.log("✅ Success! we made it to the correct page");
-  } else {
-    console.log(
-      "❌ Whoops, looks like we didn't make it to the correct page. " +
-        "\nThanks for testing out this new Stagehand feature!" +
-        "\nReach us on Slack if you have any feedback/questions/suggestions!",
-    );
-  }
-}
-
-(async () => {
-  await example();
-})();
diff --git a/examples/ai_sdk_example.ts b/examples/ai_sdk_example.ts
deleted file mode 100644
index b650de5c1..000000000
--- a/examples/ai_sdk_example.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { openai } from "@ai-sdk/openai";
-import { Stagehand } from "@/dist";
-import { AISdkClient } from "./external_clients/aisdk";
-import StagehandConfig from "@/stagehand.config";
-import { z } from "zod";
-
-async function example() {
-  const stagehand = new Stagehand({
-    ...StagehandConfig,
-    llmClient: new AISdkClient({
-      model: openai("gpt-4o"),
-    }),
-  });
-
-  await stagehand.init();
-  await stagehand.page.goto("https://news.ycombinator.com");
-
-  const { story } = await stagehand.page.extract({
-    instruction: "extract the title of the top story on the page",
-    schema: z.object({
-      story: z.string().describe("the top story on the page"),
-    }),
-  });
-
-  console.log("The top story is:", story);
-
-  await stagehand.page.act("click the first story");
-
-  await stagehand.close();
-}
-
-(async () => {
-  await example();
-})();
diff --git a/examples/cua-example.ts b/examples/cua-example.ts
deleted file mode 100644
index e48eaf25b..000000000
--- a/examples/cua-example.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-import { Stagehand } from "@/dist";
-import dotenv from "dotenv";
-import StagehandConfig from "@/stagehand.config";
-import chalk from "chalk";
-
-// Load environment variables
-dotenv.config();
-
-async function main() {
-  console.log(
-    `\n${chalk.bold("Stagehand 🤘 Computer Use Agent (CUA) Demo")}\n`,
-  );
-
-  // Initialize Stagehand
-  console.log(`${chalk.cyan("→")} Initializing Stagehand...`);
-  const stagehand = new Stagehand({
-    ...StagehandConfig,
-  });
-
-  await stagehand.init();
-  console.log(`${chalk.green("✓")} Stagehand initialized`);
-
-  try {
-    const page = stagehand.page;
-
-    console.log(`\n${chalk.magenta.bold("⚡ First Agent Execution")}`);
-
-    const agent = stagehand.agent({
-      provider: "openai",
-      model: "computer-use-preview",
-      instructions: `You are a helpful assistant that can use a web browser.
-      You are currently on the following page: ${page.url()}.
-      Do not ask follow up questions, the user will trust your judgement.`,
-      options: {
-        apiKey: process.env.OPENAI_API_KEY,
-      },
-    });
-
-    console.log(`${chalk.yellow("→")} Navigating to Google...`);
-    await stagehand.page.goto("https://www.google.com");
-    console.log(`${chalk.green("✓")} Loaded: ${chalk.dim(page.url())}`);
-
-    const firstInstruction =
-      "Search for openai news on google and extract the name of the first 3 results";
-    console.log(
-      `${chalk.cyan("↳")} Instruction: ${chalk.white(firstInstruction)}`,
-    );
-
-    const result1 = await agent.execute(firstInstruction);
-
-    console.log(`${chalk.green("✓")} Execution complete`);
-    console.log(`${chalk.yellow("⤷")} Result:`);
-    console.log(chalk.white(JSON.stringify(result1, null, 2)));
-
-    console.log(`\n${chalk.magenta.bold("⚡ Second Agent Execution")}`);
-
-    console.log(
-      `\n${chalk.yellow("→")} Navigating to Browserbase careers page...`,
-    );
-    await page.goto("https://www.browserbase.com/careers");
-    console.log(`${chalk.green("✓")} Loaded: ${chalk.dim(page.url())}`);
-
-    const instruction =
-      "Apply for the first engineer position with mock data. Don't submit the form.";
-    console.log(`${chalk.cyan("↳")} Instruction: ${chalk.white(instruction)}`);
-
-    const result = await agent.execute({
-      instruction,
-      maxSteps: 20,
-    });
-
-    console.log(`${chalk.green("✓")} Execution complete`);
-    console.log(`${chalk.yellow("⤷")} Result:`);
-    console.log(chalk.white(JSON.stringify(result, null, 2)));
-  } catch (error) {
-    console.log(`${chalk.red("✗")} Error: ${error}`);
-    if (error instanceof Error && error.stack) {
-      console.log(chalk.dim(error.stack.split("\n").slice(1).join("\n")));
-    }
-  } finally {
-    // Close the browser
-    console.log(`\n${chalk.yellow("→")} Closing browser...`);
-    await stagehand.close();
-    console.log(`${chalk.green("✓")} Browser closed\n`);
-  }
-}
-
-main().catch((error) => {
-  console.log(`${chalk.red("✗")} Unhandled error in main function`);
-  console.log(chalk.red(error));
-});
diff --git a/examples/debugUrl.ts b/examples/debugUrl.ts
deleted file mode 100644
index e54bb1e2a..000000000
--- a/examples/debugUrl.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { Stagehand } from "@/dist";
-
-async function debug(url: string) {
-  const stagehand = new Stagehand({
-    env: "LOCAL",
-    verbose: 2,
-    localBrowserLaunchOptions: {
-      headless: true,
-    },
-  });
-  await stagehand.init();
-  await stagehand.page.goto(url);
-}
-
-(async () => {
-  const url = process.argv.find((arg) => arg.startsWith("--url="));
-  if (!url) {
-    console.error("No URL flag provided. Usage: --url=https://example.com");
-    process.exit(1);
-  }
-  const targetUrl = url.split("=")[1];
-  console.log(`Navigating to: ${targetUrl}`);
-  await debug(targetUrl);
-})();
diff --git a/examples/example.ts b/examples/example.ts
deleted file mode 100644
index 372d72e5c..000000000
--- a/examples/example.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-/**
- * This file is meant to be used as a scratchpad for developing new evals.
- * To create a Stagehand project with best practices and configuration, run:
- *
- * npx create-browser-app@latest my-browser-app
- */
-
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/stagehand.config";
-
-async function example() {
-  const stagehand = new Stagehand({
-    ...StagehandConfig,
-  });
-  await stagehand.init();
-  await stagehand.page.goto("https://docs.stagehand.dev");
-  /**
-   * Add your code here!
-   */
-  await stagehand.close();
-}
-
-(async () => {
-  await example();
-})();
diff --git a/examples/external_client.ts b/examples/external_client.ts
deleted file mode 100644
index 63f92256a..000000000
--- a/examples/external_client.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import { Stagehand } from "@/dist";
-import { z } from "zod";
-import { CustomOpenAIClient } from "./external_clients/customOpenAI";
-import StagehandConfig from "@/stagehand.config";
-import OpenAI from "openai";
-
-async function example() {
-  const stagehand = new Stagehand({
-    ...StagehandConfig,
-    llmClient: new CustomOpenAIClient({
-      modelName: "gpt-4o-mini",
-      client: new OpenAI({
-        apiKey: process.env.OPENAI_API_KEY,
-      }),
-    }),
-  });
-
-  await stagehand.init();
-  await stagehand.page.goto("https://news.ycombinator.com");
-  await stagehand.page.act("click on the 'new' link");
-
-  const headlines = await stagehand.page.extract({
-    instruction: "Extract the top 3 stories from the Hacker News homepage.",
-    schema: z.object({
-      stories: z.array(
-        z.object({
-          title: z.string(),
-          url: z.string(),
-          points: z.number(),
-        }),
-      ),
-    }),
-  });
-
-  console.log(headlines);
-
-  await stagehand.close();
-}
-
-(async () => {
-  await example();
-})();
diff --git a/examples/external_clients/aisdk.ts b/examples/external_clients/aisdk.ts
deleted file mode 100644
index 1d72d984f..000000000
--- a/examples/external_clients/aisdk.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-import {
-  CoreAssistantMessage,
-  CoreMessage,
-  CoreSystemMessage,
-  CoreTool,
-  CoreUserMessage,
-  generateObject,
-  generateText,
-  ImagePart,
-  LanguageModel,
-  TextPart,
-} from "ai";
-import { CreateChatCompletionOptions, LLMClient, AvailableModel } from "@/dist";
-import { ChatCompletion } from "openai/resources";
-
-export class AISdkClient extends LLMClient {
-  public type = "aisdk" as const;
-  private model: LanguageModel;
-
-  constructor({ model }: { model: LanguageModel }) {
-    super(model.modelId as AvailableModel);
-    this.model = model;
-  }
-
-  async createChatCompletion<T = ChatCompletion>({
-    options,
-  }: CreateChatCompletionOptions): Promise<T> {
-    const formattedMessages: CoreMessage[] = options.messages.map((message) => {
-      if (Array.isArray(message.content)) {
-        if (message.role === "system") {
-          const systemMessage: CoreSystemMessage = {
-            role: "system",
-            content: message.content
-              .map((c) => ("text" in c ? c.text : ""))
-              .join("\n"),
-          };
-          return systemMessage;
-        }
-
-        const contentParts = message.content.map((content) => {
-          if ("image_url" in content) {
-            const imageContent: ImagePart = {
-              type: "image",
-              image: content.image_url.url,
-            };
-            return imageContent;
-          } else {
-            const textContent: TextPart = {
-              type: "text",
-              text: content.text,
-            };
-            return textContent;
-          }
-        });
-
-        if (message.role === "user") {
-          const userMessage: CoreUserMessage = {
-            role: "user",
-            content: contentParts,
-          };
-          return userMessage;
-        } else {
-          const textOnlyParts = contentParts.map((part) => ({
-            type: "text" as const,
-            text: part.type === "image" ? "[Image]" : part.text,
-          }));
-          const assistantMessage: CoreAssistantMessage = {
-            role: "assistant",
-            content: textOnlyParts,
-          };
-          return assistantMessage;
-        }
-      }
-
-      return {
-        role: message.role,
-        content: message.content,
-      };
-    });
-
-    if (options.response_model) {
-      const response = await generateObject({
-        model: this.model,
-        messages: formattedMessages,
-        schema: options.response_model.schema,
-      });
-
-      return {
-        data: response.object,
-        usage: {
-          prompt_tokens: response.usage.promptTokens ?? 0,
-          completion_tokens: response.usage.completionTokens ?? 0,
-          total_tokens: response.usage.totalTokens ?? 0,
-        },
-      } as T;
-    }
-
-    const tools: Record<string, CoreTool> = {};
-
-    for (const rawTool of options.tools) {
-      tools[rawTool.name] = {
-        description: rawTool.description,
-        parameters: rawTool.parameters,
-      };
-    }
-
-    const response = await generateText({
-      model: this.model,
-      messages: formattedMessages,
-      tools,
-    });
-
-    return {
-      data: response.text,
-      usage: {
-        prompt_tokens: response.usage.promptTokens ?? 0,
-        completion_tokens: response.usage.completionTokens ?? 0,
-        total_tokens: response.usage.totalTokens ?? 0,
-      },
-    } as T;
-  }
-}
diff --git a/examples/form_filling_sensible_cerebras.ts b/examples/form_filling_sensible_cerebras.ts
deleted file mode 100644
index 862a3e471..000000000
--- a/examples/form_filling_sensible_cerebras.ts
+++ /dev/null
@@ -1,97 +0,0 @@
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/stagehand.config";
-import { CerebrasClient } from "../lib/llm/CerebrasClient";
-import chalk from "chalk";
-
-async function formFillingSensible() {
-  const stagehand = new Stagehand({
-    ...StagehandConfig,
-    env: "LOCAL",
-    llmClient: new CerebrasClient({
-      modelName: "cerebras-llama-3.3-70b",
-      clientOptions: {
-        apiKey: process.env.CEREBRAS_API_KEY,
-      },
-      logger: console.log,
-    }),
-  });
-  await stagehand.init();
-
-  // Block manifest worker to prevent PWA installation popup.
-  // This is necessary because the website prompts the user to install the PWA and prevents form filling.
-  await stagehand.page.route("**/manifest.json", (route) => route.abort());
-
-  // Go to the website and wait for it to load
-  await stagehand.page.goto("https://file.1040.com/estimate/", {
-    waitUntil: "networkidle",
-    timeout: 30000,
-  });
-
-  // Observe the form fields with suggested actions
-  const observed = await stagehand.page.observe({
-    instruction:
-      "fill all the form fields in the page with mock data. In the description inlcude the field name",
-    returnAction: true,
-  });
-
-  // Uncomment the following snippet to see the stagehand candidate suggestions (initial)
-  console.log(
-    `${chalk.green("Observe:")} Form fields found:\n${observed
-      .map((r) => `${chalk.yellow(r.description)} -> ${chalk.gray(r.selector)}`)
-      .join("\n")}`,
-  );
-
-  // Create a mapping of 1+ keywords in the form fields to standardize field names
-  const mapping = (description: string): string | null => {
-    const keywords: { [key: string]: string[] } = {
-      age: ["old"],
-      dependentsUnder17: ["under age 17", "child", "minor"],
-      dependents17to23: ["17-23", "school", "student"],
-      wages: ["wages", "W-2 Box 1"],
-      federalTax: ["federal tax", "Box 2"],
-      stateTax: ["state tax", "Box 17"],
-    };
-
-    for (const [key, terms] of Object.entries(keywords)) {
-      if (terms.some((term) => description.toLowerCase().includes(term))) {
-        return key;
-      }
-    }
-    return null;
-  };
-
-  // Fill the form fields with sensible data. This data will only be used in your session and not be shared with LLM providers/external APIs.
-  const userInputs: { [key: string]: string } = {
-    age: "26",
-    dependentsUnder17: "1",
-    wages: "54321",
-    federalTax: "8345",
-    stateTax: "2222",
-  };
-
-  const updatedFields = observed.map((candidate) => {
-    const key = mapping(candidate.description);
-    if (key && userInputs[key]) {
-      candidate.arguments = [userInputs[key]];
-    }
-    return candidate;
-  });
-  // List of sensible-data candidates
-  console.log(
-    `\n${chalk.green("Sensible Data form inputs:")} Form fields to be filled:\n${updatedFields
-      .map(
-        (r) =>
-          `${chalk.yellow(r.description)} -> ${chalk.blue(r.arguments?.[0] || "no value")}`,
-      )
-      .join("\n")}`,
-  );
-
-  // Fill all the form fields with the sensible candidates
-  for (const candidate of updatedFields) {
-    await stagehand.page.act(candidate);
-  }
-}
-
-(async () => {
-  await formFillingSensible();
-})();
diff --git a/examples/form_filling_sensible_groq.ts b/examples/form_filling_sensible_groq.ts
deleted file mode 100644
index cf885e215..000000000
--- a/examples/form_filling_sensible_groq.ts
+++ /dev/null
@@ -1,97 +0,0 @@
-import { Stagehand } from "@/dist";
-import { GroqClient } from "@/lib/llm/GroqClient";
-import StagehandConfig from "@/stagehand.config";
-import chalk from "chalk";
-
-async function formFillingSensible() {
-  const stagehand = new Stagehand({
-    ...StagehandConfig,
-    env: "LOCAL",
-    llmClient: new GroqClient({
-      modelName: "groq-llama-3.3-70b-versatile",
-      clientOptions: {
-        apiKey: process.env.GROQ_API_KEY,
-      },
-      logger: console.log,
-    }),
-  });
-  await stagehand.init();
-
-  // Block manifest worker to prevent PWA installation popup.
-  // This is necessary because the website prompts the user to install the PWA and prevents form filling.
-  await stagehand.page.route("**/manifest.json", (route) => route.abort());
-
-  // Go to the website and wait for it to load
-  await stagehand.page.goto("https://file.1040.com/estimate/", {
-    waitUntil: "networkidle",
-    timeout: 30000,
-  });
-
-  // Observe the form fields with suggested actions
-  const observed = await stagehand.page.observe({
-    instruction:
-      "fill all the form fields in the page with mock data. In the description inlcude the field name",
-    returnAction: true,
-  });
-
-  // Uncomment the following snippet to see the stagehand candidate suggestions (initial)
-  console.log(
-    `${chalk.green("Observe:")} Form fields found:\n${observed
-      .map((r) => `${chalk.yellow(r.description)} -> ${chalk.gray(r.selector)}`)
-      .join("\n")}`,
-  );
-
-  // Create a mapping of 1+ keywords in the form fields to standardize field names
-  const mapping = (description: string): string | null => {
-    const keywords: { [key: string]: string[] } = {
-      age: ["old"],
-      dependentsUnder17: ["under age 17", "child", "minor"],
-      dependents17to23: ["17-23", "school", "student"],
-      wages: ["wages", "W-2 Box 1"],
-      federalTax: ["federal tax", "Box 2"],
-      stateTax: ["state tax", "Box 17"],
-    };
-
-    for (const [key, terms] of Object.entries(keywords)) {
-      if (terms.some((term) => description.toLowerCase().includes(term))) {
-        return key;
-      }
-    }
-    return null;
-  };
-
-  // Fill the form fields with sensible data. This data will only be used in your session and not be shared with LLM providers/external APIs.
-  const userInputs: { [key: string]: string } = {
-    age: "26",
-    dependentsUnder17: "1",
-    wages: "54321",
-    federalTax: "8345",
-    stateTax: "2222",
-  };
-
-  const updatedFields = observed.map((candidate) => {
-    const key = mapping(candidate.description);
-    if (key && userInputs[key]) {
-      candidate.arguments = [userInputs[key]];
-    }
-    return candidate;
-  });
-  // List of sensible-data candidates
-  console.log(
-    `\n${chalk.green("Sensible Data form inputs:")} Form fields to be filled:\n${updatedFields
-      .map(
-        (r) =>
-          `${chalk.yellow(r.description)} -> ${chalk.blue(r.arguments?.[0] || "no value")}`,
-      )
-      .join("\n")}`,
-  );
-
-  // Fill all the form fields with the sensible candidates
-  for (const candidate of updatedFields) {
-    await stagehand.page.act(candidate);
-  }
-}
-
-(async () => {
-  await formFillingSensible();
-})();
diff --git a/examples/google_enter.ts b/examples/google_enter.ts
deleted file mode 100644
index affa1eb93..000000000
--- a/examples/google_enter.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-/**
- * This file is meant to be used as a scratchpad for developing new evals.
- * To create a Stagehand project with best practices and configuration, run:
- *
- * npx create-browser-app@latest my-browser-app
- */
-
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/stagehand.config";
-
-async function example() {
-  const stagehand = new Stagehand({
-    ...StagehandConfig,
-  });
-  await stagehand.init();
-  const page = stagehand.page;
-  await page.goto("https://google.com");
-  await page.act("type in 'Browserbase'");
-  await page.act("press enter");
-  await stagehand.close();
-}
-
-(async () => {
-  await example();
-})();
diff --git a/examples/langchain.ts b/examples/langchain.ts
deleted file mode 100644
index 98fe41d4c..000000000
--- a/examples/langchain.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import { z } from "zod";
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/stagehand.config";
-import { LangchainClient } from "./external_clients/langchain";
-import { ChatOpenAI } from "@langchain/openai";
-
-async function example() {
-  const stagehand = new Stagehand({
-    ...StagehandConfig,
-    llmClient: new LangchainClient(
-      new ChatOpenAI({
-        model: "gpt-4o",
-      }),
-    ),
-  });
-
-  await stagehand.init();
-  await stagehand.page.goto("https://news.ycombinator.com");
-
-  const { story } = await stagehand.page.extract({
-    schema: z.object({
-      story: z.string().describe("the top story on the page"),
-    }),
-  });
-
-  console.log("The top story is:", story);
-
-  await stagehand.page.act("click the first story");
-
-  await stagehand.close();
-}
-
-(async () => {
-  await example();
-})();
diff --git a/examples/popup.ts b/examples/popup.ts
deleted file mode 100644
index 72ec0369e..000000000
--- a/examples/popup.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-/**
- * This file is meant to be used as a scratchpad for developing new evals.
- * To create a Stagehand project with best practices and configuration, run:
- *
- * npx create-browser-app@latest my-browser-app
- */
-
-import { ObserveResult, Stagehand } from "@/dist";
-import StagehandConfig from "@/stagehand.config";
-
-async function example() {
-  const stagehand = new Stagehand(StagehandConfig);
-  await stagehand.init();
-
-  const page = await stagehand.page;
-
-  let observePromise: Promise<ObserveResult[]>;
-
-  page.on("popup", async (newPage) => {
-    observePromise = newPage.observe({
-      instruction: "return all the next possible actions from the page",
-    });
-  });
-
-  await page.goto(
-    "https://docs.browserbase.com/integrations/crew-ai/introduction",
-  );
-
-  await page.click(
-    "#content-area > div.relative.mt-8.prose.prose-gray.dark\\:prose-invert > p:nth-child(2) > a",
-  );
-
-  await page.waitForTimeout(5000);
-
-  if (observePromise) {
-    const observeResult = await observePromise;
-
-    console.log("Observed", observeResult.length, "actions");
-  }
-
-  await stagehand.close();
-}
-
-(async () => {
-  await example();
-})();
diff --git a/examples/try_wordle.ts b/examples/try_wordle.ts
deleted file mode 100644
index a8f1fe22a..000000000
--- a/examples/try_wordle.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/stagehand.config";
-
-async function example() {
-  const stagehand = new Stagehand({
-    ...StagehandConfig,
-  });
-  await stagehand.init();
-  const page = stagehand.page;
-  await page.goto("https://www.nytimes.com/games/wordle/index.html");
-  await page.act("click 'Continue'");
-  await page.act("click 'Play'");
-  await page.act("click cross sign on top right of 'How To Play' card");
-  const word = "WORDS";
-  for (const letter of word) {
-    await page.act(`press ${letter}`);
-  }
-  await page.act("press enter");
-  await stagehand.close();
-}
-
-(async () => {
-  await example();
-})();
diff --git a/lib/StagehandContext.ts b/lib/StagehandContext.ts
deleted file mode 100644
index 5d8bf4e66..000000000
--- a/lib/StagehandContext.ts
+++ /dev/null
@@ -1,125 +0,0 @@
-import type {
-  BrowserContext as PlaywrightContext,
-  Page as PlaywrightPage,
-} from "@playwright/test";
-import { Stagehand } from "./index";
-import { StagehandPage } from "./StagehandPage";
-import { Page } from "../types/page";
-import { EnhancedContext } from "../types/context";
-
-export class StagehandContext {
-  private readonly stagehand: Stagehand;
-  private readonly intContext: EnhancedContext;
-  private pageMap: WeakMap<PlaywrightPage, StagehandPage>;
-  private activeStagehandPage: StagehandPage | null = null;
-
-  private constructor(context: PlaywrightContext, stagehand: Stagehand) {
-    this.stagehand = stagehand;
-    this.pageMap = new WeakMap();
-
-    // Create proxy around the context
-    this.intContext = new Proxy(context, {
-      get: (target, prop) => {
-        if (prop === "newPage") {
-          return async (): Promise<Page> => {
-            const pwPage = await target.newPage();
-            const stagehandPage = await this.createStagehandPage(pwPage);
-            // Set as active page when created
-            this.setActivePage(stagehandPage);
-            return stagehandPage.page;
-          };
-        }
-        if (prop === "pages") {
-          return (): Page[] => {
-            const pwPages = target.pages();
-            // Convert all pages to StagehandPages synchronously
-            return pwPages.map((pwPage: PlaywrightPage) => {
-              let stagehandPage = this.pageMap.get(pwPage);
-              if (!stagehandPage) {
-                // Create a new StagehandPage and store it in the map
-                stagehandPage = new StagehandPage(
-                  pwPage,
-                  this.stagehand,
-                  this,
-                  this.stagehand.llmClient,
-                  this.stagehand.userProvidedInstructions,
-                  this.stagehand.apiClient,
-                  this.stagehand.waitForCaptchaSolves,
-                );
-                this.pageMap.set(pwPage, stagehandPage);
-              }
-              return stagehandPage.page;
-            });
-          };
-        }
-        return target[prop as keyof PlaywrightContext];
-      },
-    }) as unknown as EnhancedContext;
-  }
-
-  private async createStagehandPage(
-    page: PlaywrightPage,
-  ): Promise<StagehandPage> {
-    const stagehandPage = await new StagehandPage(
-      page,
-      this.stagehand,
-      this,
-      this.stagehand.llmClient,
-      this.stagehand.userProvidedInstructions,
-      this.stagehand.apiClient,
-      this.stagehand.waitForCaptchaSolves,
-    ).init();
-    this.pageMap.set(page, stagehandPage);
-    return stagehandPage;
-  }
-
-  static async init(
-    context: PlaywrightContext,
-    stagehand: Stagehand,
-  ): Promise<StagehandContext> {
-    const instance = new StagehandContext(context, stagehand);
-
-    // Initialize existing pages
-    const existingPages = context.pages();
-    for (const page of existingPages) {
-      const stagehandPage = await instance.createStagehandPage(page);
-      // Set the first page as active
-      if (!instance.activeStagehandPage) {
-        instance.setActivePage(stagehandPage);
-      }
-    }
-
-    return instance;
-  }
-
-  public get context(): EnhancedContext {
-    return this.intContext;
-  }
-
-  public async getStagehandPage(page: PlaywrightPage): Promise<StagehandPage> {
-    let stagehandPage = this.pageMap.get(page);
-    if (!stagehandPage) {
-      stagehandPage = await this.createStagehandPage(page);
-    }
-    // Update active page when getting a page
-    this.setActivePage(stagehandPage);
-    return stagehandPage;
-  }
-
-  public async getStagehandPages(): Promise<StagehandPage[]> {
-    const pwPages = this.intContext.pages();
-    return Promise.all(
-      pwPages.map((page: PlaywrightPage) => this.getStagehandPage(page)),
-    );
-  }
-
-  public setActivePage(page: StagehandPage): void {
-    this.activeStagehandPage = page;
-    // Update the stagehand's active page reference
-    this.stagehand["setActivePage"](page);
-  }
-
-  public getActivePage(): StagehandPage | null {
-    return this.activeStagehandPage;
-  }
-}
diff --git a/lib/StagehandPage.ts b/lib/StagehandPage.ts
deleted file mode 100644
index 6d2aad423..000000000
--- a/lib/StagehandPage.ts
+++ /dev/null
@@ -1,829 +0,0 @@
-import { Browserbase } from "@browserbasehq/sdk";
-import type { CDPSession, Page as PlaywrightPage } from "@playwright/test";
-import { chromium } from "@playwright/test";
-import { z } from "zod";
-import { Page, defaultExtractSchema } from "../types/page";
-import {
-  ExtractOptions,
-  ExtractResult,
-  HistoryEntry,
-  ObserveOptions,
-  ObserveResult,
-} from "../types/stagehand";
-import { StagehandAPI } from "./api";
-import { StagehandActHandler } from "./handlers/actHandler";
-import { StagehandExtractHandler } from "./handlers/extractHandler";
-import { StagehandObserveHandler } from "./handlers/observeHandler";
-import { ActOptions, ActResult, GotoOptions, Stagehand } from "./index";
-import { LLMClient } from "./llm/LLMClient";
-import { StagehandContext } from "./StagehandContext";
-import { EnhancedContext } from "../types/context";
-import { clearOverlays } from "./utils";
-import {
-  StagehandError,
-  StagehandNotInitializedError,
-  StagehandEnvironmentError,
-  CaptchaTimeoutError,
-  StagehandNotImplementedError,
-  BrowserbaseSessionNotFoundError,
-  MissingLLMConfigurationError,
-  HandlerNotInitializedError,
-  StagehandDefaultError,
-} from "../types/stagehandErrors";
-import { StagehandAPIError } from "@/types/stagehandApiErrors";
-
-export class StagehandPage {
-  private stagehand: Stagehand;
-  private intPage: Page;
-  private intContext: StagehandContext;
-  private actHandler: StagehandActHandler;
-  private extractHandler: StagehandExtractHandler;
-  private observeHandler: StagehandObserveHandler;
-  private llmClient: LLMClient;
-  private cdpClient: CDPSession | null = null;
-  private api: StagehandAPI;
-  private userProvidedInstructions?: string;
-  private waitForCaptchaSolves: boolean;
-  private initialized: boolean = false;
-  private _history: Array<HistoryEntry> = [];
-
-  public get history(): ReadonlyArray<HistoryEntry> {
-    return Object.freeze([...this._history]);
-  }
-
-  constructor(
-    page: PlaywrightPage,
-    stagehand: Stagehand,
-    context: StagehandContext,
-    llmClient: LLMClient,
-    userProvidedInstructions?: string,
-    api?: StagehandAPI,
-    waitForCaptchaSolves?: boolean,
-  ) {
-    // Create a proxy to intercept all method calls and property access
-    this.intPage = new Proxy(page, {
-      get: (target: PlaywrightPage, prop: keyof PlaywrightPage) => {
-        // Special handling for our enhanced methods before initialization
-        if (
-          !this.initialized &&
-          (prop === ("act" as keyof Page) ||
-            prop === ("extract" as keyof Page) ||
-            prop === ("observe" as keyof Page) ||
-            prop === ("on" as keyof Page))
-        ) {
-          return () => {
-            throw new StagehandNotInitializedError(String(prop));
-          };
-        }
-
-        const value = target[prop];
-        // If the property is a function, wrap it to update active page before execution
-        if (typeof value === "function" && prop !== "on") {
-          return (...args: unknown[]) => {
-            // Update active page before executing the method
-            this.intContext.setActivePage(this);
-            return value.apply(target, args);
-          };
-        }
-        return value;
-      },
-    }) as Page;
-
-    this.stagehand = stagehand;
-    this.intContext = context;
-    this.llmClient = llmClient;
-    this.api = api;
-    this.userProvidedInstructions = userProvidedInstructions;
-    this.waitForCaptchaSolves = waitForCaptchaSolves ?? false;
-
-    if (this.llmClient) {
-      this.actHandler = new StagehandActHandler({
-        logger: this.stagehand.logger,
-        stagehandPage: this,
-        selfHeal: this.stagehand.selfHeal,
-      });
-      this.extractHandler = new StagehandExtractHandler({
-        stagehand: this.stagehand,
-        logger: this.stagehand.logger,
-        stagehandPage: this,
-        userProvidedInstructions,
-      });
-      this.observeHandler = new StagehandObserveHandler({
-        stagehand: this.stagehand,
-        logger: this.stagehand.logger,
-        stagehandPage: this,
-        userProvidedInstructions,
-      });
-    }
-  }
-
-  private async _refreshPageFromAPI() {
-    if (!this.api) return;
-
-    const sessionId = this.stagehand.browserbaseSessionID;
-    if (!sessionId) {
-      throw new BrowserbaseSessionNotFoundError();
-    }
-
-    const browserbase = new Browserbase({
-      apiKey: process.env.BROWSERBASE_API_KEY,
-    });
-
-    const sessionStatus = await browserbase.sessions.retrieve(sessionId);
-
-    const connectUrl = sessionStatus.connectUrl;
-    const browser = await chromium.connectOverCDP(connectUrl);
-    const context = browser.contexts()[0];
-    const newPage = context.pages()[0];
-
-    const newStagehandPage = await new StagehandPage(
-      newPage,
-      this.stagehand,
-      this.intContext,
-      this.llmClient,
-      this.userProvidedInstructions,
-      this.api,
-    ).init();
-
-    this.intPage = newStagehandPage.page;
-
-    if (this.stagehand.debugDom) {
-      this.stagehand.log({
-        category: "deprecation",
-        message:
-          "Warning: debugDom is not supported in this version of Stagehand",
-        level: 1,
-      });
-    }
-    await this.intPage.waitForLoadState("domcontentloaded");
-    await this._waitForSettledDom();
-  }
-
-  /**
-   * Waits for a captcha to be solved when using Browserbase environment.
-   *
-   * @param timeoutMs - Optional timeout in milliseconds. If provided, the promise will reject if the captcha solving hasn't started within the given time.
-   * @throws StagehandEnvironmentError if called in a LOCAL environment
-   * @throws CaptchaTimeoutError if the timeout is reached before captcha solving starts
-   * @returns Promise that resolves when the captcha is solved
-   */
-  public async waitForCaptchaSolve(timeoutMs?: number) {
-    if (this.stagehand.env === "LOCAL") {
-      throw new StagehandEnvironmentError(
-        this.stagehand.env,
-        "BROWSERBASE",
-        "waitForCaptcha method",
-      );
-    }
-
-    this.stagehand.log({
-      category: "captcha",
-      message: "Waiting for captcha",
-      level: 1,
-    });
-
-    return new Promise<void>((resolve, reject) => {
-      let started = false;
-      let timeoutId: NodeJS.Timeout;
-
-      if (timeoutMs) {
-        timeoutId = setTimeout(() => {
-          if (!started) {
-            reject(new CaptchaTimeoutError());
-          }
-        }, timeoutMs);
-      }
-
-      this.intPage.on("console", (msg) => {
-        if (msg.text() === "browserbase-solving-finished") {
-          this.stagehand.log({
-            category: "captcha",
-            message: "Captcha solving finished",
-            level: 1,
-          });
-          if (timeoutId) clearTimeout(timeoutId);
-          resolve();
-        } else if (msg.text() === "browserbase-solving-started") {
-          started = true;
-          this.stagehand.log({
-            category: "captcha",
-            message: "Captcha solving started",
-            level: 1,
-          });
-        }
-      });
-    });
-  }
-
-  async init(): Promise<StagehandPage> {
-    try {
-      const page = this.intPage;
-      const stagehand = this.stagehand;
-
-      // Create a proxy that updates active page on method calls
-      const handler = {
-        get: (target: PlaywrightPage, prop: string | symbol) => {
-          const value = target[prop as keyof PlaywrightPage];
-
-          // Handle enhanced methods
-          if (prop === "act" || prop === "extract" || prop === "observe") {
-            if (!this.llmClient) {
-              return () => {
-                throw new MissingLLMConfigurationError();
-              };
-            }
-
-            // Use type assertion to safely call the method with proper typing
-            type EnhancedMethod = (
-              options:
-                | ActOptions
-                | ExtractOptions<z.AnyZodObject>
-                | ObserveOptions,
-            ) => Promise<
-              ActResult | ExtractResult<z.AnyZodObject> | ObserveResult[]
-            >;
-
-            const method = this[prop as keyof StagehandPage] as EnhancedMethod;
-            return async (options: unknown) => {
-              this.intContext.setActivePage(this);
-              return method.call(this, options);
-            };
-          }
-
-          // Handle screenshots with CDP
-          if (prop === "screenshot" && this.stagehand.env === "BROWSERBASE") {
-            return async (
-              options: {
-                type?: "png" | "jpeg";
-                quality?: number;
-                fullPage?: boolean;
-                clip?: { x: number; y: number; width: number; height: number };
-                omitBackground?: boolean;
-              } = {},
-            ) => {
-              const cdpOptions: Record<string, unknown> = {
-                format: options.type === "jpeg" ? "jpeg" : "png",
-                quality: options.quality,
-                clip: options.clip,
-                omitBackground: options.omitBackground,
-                fromSurface: true,
-              };
-
-              if (options.fullPage) {
-                cdpOptions.captureBeyondViewport = true;
-              }
-
-              const data = await this.sendCDP<{ data: string }>(
-                "Page.captureScreenshot",
-                cdpOptions,
-              );
-
-              // Convert base64 to buffer
-              const buffer = Buffer.from(data.data, "base64");
-
-              return buffer;
-            };
-          }
-
-          // Handle goto specially
-          if (prop === "goto") {
-            return async (url: string, options: GotoOptions) => {
-              this.intContext.setActivePage(this);
-              const result = this.api
-                ? await this.api.goto(url, options)
-                : await target.goto(url, options);
-
-              this.addToHistory("navigate", { url, options }, result);
-
-              if (this.waitForCaptchaSolves) {
-                try {
-                  await this.waitForCaptchaSolve(1000);
-                } catch {
-                  // ignore
-                }
-              }
-
-              if (this.api) {
-                await this._refreshPageFromAPI();
-              } else {
-                if (stagehand.debugDom) {
-                  this.stagehand.log({
-                    category: "deprecation",
-                    message:
-                      "Warning: debugDom is not supported in this version of Stagehand",
-                    level: 1,
-                  });
-                }
-                await target.waitForLoadState("domcontentloaded");
-                await this._waitForSettledDom();
-              }
-              return result;
-            };
-          }
-
-          // Handle event listeners
-          if (prop === "on") {
-            return (
-              event: keyof PlaywrightPage["on"],
-              listener: Parameters<PlaywrightPage["on"]>[1],
-            ) => {
-              if (event === "popup") {
-                return this.context.on("page", async (page: PlaywrightPage) => {
-                  const newContext = await StagehandContext.init(
-                    page.context(),
-                    stagehand,
-                  );
-                  const newStagehandPage = new StagehandPage(
-                    page,
-                    stagehand,
-                    newContext,
-                    this.llmClient,
-                  );
-
-                  await newStagehandPage.init();
-                  listener(newStagehandPage.page);
-                });
-              }
-              this.intContext.setActivePage(this);
-              return target.on(event, listener);
-            };
-          }
-
-          // For all other method calls, update active page
-          if (typeof value === "function") {
-            return (...args: unknown[]) => {
-              this.intContext.setActivePage(this);
-              return value.apply(target, args);
-            };
-          }
-
-          return value;
-        },
-      };
-
-      this.intPage = new Proxy(page, handler) as unknown as Page;
-      this.initialized = true;
-      return this;
-    } catch (err: unknown) {
-      if (err instanceof StagehandError || err instanceof StagehandAPIError) {
-        throw err;
-      }
-      throw new StagehandDefaultError(err);
-    }
-  }
-
-  public get page(): Page {
-    return this.intPage;
-  }
-
-  public get context(): EnhancedContext {
-    return this.intContext.context;
-  }
-
-  // We can make methods public because StagehandPage is private to the Stagehand class.
-  // When a user gets stagehand.page, they are getting a proxy to the Playwright page.
-  // We can override the methods on the proxy to add our own behavior
-  public async _waitForSettledDom(timeoutMs?: number) {
-    try {
-      const timeout = timeoutMs ?? this.stagehand.domSettleTimeoutMs;
-      let timeoutHandle: NodeJS.Timeout;
-
-      await this.page.waitForLoadState("domcontentloaded");
-
-      const timeoutPromise = new Promise<void>((resolve) => {
-        timeoutHandle = setTimeout(() => {
-          this.stagehand.log({
-            category: "dom",
-            message: "DOM settle timeout exceeded, continuing anyway",
-            level: 1,
-            auxiliary: {
-              timeout_ms: {
-                value: timeout.toString(),
-                type: "integer",
-              },
-            },
-          });
-          resolve();
-        }, timeout);
-      });
-
-      try {
-        await Promise.race([
-          this.page.evaluate(() => {
-            return new Promise<void>((resolve) => {
-              if (typeof window.waitForDomSettle === "function") {
-                window.waitForDomSettle().then(resolve);
-              } else {
-                console.warn(
-                  "waitForDomSettle is not defined, considering DOM as settled",
-                );
-                resolve();
-              }
-            });
-          }),
-          this.page.waitForLoadState("domcontentloaded"),
-          this.page.waitForSelector("body"),
-          timeoutPromise,
-        ]);
-      } finally {
-        clearTimeout(timeoutHandle!);
-      }
-    } catch (e) {
-      this.stagehand.log({
-        category: "dom",
-        message: "Error in waitForSettledDom",
-        level: 1,
-        auxiliary: {
-          error: {
-            value: e.message,
-            type: "string",
-          },
-          trace: {
-            value: e.stack,
-            type: "string",
-          },
-        },
-      });
-    }
-  }
-
-  public addToHistory(
-    method: HistoryEntry["method"],
-    parameters:
-      | ActOptions
-      | ExtractOptions<z.AnyZodObject>
-      | ObserveOptions
-      | { url: string; options: GotoOptions }
-      | string,
-    result?: unknown,
-  ): void {
-    this._history.push({
-      method,
-      parameters,
-      result: result ?? null,
-      timestamp: new Date().toISOString(),
-    });
-  }
-
-  async act(
-    actionOrOptions: string | ActOptions | ObserveResult,
-  ): Promise<ActResult> {
-    try {
-      if (!this.actHandler) {
-        throw new HandlerNotInitializedError("Act");
-      }
-
-      await clearOverlays(this.page);
-
-      // If actionOrOptions is an ObserveResult, we call actFromObserveResult.
-      // We need to ensure there is both a selector and a method in the ObserveResult.
-      if (typeof actionOrOptions === "object" && actionOrOptions !== null) {
-        // If it has selector AND method => treat as ObserveResult
-        if ("selector" in actionOrOptions && "method" in actionOrOptions) {
-          const observeResult = actionOrOptions as ObserveResult;
-
-          if (this.api) {
-            const result = await this.api.act(observeResult);
-            await this._refreshPageFromAPI();
-            this.addToHistory("act", observeResult, result);
-            return result;
-          }
-
-          // validate observeResult.method, etc.
-          return this.actHandler.actFromObserveResult(observeResult);
-        } else {
-          // If it's an object but no selector/method,
-          // check that it's truly ActOptions (i.e., has an `action` field).
-          if (!("action" in actionOrOptions)) {
-            throw new StagehandError(
-              "Invalid argument. Valid arguments are: a string, an ActOptions object, " +
-                "or an ObserveResult WITH 'selector' and 'method' fields.",
-            );
-          }
-        }
-      } else if (typeof actionOrOptions === "string") {
-        // Convert string to ActOptions
-        actionOrOptions = { action: actionOrOptions };
-      } else {
-        throw new StagehandError(
-          "Invalid argument: you may have called act with an empty ObserveResult.\n" +
-            "Valid arguments are: a string, an ActOptions object, or an ObserveResult " +
-            "WITH 'selector' and 'method' fields.",
-        );
-      }
-
-      const { action, modelName, modelClientOptions } = actionOrOptions;
-
-      if (this.api) {
-        const result = await this.api.act(actionOrOptions);
-        await this._refreshPageFromAPI();
-        this.addToHistory("act", actionOrOptions, result);
-        return result;
-      }
-
-      const requestId = Math.random().toString(36).substring(2);
-      const llmClient: LLMClient = modelName
-        ? this.stagehand.llmProvider.getClient(modelName, modelClientOptions)
-        : this.llmClient;
-
-      this.stagehand.log({
-        category: "act",
-        message: "running act",
-        level: 1,
-        auxiliary: {
-          action: {
-            value: action,
-            type: "string",
-          },
-          requestId: {
-            value: requestId,
-            type: "string",
-          },
-          modelName: {
-            value: llmClient.modelName,
-            type: "string",
-          },
-        },
-      });
-
-      const result = await this.actHandler.observeAct(
-        actionOrOptions,
-        this.observeHandler,
-        llmClient,
-        requestId,
-      );
-
-      this.addToHistory("act", actionOrOptions, result);
-      return result;
-    } catch (err: unknown) {
-      if (err instanceof StagehandError || err instanceof StagehandAPIError) {
-        throw err;
-      }
-      throw new StagehandDefaultError(err);
-    }
-  }
-
-  async extract<T extends z.AnyZodObject = typeof defaultExtractSchema>(
-    instructionOrOptions?: string | ExtractOptions<T>,
-  ): Promise<ExtractResult<T>> {
-    try {
-      if (!this.extractHandler) {
-        throw new HandlerNotInitializedError("Extract");
-      }
-
-      await clearOverlays(this.page);
-
-      // check if user called extract() with no arguments
-      if (!instructionOrOptions) {
-        let result: ExtractResult<T>;
-        if (this.api) {
-          result = await this.api.extract<T>({});
-        } else {
-          result = await this.extractHandler.extract();
-        }
-        this.addToHistory("extract", instructionOrOptions, result);
-        return result;
-      }
-
-      const options: ExtractOptions<T> =
-        typeof instructionOrOptions === "string"
-          ? {
-              instruction: instructionOrOptions,
-              schema: defaultExtractSchema as T,
-            }
-          : instructionOrOptions;
-
-      const {
-        instruction,
-        schema,
-        modelName,
-        modelClientOptions,
-        domSettleTimeoutMs,
-        useTextExtract,
-        selector,
-      } = options;
-
-      // Throw a NotImplementedError if the user passed in an `xpath`
-      // and `useTextExtract` is false
-      if (selector && useTextExtract !== true) {
-        throw new StagehandNotImplementedError(
-          "Passing an xpath into extract is only supported when `useTextExtract: true`.",
-        );
-      }
-
-      if (this.api) {
-        const result = await this.api.extract<T>(options);
-        this.addToHistory("extract", instructionOrOptions, result);
-        return result;
-      }
-
-      const requestId = Math.random().toString(36).substring(2);
-      const llmClient = modelName
-        ? this.stagehand.llmProvider.getClient(modelName, modelClientOptions)
-        : this.llmClient;
-
-      this.stagehand.log({
-        category: "extract",
-        message: "running extract",
-        level: 1,
-        auxiliary: {
-          instruction: {
-            value: instruction,
-            type: "string",
-          },
-          requestId: {
-            value: requestId,
-            type: "string",
-          },
-          modelName: {
-            value: llmClient.modelName,
-            type: "string",
-          },
-        },
-      });
-
-      const result = await this.extractHandler
-        .extract({
-          instruction,
-          schema,
-          llmClient,
-          requestId,
-          domSettleTimeoutMs,
-          useTextExtract,
-          selector,
-        })
-        .catch((e) => {
-          this.stagehand.log({
-            category: "extract",
-            message: "error extracting",
-            level: 1,
-            auxiliary: {
-              error: {
-                value: e.message,
-                type: "string",
-              },
-              trace: {
-                value: e.stack,
-                type: "string",
-              },
-            },
-          });
-
-          if (this.stagehand.enableCaching) {
-            this.stagehand.llmProvider.cleanRequestCache(requestId);
-          }
-
-          throw e;
-        });
-
-      this.addToHistory("extract", instructionOrOptions, result);
-
-      return result;
-    } catch (err: unknown) {
-      if (err instanceof StagehandError || err instanceof StagehandAPIError) {
-        throw err;
-      }
-      throw new StagehandDefaultError(err);
-    }
-  }
-
-  async observe(
-    instructionOrOptions?: string | ObserveOptions,
-  ): Promise<ObserveResult[]> {
-    try {
-      if (!this.observeHandler) {
-        throw new HandlerNotInitializedError("Observe");
-      }
-
-      await clearOverlays(this.page);
-
-      const options: ObserveOptions =
-        typeof instructionOrOptions === "string"
-          ? { instruction: instructionOrOptions }
-          : instructionOrOptions || {};
-
-      const {
-        instruction,
-        modelName,
-        modelClientOptions,
-        domSettleTimeoutMs,
-        returnAction = true,
-        onlyVisible = false,
-        drawOverlay,
-      } = options;
-
-      if (this.api) {
-        const result = await this.api.observe(options);
-        this.addToHistory("observe", instructionOrOptions, result);
-        return result;
-      }
-
-      const requestId = Math.random().toString(36).substring(2);
-      const llmClient = modelName
-        ? this.stagehand.llmProvider.getClient(modelName, modelClientOptions)
-        : this.llmClient;
-
-      this.stagehand.log({
-        category: "observe",
-        message: "running observe",
-        level: 1,
-        auxiliary: {
-          instruction: {
-            value: instruction,
-            type: "string",
-          },
-          requestId: {
-            value: requestId,
-            type: "string",
-          },
-          modelName: {
-            value: llmClient.modelName,
-            type: "string",
-          },
-          onlyVisible: {
-            value: onlyVisible ? "true" : "false",
-            type: "boolean",
-          },
-        },
-      });
-
-      const result = await this.observeHandler
-        .observe({
-          instruction,
-          llmClient,
-          requestId,
-          domSettleTimeoutMs,
-          returnAction,
-          onlyVisible,
-          drawOverlay,
-        })
-        .catch((e) => {
-          this.stagehand.log({
-            category: "observe",
-            message: "error observing",
-            level: 1,
-            auxiliary: {
-              error: {
-                value: e.message,
-                type: "string",
-              },
-              trace: {
-                value: e.stack,
-                type: "string",
-              },
-              requestId: {
-                value: requestId,
-                type: "string",
-              },
-              instruction: {
-                value: instruction,
-                type: "string",
-              },
-            },
-          });
-
-          if (this.stagehand.enableCaching) {
-            this.stagehand.llmProvider.cleanRequestCache(requestId);
-          }
-
-          throw e;
-        });
-
-      this.addToHistory("observe", instructionOrOptions, result);
-
-      return result;
-    } catch (err: unknown) {
-      if (err instanceof StagehandError || err instanceof StagehandAPIError) {
-        throw err;
-      }
-      throw new StagehandDefaultError(err);
-    }
-  }
-
-  async getCDPClient(): Promise<CDPSession> {
-    if (!this.cdpClient) {
-      this.cdpClient = await this.context.newCDPSession(this.page);
-    }
-    return this.cdpClient;
-  }
-
-  async sendCDP<T>(
-    command: string,
-    args?: Record<string, unknown>,
-  ): Promise<T> {
-    const client = await this.getCDPClient();
-    // Type assertion needed because CDP command strings are not fully typed
-    return client.send(
-      command as Parameters<CDPSession["send"]>[0],
-      args || {},
-    ) as Promise<T>;
-  }
-
-  async enableCDP(domain: string): Promise<void> {
-    await this.sendCDP(`${domain}.enable`, {});
-  }
-
-  async disableCDP(domain: string): Promise<void> {
-    await this.sendCDP(`${domain}.disable`, {});
-  }
-}
diff --git a/lib/a11y/utils.ts b/lib/a11y/utils.ts
deleted file mode 100644
index f19ba765a..000000000
--- a/lib/a11y/utils.ts
+++ /dev/null
@@ -1,825 +0,0 @@
-import { AccessibilityNode, TreeResult, AXNode } from "../../types/context";
-import { StagehandPage } from "../StagehandPage";
-import { LogLine } from "../../types/log";
-import { CDPSession, Page, Locator } from "playwright";
-import {
-  PlaywrightCommandMethodNotSupportedException,
-  PlaywrightCommandException,
-} from "@/types/playwright";
-
-// Parser function for str output
-export function formatSimplifiedTree(
-  node: AccessibilityNode,
-  level = 0,
-): string {
-  const indent = "  ".repeat(level);
-  let result = `${indent}[${node.nodeId}] ${node.role}${
-    node.name ? `: ${node.name}` : ""
-  }\n`;
-
-  if (node.children?.length) {
-    result += node.children
-      .map((child) => formatSimplifiedTree(child, level + 1))
-      .join("");
-  }
-  return result;
-}
-
-/**
- * Helper function to remove or collapse unnecessary structural nodes
- * Handles three cases:
- * 1. Removes generic/none nodes with no children
- * 2. Collapses generic/none nodes with single child
- * 3. Keeps generic/none nodes with multiple children but cleans their subtrees
- *    and attempts to resolve their role to a DOM tag name
- */
-async function cleanStructuralNodes(
-  node: AccessibilityNode,
-  page?: StagehandPage,
-  logger?: (logLine: LogLine) => void,
-): Promise<AccessibilityNode | null> {
-  // 1) Filter out nodes with negative IDs
-  if (node.nodeId && parseInt(node.nodeId) < 0) {
-    return null;
-  }
-
-  // 2) Base case: if no children exist, this is effectively a leaf.
-  //    If it's "generic" or "none", we remove it; otherwise, keep it.
-  if (!node.children || node.children.length === 0) {
-    return node.role === "generic" || node.role === "none" ? null : node;
-  }
-
-  // 3) Recursively clean children
-  const cleanedChildrenPromises = node.children.map((child) =>
-    cleanStructuralNodes(child, page, logger),
-  );
-  const resolvedChildren = await Promise.all(cleanedChildrenPromises);
-  let cleanedChildren = resolvedChildren.filter(
-    (child): child is AccessibilityNode => child !== null,
-  );
-
-  // 4) **Prune** "generic" or "none" nodes first,
-  //    before resolving them to their tag names.
-  if (node.role === "generic" || node.role === "none") {
-    if (cleanedChildren.length === 1) {
-      // Collapse single-child structural node
-      return cleanedChildren[0];
-    } else if (cleanedChildren.length === 0) {
-      // Remove empty structural node
-      return null;
-    }
-    // If we have multiple children, we keep this node as a container.
-    // We'll update role below if needed.
-  }
-
-  // 5) If we still have a "generic"/"none" node after pruning
-  //    (i.e., because it had multiple children), now we try
-  //    to resolve and replace its role with the DOM tag name.
-  if (
-    page &&
-    logger &&
-    node.backendDOMNodeId !== undefined &&
-    (node.role === "generic" || node.role === "none")
-  ) {
-    try {
-      const { object } = await page.sendCDP<{
-        object: { objectId?: string };
-      }>("DOM.resolveNode", {
-        backendNodeId: node.backendDOMNodeId,
-      });
-
-      if (object && object.objectId) {
-        try {
-          // Get the tagName for the node
-          const { result } = await page.sendCDP<{
-            result: { type: string; value?: string };
-          }>("Runtime.callFunctionOn", {
-            objectId: object.objectId,
-            functionDeclaration: `
-              function() {
-                return this.tagName ? this.tagName.toLowerCase() : "";
-              }
-            `,
-            returnByValue: true,
-          });
-
-          // If we got a tagName, update the node's role
-          if (result?.value) {
-            node.role = result.value;
-          }
-        } catch (tagNameError) {
-          logger({
-            category: "observation",
-            message: `Could not fetch tagName for node ${node.backendDOMNodeId}`,
-            level: 2,
-            auxiliary: {
-              error: {
-                value: tagNameError.message,
-                type: "string",
-              },
-            },
-          });
-        }
-      }
-    } catch (resolveError) {
-      logger({
-        category: "observation",
-        message: `Could not resolve DOM node ID ${node.backendDOMNodeId}`,
-        level: 2,
-        auxiliary: {
-          error: {
-            value: resolveError.message,
-            type: "string",
-          },
-        },
-      });
-    }
-  }
-
-  // rm redundant StaticText children
-  cleanedChildren = removeRedundantStaticTextChildren(node, cleanedChildren);
-
-  if (cleanedChildren.length === 0) {
-    if (node.role === "generic" || node.role === "none") {
-      return null;
-    } else {
-      return { ...node, children: [] };
-    }
-  }
-
-  // 6) Return the updated node.
-  //    If it has children, update them; otherwise keep it as-is.
-  return cleanedChildren.length > 0
-    ? { ...node, children: cleanedChildren }
-    : node;
-}
-
-/**
- * Builds a hierarchical tree structure from a flat array of accessibility nodes.
- * The function processes nodes in multiple passes to create a clean, meaningful tree.
- * @param nodes - Flat array of accessibility nodes from the CDP
- * @returns Object containing both the tree structure and a simplified string representation
- */
-export async function buildHierarchicalTree(
-  nodes: AccessibilityNode[],
-  page?: StagehandPage,
-  logger?: (logLine: LogLine) => void,
-): Promise<TreeResult> {
-  // Map to store nodeId -> URL for only those nodes that do have a URL.
-  const idToUrl: Record<string, string> = {};
-
-  // Map to store processed nodes for quick lookup
-  const nodeMap = new Map<string, AccessibilityNode>();
-  const iframe_list: AccessibilityNode[] = [];
-
-  // First pass: Create nodes that are meaningful
-  // We only keep nodes that either have a name or children to avoid cluttering the tree
-  nodes.forEach((node) => {
-    // Skip node if its ID is negative (e.g., "-1000002014")
-    const nodeIdValue = parseInt(node.nodeId, 10);
-    if (nodeIdValue < 0) {
-      return;
-    }
-
-    const url = extractUrlFromAXNode(node);
-    if (url) {
-      idToUrl[node.nodeId] = url;
-    }
-
-    const hasChildren = node.childIds && node.childIds.length > 0;
-    const hasValidName = node.name && node.name.trim() !== "";
-    const isInteractive =
-      node.role !== "none" &&
-      node.role !== "generic" &&
-      node.role !== "InlineTextBox"; //add other interactive roles here
-
-    // Include nodes that are either named, have children, or are interactive
-    if (!hasValidName && !hasChildren && !isInteractive) {
-      return;
-    }
-
-    // Create a clean node object with only relevant properties
-    nodeMap.set(node.nodeId, {
-      role: node.role,
-      nodeId: node.nodeId,
-      ...(hasValidName && { name: node.name }), // Only include name if it exists and isn't empty
-      ...(node.description && { description: node.description }),
-      ...(node.value && { value: node.value }),
-      ...(node.backendDOMNodeId !== undefined && {
-        backendDOMNodeId: node.backendDOMNodeId,
-      }),
-    });
-  });
-
-  // Second pass: Establish parent-child relationships
-  // This creates the actual tree structure by connecting nodes based on parentId
-  nodes.forEach((node) => {
-    // Add iframes to a list and include in the return object
-    const isIframe = node.role === "Iframe";
-    if (isIframe) {
-      const iframeNode = {
-        role: node.role,
-        nodeId: node.nodeId,
-      };
-      iframe_list.push(iframeNode);
-    }
-    if (node.parentId && nodeMap.has(node.nodeId)) {
-      const parentNode = nodeMap.get(node.parentId);
-      const currentNode = nodeMap.get(node.nodeId);
-
-      if (parentNode && currentNode) {
-        if (!parentNode.children) {
-          parentNode.children = [];
-        }
-        parentNode.children.push(currentNode);
-      }
-    }
-  });
-
-  // Final pass: Build the root-level tree and clean up structural nodes
-  const rootNodes = nodes
-    .filter((node) => !node.parentId && nodeMap.has(node.nodeId)) // Get root nodes
-    .map((node) => nodeMap.get(node.nodeId))
-    .filter(Boolean) as AccessibilityNode[];
-
-  const cleanedTreePromises = rootNodes.map((node) =>
-    cleanStructuralNodes(node, page, logger),
-  );
-  const finalTree = (await Promise.all(cleanedTreePromises)).filter(
-    Boolean,
-  ) as AccessibilityNode[];
-
-  // Generate a simplified string representation of the tree
-  const simplifiedFormat = finalTree
-    .map((node) => formatSimplifiedTree(node))
-    .join("\n");
-
-  return {
-    tree: finalTree,
-    simplified: simplifiedFormat,
-    iframes: iframe_list,
-    idToUrl: idToUrl,
-  };
-}
-
-/**
- * Retrieves the full accessibility tree via CDP and transforms it into a hierarchical structure.
- */
-export async function getAccessibilityTree(
-  page: StagehandPage,
-  logger: (logLine: LogLine) => void,
-): Promise<TreeResult> {
-  await page.enableCDP("Accessibility");
-
-  try {
-    // Identify which elements are scrollable and get their backendNodeIds
-    const scrollableBackendIds = await findScrollableElementIds(page);
-
-    // Fetch the full accessibility tree from Chrome DevTools Protocol
-    const { nodes } = await page.sendCDP<{ nodes: AXNode[] }>(
-      "Accessibility.getFullAXTree",
-    );
-    const startTime = Date.now();
-
-    // Transform into hierarchical structure
-    const hierarchicalTree = await buildHierarchicalTree(
-      nodes.map((node) => {
-        let roleValue = node.role?.value || "";
-
-        if (scrollableBackendIds.has(node.backendDOMNodeId)) {
-          if (roleValue === "generic" || roleValue === "none") {
-            roleValue = "scrollable";
-          } else {
-            roleValue = roleValue ? `scrollable, ${roleValue}` : "scrollable";
-          }
-        }
-
-        return {
-          role: roleValue,
-          name: node.name?.value,
-          description: node.description?.value,
-          value: node.value?.value,
-          nodeId: node.nodeId,
-          backendDOMNodeId: node.backendDOMNodeId,
-          parentId: node.parentId,
-          childIds: node.childIds,
-          properties: node.properties,
-        };
-      }),
-      page,
-      logger,
-    );
-
-    logger({
-      category: "observation",
-      message: `got accessibility tree in ${Date.now() - startTime}ms`,
-      level: 1,
-    });
-    return hierarchicalTree;
-  } catch (error) {
-    logger({
-      category: "observation",
-      message: "Error getting accessibility tree",
-      level: 1,
-      auxiliary: {
-        error: {
-          value: error.message,
-          type: "string",
-        },
-        trace: {
-          value: error.stack,
-          type: "string",
-        },
-      },
-    });
-    throw error;
-  } finally {
-    await page.disableCDP("Accessibility");
-  }
-}
-
-// This function is wrapped into a string and sent as a CDP command
-// It is not meant to be actually executed here
-const functionString = `
-function getNodePath(el) {
-  if (!el || (el.nodeType !== Node.ELEMENT_NODE && el.nodeType !== Node.TEXT_NODE)) {
-    console.log("el is not a valid node type");
-    return "";
-  }
-
-  const parts = [];
-  let current = el;
-
-  while (current && (current.nodeType === Node.ELEMENT_NODE || current.nodeType === Node.TEXT_NODE)) {
-    let index = 0;
-    let hasSameTypeSiblings = false;
-    const siblings = current.parentElement
-      ? Array.from(current.parentElement.childNodes)
-      : [];
-
-    for (let i = 0; i < siblings.length; i++) {
-      const sibling = siblings[i];
-      if (
-        sibling.nodeType === current.nodeType &&
-        sibling.nodeName === current.nodeName
-      ) {
-        index = index + 1;
-        hasSameTypeSiblings = true;
-        if (sibling.isSameNode(current)) {
-          break;
-        }
-      }
-    }
-
-    if (!current || !current.parentNode) break;
-    if (current.nodeName.toLowerCase() === "html"){
-      parts.unshift("html");
-      break;
-    }
-
-    // text nodes are handled differently in XPath
-    if (current.nodeName !== "#text") {
-      const tagName = current.nodeName.toLowerCase();
-      const pathIndex = hasSameTypeSiblings ? \`[\${index}]\` : "";
-      parts.unshift(\`\${tagName}\${pathIndex}\`);
-    }
-    
-    current = current.parentElement;
-  }
-
-  return parts.length ? \`/\${parts.join("/")}\` : "";
-}`;
-
-export async function getXPathByResolvedObjectId(
-  cdpClient: CDPSession,
-  resolvedObjectId: string,
-): Promise<string> {
-  const { result } = await cdpClient.send("Runtime.callFunctionOn", {
-    objectId: resolvedObjectId,
-    functionDeclaration: `function() {
-      ${functionString}
-      return getNodePath(this);
-    }`,
-    returnByValue: true,
-  });
-
-  return result.value || "";
-}
-
-/**
- * `findScrollableElementIds` is a function that identifies elements in
- * the browser that are deemed "scrollable". At a high level, it does the
- * following:
- * - Calls the browser-side `window.getScrollableElementXpaths()` function,
- *   which returns a list of XPaths for scrollable containers.
- * - Iterates over the returned list of XPaths, locating each element in the DOM
- *   using `stagehandPage.sendCDP(...)`
- *     - During each iteration, we call `Runtime.evaluate` to run `document.evaluate(...)`
- *       with each XPath, obtaining a `RemoteObject` reference if it exists.
- *     - Then, for each valid object reference, we call `DOM.describeNode` to retrieve
- *       the element’s `backendNodeId`.
- * - Collects all resulting `backendNodeId`s in a Set and returns them.
- *
- * @param stagehandPage - A StagehandPage instance with built-in CDP helpers.
- * @returns A Promise that resolves to a Set of unique `backendNodeId`s corresponding
- *          to scrollable elements in the DOM.
- */
-export async function findScrollableElementIds(
-  stagehandPage: StagehandPage,
-): Promise<Set<number>> {
-  // get the xpaths of the scrollable elements
-  const xpaths = await stagehandPage.page.evaluate(() => {
-    return window.getScrollableElementXpaths();
-  });
-
-  const scrollableBackendIds = new Set<number>();
-
-  for (const xpath of xpaths) {
-    if (!xpath) continue;
-
-    // evaluate the XPath in the stagehandPage
-    const { result } = await stagehandPage.sendCDP<{
-      result?: { objectId?: string };
-    }>("Runtime.evaluate", {
-      expression: `
-        (function() {
-          const res = document.evaluate(${JSON.stringify(
-            xpath,
-          )}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
-          return res.singleNodeValue;
-        })();
-      `,
-      returnByValue: false,
-    });
-
-    // if we have an objectId, call DOM.describeNode to get backendNodeId
-    if (result?.objectId) {
-      const { node } = await stagehandPage.sendCDP<{
-        node?: { backendNodeId?: number };
-      }>("DOM.describeNode", {
-        objectId: result.objectId,
-      });
-
-      if (node?.backendNodeId) {
-        scrollableBackendIds.add(node.backendNodeId);
-      }
-    }
-  }
-
-  return scrollableBackendIds;
-}
-
-/**
- * Removes any StaticText children whose combined text equals the parent's name.
- * This is most often used to avoid duplicating a link's accessible name in separate child nodes.
- *
- * @param parent     The parent accessibility node whose `.name` we check.
- * @param children   The parent's current children list, typically after cleaning.
- * @returns          A filtered list of children with redundant StaticText nodes removed.
- */
-function removeRedundantStaticTextChildren(
-  parent: AccessibilityNode,
-  children: AccessibilityNode[],
-): AccessibilityNode[] {
-  if (!parent.name) {
-    return children;
-  }
-
-  const parentName = parent.name.replace(/\s+/g, " ").trim();
-
-  // Gather all StaticText children and combine their text
-  const staticTextChildren = children.filter(
-    (child) => child.role === "StaticText" && child.name,
-  );
-  const combinedChildText = staticTextChildren
-    .map((child) => child.name!.replace(/\s+/g, " ").trim())
-    .join("");
-
-  // If the combined text exactly matches the parent's name, remove those child nodes
-  if (combinedChildText === parentName) {
-    return children.filter((child) => child.role !== "StaticText");
-  }
-
-  return children;
-}
-
-function extractUrlFromAXNode(axNode: AccessibilityNode): string | undefined {
-  if (!axNode.properties) return undefined;
-  const urlProp = axNode.properties.find((prop) => prop.name === "url");
-  if (urlProp && urlProp.value && typeof urlProp.value.value === "string") {
-    return urlProp.value.value.trim();
-  }
-  return undefined;
-}
-
-export async function performPlaywrightMethod(
-  stagehandPage: Page,
-  logger: (logLine: LogLine) => void,
-  method: string,
-  args: unknown[],
-  xpath: string,
-) {
-  const locator = stagehandPage.locator(`xpath=${xpath}`).first();
-  const initialUrl = stagehandPage.url();
-
-  logger({
-    category: "action",
-    message: "performing playwright method",
-    level: 2,
-    auxiliary: {
-      xpath: {
-        value: xpath,
-        type: "string",
-      },
-      method: {
-        value: method,
-        type: "string",
-      },
-    },
-  });
-
-  if (method === "scrollIntoView") {
-    logger({
-      category: "action",
-      message: "scrolling element into view",
-      level: 2,
-      auxiliary: {
-        xpath: {
-          value: xpath,
-          type: "string",
-        },
-      },
-    });
-    try {
-      await locator
-        .evaluate((element: HTMLElement) => {
-          element.scrollIntoView({ behavior: "smooth", block: "center" });
-        })
-        .catch((e: Error) => {
-          logger({
-            category: "action",
-            message: "error scrolling element into view",
-            level: 1,
-            auxiliary: {
-              error: {
-                value: e.message,
-                type: "string",
-              },
-              trace: {
-                value: e.stack,
-                type: "string",
-              },
-              xpath: {
-                value: xpath,
-                type: "string",
-              },
-            },
-          });
-        });
-    } catch (e) {
-      logger({
-        category: "action",
-        message: "error scrolling element into view",
-        level: 1,
-        auxiliary: {
-          error: {
-            value: e.message,
-            type: "string",
-          },
-          trace: {
-            value: e.stack,
-            type: "string",
-          },
-          xpath: {
-            value: xpath,
-            type: "string",
-          },
-        },
-      });
-
-      throw new PlaywrightCommandException(e.message);
-    }
-  } else if (method === "fill" || method === "type") {
-    try {
-      await locator.fill("");
-      await locator.click();
-      const text = args[0]?.toString();
-      for (const char of text) {
-        await stagehandPage.keyboard.type(char, {
-          delay: Math.random() * 50 + 25,
-        });
-      }
-    } catch (e) {
-      logger({
-        category: "action",
-        message: "error filling element",
-        level: 1,
-        auxiliary: {
-          error: {
-            value: e.message,
-            type: "string",
-          },
-          trace: {
-            value: e.stack,
-            type: "string",
-          },
-          xpath: {
-            value: xpath,
-            type: "string",
-          },
-        },
-      });
-
-      throw new PlaywrightCommandException(e.message);
-    }
-  } else if (method === "press") {
-    try {
-      const key = args[0]?.toString();
-      await stagehandPage.keyboard.press(key);
-    } catch (e) {
-      logger({
-        category: "action",
-        message: "error pressing key",
-        level: 1,
-        auxiliary: {
-          error: {
-            value: e.message,
-            type: "string",
-          },
-          trace: {
-            value: e.stack,
-            type: "string",
-          },
-          key: {
-            value: args[0]?.toString() ?? "unknown",
-            type: "string",
-          },
-        },
-      });
-
-      throw new PlaywrightCommandException(e.message);
-    }
-  } else if (typeof locator[method as keyof typeof locator] === "function") {
-    // Log current URL before action
-    logger({
-      category: "action",
-      message: "page URL before action",
-      level: 2,
-      auxiliary: {
-        url: {
-          value: stagehandPage.url(),
-          type: "string",
-        },
-      },
-    });
-
-    // Perform the action
-    try {
-      await (
-        locator[method as keyof Locator] as unknown as (
-          ...args: string[]
-        ) => Promise<void>
-      )(...args.map((arg) => arg?.toString() || ""));
-    } catch (e) {
-      logger({
-        category: "action",
-        message: "error performing method",
-        level: 1,
-        auxiliary: {
-          error: {
-            value: e.message,
-            type: "string",
-          },
-          trace: {
-            value: e.stack,
-            type: "string",
-          },
-          xpath: {
-            value: xpath,
-            type: "string",
-          },
-          method: {
-            value: method,
-            type: "string",
-          },
-          args: {
-            value: JSON.stringify(args),
-            type: "object",
-          },
-        },
-      });
-
-      throw new PlaywrightCommandException(e.message);
-    }
-
-    // Handle navigation if a new page is opened
-    if (method === "click") {
-      logger({
-        category: "action",
-        message: "clicking element, checking for page navigation",
-        level: 1,
-        auxiliary: {
-          xpath: {
-            value: xpath,
-            type: "string",
-          },
-        },
-      });
-
-      const newOpenedTab = await Promise.race([
-        new Promise<Page | null>((resolve) => {
-          Promise.resolve(stagehandPage.context()).then((context) => {
-            context.once("page", (page: Page) => resolve(page));
-            setTimeout(() => resolve(null), 1_500);
-          });
-        }),
-      ]);
-
-      logger({
-        category: "action",
-        message: "clicked element",
-        level: 1,
-        auxiliary: {
-          newOpenedTab: {
-            value: newOpenedTab ? "opened a new tab" : "no new tabs opened",
-            type: "string",
-          },
-        },
-      });
-
-      if (newOpenedTab) {
-        logger({
-          category: "action",
-          message: "new page detected (new tab) with URL",
-          level: 1,
-          auxiliary: {
-            url: {
-              value: newOpenedTab.url(),
-              type: "string",
-            },
-          },
-        });
-        await newOpenedTab.close();
-        await stagehandPage.goto(newOpenedTab.url());
-        await stagehandPage.waitForLoadState("domcontentloaded");
-      }
-
-      await Promise.race([
-        stagehandPage.waitForLoadState("networkidle"),
-        new Promise((resolve) => setTimeout(resolve, 5_000)),
-      ]).catch((e) => {
-        logger({
-          category: "action",
-          message: "network idle timeout hit",
-          level: 1,
-          auxiliary: {
-            trace: {
-              value: e.stack,
-              type: "string",
-            },
-            message: {
-              value: e.message,
-              type: "string",
-            },
-          },
-        });
-      });
-
-      logger({
-        category: "action",
-        message: "finished waiting for (possible) page navigation",
-        level: 1,
-      });
-
-      if (stagehandPage.url() !== initialUrl) {
-        logger({
-          category: "action",
-          message: "new page detected with URL",
-          level: 1,
-          auxiliary: {
-            url: {
-              value: stagehandPage.url(),
-              type: "string",
-            },
-          },
-        });
-      }
-    }
-  } else {
-    logger({
-      category: "action",
-      message: "chosen method is invalid",
-      level: 1,
-      auxiliary: {
-        method: {
-          value: method,
-          type: "string",
-        },
-      },
-    });
-
-    throw new PlaywrightCommandMethodNotSupportedException(
-      `Method ${method} not supported`,
-    );
-  }
-}
diff --git a/lib/agent/AgentProvider.ts b/lib/agent/AgentProvider.ts
deleted file mode 100644
index cc8110fa4..000000000
--- a/lib/agent/AgentProvider.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-import { LogLine } from "@/types/log";
-import { AgentClient } from "./AgentClient";
-import { AgentType } from "@/types/agent";
-import { OpenAICUAClient } from "./OpenAICUAClient";
-import { AnthropicCUAClient } from "./AnthropicCUAClient";
-import {
-  UnsupportedModelError,
-  UnsupportedModelProviderError,
-} from "@/types/stagehandErrors";
-
-// Map model names to their provider types
-const modelToAgentProviderMap: Record<string, AgentType> = {
-  "computer-use-preview": "openai",
-  "claude-3-5-sonnet-20240620": "anthropic",
-  "claude-3-7-sonnet-20250219": "anthropic", // Add newer Claude models
-};
-
-/**
- * Provider for agent clients
- * This class is responsible for creating the appropriate agent client
- * based on the provider type
- */
-export class AgentProvider {
-  private logger: (message: LogLine) => void;
-
-  /**
-   * Create a new agent provider
-   */
-  constructor(logger: (message: LogLine) => void) {
-    this.logger = logger;
-  }
-
-  getClient(
-    modelName: string,
-    clientOptions?: Record<string, unknown>,
-    userProvidedInstructions?: string,
-  ): AgentClient {
-    const type = AgentProvider.getAgentProvider(modelName);
-    this.logger({
-      category: "agent",
-      message: `Getting agent client for type: ${type}, model: ${modelName}`,
-      level: 2,
-    });
-
-    try {
-      switch (type) {
-        case "openai":
-          return new OpenAICUAClient(
-            type,
-            modelName,
-            userProvidedInstructions,
-            clientOptions,
-          );
-        case "anthropic":
-          return new AnthropicCUAClient(
-            type,
-            modelName,
-            userProvidedInstructions,
-            clientOptions,
-          );
-        default:
-          throw new UnsupportedModelProviderError(
-            ["openai", "anthropic"],
-            "Computer Use Agent",
-          );
-      }
-    } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-      this.logger({
-        category: "agent",
-        message: `Error creating agent client: ${errorMessage}`,
-        level: 0,
-      });
-      throw error;
-    }
-  }
-
-  static getAgentProvider(modelName: string): AgentType {
-    // First check the exact model name in the map
-    if (modelName in modelToAgentProviderMap) {
-      return modelToAgentProviderMap[modelName];
-    }
-
-    throw new UnsupportedModelError(
-      Object.keys(modelToAgentProviderMap),
-      "Computer Use Agent",
-    );
-  }
-}
diff --git a/lib/agent/StagehandAgent.ts b/lib/agent/StagehandAgent.ts
deleted file mode 100644
index ab65d1efb..000000000
--- a/lib/agent/StagehandAgent.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import { LogLine } from "@/types/log";
-import {
-  AgentExecuteOptions,
-  AgentResult,
-  AgentExecutionOptions,
-} from "@/types/agent";
-import { AgentClient } from "./AgentClient";
-
-/**
- * Main interface for agent operations in Stagehand
- * This class provides methods for executing tasks with an agent
- */
-export class StagehandAgent {
-  private client: AgentClient;
-  private logger: (message: LogLine) => void;
-
-  constructor(client: AgentClient, logger: (message: LogLine) => void) {
-    this.client = client;
-    this.logger = logger;
-  }
-
-  async execute(
-    optionsOrInstruction: AgentExecuteOptions | string,
-  ): Promise<AgentResult> {
-    const options =
-      typeof optionsOrInstruction === "string"
-        ? { instruction: optionsOrInstruction }
-        : optionsOrInstruction;
-
-    this.logger({
-      category: "agent",
-      message: `Executing agent task: ${options.instruction}`,
-      level: 1,
-    });
-
-    const executionOptions: AgentExecutionOptions = {
-      options,
-      logger: this.logger,
-      retries: 3,
-    };
-
-    return await this.client.execute(executionOptions);
-  }
-
-  getModelName(): string {
-    return this.client.modelName;
-  }
-
-  getAgentType(): string {
-    return this.client.type;
-  }
-}
diff --git a/lib/api.ts b/lib/api.ts
deleted file mode 100644
index e05b96aad..000000000
--- a/lib/api.ts
+++ /dev/null
@@ -1,247 +0,0 @@
-import { z } from "zod";
-import zodToJsonSchema from "zod-to-json-schema";
-import {
-  ApiResponse,
-  ExecuteActionParams,
-  StagehandAPIConstructorParams,
-  StartSessionParams,
-  StartSessionResult,
-} from "../types/api";
-import { LogLine } from "../types/log";
-import { GotoOptions } from "../types/playwright";
-import {
-  ActOptions,
-  ActResult,
-  AgentConfig,
-  ExtractOptions,
-  ExtractResult,
-  ObserveOptions,
-  ObserveResult,
-} from "../types/stagehand";
-import { AgentExecuteOptions, AgentResult } from ".";
-import {
-  StagehandAPIUnauthorizedError,
-  StagehandHttpError,
-  StagehandAPIError,
-  StagehandServerError,
-  StagehandResponseBodyError,
-  StagehandResponseParseError,
-} from "../types/stagehandApiErrors";
-
-export class StagehandAPI {
-  private apiKey: string;
-  private projectId: string;
-  private sessionId?: string;
-  private modelApiKey: string;
-  private logger: (message: LogLine) => void;
-
-  constructor({ apiKey, projectId, logger }: StagehandAPIConstructorParams) {
-    this.apiKey = apiKey;
-    this.projectId = projectId;
-    this.logger = logger;
-  }
-
-  async init({
-    modelName,
-    modelApiKey,
-    domSettleTimeoutMs,
-    verbose,
-    debugDom,
-    systemPrompt,
-    selfHeal,
-    waitForCaptchaSolves,
-    actionTimeoutMs,
-    browserbaseSessionCreateParams,
-    browserbaseSessionID,
-  }: StartSessionParams): Promise<StartSessionResult> {
-    if (!modelApiKey) {
-      throw new StagehandAPIError("modelApiKey is required");
-    }
-    this.modelApiKey = modelApiKey;
-    const sessionResponse = await this.request("/sessions/start", {
-      method: "POST",
-      body: JSON.stringify({
-        modelName,
-        domSettleTimeoutMs,
-        verbose,
-        debugDom,
-        systemPrompt,
-        selfHeal,
-        waitForCaptchaSolves,
-        actionTimeoutMs,
-        browserbaseSessionCreateParams,
-        browserbaseSessionID,
-      }),
-    });
-
-    if (sessionResponse.status === 401) {
-      throw new StagehandAPIUnauthorizedError(
-        "Unauthorized. Ensure you provided a valid API key and that it is whitelisted.",
-      );
-    } else if (sessionResponse.status !== 200) {
-      console.log(await sessionResponse.text());
-      throw new StagehandHttpError(`Unknown error: ${sessionResponse.status}`);
-    }
-
-    const sessionResponseBody =
-      (await sessionResponse.json()) as ApiResponse<StartSessionResult>;
-
-    if (sessionResponseBody.success === false) {
-      throw new StagehandAPIError(sessionResponseBody.message);
-    }
-
-    this.sessionId = sessionResponseBody.data.sessionId;
-
-    return sessionResponseBody.data;
-  }
-
-  async act(options: ActOptions | ObserveResult): Promise<ActResult> {
-    return this.execute<ActResult>({
-      method: "act",
-      args: { ...options },
-    });
-  }
-
-  async extract<T extends z.AnyZodObject>(
-    options: ExtractOptions<T>,
-  ): Promise<ExtractResult<T>> {
-    if (!options.schema) {
-      return this.execute<ExtractResult<T>>({
-        method: "extract",
-        args: {},
-      });
-    }
-    const parsedSchema = zodToJsonSchema(options.schema);
-    return this.execute<ExtractResult<T>>({
-      method: "extract",
-      args: { ...options, schemaDefinition: parsedSchema },
-    });
-  }
-
-  async observe(options?: ObserveOptions): Promise<ObserveResult[]> {
-    return this.execute<ObserveResult[]>({
-      method: "observe",
-      args: { ...options },
-    });
-  }
-
-  async goto(url: string, options?: GotoOptions): Promise<void> {
-    return this.execute<void>({
-      method: "navigate",
-      args: { url, options },
-    });
-  }
-
-  async agentExecute(
-    agentConfig: AgentConfig,
-    executeOptions: AgentExecuteOptions,
-  ): Promise<AgentResult> {
-    return this.execute<AgentResult>({
-      method: "agentExecute",
-      args: { agentConfig, executeOptions },
-    });
-  }
-
-  async end(): Promise<Response> {
-    const url = `/sessions/${this.sessionId}/end`;
-    return await this.request(url, {
-      method: "POST",
-    });
-  }
-
-  private async execute<T>({
-    method,
-    args,
-    params,
-  }: ExecuteActionParams): Promise<T> {
-    const urlParams = new URLSearchParams(params as Record<string, string>);
-    const queryString = urlParams.toString();
-    const url = `/sessions/${this.sessionId}/${method}${queryString ? `?${queryString}` : ""}`;
-
-    const response = await this.request(url, {
-      method: "POST",
-      body: JSON.stringify(args),
-    });
-
-    if (!response.ok) {
-      const errorBody = await response.text();
-      throw new StagehandHttpError(
-        `HTTP error! status: ${response.status}, body: ${errorBody}`,
-      );
-    }
-
-    if (!response.body) {
-      throw new StagehandResponseBodyError();
-    }
-
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-
-    while (true) {
-      const { value, done } = await reader.read();
-
-      if (done && !buffer) {
-        return null;
-      }
-
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n\n");
-      buffer = lines.pop() || "";
-
-      for (const line of lines) {
-        if (!line.startsWith("data: ")) continue;
-
-        try {
-          const eventData = JSON.parse(line.slice(6));
-
-          if (eventData.type === "system") {
-            if (eventData.data.status === "error") {
-              throw new StagehandServerError(eventData.data.error);
-            }
-            if (eventData.data.status === "finished") {
-              return eventData.data.result as T;
-            }
-          } else if (eventData.type === "log") {
-            this.logger(eventData.data.message);
-          }
-        } catch (e) {
-          console.error("Error parsing event data:", e);
-          throw new StagehandResponseParseError(
-            "Failed to parse server response",
-          );
-        }
-      }
-
-      if (done) break;
-    }
-  }
-
-  private async request(
-    path: string,
-    options: RequestInit = {},
-  ): Promise<Response> {
-    const defaultHeaders: Record<string, string> = {
-      "x-bb-api-key": this.apiKey,
-      "x-bb-project-id": this.projectId,
-      "x-bb-session-id": this.sessionId,
-      // we want real-time logs, so we stream the response
-      "x-stream-response": "true",
-      "x-model-api-key": this.modelApiKey,
-    };
-
-    if (options.method === "POST" && options.body) {
-      defaultHeaders["Content-Type"] = "application/json";
-    }
-
-    const response = await fetch(`${process.env.STAGEHAND_API_URL}${path}`, {
-      ...options,
-      headers: {
-        ...defaultHeaders,
-        ...options.headers,
-      },
-    });
-
-    return response;
-  }
-}
diff --git a/lib/cache.ts b/lib/cache.ts
deleted file mode 100644
index a9e2a981d..000000000
--- a/lib/cache.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-import fs from "fs";
-const observationsPath = "./.cache/observations.json";
-const actionsPath = "./.cache/actions.json";
-
-/**
- * A file system cache to skip inference when repeating steps
- * It also acts as the source of truth for identifying previously seen actions and observations
- */
-class Cache {
-  disabled: boolean;
-
-  constructor({ disabled = false } = {}) {
-    this.disabled = disabled;
-    if (!this.disabled) {
-      this.initCache();
-    }
-  }
-
-  readObservations() {
-    if (this.disabled) {
-      return {};
-    }
-    try {
-      return JSON.parse(fs.readFileSync(observationsPath, "utf8"));
-    } catch (error) {
-      console.error("Error reading from observations.json", error);
-      return {};
-    }
-  }
-
-  readActions() {
-    if (this.disabled) {
-      return {};
-    }
-    try {
-      return JSON.parse(fs.readFileSync(actionsPath, "utf8"));
-    } catch (error) {
-      console.error("Error reading from actions.json", error);
-      return {};
-    }
-  }
-
-  writeObservations({
-    key,
-    value,
-  }: {
-    key: string;
-    value: { id: string; result: string };
-  }) {
-    if (this.disabled) {
-      return;
-    }
-
-    const observations = this.readObservations();
-    observations[key] = value;
-    fs.writeFileSync(observationsPath, JSON.stringify(observations, null, 2));
-  }
-
-  writeActions({
-    key,
-    value,
-  }: {
-    key: string;
-    value: { id: string; result: string };
-  }) {
-    if (this.disabled) {
-      return;
-    }
-
-    const actions = this.readActions();
-    actions[key] = value;
-    fs.writeFileSync(actionsPath, JSON.stringify(actions, null, 2));
-  }
-
-  evictCache() {
-    throw new Error("implement me");
-  }
-
-  private initCache() {
-    if (this.disabled) {
-      return;
-    }
-    const cacheDir = ".cache";
-
-    if (!fs.existsSync(cacheDir)) {
-      fs.mkdirSync(cacheDir);
-    }
-    if (!fs.existsSync(actionsPath)) {
-      fs.writeFileSync(actionsPath, JSON.stringify({}));
-    }
-
-    if (!fs.existsSync(observationsPath)) {
-      fs.writeFileSync(observationsPath, JSON.stringify({}));
-    }
-  }
-}
-
-export default Cache;
diff --git a/lib/cache/ActionCache.ts b/lib/cache/ActionCache.ts
deleted file mode 100644
index b54801d6c..000000000
--- a/lib/cache/ActionCache.ts
+++ /dev/null
@@ -1,158 +0,0 @@
-import { LogLine } from "../../types/log";
-import { BaseCache, CacheEntry } from "./BaseCache";
-
-export interface PlaywrightCommand {
-  method: string;
-  args: string[];
-}
-
-export interface ActionEntry extends CacheEntry {
-  data: {
-    playwrightCommand: PlaywrightCommand;
-    componentString: string;
-    xpaths: string[];
-    newStepString: string;
-    completed: boolean;
-    previousSelectors: string[];
-    action: string;
-  };
-}
-
-/**
- * ActionCache handles logging and retrieving actions along with their Playwright commands.
- */
-export class ActionCache extends BaseCache<ActionEntry> {
-  constructor(
-    logger: (message: LogLine) => void,
-    cacheDir?: string,
-    cacheFile?: string,
-  ) {
-    super(logger, cacheDir, cacheFile || "action_cache.json");
-  }
-
-  public async addActionStep({
-    url,
-    action,
-    previousSelectors,
-    playwrightCommand,
-    componentString,
-    xpaths,
-    newStepString,
-    completed,
-    requestId,
-  }: {
-    url: string;
-    action: string;
-    previousSelectors: string[];
-    playwrightCommand: PlaywrightCommand;
-    componentString: string;
-    requestId: string;
-    xpaths: string[];
-    newStepString: string;
-    completed: boolean;
-  }): Promise<void> {
-    this.logger({
-      category: "action_cache",
-      message: "adding action step to cache",
-      level: 1,
-      auxiliary: {
-        action: {
-          value: action,
-          type: "string",
-        },
-        requestId: {
-          value: requestId,
-          type: "string",
-        },
-        url: {
-          value: url,
-          type: "string",
-        },
-        previousSelectors: {
-          value: JSON.stringify(previousSelectors),
-          type: "object",
-        },
-      },
-    });
-
-    await this.set(
-      { url, action, previousSelectors },
-      {
-        playwrightCommand,
-        componentString,
-        xpaths,
-        newStepString,
-        completed,
-        previousSelectors,
-        action,
-      },
-      requestId,
-    );
-  }
-
-  /**
-   * Retrieves all actions for a specific trajectory.
-   * @param trajectoryId - Unique identifier for the trajectory.
-   * @param requestId - The identifier for the current request.
-   * @returns An array of TrajectoryEntry objects or null if not found.
-   */
-  public async getActionStep({
-    url,
-    action,
-    previousSelectors,
-    requestId,
-  }: {
-    url: string;
-    action: string;
-    previousSelectors: string[];
-    requestId: string;
-  }): Promise<ActionEntry["data"] | null> {
-    const data = await super.get({ url, action, previousSelectors }, requestId);
-    if (!data) {
-      return null;
-    }
-
-    return data;
-  }
-
-  public async removeActionStep(cacheHashObj: {
-    url: string;
-    action: string;
-    previousSelectors: string[];
-    requestId: string;
-  }): Promise<void> {
-    await super.delete(cacheHashObj);
-  }
-
-  /**
-   * Clears all actions for a specific trajectory.
-   * @param trajectoryId - Unique identifier for the trajectory.
-   * @param requestId - The identifier for the current request.
-   */
-  public async clearAction(requestId: string): Promise<void> {
-    await super.deleteCacheForRequestId(requestId);
-    this.logger({
-      category: "action_cache",
-      message: "cleared action for ID",
-      level: 1,
-      auxiliary: {
-        requestId: {
-          value: requestId,
-          type: "string",
-        },
-      },
-    });
-  }
-
-  /**
-   * Resets the entire action cache.
-   */
-  public async resetCache(): Promise<void> {
-    await super.resetCache();
-    this.logger({
-      category: "action_cache",
-      message: "Action cache has been reset.",
-      level: 1,
-    });
-  }
-}
diff --git a/lib/cache/BaseCache.ts b/lib/cache/BaseCache.ts
deleted file mode 100644
index 18ef61690..000000000
--- a/lib/cache/BaseCache.ts
+++ /dev/null
@@ -1,568 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import * as crypto from "crypto";
-import { LogLine } from "../../types/log";
-
-export interface CacheEntry {
-  timestamp: number;
-  data: unknown;
-  requestId: string;
-}
-
-export interface CacheStore {
-  [key: string]: CacheEntry;
-}
-
-export class BaseCache<T extends CacheEntry> {
-  private readonly CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 1 week in milliseconds
-  private readonly CLEANUP_PROBABILITY = 0.01; // 1% chance
-
-  protected cacheDir: string;
-  protected cacheFile: string;
-  protected lockFile: string;
-  protected logger: (message: LogLine) => void;
-
-  private readonly LOCK_TIMEOUT_MS = 1_000;
-  protected lockAcquired = false;
-  protected lockAcquireFailures = 0;
-
-  // Added for request ID tracking
-  protected requestIdToUsedHashes: { [key: string]: string[] } = {};
-
-  constructor(
-    logger: (message: LogLine) => void,
-    cacheDir: string = path.join(process.cwd(), "tmp", ".cache"),
-    cacheFile: string = "cache.json",
-  ) {
-    this.logger = logger;
-    this.cacheDir = cacheDir;
-    this.cacheFile = path.join(cacheDir, cacheFile);
-    this.lockFile = path.join(cacheDir, "cache.lock");
-    this.ensureCacheDirectory();
-    this.setupProcessHandlers();
-  }
-
-  private setupProcessHandlers(): void {
-    const releaseLockAndExit = () => {
-      this.releaseLock();
-      process.exit();
-    };
-
-    process.on("exit", releaseLockAndExit);
-    process.on("SIGINT", releaseLockAndExit);
-    process.on("SIGTERM", releaseLockAndExit);
-    process.on("uncaughtException", (err) => {
-      this.logger({
-        category: "base_cache",
-        message: "uncaught exception",
-        level: 2,
-        auxiliary: {
-          error: {
-            value: err.message,
-            type: "string",
-          },
-          trace: {
-            value: err.stack,
-            type: "string",
-          },
-        },
-      });
-      if (this.lockAcquired) {
-        releaseLockAndExit();
-      }
-    });
-  }
-
-  protected ensureCacheDirectory(): void {
-    if (!fs.existsSync(this.cacheDir)) {
-      fs.mkdirSync(this.cacheDir, { recursive: true });
-      this.logger({
-        category: "base_cache",
-        message: "created cache directory",
-        level: 1,
-        auxiliary: {
-          cacheDir: {
-            value: this.cacheDir,
-            type: "string",
-          },
-        },
-      });
-    }
-  }
-
-  protected createHash(data: unknown): string {
-    const hash = crypto.createHash("sha256");
-    return hash.update(JSON.stringify(data)).digest("hex");
-  }
-
-  protected sleep(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-
-  public async acquireLock(): Promise<boolean> {
-    const startTime = Date.now();
-    while (Date.now() - startTime < this.LOCK_TIMEOUT_MS) {
-      try {
-        if (fs.existsSync(this.lockFile)) {
-          const lockAge = Date.now() - fs.statSync(this.lockFile).mtimeMs;
-          if (lockAge > this.LOCK_TIMEOUT_MS) {
-            fs.unlinkSync(this.lockFile);
-            this.logger({
-              category: "base_cache",
-              message: "Stale lock file removed",
-              level: 1,
-            });
-          }
-        }
-
-        fs.writeFileSync(this.lockFile, process.pid.toString(), { flag: "wx" });
-        this.lockAcquireFailures = 0;
-        this.lockAcquired = true;
-        this.logger({
-          category: "base_cache",
-          message: "Lock acquired",
-          level: 1,
-        });
-        return true;
-      } catch (e) {
-        this.logger({
-          category: "base_cache",
-          message: "error acquiring lock",
-          level: 2,
-          auxiliary: {
-            trace: {
-              value: e.stack,
-              type: "string",
-            },
-            message: {
-              value: e.message,
-              type: "string",
-            },
-          },
-        });
-        await this.sleep(5);
-      }
-    }
-    this.logger({
-      category: "base_cache",
-      message: "Failed to acquire lock after timeout",
-      level: 2,
-    });
-    this.lockAcquireFailures++;
-    if (this.lockAcquireFailures >= 3) {
-      this.logger({
-        category: "base_cache",
-        message:
-          "Failed to acquire lock 3 times in a row. Releasing lock manually.",
-        level: 1,
-      });
-      this.releaseLock();
-    }
-    return false;
-  }
-
-  public releaseLock(): void {
-    try {
-      if (fs.existsSync(this.lockFile)) {
-        fs.unlinkSync(this.lockFile);
-        this.logger({
-          category: "base_cache",
-          message: "Lock released",
-          level: 1,
-        });
-      }
-      this.lockAcquired = false;
-    } catch (error) {
-      this.logger({
-        category: "base_cache",
-        message: "error releasing lock",
-        level: 2,
-        auxiliary: {
-          error: {
-            value: error.message,
-            type: "string",
-          },
-          trace: {
-            value: error.stack,
-            type: "string",
-          },
-        },
-      });
-    }
-  }
-
-  /**
-   * Cleans up stale cache entries that exceed the maximum age.
-   */
-  public async cleanupStaleEntries(): Promise<void> {
-    if (!(await this.acquireLock())) {
-      this.logger({
-        category: "llm_cache",
-        message: "failed to acquire lock for cleanup",
-        level: 2,
-      });
-      return;
-    }
-
-    try {
-      const cache = this.readCache();
-      const now = Date.now();
-      let entriesRemoved = 0;
-
-      for (const [hash, entry] of Object.entries(cache)) {
-        if (now - entry.timestamp > this.CACHE_MAX_AGE_MS) {
-          delete cache[hash];
-          entriesRemoved++;
-        }
-      }
-
-      if (entriesRemoved > 0) {
-        this.writeCache(cache);
-        this.logger({
-          category: "llm_cache",
-          message: "cleaned up stale cache entries",
-          level: 1,
-          auxiliary: {
-            entriesRemoved: {
-              value: entriesRemoved.toString(),
-              type: "integer",
-            },
-          },
-        });
-      }
-    } catch (error) {
-      this.logger({
-        category: "llm_cache",
-        message: "error during cache cleanup",
-        level: 2,
-        auxiliary: {
-          error: {
-            value: error.message,
-            type: "string",
-          },
-          trace: {
-            value: error.stack,
-            type: "string",
-          },
-        },
-      });
-    } finally {
-      this.releaseLock();
-    }
-  }
-
-  protected readCache(): CacheStore {
-    if (fs.existsSync(this.cacheFile)) {
-      try {
-        const data = fs.readFileSync(this.cacheFile, "utf-8");
-        return JSON.parse(data) as CacheStore;
-      } catch (error) {
-        this.logger({
-          category: "base_cache",
-          message: "error reading cache file. resetting cache.",
-          level: 1,
-          auxiliary: {
-            error: {
-              value: error.message,
-              type: "string",
-            },
-            trace: {
-              value: error.stack,
-              type: "string",
-            },
-          },
-        });
-        this.resetCache();
-        return {};
-      }
-    }
-    return {};
-  }
-
-  protected writeCache(cache: CacheStore): void {
-    try {
-      fs.writeFileSync(this.cacheFile, JSON.stringify(cache, null, 2));
-      this.logger({
-        category: "base_cache",
-        message: "Cache written to file",
-        level: 1,
-      });
-    } catch (error) {
-      this.logger({
-        category: "base_cache",
-        message: "error writing cache file",
-        level: 2,
-        auxiliary: {
-          error: {
-            value: error.message,
-            type: "string",
-          },
-          trace: {
-            value: error.stack,
-            type: "string",
-          },
-        },
-      });
-    } finally {
-      this.releaseLock();
-    }
-  }
-
-  /**
-   * Retrieves data from the cache based on the provided options.
-   * @param hashObj - The options used to generate the cache key.
-   * @param requestId - The identifier for the current request.
-   * @returns The cached data if available, otherwise null.
-   */
-  public async get(
-    hashObj: Record<string, unknown> | string,
-    requestId: string,
-  ): Promise<T["data"] | null> {
-    if (!(await this.acquireLock())) {
-      this.logger({
-        category: "base_cache",
-        message: "Failed to acquire lock for getting cache",
-        level: 2,
-      });
-      return null;
-    }
-
-    try {
-      const hash = this.createHash(hashObj);
-      const cache = this.readCache();
-
-      if (cache[hash]) {
-        this.trackRequestIdUsage(requestId, hash);
-        return cache[hash].data;
-      }
-      return null;
-    } catch (error) {
-      this.logger({
-        category: "base_cache",
-        message: "error getting cache. resetting cache.",
-        level: 1,
-        auxiliary: {
-          error: {
-            value: error.message,
-            type: "string",
-          },
-          trace: {
-            value: error.stack,
-            type: "string",
-          },
-        },
-      });
-
-      this.resetCache();
-      return null;
-    } finally {
-      this.releaseLock();
-    }
-  }
-
-  /**
-   * Stores data in the cache based on the provided options and requestId.
-   * @param hashObj - The options used to generate the cache key.
-   * @param data - The data to be cached.
-   * @param requestId - The identifier for the cache entry.
-   */
-  public async set(
-    hashObj: Record<string, unknown>,
-    data: T["data"],
-    requestId: string,
-  ): Promise<void> {
-    if (!(await this.acquireLock())) {
-      this.logger({
-        category: "base_cache",
-        message: "Failed to acquire lock for setting cache",
-        level: 2,
-      });
-      return;
-    }
-
-    try {
-      const hash = this.createHash(hashObj);
-      const cache = this.readCache();
-      cache[hash] = {
-        data,
-        timestamp: Date.now(),
-        requestId,
-      };
-
-      this.writeCache(cache);
-      this.trackRequestIdUsage(requestId, hash);
-    } catch (error) {
-      this.logger({
-        category: "base_cache",
-        message: "error setting cache. resetting cache.",
-        level: 1,
-        auxiliary: {
-          error: {
-            value: error.message,
-            type: "string",
-          },
-          trace: {
-            value: error.stack,
-            type: "string",
-          },
-        },
-      });
-
-      this.resetCache();
-    } finally {
-      this.releaseLock();
-
-      if (Math.random() < this.CLEANUP_PROBABILITY) {
-        this.cleanupStaleEntries();
-      }
-    }
-  }
-
-  public async delete(hashObj: Record<string, unknown>): Promise<void> {
-    if (!(await this.acquireLock())) {
-      this.logger({
-        category: "base_cache",
-        message: "Failed to acquire lock for removing cache entry",
-        level: 2,
-      });
-      return;
-    }
-
-    try {
-      const hash = this.createHash(hashObj);
-      const cache = this.readCache();
-
-      if (cache[hash]) {
-        delete cache[hash];
-        this.writeCache(cache);
-      } else {
-        this.logger({
-          category: "base_cache",
-          message: "Cache entry not found to delete",
-          level: 1,
-        });
-      }
-    } catch (error) {
-      this.logger({
-        category: "base_cache",
-        message: "error removing cache entry",
-        level: 2,
-        auxiliary: {
-          error: {
-            value: error.message,
-            type: "string",
-          },
-          trace: {
-            value: error.stack,
-            type: "string",
-          },
-        },
-      });
-    } finally {
-      this.releaseLock();
-    }
-  }
-
-  /**
-   * Tracks the usage of a hash with a specific requestId.
-   * @param requestId - The identifier for the current request.
-   * @param hash - The cache key hash.
-   */
-  protected trackRequestIdUsage(requestId: string, hash: string): void {
-    this.requestIdToUsedHashes[requestId] ??= [];
-    this.requestIdToUsedHashes[requestId].push(hash);
-  }
-
-  /**
-   * Deletes all cache entries associated with a specific requestId.
-   * @param requestId - The identifier for the request whose cache entries should be deleted.
-   */
-  public async deleteCacheForRequestId(requestId: string): Promise<void> {
-    if (!(await this.acquireLock())) {
-      this.logger({
-        category: "base_cache",
-        message: "Failed to acquire lock for deleting cache",
-        level: 2,
-      });
-      return;
-    }
-    try {
-      const cache = this.readCache();
-      const hashes = this.requestIdToUsedHashes[requestId] ?? [];
-      let entriesRemoved = 0;
-      for (const hash of hashes) {
-        if (cache[hash]) {
-          delete cache[hash];
-          entriesRemoved++;
-        }
-      }
-      if (entriesRemoved > 0) {
-        this.writeCache(cache);
-      } else {
-        this.logger({
-          category: "base_cache",
-          message: "no cache entries found for requestId",
-          level: 1,
-          auxiliary: {
-            requestId: {
-              value: requestId,
-              type: "string",
-            },
-          },
-        });
-      }
-      // Remove the requestId from the mapping after deletion
-      delete this.requestIdToUsedHashes[requestId];
-    } catch (error) {
-      this.logger({
-        category: "base_cache",
-        message: "error deleting cache for requestId",
-        level: 2,
-        auxiliary: {
-          error: {
-            value: error.message,
-            type: "string",
-          },
-          trace: {
-            value: error.stack,
-            type: "string",
-          },
-          requestId: {
-            value: requestId,
-            type: "string",
-          },
-        },
-      });
-    } finally {
-      this.releaseLock();
-    }
-  }
-
-  /**
-   * Resets the entire cache by clearing the cache file.
-   */
-  public resetCache(): void {
-    try {
-      fs.writeFileSync(this.cacheFile, "{}");
-      this.requestIdToUsedHashes = {}; // Reset requestId tracking
-    } catch (error) {
-      this.logger({
-        category: "base_cache",
-        message: "error resetting cache",
-        level: 2,
-        auxiliary: {
-          error: {
-            value: error.message,
-            type: "string",
-          },
-          trace: {
-            value: error.stack,
-            type: "string",
-          },
-        },
-      });
-    } finally {
-      this.releaseLock();
-    }
-  }
-}
diff --git a/lib/cache/LLMCache.ts b/lib/cache/LLMCache.ts
deleted file mode 100644
index 53bd78213..000000000
--- a/lib/cache/LLMCache.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { BaseCache, CacheEntry } from "./BaseCache";
-
-export class LLMCache extends BaseCache<CacheEntry> {
-  constructor(
-    logger: (message: {
-      category?: string;
-      message: string;
-      level?: number;
-    }) => void,
-    cacheDir?: string,
-    cacheFile?: string,
-  ) {
-    super(logger, cacheDir, cacheFile || "llm_calls.json");
-  }
-
-  /**
-   * Overrides the get method to track used hashes by requestId.
-   * @param options - The options used to generate the cache key.
-   * @param requestId - The identifier for the current request.
-   * @returns The cached data if available, otherwise null.
-   */
-  public async get<T>(
-    options: Record<string, unknown>,
-    requestId: string,
-  ): Promise<T | null> {
-    const data = await super.get(options, requestId);
-    return data as T | null; // TODO: remove this cast
-  }
-
-  /**
-   * Overrides the set method to include cache cleanup logic.
-   * @param options - The options used to generate the cache key.
-   * @param data - The data to be cached.
-   * @param requestId - The identifier for the current request.
-   */
-  public async set(
-    options: Record<string, unknown>,
-    data: unknown,
-    requestId: string,
-  ): Promise<void> {
-    await super.set(options, data, requestId);
-    this.logger({
-      category: "llm_cache",
-      message: "Cache miss - saved new response",
-      level: 1,
-    });
-  }
-}
diff --git a/lib/dom/DomChunk.ts b/lib/dom/DomChunk.ts
deleted file mode 100644
index 0b2232efa..000000000
--- a/lib/dom/DomChunk.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-export interface DomChunk {
-  startOffset: number;
-  endOffset: number;
-  outputString: string;
-  selectorMap: Record<number, string[]>;
-}
diff --git a/lib/dom/ElementContainer.ts b/lib/dom/ElementContainer.ts
deleted file mode 100644
index c831e0489..000000000
--- a/lib/dom/ElementContainer.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-import { StagehandContainer } from "./StagehandContainer";
-
-/**
- * The ElementContainer class is a container implementation for a specific
- * HTML element.
- *
- * Unlike `GlobalPageContainer`, which manages the entire page,
- * this class focuses on one particular `HTMLElement`. Operations
- * such as `scrollTo` and `scrollIntoView` apply to that element
- * rather than `window`.
- */
-export class ElementContainer extends StagehandContainer {
-  /**
-   * Creates an instance of `ElementContainer` tied to a specific element.
-   * @param el - The scrollable `HTMLElement` that this container controls.
-   */
-  constructor(private el: HTMLElement) {
-    super();
-  }
-
-  public getRootElement(): HTMLElement {
-    return this.el;
-  }
-
-  /**
-   * Retrieves the height of the visible viewport within this element
-   * (`el.clientHeight`).
-   *
-   * @returns The visible (client) height of the element, in pixels.
-   */
-  public getViewportHeight(): number {
-    return this.el.clientHeight;
-  }
-
-  public getScrollHeight(): number {
-    return this.el.scrollHeight;
-  }
-
-  /**
-   * Returns the element's current vertical scroll offset.
-   */
-  public getScrollPosition(): number {
-    return this.el.scrollTop;
-  }
-
-  /**
-   * Smoothly scrolls this element to the specified vertical offset, and
-   * waits for the scrolling to complete.
-   *
-   * @param offset - The scroll offset (in pixels) from the top of the element.
-   * @returns A promise that resolves once scrolling is finished.
-   */
-  public async scrollTo(offset: number): Promise<void> {
-    await new Promise((resolve) => setTimeout(resolve, 1500));
-    this.el.scrollTo({ top: offset, behavior: "smooth" });
-    await this.waitForScrollEnd();
-  }
-
-  /**
-   * Scrolls this element so that the given `element` is visible, or
-   * scrolls to the top if none is provided. Smoothly animates the scroll
-   * and waits until it finishes.
-   *
-   * @param element - The child element to bring into view. If omitted, scrolls to top.
-   * @returns A promise that resolves once scrolling completes.
-   */
-  public async scrollIntoView(element?: HTMLElement): Promise<void> {
-    if (!element) {
-      this.el.scrollTo({ top: 0, behavior: "smooth" });
-    } else {
-      element.scrollIntoView();
-    }
-    await this.waitForScrollEnd();
-  }
-
-  /**
-   * Internal helper that waits until scrolling in this element has
-   * fully stopped. It listens for scroll events on the element,
-   * resetting a short timer every time a scroll occurs, and resolves
-   * once there's no scroll for ~100ms.
-   *
-   * @returns A promise that resolves when scrolling has finished.
-   */
-  private async waitForScrollEnd(): Promise<void> {
-    return new Promise<void>((resolve) => {
-      let scrollEndTimer: number;
-      const handleScroll = () => {
-        clearTimeout(scrollEndTimer);
-        scrollEndTimer = window.setTimeout(() => {
-          this.el.removeEventListener("scroll", handleScroll);
-          resolve();
-        }, 100);
-      };
-      this.el.addEventListener("scroll", handleScroll, { passive: true });
-      handleScroll();
-    });
-  }
-}
diff --git a/lib/dom/GlobalPageContainer.ts b/lib/dom/GlobalPageContainer.ts
deleted file mode 100644
index 46270fd1d..000000000
--- a/lib/dom/GlobalPageContainer.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-import { StagehandContainer } from "./StagehandContainer";
-import { calculateViewportHeight } from "./utils";
-
-/**
- * The `GlobalPageContainer` class is a container implementation for the entire
- * webpage or global document.
- *
- * This container manages the global `window` scroll position and provides
- * measurements using `document.documentElement`. It extends `StagehandContainer`
- * to unify scrolling/height logic with other container types, such as element
- * based containers from the `ElementContainer` class.
- */
-export class GlobalPageContainer extends StagehandContainer {
-  public getRootElement(): HTMLElement {
-    return document.body;
-  }
-
-  /**
-   * Calculates the viewport height for the entire page, using a helper.
-   * The helper returns 75% of the window height, to ensure that we don't
-   * miss any content that may be behind sticky elements like nav bars.
-   *
-   * @returns The current height of the global viewport, in pixels.
-   */
-  public getViewportHeight(): number {
-    return calculateViewportHeight();
-  }
-
-  public getScrollHeight(): number {
-    return document.documentElement.scrollHeight;
-  }
-
-  public getScrollPosition(): number {
-    return window.scrollY;
-  }
-
-  /**
-   * Smoothly scrolls the page to the specified vertical offset, and then
-   * waits until scrolling has stopped. There is a delay built in to allow
-   * for lazy loading and other asynchronous content to load.
-   *
-   * @param offset - The desired scroll offset from the top of the page.
-   * @returns A promise that resolves once scrolling is complete.
-   */
-  public async scrollTo(offset: number): Promise<void> {
-    await new Promise((resolve) => setTimeout(resolve, 1500));
-    window.scrollTo({ top: offset, behavior: "smooth" });
-    await this.waitForScrollEnd();
-  }
-
-  /**
-   * Scrolls the page so that a given element is visible, or scrolls to the top
-   * if no element is specified. Uses smooth scrolling and waits for it to complete.
-   *
-   * @param element - The DOM element to bring into view. If omitted, scrolls to top.
-   * @returns A promise that resolves once scrolling is complete.
-   */
-  public async scrollIntoView(element?: HTMLElement): Promise<void> {
-    if (!element) {
-      window.scrollTo({ top: 0, behavior: "smooth" });
-    } else {
-      const rect = element.getBoundingClientRect();
-      const currentY = window.scrollY || document.documentElement.scrollTop;
-      const elementY = currentY + rect.top - window.innerHeight * 0.25;
-      window.scrollTo({ top: elementY, behavior: "smooth" });
-    }
-    await this.waitForScrollEnd();
-  }
-
-  /**
-   * Internal helper that waits until the global scroll activity has stopped.
-   * It listens for scroll events, resetting a short timer every time a scroll
-   * occurs, and resolves once there's no scroll for ~100ms.
-   *
-   * @returns A promise that resolves when scrolling has finished.
-   */
-  private async waitForScrollEnd(): Promise<void> {
-    return new Promise<void>((resolve) => {
-      let scrollEndTimer: number;
-      const handleScroll = () => {
-        clearTimeout(scrollEndTimer);
-        scrollEndTimer = window.setTimeout(() => {
-          window.removeEventListener("scroll", handleScroll);
-          resolve();
-        }, 100);
-      };
-      window.addEventListener("scroll", handleScroll, { passive: true });
-      handleScroll();
-    });
-  }
-}
diff --git a/lib/dom/StagehandContainer.ts b/lib/dom/StagehandContainer.ts
deleted file mode 100644
index 94e107e93..000000000
--- a/lib/dom/StagehandContainer.ts
+++ /dev/null
@@ -1,128 +0,0 @@
-import { DomChunk } from "@/lib/dom/DomChunk";
-import { collectCandidateElements } from "@/lib/dom/candidateCollector";
-
-/**
- * The `StagehandContainer` class defines an abstract interface for
- * scrolling and DOM inspection across various container types e.g.,
- * the entire page (GlobalPageContainer), a specific sub element of the DOM,
- * (ElementContainer).
- */
-export abstract class StagehandContainer {
-  public abstract getViewportHeight(): number;
-  public abstract getScrollHeight(): number;
-  public abstract scrollTo(offset: number): Promise<void>;
-  public abstract getRootElement(): HTMLElement | Document;
-  public abstract scrollIntoView(element?: HTMLElement): Promise<void>;
-  public abstract getScrollPosition(): number;
-
-  /**
-   * Collects multiple "DOM chunks" by scrolling through the container
-   * in increments from `startOffset` to `endOffset`. At each scroll
-   * position, the function extracts a snapshot of "candidate elements"
-   * using `collectCandidateElements`.
-   *
-   * Each chunk represents a subset of the DOM at a particular
-   * vertical scroll offset, including:
-   *
-   * - `startOffset` & `endOffset`: The vertical scroll bounds for this chunk.
-   * - `outputString`: A serialized representation of extracted DOM text.
-   * - `selectorMap`: A mapping of temporary indices to the actual element(s)
-   *   that were collected in this chunk, useful for further processing.
-   *
-   * @param startOffset - The initial scroll offset from which to begin collecting.
-   * @param endOffset - The maximum scroll offset to collect up to.
-   * @param chunkSize - The vertical increment to move between each chunk.
-   * @param scrollTo - Whether we should scroll to the chunk
-   * @param scrollBackToTop - Whether to scroll the container back to the top once finished.
-   * @param candidateContainer - Optionally, a specific container element within
-   * the root for which to collect data. If omitted, uses `this.getRootElement()`.
-   *
-   * @returns A promise that resolves with an array of `DomChunk` objects.
-   *
-   * ### How It Works
-   *
-   * 1. **Scroll Range Calculation**:
-   *    - Computes `maxOffset` as the maximum offset that can be scrolled
-   *      (`scrollHeight - viewportHeight`).
-   *    - Restricts `endOffset` to not exceed `maxOffset`.
-   *
-   * 2. **Chunk Iteration**:
-   *    - Loops from `startOffset` to `endOffset` in steps of `chunkSize`.
-   *    - For each offset `current`, we call `this.scrollTo(current)`
-   *      to position the container.
-   *
-   * 3. **Element Collection**:
-   *    - Invokes `collectCandidateElements` on either `candidateContainer`
-   *      (if provided) or the result of `this.getRootElement()`.
-   *    - This returns both an `outputString` (serialized text)
-   *      and a `selectorMap` of found elements for that section of the DOM.
-   *
-   * 4. **Chunk Assembly**:
-   *    - Creates a `DomChunk` object for the current offset range,
-   *      storing `outputString`, `selectorMap`, and scroll offsets.
-   *    - Pushes it onto the `chunks` array.
-   *
-   * 5. **Scroll Reset**:
-   *    - Once iteration completes, if `scrollBackToTop` is `true`,
-   *      we scroll back to offset `0`.
-   */
-  public async collectDomChunks(
-    startOffset: number,
-    endOffset: number,
-    chunkSize: number,
-    scrollTo: boolean = true,
-    scrollBackToTop: boolean = true,
-    candidateContainer?: HTMLElement,
-  ): Promise<DomChunk[]> {
-    const chunks: DomChunk[] = [];
-    let maxOffset = this.getScrollHeight();
-    let current = startOffset;
-    let finalEnd = endOffset;
-
-    let index = 0;
-
-    while (current <= finalEnd) {
-      // Move the container's scroll position
-      if (scrollTo) {
-        await this.scrollTo(current);
-      }
-
-      // Collect the candidate elements at this offset
-      const rootCandidate =
-        candidateContainer || (this.getRootElement() as HTMLElement);
-      const { outputString, selectorMap } = await collectCandidateElements(
-        rootCandidate,
-        index,
-      );
-
-      chunks.push({
-        startOffset: current,
-        endOffset: current + chunkSize,
-        outputString,
-        selectorMap,
-      });
-
-      index += Object.keys(selectorMap).length;
-      current += chunkSize;
-
-      // Only extend finalEnd if there is no candidateContainer
-      // (meaning we're looking at the entire scrollable area)
-      if (!candidateContainer && current > endOffset) {
-        // Check if new content extended the scroll height
-        const newScrollHeight = this.getScrollHeight();
-        if (newScrollHeight > maxOffset) {
-          maxOffset = newScrollHeight;
-        }
-        if (newScrollHeight > finalEnd) {
-          finalEnd = newScrollHeight;
-        }
-      }
-    }
-
-    if (scrollBackToTop) {
-      await this.scrollTo(0);
-    }
-
-    return chunks;
-  }
-}
diff --git a/lib/dom/candidateCollector.ts b/lib/dom/candidateCollector.ts
deleted file mode 100644
index e577653f1..000000000
--- a/lib/dom/candidateCollector.ts
+++ /dev/null
@@ -1,139 +0,0 @@
-import {
-  isElementNode,
-  isTextNode,
-  isInteractiveElement,
-  isLeafElement,
-  isVisible,
-  isTextVisible,
-  isActive,
-} from "./elementCheckUtils";
-import { generateXPathsForElement as generateXPaths } from "./xpathUtils";
-
-const xpathCache: Map<Node, string[]> = new Map();
-
-/**
- * `collectCandidateElements` performs a depth-first traversal (despite the BFS naming) of the given `candidateContainerRoot`
- * to find “candidate elements” or text nodes that meet certain criteria (e.g., visible, active,
- * interactive, or leaf). This function does not scroll the page; it only collects nodes from
- * the in-memory DOM structure starting at `candidateContainerRoot`.
- *
- * @param candidateContainerRoot - The HTMLElement to search within
- * @param indexOffset - A numeric offset used to label/number your candidate elements
- * @returns { outputString, selectorMap }
- */
-export async function collectCandidateElements(
-  candidateContainerRoot: HTMLElement,
-  indexOffset: number = 0,
-): Promise<{
-  outputString: string;
-  selectorMap: Record<number, string[]>;
-}> {
-  const DOMQueue: ChildNode[] = [...candidateContainerRoot.childNodes];
-  const candidateElements: ChildNode[] = [];
-
-  while (DOMQueue.length > 0) {
-    const node = DOMQueue.pop();
-    let shouldAdd = false;
-
-    if (node && isElementNode(node)) {
-      for (let i = node.childNodes.length - 1; i >= 0; i--) {
-        DOMQueue.push(node.childNodes[i]);
-      }
-
-      if (isInteractiveElement(node)) {
-        if (isActive(node) && isVisible(node)) {
-          shouldAdd = true;
-        }
-      }
-      if (isLeafElement(node)) {
-        if (isActive(node) && isVisible(node)) {
-          shouldAdd = true;
-        }
-      }
-    }
-
-    if (node && isTextNode(node) && isTextVisible(node)) {
-      shouldAdd = true;
-    }
-
-    if (shouldAdd) {
-      candidateElements.push(node);
-    }
-  }
-
-  const selectorMap: Record<number, string[]> = {};
-  let outputString = "";
-
-  const xpathLists = await Promise.all(
-    candidateElements.map((elem) => {
-      if (xpathCache.has(elem)) {
-        return Promise.resolve(xpathCache.get(elem)!);
-      }
-      return generateXPaths(elem).then((xpaths: string[]) => {
-        xpathCache.set(elem, xpaths);
-        return xpaths;
-      });
-    }),
-  );
-
-  candidateElements.forEach((elem, idx) => {
-    const xpaths = xpathLists[idx];
-    let elemOutput = "";
-
-    if (isTextNode(elem)) {
-      const textContent = elem.textContent?.trim();
-      if (textContent) {
-        elemOutput += `${idx + indexOffset}:${textContent}\n`;
-      }
-    } else if (isElementNode(elem)) {
-      const tagName = elem.tagName.toLowerCase();
-      const attributes = collectEssentialAttributes(elem);
-      const opening = `<${tagName}${attributes ? " " + attributes : ""}>`;
-      const closing = `</${tagName}>`;
-      const textContent = elem.textContent?.trim() || "";
-      elemOutput += `${idx + indexOffset}:${opening}${textContent}${closing}\n`;
-    }
-
-    outputString += elemOutput;
-    selectorMap[idx + indexOffset] = xpaths;
-  });
-
-  return { outputString, selectorMap };
-}
-
-/**
- * Collects essential attributes from an element.
- * @param element The DOM element.
- * @returns A string of formatted attributes.
- */
-function collectEssentialAttributes(element: Element): string {
-  const essentialAttributes = [
-    "id",
-    "class",
-    "href",
-    "src",
-    "aria-label",
-    "aria-name",
-    "aria-role",
-    "aria-description",
-    "aria-expanded",
-    "aria-haspopup",
-    "type",
-    "value",
-  ];
-
-  const attrs: string[] = essentialAttributes
-    .map((attr) => {
-      const value = element.getAttribute(attr);
-      return value ? `${attr}="${value}"` : "";
-    })
-    .filter((attr) => attr !== "");
-
-  Array.from(element.attributes).forEach((attr) => {
-    if (attr.name.startsWith("data-")) {
-      attrs.push(`${attr.name}="${attr.value}"`);
-    }
-  });
-
-  return attrs.join(" ");
-}
diff --git a/lib/dom/containerFactory.ts b/lib/dom/containerFactory.ts
deleted file mode 100644
index 2375a5737..000000000
--- a/lib/dom/containerFactory.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import { StagehandContainer } from "./StagehandContainer";
-import { GlobalPageContainer } from "./GlobalPageContainer";
-import { ElementContainer } from "./ElementContainer";
-
-/**
- * Decide which container to create.
- */
-export function createStagehandContainer(
-  obj: Window | HTMLElement,
-): StagehandContainer {
-  if (obj instanceof Window) {
-    return new GlobalPageContainer();
-  } else {
-    return new ElementContainer(obj);
-  }
-}
diff --git a/lib/dom/elementCheckUtils.ts b/lib/dom/elementCheckUtils.ts
deleted file mode 100644
index b62637730..000000000
--- a/lib/dom/elementCheckUtils.ts
+++ /dev/null
@@ -1,168 +0,0 @@
-export function isElementNode(node: Node): node is Element {
-  return node.nodeType === Node.ELEMENT_NODE;
-}
-
-export function isTextNode(node: Node): node is Text {
-  return node.nodeType === Node.TEXT_NODE && Boolean(node.textContent?.trim());
-}
-
-const leafElementDenyList = ["SVG", "IFRAME", "SCRIPT", "STYLE", "LINK"];
-
-const interactiveElementTypes = [
-  "A",
-  "BUTTON",
-  "DETAILS",
-  "EMBED",
-  "INPUT",
-  "LABEL",
-  "MENU",
-  "MENUITEM",
-  "OBJECT",
-  "SELECT",
-  "TEXTAREA",
-  "SUMMARY",
-];
-
-const interactiveRoles = [
-  "button",
-  "menu",
-  "menuitem",
-  "link",
-  "checkbox",
-  "radio",
-  "slider",
-  "tab",
-  "tabpanel",
-  "textbox",
-  "combobox",
-  "grid",
-  "listbox",
-  "option",
-  "progressbar",
-  "scrollbar",
-  "searchbox",
-  "switch",
-  "tree",
-  "treeitem",
-  "spinbutton",
-  "tooltip",
-];
-const interactiveAriaRoles = ["menu", "menuitem", "button"];
-
-/*
- * Checks if an element is visible and therefore relevant for LLMs to consider. We check:
- * - Size
- * - Display properties
- * - Opacity
- * If the element is a child of a previously hidden element, it should not be included, so we don't consider downstream effects of a parent element here
- */
-export const isVisible = (element: Element) => {
-  const rect = element.getBoundingClientRect();
-  // Ensure the element is within the viewport
-  if (
-    rect.width === 0 ||
-    rect.height === 0 ||
-    rect.top < 0 ||
-    rect.top > window.innerHeight
-  ) {
-    return false;
-  }
-  if (!isTopElement(element, rect)) {
-    return false;
-  }
-
-  const visible = element.checkVisibility({
-    checkOpacity: true,
-    checkVisibilityCSS: true,
-  });
-
-  return visible;
-};
-
-export const isTextVisible = (element: ChildNode) => {
-  const range = document.createRange();
-  range.selectNodeContents(element);
-  const rect = range.getBoundingClientRect();
-
-  if (
-    rect.width === 0 ||
-    rect.height === 0 ||
-    rect.top < 0 ||
-    rect.top > window.innerHeight
-  ) {
-    return false;
-  }
-  const parent = element.parentElement;
-  if (!parent) {
-    return false;
-  }
-
-  const visible = parent.checkVisibility({
-    checkOpacity: true,
-    checkVisibilityCSS: true,
-  });
-
-  return visible;
-};
-
-export function isTopElement(elem: ChildNode, rect: DOMRect) {
-  const points = [
-    { x: rect.left + rect.width * 0.25, y: rect.top + rect.height * 0.25 },
-    { x: rect.left + rect.width * 0.75, y: rect.top + rect.height * 0.25 },
-    { x: rect.left + rect.width * 0.25, y: rect.top + rect.height * 0.75 },
-    { x: rect.left + rect.width * 0.75, y: rect.top + rect.height * 0.75 },
-    { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 },
-  ];
-
-  return points.some((point) => {
-    const topEl = document.elementFromPoint(point.x, point.y);
-    let current = topEl;
-    while (current && current !== document.body) {
-      if (current.isSameNode(elem)) {
-        return true;
-      }
-      current = current.parentElement;
-    }
-    return false;
-  });
-}
-
-export const isActive = (element: Element) => {
-  if (
-    element.hasAttribute("disabled") ||
-    element.hasAttribute("hidden") ||
-    element.getAttribute("aria-disabled") === "true"
-  ) {
-    return false;
-  }
-
-  return true;
-};
-export const isInteractiveElement = (element: Element) => {
-  const elementType = element.tagName;
-  const elementRole = element.getAttribute("role");
-  const elementAriaRole = element.getAttribute("aria-role");
-
-  return (
-    (elementType && interactiveElementTypes.includes(elementType)) ||
-    (elementRole && interactiveRoles.includes(elementRole)) ||
-    (elementAriaRole && interactiveAriaRoles.includes(elementAriaRole))
-  );
-};
-
-export const isLeafElement = (element: Element) => {
-  if (element.textContent === "") {
-    return false;
-  }
-
-  if (element.childNodes.length === 0) {
-    return !leafElementDenyList.includes(element.tagName);
-  }
-
-  // This case ensures that extra context will be included for simple element nodes that contain only text
-  if (element.childNodes.length === 1 && isTextNode(element.childNodes[0])) {
-    return true;
-  }
-
-  return false;
-};
diff --git a/lib/dom/genDomScripts.ts b/lib/dom/genDomScripts.ts
deleted file mode 100644
index d3c3edc1c..000000000
--- a/lib/dom/genDomScripts.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-/**
- * We have a collection of typescript functions that we need to run in the browser.
- * First, we build them into a single js file
- * Second, due to framework differences we need to get our script content as a string to avoid pathing issues due to file routing in frameworks like Next.js
- * Playwright allows us to pass in script content directly as a string instead of reading a file from a path
- * https://github.com/browserbase/stagehand/issues/180
- *
- * We can't rely on the normal build process for stagehand, because we need our script content as a string so that the import *just works*
- */
-import fs from "fs";
-import path from "path";
-import esbuild from "esbuild";
-
-fs.mkdirSync(path.join(__dirname, "./build"), { recursive: true });
-
-esbuild.buildSync({
-  entryPoints: [path.join(__dirname, "index.ts")],
-  bundle: true,
-  outdir: path.join(__dirname, "build"),
-});
-
-const scriptContent = fs.readFileSync(
-  path.join(__dirname, "./build/index.js"),
-  "utf8",
-);
-
-const output = `export const scriptContent = ${JSON.stringify(scriptContent)};`;
-
-fs.writeFileSync(path.join(__dirname, "./build/scriptContent.ts"), output);
diff --git a/lib/dom/global.d.ts b/lib/dom/global.d.ts
deleted file mode 100644
index 742c15433..000000000
--- a/lib/dom/global.d.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { StagehandContainer } from "./StagehandContainer";
-
-export {};
-declare global {
-  interface Window {
-    chunkNumber: number;
-    showChunks?: boolean;
-    processDom: (chunksSeen: Array<number>) => Promise<{
-      outputString: string;
-      selectorMap: Record<number, string[]>;
-      chunk: number;
-      chunks: number[];
-    }>;
-    processAllOfDom: (xpath?: string) => Promise<{
-      outputString: string;
-      selectorMap: Record<number, string[]>;
-    }>;
-    createStagehandContainer: (obj: Window | HTMLElement) => StagehandContainer;
-    waitForDomSettle: () => Promise<void>;
-    __playwright?: unknown;
-    __pw_manual?: unknown;
-    __PW_inspect?: unknown;
-    storeDOM: (xpath?: string) => string;
-    restoreDOM: (storedDOM: string, xpath?: string) => void;
-    createTextBoundingBoxes: (xpath?: string) => void;
-    getElementBoundingBoxes: (xpath: string) => Array<{
-      text: string;
-      top: number;
-      left: number;
-      width: number;
-      height: number;
-    }>;
-    getScrollableElementXpaths: (topN?: number) => Promise<string[]>;
-    getNodeFromXpath: (xpath: string) => Node | null;
-    waitForElementScrollEnd: (element: HTMLElement) => Promise<void>;
-  }
-}
diff --git a/lib/dom/index.ts b/lib/dom/index.ts
deleted file mode 100644
index 96b53216a..000000000
--- a/lib/dom/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export * from "./process";
-export * from "./utils";
diff --git a/lib/dom/process.ts b/lib/dom/process.ts
deleted file mode 100644
index c9aa28408..000000000
--- a/lib/dom/process.ts
+++ /dev/null
@@ -1,567 +0,0 @@
-import { generateXPathsForElement as generateXPaths } from "./xpathUtils";
-import {
-  calculateViewportHeight,
-  canElementScroll,
-  getNodeFromXpath,
-  waitForDomSettle,
-  waitForElementScrollEnd,
-} from "./utils";
-import { createStagehandContainer } from "./containerFactory";
-import { StagehandContainer } from "./StagehandContainer";
-import { GlobalPageContainer } from "@/lib/dom/GlobalPageContainer";
-import { ElementContainer } from "@/lib/dom/ElementContainer";
-import { DomChunk } from "@/lib/dom/DomChunk";
-import { StagehandDomProcessError } from "@/types/stagehandErrors";
-
-/**
- * Finds and returns a list of scrollable elements on the page,
- * ordered from the element with the largest scrollHeight to the smallest.
- *
- * @param topN Optional maximum number of scrollable elements to return.
- *             If not provided, all found scrollable elements are returned.
- * @returns An array of HTMLElements sorted by descending scrollHeight.
- */
-export function getScrollableElements(topN?: number): HTMLElement[] {
-  // Get the root <html> element
-  const docEl = document.documentElement;
-
-  // 1) Initialize an array to hold all scrollable elements.
-  //    Always include the root <html> element as a fallback.
-  const scrollableElements: HTMLElement[] = [docEl];
-
-  // 2) Scan all elements to find potential scrollable containers.
-  //    A candidate must have a scrollable overflow style and extra scrollable content.
-  const allElements = document.querySelectorAll<HTMLElement>("*");
-  for (const elem of allElements) {
-    const style = window.getComputedStyle(elem);
-    const overflowY = style.overflowY;
-
-    const isPotentiallyScrollable =
-      overflowY === "auto" || overflowY === "scroll" || overflowY === "overlay";
-
-    if (isPotentiallyScrollable) {
-      const candidateScrollDiff = elem.scrollHeight - elem.clientHeight;
-      // Only consider this element if it actually has extra scrollable content
-      // and it can truly scroll.
-      if (candidateScrollDiff > 0 && canElementScroll(elem)) {
-        scrollableElements.push(elem);
-      }
-    }
-  }
-
-  // 3) Sort the scrollable elements from largest scrollHeight to smallest.
-  scrollableElements.sort((a, b) => b.scrollHeight - a.scrollHeight);
-
-  // 4) If a topN limit is specified, return only the first topN elements.
-  if (topN !== undefined) {
-    return scrollableElements.slice(0, topN);
-  }
-
-  // Return all found scrollable elements if no limit is provided.
-  return scrollableElements;
-}
-
-/**
- * Calls getScrollableElements, then for each element calls generateXPaths,
- * and returns the first XPath for each.
- *
- * @param topN (optional) integer limit on how many scrollable elements to process
- * @returns string[] list of XPaths (1 for each scrollable element)
- */
-export async function getScrollableElementXpaths(
-  topN?: number,
-): Promise<string[]> {
-  const scrollableElems = getScrollableElements(topN);
-  const xpaths = [];
-  for (const elem of scrollableElems) {
-    const allXPaths = await generateXPaths(elem);
-    const firstXPath = allXPaths?.[0] || "";
-    xpaths.push(firstXPath);
-  }
-  return xpaths;
-}
-
-export function getNearestScrollableParent(el: HTMLElement): HTMLElement {
-  // 1) Get *all* scrollable elements on the page
-  //    (You could pass a large topN or omit it for “all”)
-  const allScrollables = getScrollableElements();
-
-  // 2) Climb up the DOM tree
-  let current: HTMLElement | null = el;
-  while (current) {
-    // If `current` is in the scrollable list, we have our nearest scrollable parent
-    if (allScrollables.includes(current)) {
-      return current;
-    }
-    current = current.parentElement;
-  }
-
-  // 3) If we exhaust the ancestors, default to root
-  return document.documentElement;
-}
-
-/**
- * processDom
- * ----------
- * This function now just picks a single chunk index,
- * creates a container, and calls collectDomChunk to get a single DomChunk.
- *
- * @param chunksSeen - The chunks we've seen so far
- */
-export async function processDom(chunksSeen: number[]) {
-  // 1) choose a chunk index from chunksSeen
-  const { chunk, chunksArray } = await pickChunk(chunksSeen);
-
-  // 2) create a container for the entire page
-  const container = new GlobalPageContainer();
-
-  // 3) pick a chunk size, e.g. container.getViewportHeight()
-  const chunkSize = container.getViewportHeight();
-
-  // 4) compute startOffset from `chunkIndex * chunkSize`
-  const startOffset = chunk * chunkSize;
-  // if we only want a single chunk, pass the same value for `endOffset`
-  const endOffset = startOffset;
-
-  // 5) collectAllDomChunks with identical start & end => exactly 1 iteration
-  const domChunks = await container.collectDomChunks(
-    startOffset,
-    endOffset,
-    chunkSize,
-    true,
-    false, // scrollBackToTop
-    container.getRootElement(), // BFS entire doc
-  );
-
-  // We expect exactly 1 chunk
-  const [domChunk] = domChunks;
-  if (!domChunk) {
-    // fallback, no chunk
-    return {
-      outputString: "",
-      selectorMap: {},
-      chunk,
-      chunks: chunksArray,
-    };
-  }
-
-  console.log("Extracted DOM chunk:\n", domChunk.outputString);
-
-  return {
-    outputString: domChunk.outputString,
-    selectorMap: domChunk.selectorMap,
-    chunk,
-    chunks: chunksArray,
-  };
-}
-
-/**
- * processAllOfDom
- * ---------------
- * If an xpath is provided, we find that element and build an appropriate container
- * (global or element) based on the nearest scrollable parent. Then we chunk from
- * startOffset..endOffset. We BFS within the element's subtree (candidateContainer).
- */
-export async function processAllOfDom(xpath?: string) {
-  let candidateElementContainer: HTMLElement | null = null;
-  let scrollTarget: StagehandContainer;
-
-  if (xpath) {
-    // 1) Find the element
-    const node = getNodeFromXpath(xpath) as HTMLElement | null;
-
-    if (node) {
-      candidateElementContainer = node;
-      console.log(`Found element via XPath: ${xpath}`);
-
-      // 2) Always find the nearest scrollable parent
-      const scrollableElem = getNearestScrollableParent(
-        candidateElementContainer,
-      );
-      if (scrollableElem === document.documentElement) {
-        scrollTarget = new GlobalPageContainer();
-      } else {
-        scrollTarget = new ElementContainer(scrollableElem);
-      }
-
-      // 3) Scroll the candidateElementContainer into view
-      //    (use the container's scroll logic)
-      await scrollTarget.scrollIntoView(candidateElementContainer);
-
-      // 4) Measure the container’s new scroll offset AFTER we've scrolled
-      const startOffset = scrollTarget.getScrollPosition();
-
-      // Now check if the element “fits” in the container’s viewport
-      const scrollTargetHeight = scrollTarget.getViewportHeight();
-      const candidateElementContainerHeight =
-        candidateElementContainer.scrollHeight;
-
-      if (candidateElementContainerHeight <= scrollTargetHeight) {
-        // Single-chunk approach
-        console.log(
-          "Element is smaller/equal to container’s viewport. Doing single chunk.",
-        );
-
-        // We'll define a "single-chunk" scenario by telling
-        // the container to gather from startOffset..startOffset
-        // so it only processes exactly one chunk iteration
-        const domChunks = await scrollTarget.collectDomChunks(
-          startOffset, // startOffset
-          startOffset, // endOffset => same as start => 1 chunk
-          1, // chunkSize=1 => doesn't matter, because start==end means exactly 1 iteration
-          true,
-          true,
-          candidateElementContainer,
-        );
-
-        const singleChunkOutput = combineChunks(domChunks);
-        console.log(
-          "Final output (single-chunk):",
-          singleChunkOutput.outputString,
-        );
-        return singleChunkOutput;
-      }
-
-      console.log("Element is bigger. Doing multi-chunk approach.");
-    } else {
-      console.warn(`XPath not found: ${xpath}. Using entire doc.`);
-    }
-  } else {
-    const scrollableElems = getScrollableElements(1);
-    const mainScrollable = scrollableElems[0];
-
-    scrollTarget =
-      mainScrollable === document.documentElement
-        ? createStagehandContainer(window)
-        : createStagehandContainer(mainScrollable);
-  }
-
-  const startOffset = scrollTarget.getScrollPosition();
-  const viewportHeight = scrollTarget.getViewportHeight();
-  const maxScroll = candidateElementContainer
-    ? startOffset + candidateElementContainer.scrollHeight
-    : scrollTarget.getScrollHeight();
-  const chunkSize = viewportHeight;
-
-  console.log("processAllOfDom chunk-based from", startOffset, "to", maxScroll);
-
-  const domChunks = await scrollTarget.collectDomChunks(
-    startOffset,
-    maxScroll,
-    chunkSize,
-    true,
-    true,
-    candidateElementContainer ?? undefined,
-  );
-
-  const finalOutput = combineChunks(domChunks);
-  console.log(
-    "All DOM elements combined (chunk-based):",
-    finalOutput.outputString,
-  );
-  return finalOutput;
-}
-
-function combineChunks(domChunks: DomChunk[]): {
-  outputString: string;
-  selectorMap: Record<number, string[]>;
-} {
-  const outputString = domChunks.map((c: DomChunk) => c.outputString).join("");
-  let finalSelectorMap: Record<number, string[]> = {};
-  domChunks.forEach((c: DomChunk) => {
-    finalSelectorMap = { ...finalSelectorMap, ...c.selectorMap };
-  });
-  return { outputString, selectorMap: finalSelectorMap };
-}
-
-/**
- * Stores either the entire DOM (if no `xpath` is given),
- * or the specific element that `xpath` points to.
- * Returns the outer HTML of what is stored.
- */
-export function storeDOM(xpath?: string): string {
-  if (!xpath) {
-    const originalDOM = document.body.cloneNode(true) as HTMLElement;
-    console.log("DOM state stored (root).");
-    return originalDOM.outerHTML;
-  } else {
-    const node = getNodeFromXpath(xpath) as HTMLElement | null;
-
-    if (!node) {
-      console.error(
-        `storeDOM: No element found for xpath: ${xpath}. Returning empty string.`,
-      );
-      return "";
-    }
-
-    console.log(`DOM state stored (element at xpath: ${xpath}).`);
-    return node.outerHTML;
-  }
-}
-
-/**
- * Restores either the entire DOM (if no `xpath` is given),
- * or the specific element that `xpath` points to, based on `storedDOM`.
- */
-export function restoreDOM(storedDOM: string, xpath?: string): void {
-  console.log("Restoring DOM...");
-
-  if (!storedDOM) {
-    console.error("No DOM state was provided.");
-    return;
-  }
-
-  if (!xpath) {
-    document.body.innerHTML = storedDOM;
-    console.log("DOM restored (root).");
-  } else {
-    const node = getNodeFromXpath(xpath) as HTMLElement | null;
-
-    if (!node) {
-      console.error(
-        `restoreDOM: No element found for xpath: ${xpath}. Cannot restore.`,
-      );
-      return;
-    }
-
-    node.outerHTML = storedDOM;
-    console.log(`DOM restored (element at xpath: ${xpath}).`);
-  }
-}
-
-export function createTextBoundingBoxes(xpath?: string): void {
-  const style = document.createElement("style");
-  document.head.appendChild(style);
-  if (style.sheet) {
-    style.sheet.insertRule(
-      `
-      .stagehand-highlighted-word, .stagehand-space {
-        border: 0px solid orange;
-        display: inline-block !important;
-        visibility: visible;
-      }
-    `,
-      0,
-    );
-
-    style.sheet.insertRule(
-      `
-        code .stagehand-highlighted-word, code .stagehand-space,
-        pre .stagehand-highlighted-word, pre .stagehand-space {
-          white-space: pre-wrap;
-          display: inline !important;
-      }
-     `,
-      1,
-    );
-  }
-
-  /**
-   * Applies highlighting to every text node under `root`.
-   * If `root` is the entire `document`, we query "body *".
-   * If `root` is a specific `HTMLElement`, we query "*".
-   */
-  function applyHighlighting(root: Document | HTMLElement): void {
-    // If root is a Document, highlight everything under <body>. Otherwise, highlight all children of that HTMLElement.
-    const containerSelector = root instanceof Document ? "body *" : "*";
-
-    root.querySelectorAll(containerSelector).forEach((element) => {
-      if (
-        element.closest &&
-        element.closest(".stagehand-nav, .stagehand-marker")
-      ) {
-        return;
-      }
-      if (["SCRIPT", "STYLE", "IFRAME", "INPUT"].includes(element.tagName)) {
-        return;
-      }
-
-      const childNodes = Array.from(element.childNodes);
-      childNodes.forEach((node) => {
-        if (node.nodeType === 3 && node.textContent?.trim().length > 0) {
-          const textContent = node.textContent.replace(/\u00A0/g, " ");
-          const tokens = textContent.split(/(\s+)/g); // Split text by spaces
-          const fragment = document.createDocumentFragment();
-          const parentIsCode = element.tagName === "CODE";
-
-          tokens.forEach((token) => {
-            const span = document.createElement("span");
-            span.textContent = token;
-            if (parentIsCode) {
-              // Special handling for <code> tags
-              span.style.whiteSpace = "pre-wrap";
-              span.style.display = "inline";
-            }
-            span.className =
-              token.trim().length === 0
-                ? "stagehand-space"
-                : "stagehand-highlighted-word";
-            fragment.appendChild(span);
-          });
-
-          if (fragment.childNodes.length > 0 && node.parentNode) {
-            element.insertBefore(fragment, node);
-            node.remove();
-          }
-        }
-      });
-    });
-  }
-
-  if (!xpath) {
-    applyHighlighting(document);
-
-    document.querySelectorAll("iframe").forEach((iframe) => {
-      try {
-        iframe.contentWindow?.postMessage({ action: "highlight" }, "*");
-      } catch (error) {
-        console.error("Error accessing iframe content: ", error);
-      }
-    });
-  } else {
-    const node = getNodeFromXpath(xpath) as HTMLElement | null;
-
-    if (!node) {
-      console.warn(
-        `createTextBoundingBoxes: No element found for xpath "${xpath}".`,
-      );
-      return;
-    }
-
-    applyHighlighting(node);
-  }
-}
-
-export function getElementBoundingBoxes(xpath: string): Array<{
-  text: string;
-  top: number;
-  left: number;
-  width: number;
-  height: number;
-}> {
-  const element = getNodeFromXpath(xpath) as HTMLElement;
-
-  if (!element) return [];
-
-  const isValidText = (text: string) => text && text.trim().length > 0;
-  let dropDownElem = element.querySelector("option[selected]");
-
-  if (!dropDownElem) {
-    dropDownElem = element.querySelector("option");
-  }
-
-  if (dropDownElem) {
-    const elemText = dropDownElem.textContent || "";
-    if (isValidText(elemText)) {
-      const parentRect = element.getBoundingClientRect();
-      return [
-        {
-          text: elemText.trim(),
-          top: parentRect.top + window.scrollY,
-          left: parentRect.left + window.scrollX,
-          width: parentRect.width,
-          height: parentRect.height,
-        },
-      ];
-    } else {
-      return [];
-    }
-  }
-
-  let placeholderText = "";
-  if (
-    (element.tagName.toLowerCase() === "input" ||
-      element.tagName.toLowerCase() === "textarea") &&
-    (element as HTMLInputElement).placeholder
-  ) {
-    placeholderText = (element as HTMLInputElement).placeholder;
-  } else if (element.tagName.toLowerCase() === "a") {
-    placeholderText = "";
-  } else if (element.tagName.toLowerCase() === "img") {
-    placeholderText = (element as HTMLImageElement).alt || "";
-  }
-
-  const words = element.querySelectorAll(
-    ".stagehand-highlighted-word",
-  ) as NodeListOf<HTMLElement>;
-
-  const boundingBoxes = Array.from(words)
-    .map((word) => {
-      const rect = word.getBoundingClientRect();
-      return {
-        text: word.innerText || "",
-        top: rect.top + window.scrollY,
-        left: rect.left + window.scrollX,
-        width: rect.width,
-        height: rect.height * 0.75,
-      };
-    })
-    .filter(
-      (box) =>
-        box.width > 0 &&
-        box.height > 0 &&
-        box.top >= 0 &&
-        box.left >= 0 &&
-        isValidText(box.text),
-    );
-
-  if (boundingBoxes.length === 0) {
-    const elementRect = element.getBoundingClientRect();
-    return [
-      {
-        text: placeholderText,
-        top: elementRect.top + window.scrollY,
-        left: elementRect.left + window.scrollX,
-        width: elementRect.width,
-        height: elementRect.height * 0.75,
-      },
-    ];
-  }
-
-  return boundingBoxes;
-}
-
-window.waitForDomSettle = waitForDomSettle;
-window.processDom = processDom;
-window.processAllOfDom = processAllOfDom;
-window.storeDOM = storeDOM;
-window.restoreDOM = restoreDOM;
-window.createTextBoundingBoxes = createTextBoundingBoxes;
-window.getElementBoundingBoxes = getElementBoundingBoxes;
-window.createStagehandContainer = createStagehandContainer;
-window.getScrollableElementXpaths = getScrollableElementXpaths;
-window.getNodeFromXpath = getNodeFromXpath;
-window.waitForElementScrollEnd = waitForElementScrollEnd;
-
-async function pickChunk(chunksSeen: Array<number>) {
-  const viewportHeight = calculateViewportHeight();
-  const documentHeight = document.documentElement.scrollHeight;
-
-  const chunks = Math.ceil(documentHeight / viewportHeight);
-
-  const chunksArray = Array.from({ length: chunks }, (_, i) => i);
-  const chunksRemaining = chunksArray.filter((chunk) => {
-    return !chunksSeen.includes(chunk);
-  });
-
-  const currentScrollPosition = window.scrollY;
-  const closestChunk = chunksRemaining.reduce((closest, current) => {
-    const currentChunkTop = viewportHeight * current;
-    const closestChunkTop = viewportHeight * closest;
-    return Math.abs(currentScrollPosition - currentChunkTop) <
-      Math.abs(currentScrollPosition - closestChunkTop)
-      ? current
-      : closest;
-  }, chunksRemaining[0]);
-  const chunk = closestChunk;
-
-  if (chunk === undefined) {
-    throw new StagehandDomProcessError(
-      `No chunks remaining to check: ${chunksRemaining}`,
-    );
-  }
-  return {
-    chunk,
-    chunksArray,
-  };
-}
diff --git a/lib/dom/utils.ts b/lib/dom/utils.ts
deleted file mode 100644
index 65255578c..000000000
--- a/lib/dom/utils.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-import { StagehandDomProcessError } from "@/types/stagehandErrors";
-
-export async function waitForDomSettle() {
-  return new Promise<void>((resolve) => {
-    const createTimeout = () => {
-      return setTimeout(() => {
-        resolve();
-      }, 2000);
-    };
-    let timeout = createTimeout();
-    const observer = new MutationObserver(() => {
-      clearTimeout(timeout);
-      timeout = createTimeout();
-    });
-    observer.observe(window.document.body, { childList: true, subtree: true });
-  });
-}
-
-export function calculateViewportHeight() {
-  return Math.ceil(window.innerHeight * 0.75);
-}
-
-/**
- * Tests if the element actually responds to .scrollTo(...)
- * and that scrollTop changes as expected.
- */
-export function canElementScroll(elem: HTMLElement): boolean {
-  // Quick check if scrollTo is a function
-  if (typeof elem.scrollTo !== "function") {
-    console.warn("canElementScroll: .scrollTo is not a function.");
-    return false;
-  }
-
-  try {
-    const originalTop = elem.scrollTop;
-
-    // try to scroll
-    elem.scrollTo({
-      top: originalTop + 100,
-      left: 0,
-      behavior: "instant",
-    });
-
-    // If scrollTop never changed, consider it unscrollable
-    if (elem.scrollTop === originalTop) {
-      throw new StagehandDomProcessError("scrollTop did not change");
-    }
-
-    // Scroll back to original place
-    elem.scrollTo({
-      top: originalTop,
-      left: 0,
-      behavior: "instant",
-    });
-
-    return true;
-  } catch (error) {
-    console.warn("canElementScroll error:", (error as Error).message || error);
-    return false;
-  }
-}
-
-export function getNodeFromXpath(xpath: string) {
-  return document.evaluate(
-    xpath,
-    document.documentElement,
-    null,
-    XPathResult.FIRST_ORDERED_NODE_TYPE,
-    null,
-  ).singleNodeValue;
-}
-
-export function waitForElementScrollEnd(
-  element: HTMLElement,
-  idleMs = 100,
-): Promise<void> {
-  return new Promise<void>((resolve) => {
-    let scrollEndTimer: number | undefined;
-
-    const handleScroll = () => {
-      clearTimeout(scrollEndTimer);
-      scrollEndTimer = window.setTimeout(() => {
-        element.removeEventListener("scroll", handleScroll);
-        resolve();
-      }, idleMs);
-    };
-
-    element.addEventListener("scroll", handleScroll, { passive: true });
-    handleScroll();
-  });
-}
diff --git a/lib/dom/xpathUtils.ts b/lib/dom/xpathUtils.ts
deleted file mode 100644
index f08eb7479..000000000
--- a/lib/dom/xpathUtils.ts
+++ /dev/null
@@ -1,243 +0,0 @@
-import { isElementNode, isTextNode } from "./elementCheckUtils";
-
-function getParentElement(node: ChildNode): Element | null {
-  return isElementNode(node)
-    ? node.parentElement
-    : (node.parentNode as Element);
-}
-
-/**
- * Generates all possible combinations of a given array of attributes.
- * @param attributes Array of attributes.
- * @param size The size of each combination.
- * @returns An array of attribute combinations.
- */
-function getCombinations(
-  attributes: { attr: string; value: string }[],
-  size: number,
-): { attr: string; value: string }[][] {
-  const results: { attr: string; value: string }[][] = [];
-
-  function helper(start: number, combo: { attr: string; value: string }[]) {
-    if (combo.length === size) {
-      results.push([...combo]);
-      return;
-    }
-    for (let i = start; i < attributes.length; i++) {
-      combo.push(attributes[i]);
-      helper(i + 1, combo);
-      combo.pop();
-    }
-  }
-
-  helper(0, []);
-  return results;
-}
-
-/**
- * Checks if the generated XPath uniquely identifies the target element.
- * @param xpath The XPath string to test.
- * @param target The target DOM element.
- * @returns True if unique, else false.
- */
-function isXPathFirstResultElement(xpath: string, target: Element): boolean {
-  try {
-    const result = document.evaluate(
-      xpath,
-      document.documentElement,
-      null,
-      XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,
-      null,
-    );
-    return result.snapshotItem(0) === target;
-  } catch (error) {
-    // If there's an error evaluating the XPath, consider it not unique
-    console.warn(`Invalid XPath expression: ${xpath}`, error);
-    return false;
-  }
-}
-
-/**
- * Escapes a string for use in an XPath expression.
- * Handles special characters, including single and double quotes.
- * @param value - The string to escape.
- * @returns The escaped string safe for XPath.
- */
-export function escapeXPathString(value: string): string {
-  if (value.includes("'")) {
-    if (value.includes('"')) {
-      // If the value contains both single and double quotes, split into parts
-      return (
-        "concat(" +
-        value
-          .split(/('+)/)
-          .map((part) => {
-            if (part === "'") {
-              return `"'"`;
-            } else if (part.startsWith("'") && part.endsWith("'")) {
-              return `"${part}"`;
-            } else {
-              return `'${part}'`;
-            }
-          })
-          .join(",") +
-        ")"
-      );
-    } else {
-      // Contains single quotes but not double quotes; use double quotes
-      return `"${value}"`;
-    }
-  } else {
-    // Does not contain single quotes; use single quotes
-    return `'${value}'`;
-  }
-}
-
-/**
- * Generates both a complicated XPath and a standard XPath for a given DOM element.
- * @param element - The target DOM element.
- * @param documentOverride - Optional document override.
- * @returns An object containing both XPaths.
- */
-export async function generateXPathsForElement(
-  element: ChildNode,
-): Promise<string[]> {
-  // Generate the standard XPath
-  if (!element) return [];
-  const [complexXPath, standardXPath, idBasedXPath] = await Promise.all([
-    generateComplexXPath(element),
-    generateStandardXPath(element),
-    generatedIdBasedXPath(element),
-  ]);
-
-  // This should return in order from most accurate on current page to most cachable.
-  return [standardXPath, ...(idBasedXPath ? [idBasedXPath] : []), complexXPath];
-}
-
-async function generateComplexXPath(element: ChildNode): Promise<string> {
-  // Generate the complicated XPath
-  const parts: string[] = [];
-  let currentElement: ChildNode | null = element;
-
-  while (
-    currentElement &&
-    (isTextNode(currentElement) || isElementNode(currentElement))
-  ) {
-    if (isElementNode(currentElement)) {
-      const el = currentElement as Element;
-      let selector = el.tagName.toLowerCase();
-
-      // List of attributes to consider for uniqueness
-      const attributePriority = [
-        "data-qa",
-        "data-component",
-        "data-role",
-        "role",
-        "aria-role",
-        "type",
-        "name",
-        "aria-label",
-        "placeholder",
-        "title",
-        "alt",
-      ];
-
-      // Collect attributes present on the element
-      const attributes = attributePriority
-        .map((attr) => {
-          let value = el.getAttribute(attr);
-          if (attr === "href-full" && value) {
-            value = el.getAttribute("href");
-          }
-          return value
-            ? { attr: attr === "href-full" ? "href" : attr, value }
-            : null;
-        })
-        .filter((attr) => attr !== null) as { attr: string; value: string }[];
-
-      // Attempt to find a combination of attributes that uniquely identifies the element
-      let uniqueSelector = "";
-      for (let i = 1; i <= attributes.length; i++) {
-        const combinations = getCombinations(attributes, i);
-        for (const combo of combinations) {
-          const conditions = combo
-            .map((a) => `@${a.attr}=${escapeXPathString(a.value)}`)
-            .join(" and ");
-          const xpath = `//${selector}[${conditions}]`;
-          if (isXPathFirstResultElement(xpath, el)) {
-            uniqueSelector = xpath;
-            break;
-          }
-        }
-        if (uniqueSelector) break;
-      }
-
-      if (uniqueSelector) {
-        parts.unshift(uniqueSelector.replace("//", ""));
-        break;
-      } else {
-        // Fallback to positional selector
-        const parent = getParentElement(el);
-        if (parent) {
-          const siblings = Array.from(parent.children).filter(
-            (sibling) => sibling.tagName === el.tagName,
-          );
-          const index = siblings.indexOf(el as HTMLElement) + 1;
-          selector += siblings.length > 1 ? `[${index}]` : "";
-        }
-        parts.unshift(selector);
-      }
-    }
-
-    currentElement = getParentElement(currentElement);
-  }
-
-  const xpath = "//" + parts.join("/");
-  return xpath;
-}
-
-/**
- * Generates a standard XPath for a given DOM element.
- * @param element - The target DOM element.
- * @returns A standard XPath string.
- */
-async function generateStandardXPath(element: ChildNode): Promise<string> {
-  const parts: string[] = [];
-  while (element && (isTextNode(element) || isElementNode(element))) {
-    let index = 0;
-    let hasSameTypeSiblings = false;
-    const siblings = element.parentElement
-      ? Array.from(element.parentElement.childNodes)
-      : [];
-    for (let i = 0; i < siblings.length; i++) {
-      const sibling = siblings[i];
-      if (
-        sibling.nodeType === element.nodeType &&
-        sibling.nodeName === element.nodeName
-      ) {
-        index = index + 1;
-        hasSameTypeSiblings = true;
-        if (sibling.isSameNode(element)) {
-          break;
-        }
-      }
-    }
-    // text "nodes" are selected differently than elements with xPaths
-    if (element.nodeName !== "#text") {
-      const tagName = element.nodeName.toLowerCase();
-      const pathIndex = hasSameTypeSiblings ? `[${index}]` : "";
-      parts.unshift(`${tagName}${pathIndex}`);
-    }
-    element = element.parentElement as HTMLElement;
-  }
-  return parts.length ? `/${parts.join("/")}` : "";
-}
-
-async function generatedIdBasedXPath(
-  element: ChildNode,
-): Promise<string | null> {
-  if (isElementNode(element) && element.id) {
-    return `//*[@id='${element.id}']`;
-  }
-  return null;
-}
diff --git a/lib/handlers/actHandler.ts b/lib/handlers/actHandler.ts
deleted file mode 100644
index d3442f07e..000000000
--- a/lib/handlers/actHandler.ts
+++ /dev/null
@@ -1,356 +0,0 @@
-import { Locator } from "@playwright/test";
-import { LogLine } from "../../types/log";
-import {
-  PlaywrightCommandException,
-  PlaywrightCommandMethodNotSupportedException,
-} from "../../types/playwright";
-import { LLMClient } from "../llm/LLMClient";
-import { StagehandPage } from "../StagehandPage";
-import {
-  ActResult,
-  ObserveResult,
-  ActOptions,
-  ObserveOptions,
-} from "@/types/stagehand";
-import { MethodHandlerContext, SupportedPlaywrightAction } from "@/types/act";
-import { buildActObservePrompt } from "../prompt";
-import {
-  methodHandlerMap,
-  fallbackLocatorMethod,
-} from "./handlerUtils/actHandlerUtils";
-import { StagehandObserveHandler } from "@/lib/handlers/observeHandler";
-import { StagehandInvalidArgumentError } from "@/types/stagehandErrors";
-/**
- * NOTE: Vision support has been removed from this version of Stagehand.
- * If useVision or verifierUseVision is set to true, a warning is logged and
- * the flow continues as if vision = false.
- */
-export class StagehandActHandler {
-  private readonly stagehandPage: StagehandPage;
-  private readonly logger: (logLine: LogLine) => void;
-  private readonly selfHeal: boolean;
-
-  constructor({
-    logger,
-    stagehandPage,
-    selfHeal,
-  }: {
-    logger: (logLine: LogLine) => void;
-    stagehandPage: StagehandPage;
-    selfHeal: boolean;
-  }) {
-    this.logger = logger;
-    this.stagehandPage = stagehandPage;
-    this.selfHeal = selfHeal;
-  }
-
-  /**
-   * Perform an immediate Playwright action based on an ObserveResult object
-   * that was returned from `page.observe(...)`.
-   */
-  public async actFromObserveResult(
-    observe: ObserveResult,
-    domSettleTimeoutMs?: number,
-  ): Promise<ActResult> {
-    this.logger({
-      category: "action",
-      message: "Performing act from an ObserveResult",
-      level: 1,
-      auxiliary: {
-        observeResult: {
-          value: JSON.stringify(observe),
-          type: "object",
-        },
-      },
-    });
-
-    const method = observe.method;
-    if (method === "not-supported") {
-      this.logger({
-        category: "action",
-        message: "Cannot execute ObserveResult with unsupported method",
-        level: 1,
-        auxiliary: {
-          error: {
-            value:
-              "NotSupportedError: The method requested in this ObserveResult is not supported by Stagehand.",
-            type: "string",
-          },
-          trace: {
-            value: `Cannot execute act from ObserveResult with unsupported method: ${method}`,
-            type: "string",
-          },
-        },
-      });
-      return {
-        success: false,
-        message: `Unable to perform action: The method '${method}' is not supported in ObserveResult. Please use a supported Playwright locator method.`,
-        action: observe.description || `ObserveResult action (${method})`,
-      };
-    }
-    const args = observe.arguments ?? [];
-    // remove the xpath prefix on the selector
-    const selector = observe.selector.replace("xpath=", "");
-
-    try {
-      await this._performPlaywrightMethod(
-        method,
-        args,
-        selector,
-        domSettleTimeoutMs,
-      );
-
-      return {
-        success: true,
-        message: `Action [${method}] performed successfully on selector: ${selector}`,
-        action: observe.description || `ObserveResult action (${method})`,
-      };
-    } catch (err) {
-      if (
-        !this.selfHeal ||
-        err instanceof PlaywrightCommandMethodNotSupportedException
-      ) {
-        this.logger({
-          category: "action",
-          message: "Error performing act from an ObserveResult",
-          level: 1,
-          auxiliary: {
-            error: { value: err.message, type: "string" },
-            trace: { value: err.stack, type: "string" },
-          },
-        });
-        return {
-          success: false,
-          message: `Failed to perform act: ${err.message}`,
-          action: observe.description || `ObserveResult action (${method})`,
-        };
-      }
-      // We will try to use observeAct on a failed ObserveResult-act if selfHeal is true
-      this.logger({
-        category: "action",
-        message:
-          "Error performing act from an ObserveResult. Reprocessing the page and trying again",
-        level: 1,
-        auxiliary: {
-          error: { value: err.message, type: "string" },
-          trace: { value: err.stack, type: "string" },
-          observeResult: { value: JSON.stringify(observe), type: "object" },
-        },
-      });
-      try {
-        // Remove redundancy from method-description
-        const actCommand = observe.description
-          .toLowerCase()
-          .startsWith(method.toLowerCase())
-          ? observe.description
-          : method
-            ? `${method} ${observe.description}`
-            : observe.description;
-        // Call act with the ObserveResult description
-        return await this.stagehandPage.act({
-          action: actCommand,
-        });
-      } catch (err) {
-        this.logger({
-          category: "action",
-          message: "Error performing act from an ObserveResult on fallback",
-          level: 1,
-          auxiliary: {
-            error: { value: err.message, type: "string" },
-            trace: { value: err.stack, type: "string" },
-          },
-        });
-        return {
-          success: false,
-          message: `Failed to perform act: ${err.message}`,
-          action: observe.description || `ObserveResult action (${method})`,
-        };
-      }
-    }
-  }
-
-  /**
-   * Perform an act based on an instruction.
-   * This method will observe the page and then perform the act on the first element returned.
-   */
-  public async observeAct(
-    actionOrOptions: ActOptions,
-    observeHandler: StagehandObserveHandler,
-    llmClient: LLMClient,
-    requestId: string,
-  ): Promise<ActResult> {
-    // Extract the action string
-    let action: string;
-    const observeOptions: Partial<ObserveOptions> = {};
-
-    if (typeof actionOrOptions === "object" && actionOrOptions !== null) {
-      if (!("action" in actionOrOptions)) {
-        throw new StagehandInvalidArgumentError(
-          "Invalid argument. Action options must have an `action` field.",
-        );
-      }
-
-      if (
-        typeof actionOrOptions.action !== "string" ||
-        actionOrOptions.action.length === 0
-      ) {
-        throw new StagehandInvalidArgumentError(
-          "Invalid argument. No action provided.",
-        );
-      }
-
-      action = actionOrOptions.action;
-
-      // Extract options that should be passed to observe
-      if (actionOrOptions.modelName)
-        observeOptions.modelName = actionOrOptions.modelName;
-      if (actionOrOptions.modelClientOptions)
-        observeOptions.modelClientOptions = actionOrOptions.modelClientOptions;
-    } else {
-      throw new StagehandInvalidArgumentError(
-        "Invalid argument. Valid arguments are: a string, an ActOptions object with an `action` field not empty, or an ObserveResult with a `selector` and `method` field.",
-      );
-    }
-
-    // doObserveAndAct is just a wrapper of observeAct and actFromObserveResult.
-    // we did this so that we can cleanly call a Promise.race, and race
-    // doObserveAndAct against the user defined timeoutMs (if one was defined)
-    const doObserveAndAct = async (): Promise<ActResult> => {
-      const instruction = buildActObservePrompt(
-        action,
-        Object.values(SupportedPlaywrightAction),
-        actionOrOptions.variables,
-      );
-
-      const observeResults = await observeHandler.observe({
-        instruction,
-        llmClient,
-        requestId,
-        onlyVisible: false,
-        drawOverlay: false,
-        returnAction: true,
-        fromAct: true,
-      });
-
-      if (observeResults.length === 0) {
-        return {
-          success: false,
-          message: `Failed to perform act: No observe results found for action`,
-          action,
-        };
-      }
-
-      const element: ObserveResult = observeResults[0];
-
-      if (actionOrOptions.variables) {
-        Object.keys(actionOrOptions.variables).forEach((key) => {
-          element.arguments = element.arguments.map((arg) =>
-            arg.replace(`%${key}%`, actionOrOptions.variables![key]),
-          );
-        });
-      }
-
-      return this.actFromObserveResult(
-        element,
-        actionOrOptions.domSettleTimeoutMs,
-      );
-    };
-
-    // if no user defined timeoutMs, just do observeAct + actFromObserveResult
-    // with no timeout
-    if (!actionOrOptions.timeoutMs) {
-      return doObserveAndAct();
-    }
-
-    // Race observeAct + actFromObserveResult vs. the timeoutMs
-    const { timeoutMs } = actionOrOptions;
-    return await Promise.race([
-      doObserveAndAct(),
-      new Promise<ActResult>((resolve) => {
-        setTimeout(() => {
-          resolve({
-            success: false,
-            message: `Action timed out after ${timeoutMs}ms`,
-            action,
-          });
-        }, timeoutMs);
-      }),
-    ]);
-  }
-
-  private async _performPlaywrightMethod(
-    method: string,
-    args: unknown[],
-    xpath: string,
-    domSettleTimeoutMs?: number,
-  ) {
-    const locator = this.stagehandPage.page.locator(`xpath=${xpath}`).first();
-    const initialUrl = this.stagehandPage.page.url();
-
-    this.logger({
-      category: "action",
-      message: "performing playwright method",
-      level: 2,
-      auxiliary: {
-        xpath: { value: xpath, type: "string" },
-        method: { value: method, type: "string" },
-      },
-    });
-
-    const context: MethodHandlerContext = {
-      method,
-      locator,
-      xpath,
-      args,
-      logger: this.logger,
-      stagehandPage: this.stagehandPage,
-      initialUrl,
-      domSettleTimeoutMs,
-    };
-
-    try {
-      // 1) Look up a function in the map
-      const methodFn = methodHandlerMap[method];
-
-      // 2) If found, call it
-      if (methodFn) {
-        await methodFn(context);
-
-        // 3) Otherwise, see if it's a valid locator method
-      } else if (typeof locator[method as keyof Locator] === "function") {
-        await fallbackLocatorMethod(context);
-
-        // 4) If still unknown, we can’t handle it
-      } else {
-        this.logger({
-          category: "action",
-          message: "chosen method is invalid",
-          level: 1,
-          auxiliary: {
-            method: { value: method, type: "string" },
-          },
-        });
-        throw new PlaywrightCommandMethodNotSupportedException(
-          `Method ${method} not supported`,
-        );
-      }
-
-      // Always wait for DOM to settle
-      await this.stagehandPage._waitForSettledDom(domSettleTimeoutMs);
-    } catch (e) {
-      this.logger({
-        category: "action",
-        message: "error performing method",
-        level: 1,
-        auxiliary: {
-          error: { value: e.message, type: "string" },
-          trace: { value: e.stack, type: "string" },
-          method: { value: method, type: "string" },
-          xpath: { value: xpath, type: "string" },
-          args: { value: JSON.stringify(args), type: "object" },
-        },
-      });
-      throw new PlaywrightCommandException(e.message);
-    }
-  }
-}
diff --git a/lib/handlers/agentHandler.ts b/lib/handlers/agentHandler.ts
deleted file mode 100644
index 3bb0e0227..000000000
--- a/lib/handlers/agentHandler.ts
+++ /dev/null
@@ -1,671 +0,0 @@
-import { StagehandPage } from "../StagehandPage";
-import { AgentProvider } from "../agent/AgentProvider";
-import { StagehandAgent } from "../agent/StagehandAgent";
-import { AgentClient } from "../agent/AgentClient";
-import { LogLine } from "../../types/log";
-import { Page } from "playwright";
-import {
-  AgentExecuteOptions,
-  AgentAction,
-  AgentResult,
-  AgentHandlerOptions,
-  ActionExecutionResult,
-} from "@/types/agent";
-
-export class StagehandAgentHandler {
-  private stagehandPage: StagehandPage;
-  private agent: StagehandAgent;
-  private provider: AgentProvider;
-  private logger: (message: LogLine) => void;
-  private agentClient: AgentClient;
-  private options: AgentHandlerOptions;
-
-  constructor(
-    stagehandPage: StagehandPage,
-    logger: (message: LogLine) => void,
-    options: AgentHandlerOptions,
-  ) {
-    this.stagehandPage = stagehandPage;
-    this.logger = logger;
-    this.options = options;
-
-    // Initialize the provider
-    this.provider = new AgentProvider(logger);
-
-    // Create client first
-    const client = this.provider.getClient(
-      options.modelName,
-      options.clientOptions || {},
-      options.userProvidedInstructions,
-    );
-
-    // Store the client
-    this.agentClient = client;
-
-    // Set up common functionality for any client type
-    this.setupAgentClient();
-
-    // Create agent with the client
-    this.agent = new StagehandAgent(client, logger);
-  }
-
-  private setupAgentClient(): void {
-    // Set up screenshot provider for any client type
-    this.agentClient.setScreenshotProvider(async () => {
-      const screenshot = await this.stagehandPage.page.screenshot({
-        fullPage: false,
-      });
-      // Convert to base64
-      return screenshot.toString("base64");
-    });
-
-    // Set up action handler for any client type
-    this.agentClient.setActionHandler(async (action) => {
-      // Default delay between actions (1 second if not specified)
-      const defaultDelay = 1000;
-      // Use specified delay or default
-      const waitBetweenActions =
-        (this.options.clientOptions?.waitBetweenActions as number) ||
-        defaultDelay;
-
-      try {
-        // Try to inject cursor before each action
-        try {
-          await this.injectCursor();
-        } catch {
-          // Ignore cursor injection failures
-        }
-
-        // Add a small delay before the action for better visibility
-        await new Promise((resolve) => setTimeout(resolve, 500));
-
-        // Execute the action
-        await this.executeAction(action);
-
-        // Add a delay after the action for better visibility
-        await new Promise((resolve) => setTimeout(resolve, waitBetweenActions));
-
-        // After executing an action, take a screenshot
-        try {
-          await this.captureAndSendScreenshot();
-        } catch (error) {
-          const errorMessage =
-            error instanceof Error ? error.message : String(error);
-          this.logger({
-            category: "agent",
-            message: `Warning: Failed to take screenshot after action: ${errorMessage}. Continuing execution.`,
-            level: 1,
-          });
-          // Continue execution even if screenshot fails
-        }
-      } catch (error) {
-        const errorMessage =
-          error instanceof Error ? error.message : String(error);
-        this.logger({
-          category: "agent",
-          message: `Error executing action ${action.type}: ${errorMessage}`,
-          level: 0,
-        });
-        throw error; // Re-throw the error to be handled by the caller
-      }
-    });
-
-    // Update viewport and URL for any client type
-    this.updateClientViewport();
-    this.updateClientUrl();
-  }
-
-  /**
-   * Execute a task with the agent
-   */
-  async execute(
-    optionsOrInstruction: AgentExecuteOptions | string,
-  ): Promise<AgentResult> {
-    const options =
-      typeof optionsOrInstruction === "string"
-        ? { instruction: optionsOrInstruction }
-        : optionsOrInstruction;
-
-    //Redirect to Google if the URL is empty or about:blank
-    const currentUrl = this.stagehandPage.page.url();
-    if (!currentUrl || currentUrl === "about:blank") {
-      this.logger({
-        category: "agent",
-        message: `Page URL is empty or about:blank. Redirecting to www.google.com...`,
-        level: 0,
-      });
-      await this.stagehandPage.page.goto("https://www.google.com");
-    }
-
-    this.logger({
-      category: "agent",
-      message: `Executing agent task: ${options.instruction}`,
-      level: 1,
-    });
-
-    // Inject cursor for visual feedback
-    try {
-      await this.injectCursor();
-    } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-      this.logger({
-        category: "agent",
-        message: `Warning: Failed to inject cursor: ${errorMessage}. Continuing with execution.`,
-        level: 1,
-      });
-      // Continue execution even if cursor injection fails
-    }
-
-    // Take initial screenshot if needed
-    if (options.autoScreenshot !== false) {
-      try {
-        await this.captureAndSendScreenshot();
-      } catch (error) {
-        const errorMessage =
-          error instanceof Error ? error.message : String(error);
-        this.logger({
-          category: "agent",
-          message: `Warning: Failed to take initial screenshot: ${errorMessage}. Continuing with execution.`,
-          level: 1,
-        });
-        // Continue execution even if screenshot fails
-      }
-    }
-
-    // Execute the task
-    const result = await this.agent.execute(optionsOrInstruction);
-
-    // The actions are now executed during the agent's execution flow
-    // We don't need to execute them again here
-
-    return result;
-  }
-
-  /**
-   * Execute a single action on the page
-   */
-  private async executeAction(
-    action: AgentAction,
-  ): Promise<ActionExecutionResult> {
-    try {
-      switch (action.type) {
-        case "click": {
-          const { x, y, button = "left" } = action;
-          // Update cursor position first
-          await this.updateCursorPosition(x as number, y as number);
-          // Animate the click
-          await this.animateClick(x as number, y as number);
-          // Small delay to see the animation
-          await new Promise((resolve) => setTimeout(resolve, 300));
-          // Perform the actual click
-          await this.stagehandPage.page.mouse.click(x as number, y as number, {
-            button: button as "left" | "right",
-          });
-          const newOpenedTab = await Promise.race([
-            new Promise<Page | null>((resolve) => {
-              this.stagehandPage.context.once("page", (page) => resolve(page));
-              setTimeout(() => resolve(null), 1500);
-            }),
-          ]);
-          if (newOpenedTab) {
-            this.logger({
-              category: "action",
-              message: `New page detected (new tab) with URL. Opening on current page...`,
-              level: 1,
-              auxiliary: {
-                url: {
-                  value: newOpenedTab.url(),
-                  type: "string",
-                },
-              },
-            });
-            await newOpenedTab.close();
-            await this.stagehandPage.page.goto(newOpenedTab.url());
-            await this.stagehandPage.page.waitForURL(newOpenedTab.url());
-          }
-          return { success: true };
-        }
-
-        case "double_click": {
-          const { x, y } = action;
-          // Update cursor position first
-          await this.updateCursorPosition(x as number, y as number);
-          // Animate the click
-          await this.animateClick(x as number, y as number);
-          // Small delay to see the animation
-          await new Promise((resolve) => setTimeout(resolve, 200));
-          // Animate the second click
-          await this.animateClick(x as number, y as number);
-          // Small delay to see the animation
-          await new Promise((resolve) => setTimeout(resolve, 200));
-          // Perform the actual double click
-          await this.stagehandPage.page.mouse.dblclick(
-            x as number,
-            y as number,
-          );
-          return { success: true };
-        }
-
-        // Handle the case for "doubleClick" as well for backward compatibility
-        case "doubleClick": {
-          const { x, y } = action;
-          // Update cursor position first
-          await this.updateCursorPosition(x as number, y as number);
-          // Animate the click
-          await this.animateClick(x as number, y as number);
-          // Small delay to see the animation
-          await new Promise((resolve) => setTimeout(resolve, 200));
-          // Animate the second click
-          await this.animateClick(x as number, y as number);
-          // Small delay to see the animation
-          await new Promise((resolve) => setTimeout(resolve, 200));
-          // Perform the actual double click
-          await this.stagehandPage.page.mouse.dblclick(
-            x as number,
-            y as number,
-          );
-          return { success: true };
-        }
-
-        case "type": {
-          const { text } = action;
-          await this.stagehandPage.page.keyboard.type(text as string);
-          return { success: true };
-        }
-
-        case "keypress": {
-          const { keys } = action;
-          if (Array.isArray(keys)) {
-            for (const key of keys) {
-              // Handle special keys
-              if (key.includes("ENTER")) {
-                await this.stagehandPage.page.keyboard.press("Enter");
-              } else if (key.includes("SPACE")) {
-                await this.stagehandPage.page.keyboard.press(" ");
-              } else if (key.includes("TAB")) {
-                await this.stagehandPage.page.keyboard.press("Tab");
-              } else if (key.includes("ESCAPE") || key.includes("ESC")) {
-                await this.stagehandPage.page.keyboard.press("Escape");
-              } else if (key.includes("BACKSPACE")) {
-                await this.stagehandPage.page.keyboard.press("Backspace");
-              } else if (key.includes("DELETE")) {
-                await this.stagehandPage.page.keyboard.press("Delete");
-              } else if (key.includes("ARROW_UP")) {
-                await this.stagehandPage.page.keyboard.press("ArrowUp");
-              } else if (key.includes("ARROW_DOWN")) {
-                await this.stagehandPage.page.keyboard.press("ArrowDown");
-              } else if (key.includes("ARROW_LEFT")) {
-                await this.stagehandPage.page.keyboard.press("ArrowLeft");
-              } else if (key.includes("ARROW_RIGHT")) {
-                await this.stagehandPage.page.keyboard.press("ArrowRight");
-              } else {
-                // For other keys, use the existing conversion
-                const playwrightKey = this.convertKeyName(key);
-                await this.stagehandPage.page.keyboard.press(playwrightKey);
-              }
-            }
-          }
-          return { success: true };
-        }
-
-        case "scroll": {
-          const { x, y, scroll_x = 0, scroll_y = 0 } = action;
-          // First move to the position
-          await this.stagehandPage.page.mouse.move(x as number, y as number);
-          // Then scroll
-          await this.stagehandPage.page.evaluate(
-            ({ scrollX, scrollY }) => window.scrollBy(scrollX, scrollY),
-            { scrollX: scroll_x as number, scrollY: scroll_y as number },
-          );
-          return { success: true };
-        }
-
-        case "drag": {
-          const { path } = action;
-          if (Array.isArray(path) && path.length >= 2) {
-            const start = path[0];
-
-            // Update cursor position for start
-            await this.updateCursorPosition(start.x, start.y);
-            await this.stagehandPage.page.mouse.move(start.x, start.y);
-            await this.stagehandPage.page.mouse.down();
-
-            // Update cursor position for each point in the path
-            for (let i = 1; i < path.length; i++) {
-              await this.updateCursorPosition(path[i].x, path[i].y);
-              await this.stagehandPage.page.mouse.move(path[i].x, path[i].y);
-            }
-
-            await this.stagehandPage.page.mouse.up();
-          }
-          return { success: true };
-        }
-
-        case "move": {
-          const { x, y } = action;
-          // Update cursor position first
-          await this.updateCursorPosition(x as number, y as number);
-          await this.stagehandPage.page.mouse.move(x as number, y as number);
-          return { success: true };
-        }
-
-        case "wait": {
-          await new Promise((resolve) => setTimeout(resolve, 1000));
-          return { success: true };
-        }
-
-        case "screenshot": {
-          // Screenshot is handled automatically by the agent client
-          // after each action, so we don't need to do anything here
-          return { success: true };
-        }
-
-        case "function": {
-          const { name, arguments: args = {} } = action;
-
-          if (
-            name === "goto" &&
-            typeof args === "object" &&
-            args !== null &&
-            "url" in args
-          ) {
-            await this.stagehandPage.page.goto(args.url as string);
-            this.updateClientUrl();
-            return { success: true };
-          } else if (name === "back") {
-            await this.stagehandPage.page.goBack();
-            this.updateClientUrl();
-            return { success: true };
-          } else if (name === "forward") {
-            await this.stagehandPage.page.goForward();
-            this.updateClientUrl();
-            return { success: true };
-          } else if (name === "reload") {
-            await this.stagehandPage.page.reload();
-            this.updateClientUrl();
-            return { success: true };
-          }
-
-          return {
-            success: false,
-            error: `Unsupported function: ${name}`,
-          };
-        }
-
-        case "key": {
-          // Handle the 'key' action type from Anthropic
-          const { text } = action;
-          if (text === "Return" || text === "Enter") {
-            await this.stagehandPage.page.keyboard.press("Enter");
-          } else if (text === "Tab") {
-            await this.stagehandPage.page.keyboard.press("Tab");
-          } else if (text === "Escape" || text === "Esc") {
-            await this.stagehandPage.page.keyboard.press("Escape");
-          } else if (text === "Backspace") {
-            await this.stagehandPage.page.keyboard.press("Backspace");
-          } else {
-            // For other keys, try to press directly
-            await this.stagehandPage.page.keyboard.press(text as string);
-          }
-          return { success: true };
-        }
-
-        default:
-          return {
-            success: false,
-            error: `Unsupported action type: ${action.type}`,
-          };
-      }
-    } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-
-      this.logger({
-        category: "agent",
-        message: `Error executing action ${action.type}: ${errorMessage}`,
-        level: 0,
-      });
-
-      return {
-        success: false,
-        error: errorMessage,
-      };
-    }
-  }
-
-  private updateClientViewport(): void {
-    const viewportSize = this.stagehandPage.page.viewportSize();
-    if (viewportSize) {
-      this.agentClient.setViewport(viewportSize.width, viewportSize.height);
-    }
-  }
-
-  private updateClientUrl(): void {
-    const url = this.stagehandPage.page.url();
-    this.agentClient.setCurrentUrl(url);
-  }
-
-  getAgent(): StagehandAgent {
-    return this.agent;
-  }
-
-  getClient(): AgentClient {
-    return this.agentClient;
-  }
-
-  async captureAndSendScreenshot(): Promise<unknown> {
-    this.logger({
-      category: "agent",
-      message: "Taking screenshot and sending to agent",
-      level: 1,
-    });
-
-    try {
-      // Take screenshot of the current page
-      const screenshot = await this.stagehandPage.page.screenshot({
-        type: "png",
-        fullPage: false,
-      });
-
-      // Convert to base64
-      const base64Image = screenshot.toString("base64");
-
-      // Just use the captureScreenshot method on the agent client
-      return await this.agentClient.captureScreenshot({
-        base64Image,
-        currentUrl: this.stagehandPage.page.url(),
-      });
-    } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-      this.logger({
-        category: "agent",
-        message: `Error capturing screenshot: ${errorMessage}`,
-        level: 0,
-      });
-      return null;
-    }
-  }
-
-  /**
-   * Inject a cursor element into the page for visual feedback
-   */
-  private async injectCursor(): Promise<void> {
-    try {
-      // Define constants for cursor and highlight element IDs
-      const CURSOR_ID = "stagehand-cursor";
-      const HIGHLIGHT_ID = "stagehand-highlight";
-
-      // Check if cursor already exists
-      const cursorExists = await this.stagehandPage.page.evaluate(
-        (id: string) => {
-          return !!document.getElementById(id);
-        },
-        CURSOR_ID,
-      );
-
-      if (cursorExists) {
-        return;
-      }
-
-      // Inject cursor and highlight elements
-      await this.stagehandPage.page.evaluate(`
-        (function(cursorId, highlightId) {
-          // Create cursor element
-          const cursor = document.createElement('div');
-          cursor.id = cursorId;
-          
-          // Use the provided SVG for a custom cursor
-          cursor.innerHTML = \`
-          <svg xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 28 28" width="28" height="28">
-            <polygon fill="#000000" points="9.2,7.3 9.2,18.5 12.2,15.6 12.6,15.5 17.4,15.5"/>
-            <rect x="12.5" y="13.6" transform="matrix(0.9221 -0.3871 0.3871 0.9221 -5.7605 6.5909)" width="2" height="8" fill="#000000"/>
-          </svg>
-          \`;
-          
-          // Style the cursor
-          cursor.style.position = 'absolute';
-          cursor.style.top = '0';
-          cursor.style.left = '0';
-          cursor.style.width = '28px';
-          cursor.style.height = '28px';
-          cursor.style.pointerEvents = 'none';
-          cursor.style.zIndex = '9999999';
-          cursor.style.transform = 'translate(-4px, -4px)'; // Adjust to align the pointer tip
-          
-          // Create highlight element for click animation
-          const highlight = document.createElement('div');
-          highlight.id = highlightId;
-          highlight.style.position = 'absolute';
-          highlight.style.width = '20px';
-          highlight.style.height = '20px';
-          highlight.style.borderRadius = '50%';
-          highlight.style.backgroundColor = 'rgba(66, 134, 244, 0)';
-          highlight.style.transform = 'translate(-50%, -50%) scale(0)';
-          highlight.style.pointerEvents = 'none';
-          highlight.style.zIndex = '9999998';
-          highlight.style.transition = 'transform 0.3s ease-out, opacity 0.3s ease-out';
-          highlight.style.opacity = '0';
-          
-          // Add elements to the document
-          document.body.appendChild(cursor);
-          document.body.appendChild(highlight);
-          
-          // Add a function to update cursor position
-          window.__updateCursorPosition = function(x, y) {
-            if (cursor) {
-              cursor.style.transform = \`translate(\${x - 4}px, \${y - 4}px)\`;
-            }
-          };
-          
-          // Add a function to animate click
-          window.__animateClick = function(x, y) {
-            if (highlight) {
-              highlight.style.left = \`\${x}px\`;
-              highlight.style.top = \`\${y}px\`;
-              highlight.style.transform = 'translate(-50%, -50%) scale(1)';
-              highlight.style.opacity = '1';
-              
-              setTimeout(() => {
-                highlight.style.transform = 'translate(-50%, -50%) scale(0)';
-                highlight.style.opacity = '0';
-              }, 300);
-            }
-          };
-        })('${CURSOR_ID}', '${HIGHLIGHT_ID}');
-      `);
-
-      this.logger({
-        category: "agent",
-        message: "Cursor injected for visual feedback",
-        level: 1,
-      });
-    } catch (error) {
-      this.logger({
-        category: "agent",
-        message: `Failed to inject cursor: ${error}`,
-        level: 0,
-      });
-    }
-  }
-
-  /**
-   * Update the cursor position on the page
-   */
-  private async updateCursorPosition(x: number, y: number): Promise<void> {
-    try {
-      await this.stagehandPage.page.evaluate(
-        ({ x, y }) => {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          if ((window as any).__updateCursorPosition) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            (window as any).__updateCursorPosition(x, y);
-          }
-        },
-        { x, y },
-      );
-    } catch {
-      // Silently fail if cursor update fails
-      // This is not critical functionality
-    }
-  }
-
-  /**
-   * Animate a click at the given position
-   */
-  private async animateClick(x: number, y: number): Promise<void> {
-    try {
-      await this.stagehandPage.page.evaluate(
-        ({ x, y }) => {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          if ((window as any).__animateClick) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            (window as any).__animateClick(x, y);
-          }
-        },
-        { x, y },
-      );
-    } catch {
-      // Silently fail if animation fails
-      // This is not critical functionality
-    }
-  }
-
-  private convertKeyName(key: string): string {
-    // Map of CUA key names to Playwright key names
-    const keyMap: Record<string, string> = {
-      ENTER: "Enter",
-      ESCAPE: "Escape",
-      BACKSPACE: "Backspace",
-      TAB: "Tab",
-      SPACE: " ",
-      ARROWUP: "ArrowUp",
-      ARROWDOWN: "ArrowDown",
-      ARROWLEFT: "ArrowLeft",
-      ARROWRIGHT: "ArrowRight",
-      UP: "ArrowUp",
-      DOWN: "ArrowDown",
-      LEFT: "ArrowLeft",
-      RIGHT: "ArrowRight",
-      SHIFT: "Shift",
-      CONTROL: "Control",
-      ALT: "Alt",
-      META: "Meta",
-      COMMAND: "Meta",
-      CMD: "Meta",
-      CTRL: "Control",
-      DELETE: "Delete",
-      HOME: "Home",
-      END: "End",
-      PAGEUP: "PageUp",
-      PAGEDOWN: "PageDown",
-    };
-
-    // Convert to uppercase for case-insensitive matching
-    const upperKey = key.toUpperCase();
-
-    // Return the mapped key or the original key if not found
-    return keyMap[upperKey] || key;
-  }
-}
diff --git a/lib/handlers/extractHandler.ts b/lib/handlers/extractHandler.ts
deleted file mode 100644
index 085d09c79..000000000
--- a/lib/handlers/extractHandler.ts
+++ /dev/null
@@ -1,896 +0,0 @@
-import { z, ZodTypeAny } from "zod";
-import { LogLine } from "../../types/log";
-import { ZodPathSegments } from "../../types/stagehand";
-import { TextAnnotation } from "../../types/textannotation";
-import { extract } from "../inference";
-import { LLMClient } from "../llm/LLMClient";
-import { formatText } from "../utils";
-import { StagehandPage } from "../StagehandPage";
-import { Stagehand, StagehandFunctionName } from "../index";
-import { pageTextSchema } from "../../types/page";
-import { getAccessibilityTree } from "@/lib/a11y/utils";
-
-const PROXIMITY_THRESHOLD = 15;
-
-/**
- * The `StagehandExtractHandler` class is responsible for extracting structured data from a webpage.
- * It provides two approaches: `textExtract` and `domExtract`. `textExtract` is used by default.
- *
- * Here is what `textExtract` does at a high level:
- *
- * **1. Wait for the DOM to settle and start DOM debugging.**
- *    - Ensures the page is fully loaded and stable before extraction.
- *
- * **2. Store the original DOM before any mutations.**
- *    - Preserves the initial state of the DOM to restore later.
- *    - We do this because creating spans around every word in the DOM (see step 4)
- *      becomes very difficult to revert. Text nodes can be finicky, and directly
- *      removing the added spans often corrupts the structure of the DOM.
- *
- * **3. Process the DOM to generate a selector map of candidate elements.**
- *    - Identifies potential elements that contain the data to extract.
- *
- * **4. Create text bounding boxes around every word in the webpage.**
- *    - Wraps words in spans so that their bounding boxes can be used to
- *      determine their positions on the text-rendered-webpage.
- *
- * **5. Collect all text annotations (with positions and dimensions) from each of the candidate elements.**
- *    - Gathers text and positional data for each word.
- *
- * **6. Group annotations by text and deduplicate them based on proximity.**
- *    - There is no guarantee that the text annotations are unique (candidate elements can be nested).
- *    - Thus, we must remove duplicate words that are close to each other on the page.
- *
- * **7. Restore the original DOM after mutations.**
- *    - Returns the DOM to its original state after processing.
- *
- * **8. Format the deduplicated annotations into a text representation.**
- *    - Prepares the text data for the extraction process.
- *
- * **9. Pass the formatted text to an LLM for extraction according to the given instruction and schema.**
- *    - Uses a language model to extract structured data based on instructions.
- *
- * **10. Handle the extraction response and logging the results.**
- *     - Processes the output from the LLM and logs relevant information.
- *
- * @remarks
- * Each step corresponds to specific code segments, as noted in the comments throughout the code.
- */
-
-export class StagehandExtractHandler {
-  private readonly stagehand: Stagehand;
-  private readonly stagehandPage: StagehandPage;
-  private readonly logger: (logLine: LogLine) => void;
-  private readonly userProvidedInstructions?: string;
-
-  constructor({
-    stagehand,
-    logger,
-    stagehandPage,
-    userProvidedInstructions,
-  }: {
-    stagehand: Stagehand;
-    logger: (message: {
-      category?: string;
-      message: string;
-      level?: number;
-      auxiliary?: { [key: string]: { value: string; type: string } };
-    }) => void;
-    stagehandPage: StagehandPage;
-    userProvidedInstructions?: string;
-  }) {
-    this.stagehand = stagehand;
-    this.logger = logger;
-    this.stagehandPage = stagehandPage;
-    this.userProvidedInstructions = userProvidedInstructions;
-  }
-
-  public async extract<T extends z.AnyZodObject>({
-    instruction,
-    schema,
-    content = {},
-    llmClient,
-    requestId,
-    domSettleTimeoutMs,
-    useTextExtract = false,
-    selector,
-  }: {
-    instruction?: string;
-    schema?: T;
-    content?: z.infer<T>;
-    chunksSeen?: Array<number>;
-    llmClient?: LLMClient;
-    requestId?: string;
-    domSettleTimeoutMs?: number;
-    useTextExtract?: boolean;
-    selector?: string;
-  } = {}): Promise<z.infer<T>> {
-    const noArgsCalled = !instruction && !schema && !llmClient && !selector;
-    if (noArgsCalled) {
-      this.logger({
-        category: "extraction",
-        message: "Extracting the entire page text.",
-        level: 1,
-      });
-      return this.extractPageText();
-    }
-
-    if (useTextExtract) {
-      return this.textExtract({
-        instruction,
-        schema,
-        content,
-        llmClient,
-        requestId,
-        domSettleTimeoutMs,
-        selector,
-      });
-    } else {
-      return this.domExtract({
-        instruction,
-        schema,
-        content,
-        llmClient,
-        requestId,
-        domSettleTimeoutMs,
-      });
-    }
-  }
-
-  private async extractPageText(): Promise<{ page_text?: string }> {
-    await this.stagehandPage._waitForSettledDom();
-
-    const originalDOM = await this.stagehandPage.page.evaluate(() =>
-      window.storeDOM(undefined),
-    );
-
-    const { selectorMap }: { selectorMap: Record<number, string[]> } =
-      await this.stagehand.page.evaluate(() =>
-        window.processAllOfDom(undefined),
-      );
-
-    await this.stagehand.page.evaluate(() =>
-      window.createTextBoundingBoxes(undefined),
-    );
-
-    const containerDims = await this.getTargetDimensions();
-
-    const allAnnotations = await this.collectAllAnnotations(
-      selectorMap,
-      containerDims.width,
-      containerDims.height,
-      containerDims.offsetLeft,
-      containerDims.offsetTop,
-    );
-
-    const deduplicatedTextAnnotations =
-      this.deduplicateAnnotations(allAnnotations);
-
-    await this.stagehandPage.page.evaluate(
-      (dom) => window.restoreDOM(dom, undefined),
-      originalDOM,
-    );
-
-    const formattedText = formatText(
-      deduplicatedTextAnnotations,
-      containerDims.width,
-    );
-
-    const result = { page_text: formattedText };
-    return pageTextSchema.parse(result);
-  }
-
-  private async textExtract<T extends z.AnyZodObject>({
-    instruction,
-    schema,
-    content = {},
-    llmClient,
-    requestId,
-    domSettleTimeoutMs,
-    selector,
-  }: {
-    instruction?: string;
-    schema?: T;
-    content?: z.infer<T>;
-    llmClient?: LLMClient;
-    requestId?: string;
-    domSettleTimeoutMs?: number;
-    selector?: string;
-  }): Promise<z.infer<T>> {
-    this.logger({
-      category: "extraction",
-      message: "starting extraction",
-      level: 1,
-      auxiliary: {
-        instruction: {
-          value: instruction,
-          type: "string",
-        },
-      },
-    });
-
-    // **1:** Wait for the DOM to settle and start DOM debugging
-    await this.stagehandPage._waitForSettledDom(domSettleTimeoutMs);
-
-    const targetXpath = selector?.replace(/^xpath=/, "") ?? "";
-
-    // **2:** Store the original DOM before any mutations
-    // we need to store the original DOM here because calling createTextBoundingBoxes()
-    // will mutate the DOM by adding spans around every word
-    const originalDOM = await this.stagehandPage.page.evaluate(
-      (xp) => window.storeDOM(xp),
-      targetXpath,
-    );
-
-    // **3:** Process the DOM to generate a selector map of candidate elements
-    const { selectorMap }: { selectorMap: Record<number, string[]> } =
-      await this.stagehand.page.evaluate(
-        (xp) => window.processAllOfDom(xp),
-        targetXpath,
-      );
-
-    this.logger({
-      category: "extraction",
-      message: `received output from processAllOfDom. selectorMap has ${
-        Object.keys(selectorMap).length
-      } entries`,
-      level: 1,
-    });
-
-    // **4:** Create text bounding boxes around every word in the webpage
-    // calling createTextBoundingBoxes() will create a span around every word on the
-    // webpage. The bounding boxes of these spans will be used to determine their
-    // positions in the text rendered webpage
-    await this.stagehand.page.evaluate(
-      (xp) => window.createTextBoundingBoxes(xp),
-      targetXpath,
-    );
-
-    // **5:** Determine the container dimensions for either the entire page or the target element
-    const {
-      width: containerWidth,
-      height: containerHeight,
-      offsetLeft = 0,
-      offsetTop = 0,
-    } = await this.getTargetDimensions(targetXpath);
-
-    // **6:** Collect all text annotations (with positions and dimensions) from the candidate elements
-    // allAnnotations will store all the TextAnnotations BEFORE deduplication
-    const allAnnotations = await this.collectAllAnnotations(
-      selectorMap,
-      containerWidth,
-      containerHeight,
-      offsetLeft,
-      offsetTop,
-    );
-
-    // **7:** Group annotations by text and deduplicate them based on proximity
-    const annotationsGroupedByText = new Map<string, TextAnnotation[]>();
-
-    for (const annotation of allAnnotations) {
-      if (!annotationsGroupedByText.has(annotation.text)) {
-        annotationsGroupedByText.set(annotation.text, []);
-      }
-      annotationsGroupedByText.get(annotation.text)!.push(annotation);
-    }
-
-    const deduplicatedTextAnnotations: TextAnnotation[] = [];
-
-    // here, we deduplicate annotations per text group
-    for (const [text, annotations] of annotationsGroupedByText.entries()) {
-      for (const annotation of annotations) {
-        // check if this annotation is close to any existing deduplicated annotation
-        const isDuplicate = deduplicatedTextAnnotations.some(
-          (existingAnnotation) => {
-            if (existingAnnotation.text !== text) return false;
-
-            const dx =
-              existingAnnotation.bottom_left.x - annotation.bottom_left.x;
-            const dy =
-              existingAnnotation.bottom_left.y - annotation.bottom_left.y;
-            const distance = Math.hypot(dx, dy);
-            // the annotation is a duplicate if it has the same text and its bottom_left
-            // position is within the PROXIMITY_THRESHOLD of an existing annotation.
-            // we calculate the Euclidean distance between the two bottom_left points,
-            // and if the distance is less than PROXIMITY_THRESHOLD,
-            // the annotation is considered a duplicate.
-            return distance < PROXIMITY_THRESHOLD;
-          },
-        );
-
-        if (!isDuplicate) {
-          deduplicatedTextAnnotations.push(annotation);
-        }
-      }
-    }
-
-    // **8:** Restore the original DOM after mutations
-    await this.stagehandPage.page.evaluate(
-      ({ dom, xp }) => window.restoreDOM(dom, xp),
-      { dom: originalDOM, xp: targetXpath },
-    );
-
-    // **9:** Format the deduplicated annotations into a text representation
-    const formattedText = formatText(
-      deduplicatedTextAnnotations,
-      containerWidth,
-    );
-
-    // **10:** Pass the formatted text to an LLM for extraction according to the given instruction and schema
-    const extractionResponse = await extract({
-      instruction,
-      previouslyExtractedContent: content,
-      domElements: formattedText,
-      schema,
-      chunksSeen: 1,
-      chunksTotal: 1,
-      llmClient,
-      requestId,
-      userProvidedInstructions: this.userProvidedInstructions,
-      logger: this.logger,
-      logInferenceToFile: this.stagehand.logInferenceToFile,
-    });
-
-    const {
-      metadata: { completed },
-      prompt_tokens: promptTokens,
-      completion_tokens: completionTokens,
-      inference_time_ms: inferenceTimeMs,
-      ...output
-    } = extractionResponse;
-
-    this.stagehand.updateMetrics(
-      StagehandFunctionName.EXTRACT,
-      promptTokens,
-      completionTokens,
-      inferenceTimeMs,
-    );
-
-    // **11:** Handle the extraction response and log the results
-    this.logger({
-      category: "extraction",
-      message: "received extraction response",
-      auxiliary: {
-        extraction_response: {
-          value: JSON.stringify(extractionResponse),
-          type: "object",
-        },
-      },
-    });
-
-    if (completed) {
-      this.logger({
-        category: "extraction",
-        message: "extraction completed successfully",
-        level: 1,
-        auxiliary: {
-          extraction_response: {
-            value: JSON.stringify(extractionResponse),
-            type: "object",
-          },
-        },
-      });
-    } else {
-      this.logger({
-        category: "extraction",
-        message: "extraction incomplete after processing all data",
-        level: 1,
-        auxiliary: {
-          extraction_response: {
-            value: JSON.stringify(extractionResponse),
-            type: "object",
-          },
-        },
-      });
-    }
-    return output;
-  }
-
-  private async domExtract<T extends z.AnyZodObject>({
-    instruction,
-    schema,
-    content = {},
-    llmClient,
-    requestId,
-    domSettleTimeoutMs,
-  }: {
-    instruction: string;
-    schema: T;
-    content?: z.infer<T>;
-    llmClient: LLMClient;
-    requestId?: string;
-    domSettleTimeoutMs?: number;
-  }): Promise<z.infer<T>> {
-    this.logger({
-      category: "extraction",
-      message: "starting extraction using a11y tree",
-      level: 1,
-      auxiliary: {
-        instruction: {
-          value: instruction,
-          type: "string",
-        },
-      },
-    });
-
-    await this.stagehandPage._waitForSettledDom(domSettleTimeoutMs);
-    const tree = await getAccessibilityTree(this.stagehandPage, this.logger);
-    this.logger({
-      category: "extraction",
-      message: "Getting accessibility tree data",
-      level: 1,
-    });
-    const outputString = tree.simplified;
-    const idToUrlMapping = tree.idToUrl;
-
-    // Transform user defined schema to replace string().url() with .number()
-    const [transformedSchema, urlFieldPaths] =
-      transformUrlStringsToNumericIds(schema);
-
-    // call extract inference with transformed schema
-    const extractionResponse = await extract({
-      instruction,
-      previouslyExtractedContent: content,
-      domElements: outputString,
-      schema: transformedSchema,
-      chunksSeen: 1,
-      chunksTotal: 1,
-      llmClient,
-      requestId,
-      userProvidedInstructions: this.userProvidedInstructions,
-      logger: this.logger,
-      logInferenceToFile: this.stagehand.logInferenceToFile,
-    });
-
-    const {
-      metadata: { completed },
-      prompt_tokens: promptTokens,
-      completion_tokens: completionTokens,
-      inference_time_ms: inferenceTimeMs,
-      ...output
-    } = extractionResponse;
-
-    this.stagehand.updateMetrics(
-      StagehandFunctionName.EXTRACT,
-      promptTokens,
-      completionTokens,
-      inferenceTimeMs,
-    );
-
-    this.logger({
-      category: "extraction",
-      message: "received extraction response",
-      auxiliary: {
-        extraction_response: {
-          value: JSON.stringify(extractionResponse),
-          type: "object",
-        },
-      },
-    });
-
-    if (completed) {
-      this.logger({
-        category: "extraction",
-        message: "extraction completed successfully",
-        level: 1,
-        auxiliary: {
-          extraction_response: {
-            value: JSON.stringify(extractionResponse),
-            type: "object",
-          },
-        },
-      });
-    } else {
-      this.logger({
-        category: "extraction",
-        message: "extraction incomplete after processing all data",
-        level: 1,
-        auxiliary: {
-          extraction_response: {
-            value: JSON.stringify(extractionResponse),
-            type: "object",
-          },
-        },
-      });
-    }
-
-    // revert to original schema and populate with URLs
-    for (const { segments } of urlFieldPaths) {
-      injectUrls(output, segments, idToUrlMapping);
-    }
-
-    return output as z.infer<T>;
-  }
-  /**
-   * Get the width, height, and offsets of either the entire page or a specific element.
-   * (Matches your existing getTargetDimensions logic, just adapted to accept a string | undefined.)
-   */
-  private async getTargetDimensions(targetXpath?: string): Promise<{
-    width: number;
-    height: number;
-    offsetLeft: number;
-    offsetTop: number;
-  }> {
-    // If targetXpath is undefined, get entire page dimensions
-    if (!targetXpath) {
-      const { innerWidth, innerHeight } = await this.stagehand.page.evaluate(
-        () => ({
-          innerWidth: window.innerWidth,
-          innerHeight: window.innerHeight,
-        }),
-      );
-      return {
-        width: innerWidth,
-        height: innerHeight,
-        offsetLeft: 0,
-        offsetTop: 0,
-      };
-    }
-
-    // If targetXpath is present, get element-specific dimensions
-    const { elemWidth, elemHeight, offsetLeft, offsetTop } =
-      await this.stagehand.page.evaluate((xp) => {
-        const el = window.getNodeFromXpath(xp) as HTMLElement | null;
-
-        if (!el) {
-          return {
-            elemWidth: window.innerWidth,
-            elemHeight: window.innerHeight,
-            offsetLeft: 0,
-            offsetTop: 0,
-          };
-        }
-
-        const rect = el.getBoundingClientRect();
-        return {
-          elemWidth: rect.width,
-          elemHeight: rect.height,
-          offsetLeft: rect.left,
-          offsetTop: rect.top,
-        };
-      }, targetXpath);
-
-    return {
-      width: elemWidth,
-      height: elemHeight,
-      offsetLeft,
-      offsetTop,
-    };
-  }
-
-  /**
-   * Collects the bounding boxes for each word inside each of the candidate element in selectorMap,
-   * adjusting for container offsets, and producing an array of TextAnnotations.
-   */
-  private async collectAllAnnotations(
-    selectorMap: Record<number, string[]>,
-    containerWidth: number,
-    containerHeight: number,
-    offsetLeft: number,
-    offsetTop: number,
-  ): Promise<TextAnnotation[]> {
-    const allAnnotations: TextAnnotation[] = [];
-
-    // Loop over the candidate XPaths in the selector map
-    for (const xpaths of Object.values(selectorMap)) {
-      const xpath = xpaths[0];
-
-      // Evaluate in the browser to get bounding boxes
-      const boundingBoxes: Array<{
-        text: string;
-        left: number;
-        top: number;
-        width: number;
-        height: number;
-      }> = await this.stagehandPage.page.evaluate(
-        (xp) => window.getElementBoundingBoxes(xp),
-        xpath,
-      );
-
-      for (const box of boundingBoxes) {
-        // 1. Subtract container offsets to get local coordinates
-        const localLeft = box.left - offsetLeft;
-        const localTop = box.top - offsetTop;
-
-        // 2. bottom_left is local x, plus local y + height
-        //    so the baseline is at the bottom edge of the box
-        const bottom_left = { x: localLeft, y: localTop + box.height };
-
-        // 3. Normalize by dividing local positions by container width/height
-        const bottom_left_normalized = {
-          x: localLeft / containerWidth,
-          y: (localTop + box.height) / containerHeight,
-        };
-
-        if (box.text.trim().length > 0) {
-          allAnnotations.push({
-            text: box.text,
-            bottom_left,
-            bottom_left_normalized,
-            width: box.width,
-            height: box.height,
-          });
-        }
-      }
-    }
-
-    return allAnnotations;
-  }
-
-  /**
-   * Deduplicate text annotations by grouping them by text, then removing duplicates
-   * within a certain proximity threshold.
-   */
-  private deduplicateAnnotations(
-    annotations: TextAnnotation[],
-  ): TextAnnotation[] {
-    const annotationsGroupedByText = new Map<string, TextAnnotation[]>();
-    const deduplicated: TextAnnotation[] = [];
-
-    for (const annotation of annotations) {
-      if (!annotationsGroupedByText.has(annotation.text)) {
-        annotationsGroupedByText.set(annotation.text, []);
-      }
-      annotationsGroupedByText.get(annotation.text)!.push(annotation);
-    }
-
-    for (const [text, group] of annotationsGroupedByText.entries()) {
-      for (const annotation of group) {
-        const isDuplicate = deduplicated.some((existing) => {
-          if (existing.text !== text) return false;
-
-          const dx = existing.bottom_left.x - annotation.bottom_left.x;
-          const dy = existing.bottom_left.y - annotation.bottom_left.y;
-          const distance = Math.hypot(dx, dy);
-          return distance < PROXIMITY_THRESHOLD;
-        });
-
-        if (!isDuplicate) {
-          deduplicated.push(annotation);
-        }
-      }
-    }
-
-    return deduplicated;
-  }
-}
-
-/**
- * Scans the provided Zod schema for any `z.string().url()` fields and
- * replaces them with `z.number()`.
- *
- * @param schema - The Zod object schema to transform.
- * @returns A tuple containing:
- *   1. The transformed schema (or the original schema if no changes were needed).
- *   2. An array of {@link ZodPathSegments} objects representing all the replaced URL fields,
- *      with each path segment showing where in the schema the replacement occurred.
- */
-export function transformUrlStringsToNumericIds<
-  T extends z.ZodObject<z.ZodRawShape>,
->(schema: T): [T, ZodPathSegments[]] {
-  const shape = schema._def.shape();
-  const newShape: Record<string, ZodTypeAny> = {};
-  const urlPaths: ZodPathSegments[] = [];
-  let changed = false;
-
-  for (const [key, value] of Object.entries(shape)) {
-    const [childTransformed, childPaths] = transformSchema(value, [key]);
-    newShape[key] = childTransformed;
-    if (childTransformed !== value) {
-      changed = true;
-    }
-    if (childPaths.length > 0) {
-      childPaths.forEach((cp) => {
-        urlPaths.push({ segments: [key, ...cp.segments] });
-      });
-    }
-  }
-
-  const finalSchema = changed ? z.object(newShape) : schema;
-  return [finalSchema as T, urlPaths];
-}
-
-/**
- * Recursively traverses a given Zod schema, scanning for any fields of type `z.string().url()`.
- * For each such field, it replaces the `z.string().url()` with `z.number()`.
- *
- * This function is used internally by higher-level utilities (e.g., transforming entire object schemas)
- * and handles nested objects, arrays, unions, intersections, optionals.
- *
- * @param schema - The Zod schema to transform.
- * @param currentPath - An array of string/number keys representing the current schema path (used internally for recursion).
- * @returns A two-element tuple:
- *   1. The updated Zod schema, with any `.url()` fields replaced by `z.number()`.
- *   2. An array of {@link ZodPathSegments} objects representing each replaced field, including the path segments.
- */
-export function transformSchema(
-  schema: ZodTypeAny,
-  currentPath: Array<string | number>,
-): [ZodTypeAny, ZodPathSegments[]] {
-  // 1) If it's a string with .url(), convert to z.number()
-  if (schema instanceof z.ZodString) {
-    const hasUrlCheck =
-      schema._def.checks?.some((check) => check.kind === "url") ?? false;
-    if (hasUrlCheck) {
-      return [
-        z.number().describe("ID of element that points to a URL"),
-        [{ segments: [] }],
-      ];
-    }
-    return [schema, []];
-  }
-
-  // 2) If it's an object, transform each field
-  if (schema instanceof z.ZodObject) {
-    // The shape is a raw object containing fields keyed by string (no symbols):
-    const shape = schema._def.shape() as Record<string, ZodTypeAny>;
-    const newShape: Record<string, ZodTypeAny> = {};
-    const urlPaths: ZodPathSegments[] = [];
-    let changed = false;
-
-    const shapeKeys = Object.keys(shape);
-
-    for (const key of shapeKeys) {
-      const child = shape[key];
-      const [transformedChild, childPaths] = transformSchema(child, [
-        ...currentPath,
-        key,
-      ]);
-
-      if (transformedChild !== child) {
-        changed = true;
-      }
-      newShape[key] = transformedChild;
-
-      if (childPaths.length > 0) {
-        for (const cp of childPaths) {
-          urlPaths.push({ segments: [key, ...cp.segments] });
-        }
-      }
-    }
-
-    if (changed) {
-      return [z.object(newShape), urlPaths];
-    }
-    return [schema, urlPaths];
-  }
-
-  // 3) If it's an array, transform its item type
-  if (schema instanceof z.ZodArray) {
-    const itemType = schema._def.type as ZodTypeAny;
-    const [transformedItem, childPaths] = transformSchema(itemType, [
-      ...currentPath,
-      "*",
-    ]);
-    const changed = transformedItem !== itemType;
-    const arrayPaths: ZodPathSegments[] = childPaths.map((cp) => ({
-      segments: ["*", ...cp.segments],
-    }));
-
-    if (changed) {
-      return [z.array(transformedItem), arrayPaths];
-    }
-    return [schema, arrayPaths];
-  }
-
-  // 4) If it's a union, transform each option
-  if (schema instanceof z.ZodUnion) {
-    // Cast the union’s options to an array of ZodTypeAny
-    const unionOptions = schema._def.options as ZodTypeAny[];
-    const newOptions: ZodTypeAny[] = [];
-    let changed = false;
-    let allPaths: ZodPathSegments[] = [];
-
-    unionOptions.forEach((option: ZodTypeAny, idx: number) => {
-      const [newOption, childPaths] = transformSchema(option, [
-        ...currentPath,
-        `union_${idx}`,
-      ]);
-      if (newOption !== option) {
-        changed = true;
-      }
-      newOptions.push(newOption);
-      allPaths = [...allPaths, ...childPaths];
-    });
-
-    if (changed) {
-      // We assume at least two options remain:
-      return [
-        z.union(newOptions as [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]),
-        allPaths,
-      ];
-    }
-    return [schema, allPaths];
-  }
-
-  // 5) If it's an intersection, transform left and right
-  if (schema instanceof z.ZodIntersection) {
-    const leftType = schema._def.left as ZodTypeAny;
-    const rightType = schema._def.right as ZodTypeAny;
-
-    const [left, leftPaths] = transformSchema(leftType, [
-      ...currentPath,
-      "intersection_left",
-    ]);
-    const [right, rightPaths] = transformSchema(rightType, [
-      ...currentPath,
-      "intersection_right",
-    ]);
-    const changed = left !== leftType || right !== rightType;
-    const allPaths = [...leftPaths, ...rightPaths];
-    if (changed) {
-      return [z.intersection(left, right), allPaths];
-    }
-    return [schema, allPaths];
-  }
-
-  // 6) If it's optional, transform inner
-  if (schema instanceof z.ZodOptional) {
-    const innerType = schema._def.innerType as ZodTypeAny;
-    const [inner, innerPaths] = transformSchema(innerType, currentPath);
-    if (inner !== innerType) {
-      return [z.optional(inner), innerPaths];
-    }
-    return [schema, innerPaths];
-  }
-
-  // 7) If it's nullable, transform inner
-  if (schema instanceof z.ZodNullable) {
-    const innerType = schema._def.innerType as ZodTypeAny;
-    const [inner, innerPaths] = transformSchema(innerType, currentPath);
-    if (inner !== innerType) {
-      return [z.nullable(inner), innerPaths];
-    }
-    return [schema, innerPaths];
-  }
-
-  // 8) If it's an effect, transform base schema
-  if (schema instanceof z.ZodEffects) {
-    const baseSchema = schema._def.schema as ZodTypeAny;
-    const [newBaseSchema, basePaths] = transformSchema(baseSchema, currentPath);
-    if (newBaseSchema !== baseSchema) {
-      return [z.effect(newBaseSchema, schema._def.effect), basePaths];
-    }
-    return [schema, basePaths];
-  }
-
-  // 9) If none of the above, return as-is
-  return [schema, []];
-}
-
-/**
- * Once we get the final extracted object that has numeric IDs in place of URLs,
- * use `injectUrls` to walk the object and replace numeric IDs
- * with the real URL strings from idToUrlMapping. The `path` may include `*`
- * for array indices (indicating "all items in the array").
- */
-export function injectUrls(
-  obj: unknown,
-  path: Array<string | number>,
-  idToUrlMapping: Record<string, string>,
-): void {
-  if (path.length === 0) return;
-  const [key, ...rest] = path;
-
-  if (key === "*") {
-    if (Array.isArray(obj)) {
-      for (const item of obj) {
-        injectUrls(item, rest, idToUrlMapping);
-      }
-    }
-    return;
-  }
-
-  if (obj && typeof obj === "object") {
-    const record = obj as Record<string | number, unknown>;
-    if (path.length === 1) {
-      const fieldValue = record[key];
-      if (typeof fieldValue === "number") {
-        const mappedUrl = idToUrlMapping[String(fieldValue)];
-        record[key] = mappedUrl ?? ``;
-      }
-    } else {
-      injectUrls(record[key], rest, idToUrlMapping);
-    }
-  }
-}
diff --git a/lib/handlers/handlerUtils/actHandlerUtils.ts b/lib/handlers/handlerUtils/actHandlerUtils.ts
deleted file mode 100644
index 3cc41acc0..000000000
--- a/lib/handlers/handlerUtils/actHandlerUtils.ts
+++ /dev/null
@@ -1,570 +0,0 @@
-import { Page, Locator, errors as PlaywrightErrors } from "@playwright/test";
-import { PlaywrightCommandException } from "../../../types/playwright";
-import { StagehandPage } from "../../StagehandPage";
-import { getNodeFromXpath } from "@/lib/dom/utils";
-import { Logger } from "../../../types/log";
-import { MethodHandlerContext } from "@/types/act";
-
-/**
- * A mapping of playwright methods that may be chosen by the LLM to their
- * implementation.
- */
-export const methodHandlerMap: Record<
-  string,
-  (ctx: MethodHandlerContext) => Promise<void>
-> = {
-  scrollIntoView: scrollElementIntoView,
-  scrollTo: scrollElementToPercentage,
-  scroll: scrollElementToPercentage,
-  "mouse.wheel": scrollElementToPercentage,
-  fill: fillOrType,
-  type: fillOrType,
-  press: pressKey,
-  click: clickElement,
-  nextChunk: scrollToNextChunk,
-  prevChunk: scrollToPreviousChunk,
-};
-
-export async function scrollToNextChunk(ctx: MethodHandlerContext) {
-  const { stagehandPage, xpath, logger } = ctx;
-
-  logger({
-    category: "action",
-    message: "scrolling to next chunk",
-    level: 2,
-    auxiliary: {
-      xpath: { value: xpath, type: "string" },
-    },
-  });
-
-  try {
-    await stagehandPage.page.evaluate(
-      ({ xpath }) => {
-        const elementNode = getNodeFromXpath(xpath);
-        if (!elementNode || elementNode.nodeType !== Node.ELEMENT_NODE) {
-          console.warn(`Could not locate element to scroll by its height.`);
-          return Promise.resolve();
-        }
-
-        const element = elementNode as HTMLElement;
-        const tagName = element.tagName.toLowerCase();
-        let height: number;
-
-        if (tagName === "html" || tagName === "body") {
-          height = window.visualViewport.height;
-          window.scrollBy({
-            top: height,
-            left: 0,
-            behavior: "smooth",
-          });
-
-          const scrollingEl =
-            document.scrollingElement || document.documentElement;
-          return window.waitForElementScrollEnd(scrollingEl as HTMLElement);
-        } else {
-          height = element.getBoundingClientRect().height;
-          element.scrollBy({
-            top: height,
-            left: 0,
-            behavior: "smooth",
-          });
-
-          return window.waitForElementScrollEnd(element);
-        }
-      },
-      { xpath },
-    );
-  } catch (e) {
-    logger({
-      category: "action",
-      message: "error scrolling to next chunk",
-      level: 1,
-      auxiliary: {
-        error: { value: e.message, type: "string" },
-        trace: { value: e.stack, type: "string" },
-        xpath: { value: xpath, type: "string" },
-      },
-    });
-    throw new PlaywrightCommandException(e.message);
-  }
-}
-
-export async function scrollToPreviousChunk(ctx: MethodHandlerContext) {
-  const { stagehandPage, xpath, logger } = ctx;
-
-  logger({
-    category: "action",
-    message: "scrolling to previous chunk",
-    level: 2,
-    auxiliary: {
-      xpath: { value: xpath, type: "string" },
-    },
-  });
-
-  try {
-    await stagehandPage.page.evaluate(
-      ({ xpath }) => {
-        const elementNode = getNodeFromXpath(xpath);
-        if (!elementNode || elementNode.nodeType !== Node.ELEMENT_NODE) {
-          console.warn(`Could not locate element to scroll by its height.`);
-          return Promise.resolve();
-        }
-
-        const element = elementNode as HTMLElement;
-        const tagName = element.tagName.toLowerCase();
-        let height: number;
-
-        if (tagName === "html" || tagName === "body") {
-          height = window.visualViewport.height;
-          window.scrollBy({
-            top: -height,
-            left: 0,
-            behavior: "smooth",
-          });
-
-          const scrollingEl =
-            document.scrollingElement || document.documentElement;
-          return window.waitForElementScrollEnd(scrollingEl as HTMLElement);
-        } else {
-          height = element.getBoundingClientRect().height;
-          element.scrollBy({
-            top: -height,
-            left: 0,
-            behavior: "smooth",
-          });
-          return window.waitForElementScrollEnd(element);
-        }
-      },
-      { xpath },
-    );
-  } catch (e) {
-    logger({
-      category: "action",
-      message: "error scrolling to previous chunk",
-      level: 1,
-      auxiliary: {
-        error: { value: e.message, type: "string" },
-        trace: { value: e.stack, type: "string" },
-        xpath: { value: xpath, type: "string" },
-      },
-    });
-    throw new PlaywrightCommandException(e.message);
-  }
-}
-
-export async function scrollElementIntoView(ctx: MethodHandlerContext) {
-  const { locator, xpath, logger } = ctx;
-
-  logger({
-    category: "action",
-    message: "scrolling element into view",
-    level: 2,
-    auxiliary: {
-      xpath: { value: xpath, type: "string" },
-    },
-  });
-
-  try {
-    await locator.evaluate((element: HTMLElement) => {
-      element.scrollIntoView({ behavior: "smooth", block: "center" });
-    });
-  } catch (e) {
-    logger({
-      category: "action",
-      message: "error scrolling element into view",
-      level: 1,
-      auxiliary: {
-        error: { value: e.message, type: "string" },
-        trace: { value: e.stack, type: "string" },
-        xpath: { value: xpath, type: "string" },
-      },
-    });
-    throw new PlaywrightCommandException(e.message);
-  }
-}
-
-export async function scrollElementToPercentage(ctx: MethodHandlerContext) {
-  const { args, stagehandPage, xpath, logger } = ctx;
-
-  logger({
-    category: "action",
-    message: "scrolling element vertically to specified percentage",
-    level: 2,
-    auxiliary: {
-      xpath: { value: xpath, type: "string" },
-      coordinate: { value: JSON.stringify(args), type: "string" },
-    },
-  });
-
-  try {
-    const [yArg = "0%"] = args as string[];
-
-    await stagehandPage.page.evaluate(
-      ({ xpath, yArg }) => {
-        function parsePercent(val: string): number {
-          const cleaned = val.trim().replace("%", "");
-          const num = parseFloat(cleaned);
-          return Number.isNaN(num) ? 0 : Math.max(0, Math.min(num, 100));
-        }
-
-        const elementNode = getNodeFromXpath(xpath);
-        if (!elementNode || elementNode.nodeType !== Node.ELEMENT_NODE) {
-          console.warn(`Could not locate element to scroll on.`);
-          return;
-        }
-
-        const element = elementNode as HTMLElement;
-        const yPct = parsePercent(yArg);
-
-        if (element.tagName.toLowerCase() === "html") {
-          const scrollHeight = document.body.scrollHeight;
-          const viewportHeight = window.innerHeight;
-          const scrollTop = (scrollHeight - viewportHeight) * (yPct / 100);
-          window.scrollTo({
-            top: scrollTop,
-            left: window.scrollX,
-            behavior: "smooth",
-          });
-        } else {
-          const scrollHeight = element.scrollHeight;
-          const clientHeight = element.clientHeight;
-          const scrollTop = (scrollHeight - clientHeight) * (yPct / 100);
-          element.scrollTo({
-            top: scrollTop,
-            left: element.scrollLeft,
-            behavior: "smooth",
-          });
-        }
-      },
-      { xpath, yArg },
-    );
-  } catch (e) {
-    logger({
-      category: "action",
-      message: "error scrolling element vertically to percentage",
-      level: 1,
-      auxiliary: {
-        error: { value: e.message, type: "string" },
-        trace: { value: e.stack, type: "string" },
-        xpath: { value: xpath, type: "string" },
-        args: { value: JSON.stringify(args), type: "object" },
-      },
-    });
-    throw new PlaywrightCommandException(e.message);
-  }
-}
-
-export async function fillOrType(ctx: MethodHandlerContext) {
-  const { locator, xpath, args, logger } = ctx;
-
-  try {
-    await locator.fill("");
-    await locator.click();
-
-    const text = args[0]?.toString() || "";
-    for (const char of text) {
-      await locator.page().keyboard.type(char, {
-        delay: Math.random() * 50 + 25,
-      });
-    }
-  } catch (e) {
-    logger({
-      category: "action",
-      message: "error filling element",
-      level: 1,
-      auxiliary: {
-        error: { value: e.message, type: "string" },
-        trace: { value: e.stack, type: "string" },
-        xpath: { value: xpath, type: "string" },
-      },
-    });
-    throw new PlaywrightCommandException(e.message);
-  }
-}
-
-export async function pressKey(ctx: MethodHandlerContext) {
-  const {
-    locator,
-    xpath,
-    args,
-    logger,
-    stagehandPage,
-    initialUrl,
-    domSettleTimeoutMs,
-  } = ctx;
-  try {
-    const key = args[0]?.toString() ?? "";
-    await locator.page().keyboard.press(key);
-
-    await handlePossiblePageNavigation(
-      "press",
-      xpath,
-      initialUrl,
-      stagehandPage,
-      logger,
-      domSettleTimeoutMs,
-    );
-  } catch (e) {
-    logger({
-      category: "action",
-      message: "error pressing key",
-      level: 1,
-      auxiliary: {
-        error: { value: e.message, type: "string" },
-        trace: { value: e.stack, type: "string" },
-        key: { value: args[0]?.toString() ?? "unknown", type: "string" },
-      },
-    });
-    throw new PlaywrightCommandException(e.message);
-  }
-}
-
-export async function clickElement(ctx: MethodHandlerContext) {
-  const {
-    locator,
-    xpath,
-    args,
-    logger,
-    stagehandPage,
-    initialUrl,
-    domSettleTimeoutMs,
-  } = ctx;
-
-  logger({
-    category: "action",
-    message: "page URL before click",
-    level: 2,
-    auxiliary: {
-      url: {
-        value: stagehandPage.page.url(),
-        type: "string",
-      },
-    },
-  });
-
-  try {
-    // If it's a radio input, try to click its label
-    const isRadio = await locator.evaluate((el) => {
-      return el instanceof HTMLInputElement && el.type === "radio";
-    });
-
-    // Extract the click options (if any) from args[0]
-    const clickArg = (args[0] ?? {}) as Record<string, unknown>;
-
-    // Decide which locator we actually want to click (for radio inputs, prefer label if present)
-    let finalLocator = locator;
-    if (isRadio) {
-      const inputId = await locator.evaluate(
-        (el) => (el as HTMLInputElement).id,
-      );
-      let labelLocator = null;
-
-      if (inputId) {
-        labelLocator = stagehandPage.page.locator(`label[for="${inputId}"]`);
-      }
-      if (!labelLocator || (await labelLocator.count()) < 1) {
-        // Check ancestor <label>
-        labelLocator = stagehandPage.page
-          .locator(`xpath=${xpath}/ancestor::label`)
-          .first();
-      }
-      if ((await labelLocator.count()) < 1) {
-        // Check sibling <label>
-        labelLocator = locator
-          .locator("xpath=following-sibling::label")
-          .first();
-        if ((await labelLocator.count()) < 1) {
-          labelLocator = locator
-            .locator("xpath=preceding-sibling::label")
-            .first();
-        }
-      }
-
-      if ((await labelLocator.count()) > 0) {
-        finalLocator = labelLocator;
-      }
-    }
-
-    // Try clicking with a short (5s) timeout
-    try {
-      await finalLocator.click({
-        ...clickArg,
-        timeout: 5000,
-      });
-    } catch (error) {
-      // If it's a TimeoutError, retry with force: true
-      if (error instanceof PlaywrightErrors.TimeoutError) {
-        logger({
-          category: "action",
-          message: "First click attempt timed out, retrying with force...",
-          level: 2,
-        });
-        try {
-          await finalLocator.click({
-            ...clickArg,
-            force: true,
-          });
-        } catch (forceError) {
-          // If forced click also fails, throw a more descriptive error
-          throw new PlaywrightCommandException(
-            `Failed to click element at [${xpath}]. ` +
-              `Timeout after 5s, then force-click also failed. ` +
-              `Original timeout error: ${error.message}, ` +
-              `Force-click error: ${forceError.message}`,
-          );
-        }
-      } else {
-        // Non-timeout error on the first click
-        throw new PlaywrightCommandException(
-          `Failed to click element at [${xpath}]. ` + `Error: ${error.message}`,
-        );
-      }
-    }
-  } catch (e) {
-    logger({
-      category: "action",
-      message: "error performing click",
-      level: 1,
-      auxiliary: {
-        error: { value: e.message, type: "string" },
-        trace: { value: e.stack, type: "string" },
-        xpath: { value: xpath, type: "string" },
-        method: { value: "click", type: "string" },
-        args: { value: JSON.stringify(args), type: "object" },
-      },
-    });
-
-    throw new PlaywrightCommandException(
-      `Could not complete click action at [${xpath}]. Reason: ${e.message}`,
-    );
-  }
-
-  await handlePossiblePageNavigation(
-    "click",
-    xpath,
-    initialUrl,
-    stagehandPage,
-    logger,
-    domSettleTimeoutMs,
-  );
-}
-
-/**
- * Fallback method: if method is not in our map but *is* a valid Playwright locator method.
- */
-export async function fallbackLocatorMethod(ctx: MethodHandlerContext) {
-  const { locator, xpath, method, args, logger } = ctx;
-
-  logger({
-    category: "action",
-    message: "page URL before action",
-    level: 2,
-    auxiliary: {
-      url: { value: locator.page().url(), type: "string" },
-    },
-  });
-
-  try {
-    await (
-      locator[method as keyof Locator] as unknown as (
-        ...a: string[]
-      ) => Promise<void>
-    )(...args.map((arg) => arg?.toString() || ""));
-  } catch (e) {
-    logger({
-      category: "action",
-      message: "error performing method",
-      level: 1,
-      auxiliary: {
-        error: { value: e.message, type: "string" },
-        trace: { value: e.stack, type: "string" },
-        xpath: { value: xpath, type: "string" },
-        method: { value: method, type: "string" },
-        args: { value: JSON.stringify(args), type: "object" },
-      },
-    });
-    throw new PlaywrightCommandException(e.message);
-  }
-}
-
-async function handlePossiblePageNavigation(
-  actionDescription: string,
-  xpath: string,
-  initialUrl: string,
-  stagehandPage: StagehandPage,
-  logger: Logger,
-  domSettleTimeoutMs?: number,
-): Promise<void> {
-  logger({
-    category: "action",
-    message: `${actionDescription}, checking for page navigation`,
-    level: 1,
-    auxiliary: {
-      xpath: { value: xpath, type: "string" },
-    },
-  });
-
-  const newOpenedTab = await Promise.race([
-    new Promise<Page | null>((resolve) => {
-      stagehandPage.context.once("page", (page) => resolve(page));
-      setTimeout(() => resolve(null), 1500);
-    }),
-  ]);
-
-  logger({
-    category: "action",
-    message: `${actionDescription} complete`,
-    level: 1,
-    auxiliary: {
-      newOpenedTab: {
-        value: newOpenedTab ? "opened a new tab" : "no new tabs opened",
-        type: "string",
-      },
-    },
-  });
-
-  if (newOpenedTab) {
-    logger({
-      category: "action",
-      message: "new page detected (new tab) with URL",
-      level: 1,
-      auxiliary: {
-        url: { value: newOpenedTab.url(), type: "string" },
-      },
-    });
-    await newOpenedTab.close();
-    await stagehandPage.page.goto(newOpenedTab.url());
-    await stagehandPage.page.waitForLoadState("domcontentloaded");
-  }
-
-  try {
-    await stagehandPage._waitForSettledDom(domSettleTimeoutMs);
-  } catch (e) {
-    logger({
-      category: "action",
-      message: "wait for settled DOM timeout hit",
-      level: 1,
-      auxiliary: {
-        trace: { value: e.stack, type: "string" },
-        message: { value: e.message, type: "string" },
-      },
-    });
-  }
-
-  logger({
-    category: "action",
-    message: "finished waiting for (possible) page navigation",
-    level: 1,
-  });
-
-  if (stagehandPage.page.url() !== initialUrl) {
-    logger({
-      category: "action",
-      message: "new page detected with URL",
-      level: 1,
-      auxiliary: {
-        url: { value: stagehandPage.page.url(), type: "string" },
-      },
-    });
-  }
-}
diff --git a/lib/handlers/observeHandler.ts b/lib/handlers/observeHandler.ts
deleted file mode 100644
index b1e919c5c..000000000
--- a/lib/handlers/observeHandler.ts
+++ /dev/null
@@ -1,225 +0,0 @@
-import { LogLine } from "../../types/log";
-import { Stagehand, StagehandFunctionName } from "../index";
-import { observe } from "../inference";
-import { LLMClient } from "../llm/LLMClient";
-import { StagehandPage } from "../StagehandPage";
-import { generateId, drawObserveOverlay } from "../utils";
-import {
-  getAccessibilityTree,
-  getXPathByResolvedObjectId,
-} from "../a11y/utils";
-import { AccessibilityNode } from "../../types/context";
-
-export class StagehandObserveHandler {
-  private readonly stagehand: Stagehand;
-  private readonly logger: (logLine: LogLine) => void;
-  private readonly stagehandPage: StagehandPage;
-  private observations: {
-    [key: string]: {
-      result: { selector: string; description: string }[];
-      instruction: string;
-    };
-  };
-  private readonly userProvidedInstructions?: string;
-  constructor({
-    stagehand,
-    logger,
-    stagehandPage,
-    userProvidedInstructions,
-  }: {
-    stagehand: Stagehand;
-    logger: (logLine: LogLine) => void;
-    stagehandPage: StagehandPage;
-    userProvidedInstructions?: string;
-  }) {
-    this.stagehand = stagehand;
-    this.logger = logger;
-    this.stagehandPage = stagehandPage;
-    this.userProvidedInstructions = userProvidedInstructions;
-    this.observations = {};
-  }
-
-  private async _recordObservation(
-    instruction: string,
-    result: { selector: string; description: string }[],
-  ): Promise<string> {
-    const id = generateId(instruction);
-
-    this.observations[id] = { result, instruction };
-
-    return id;
-  }
-
-  public async observe({
-    instruction,
-    llmClient,
-    requestId,
-    returnAction,
-    onlyVisible,
-    drawOverlay,
-    fromAct,
-  }: {
-    instruction: string;
-    llmClient: LLMClient;
-    requestId: string;
-    domSettleTimeoutMs?: number;
-    returnAction?: boolean;
-    onlyVisible?: boolean;
-    drawOverlay?: boolean;
-    fromAct?: boolean;
-  }) {
-    if (!instruction) {
-      instruction = `Find elements that can be used for any future actions in the page. These may be navigation links, related pages, section/subsection links, buttons, or other interactive elements. Be comprehensive: if there are multiple elements that may be relevant for future actions, return all of them.`;
-    }
-
-    this.logger({
-      category: "observation",
-      message: "starting observation",
-      level: 1,
-      auxiliary: {
-        instruction: {
-          value: instruction,
-          type: "string",
-        },
-      },
-    });
-
-    let selectorMap: Record<string, string[]> = {};
-    let outputString: string;
-    let iframes: AccessibilityNode[] = [];
-    const useAccessibilityTree = !onlyVisible;
-    if (useAccessibilityTree) {
-      await this.stagehandPage._waitForSettledDom();
-      const tree = await getAccessibilityTree(this.stagehandPage, this.logger);
-      this.logger({
-        category: "observation",
-        message: "Getting accessibility tree data",
-        level: 1,
-      });
-      outputString = tree.simplified;
-      iframes = tree.iframes;
-    } else {
-      const evalResult = await this.stagehand.page.evaluate(() => {
-        return window.processAllOfDom().then((result) => result);
-      });
-      ({ outputString, selectorMap } = evalResult);
-    }
-
-    // No screenshot or vision-based annotation is performed
-    const observationResponse = await observe({
-      instruction,
-      domElements: outputString,
-      llmClient,
-      requestId,
-      userProvidedInstructions: this.userProvidedInstructions,
-      logger: this.logger,
-      isUsingAccessibilityTree: useAccessibilityTree,
-      returnAction,
-      logInferenceToFile: this.stagehand.logInferenceToFile,
-      fromAct: fromAct,
-    });
-
-    const {
-      prompt_tokens = 0,
-      completion_tokens = 0,
-      inference_time_ms = 0,
-    } = observationResponse;
-
-    this.stagehand.updateMetrics(
-      fromAct ? StagehandFunctionName.ACT : StagehandFunctionName.OBSERVE,
-      prompt_tokens,
-      completion_tokens,
-      inference_time_ms,
-    );
-
-    //Add iframes to the observation response if there are any on the page
-    if (iframes.length > 0) {
-      iframes.forEach((iframe) => {
-        observationResponse.elements.push({
-          elementId: Number(iframe.nodeId),
-          description: "an iframe",
-          method: "not-supported",
-          arguments: [],
-        });
-      });
-    }
-    const elementsWithSelectors = await Promise.all(
-      observationResponse.elements.map(async (element) => {
-        const { elementId, ...rest } = element;
-
-        if (useAccessibilityTree) {
-          // Generate xpath for the given element if not found in selectorMap
-          this.logger({
-            category: "observation",
-            message: "Getting xpath for element",
-            level: 1,
-            auxiliary: {
-              elementId: {
-                value: elementId.toString(),
-                type: "string",
-              },
-            },
-          });
-
-          const args = { backendNodeId: elementId };
-          const { object } = await this.stagehandPage.sendCDP<{
-            object: { objectId: string };
-          }>("DOM.resolveNode", args);
-
-          if (!object || !object.objectId) {
-            this.logger({
-              category: "observation",
-              message: `Invalid object ID returned for element: ${elementId}`,
-              level: 1,
-            });
-          }
-
-          const xpath = await getXPathByResolvedObjectId(
-            await this.stagehandPage.getCDPClient(),
-            object.objectId,
-          );
-
-          if (!xpath || xpath === "") {
-            this.logger({
-              category: "observation",
-              message: `Empty xpath returned for element: ${elementId}`,
-              level: 1,
-            });
-          }
-
-          return {
-            ...rest,
-            selector: `xpath=${xpath}`,
-            // Provisioning or future use if we want to use direct CDP
-            // backendNodeId: elementId,
-          };
-        }
-
-        return {
-          ...rest,
-          selector: `xpath=${selectorMap[elementId][0]}`,
-          // backendNodeId: backendNodeIdMap[elementId],
-        };
-      }),
-    );
-
-    this.logger({
-      category: "observation",
-      message: "found elements",
-      level: 1,
-      auxiliary: {
-        elements: {
-          value: JSON.stringify(elementsWithSelectors),
-          type: "object",
-        },
-      },
-    });
-
-    if (drawOverlay) {
-      await drawObserveOverlay(this.stagehandPage.page, elementsWithSelectors);
-    }
-
-    await this._recordObservation(instruction, elementsWithSelectors);
-    return elementsWithSelectors;
-  }
-}
diff --git a/lib/handlers/operatorHandler.ts b/lib/handlers/operatorHandler.ts
deleted file mode 100644
index ec5a7d5e5..000000000
--- a/lib/handlers/operatorHandler.ts
+++ /dev/null
@@ -1,242 +0,0 @@
-import { AgentAction, AgentExecuteOptions, AgentResult } from "@/types/agent";
-import { LogLine } from "@/types/log";
-import {
-  OperatorResponse,
-  operatorResponseSchema,
-  OperatorSummary,
-  operatorSummarySchema,
-} from "@/types/operator";
-import { LLMParsedResponse } from "../inference";
-import { ChatMessage, LLMClient } from "../llm/LLMClient";
-import { buildOperatorSystemPrompt } from "../prompt";
-import { StagehandPage } from "../StagehandPage";
-import { ObserveResult } from "@/types/stagehand";
-import {
-  StagehandError,
-  StagehandMissingArgumentError,
-} from "@/types/stagehandErrors";
-
-export class StagehandOperatorHandler {
-  private stagehandPage: StagehandPage;
-  private logger: (message: LogLine) => void;
-  private llmClient: LLMClient;
-  private messages: ChatMessage[];
-
-  constructor(
-    stagehandPage: StagehandPage,
-    logger: (message: LogLine) => void,
-    llmClient: LLMClient,
-  ) {
-    this.stagehandPage = stagehandPage;
-    this.logger = logger;
-    this.llmClient = llmClient;
-  }
-
-  public async execute(
-    instructionOrOptions: string | AgentExecuteOptions,
-  ): Promise<AgentResult> {
-    const options =
-      typeof instructionOrOptions === "string"
-        ? { instruction: instructionOrOptions }
-        : instructionOrOptions;
-
-    this.messages = [buildOperatorSystemPrompt(options.instruction)];
-    let completed = false;
-    let currentStep = 0;
-    const maxSteps = options.maxSteps || 10;
-    const actions: AgentAction[] = [];
-
-    while (!completed && currentStep < maxSteps) {
-      const url = this.stagehandPage.page.url();
-
-      if (!url || url === "about:blank") {
-        this.messages.push({
-          role: "user",
-          content: [
-            {
-              type: "text",
-              text: "No page is currently loaded. The first step should be a 'goto' action to navigate to a URL.",
-            },
-          ],
-        });
-      } else {
-        const screenshot = await this.stagehandPage.page.screenshot({
-          type: "png",
-          fullPage: false,
-        });
-
-        const base64Image = screenshot.toString("base64");
-
-        let messageText = `Here is a screenshot of the current page (URL: ${url}):`;
-
-        messageText = `Previous actions were: ${actions
-          .map((action) => {
-            let result: string = "";
-            if (action.type === "act") {
-              const args = action.playwrightArguments as ObserveResult;
-              result = `Performed a "${args.method}" action ${args.arguments.length > 0 ? `with arguments: ${args.arguments.map((arg) => `"${arg}"`).join(", ")}` : ""} on "${args.description}"`;
-            } else if (action.type === "extract") {
-              result = `Extracted data: ${action.extractionResult}`;
-            }
-            return `[${action.type}] ${action.reasoning}. Result: ${result}`;
-          })
-          .join("\n")}\n\n${messageText}`;
-
-        this.messages.push({
-          role: "user",
-          content: [
-            {
-              type: "text",
-              text: messageText,
-            },
-            this.llmClient.type === "anthropic"
-              ? {
-                  type: "image",
-                  source: {
-                    type: "base64",
-                    media_type: "image/png",
-                    data: base64Image,
-                  },
-                  text: "the screenshot of the current page",
-                }
-              : {
-                  type: "image_url",
-                  image_url: { url: `data:image/png;base64,${base64Image}` },
-                },
-          ],
-        });
-      }
-
-      const result = await this.getNextStep(currentStep);
-
-      if (result.method === "close") {
-        completed = true;
-      }
-
-      let playwrightArguments: ObserveResult | undefined;
-      if (result.method === "act") {
-        [playwrightArguments] = await this.stagehandPage.page.observe(
-          result.parameters,
-        );
-      }
-      let extractionResult: unknown | undefined;
-      if (result.method === "extract") {
-        extractionResult = await this.stagehandPage.page.extract(
-          result.parameters,
-        );
-      }
-
-      await this.executeAction(result, playwrightArguments, extractionResult);
-
-      actions.push({
-        type: result.method,
-        reasoning: result.reasoning,
-        taskCompleted: result.taskComplete,
-        parameters: result.parameters,
-        playwrightArguments,
-        extractionResult,
-      });
-
-      currentStep++;
-    }
-
-    return {
-      success: true,
-      message: await this.getSummary(options.instruction),
-      actions,
-      completed: actions[actions.length - 1].taskCompleted as boolean,
-    };
-  }
-
-  private async getNextStep(currentStep: number): Promise<OperatorResponse> {
-    const { data: response } =
-      (await this.llmClient.createChatCompletion<OperatorResponse>({
-        options: {
-          messages: this.messages,
-          response_model: {
-            name: "operatorResponseSchema",
-            schema: operatorResponseSchema,
-          },
-          requestId: `operator-step-${currentStep}`,
-        },
-        logger: this.logger,
-      })) as LLMParsedResponse<OperatorResponse>;
-
-    return response;
-  }
-
-  private async getSummary(goal: string): Promise<string> {
-    const { data: response } =
-      (await this.llmClient.createChatCompletion<OperatorSummary>({
-        options: {
-          messages: [
-            ...this.messages,
-            {
-              role: "user",
-              content: [
-                {
-                  type: "text",
-                  text: `Now use the steps taken to answer the original instruction of ${goal}.`,
-                },
-              ],
-            },
-          ],
-          response_model: {
-            name: "operatorSummarySchema",
-            schema: operatorSummarySchema,
-          },
-          requestId: "operator-summary",
-        },
-        logger: this.logger,
-      })) as LLMParsedResponse<OperatorSummary>;
-
-    return response.answer;
-  }
-  private async executeAction(
-    action: OperatorResponse,
-    playwrightArguments?: ObserveResult,
-    extractionResult?: unknown,
-  ): Promise<unknown> {
-    const { method, parameters } = action;
-    const page = this.stagehandPage.page;
-
-    if (method === "close") {
-      return;
-    }
-
-    switch (method) {
-      case "act":
-        if (!playwrightArguments) {
-          throw new StagehandMissingArgumentError(
-            "No arguments provided to `act()`. " +
-              "Please ensure that all required arguments are passed in.",
-          );
-        }
-        await page.act(playwrightArguments);
-        break;
-      case "extract":
-        if (!extractionResult) {
-          throw new StagehandError(
-            "Error in OperatorHandler: Cannot complete extraction. No extractionResult provided.",
-          );
-        }
-        return extractionResult;
-      case "goto":
-        await page.goto(parameters, { waitUntil: "load" });
-        break;
-      case "wait":
-        await page.waitForTimeout(parseInt(parameters));
-        break;
-      case "navback":
-        await page.goBack();
-        break;
-      case "refresh":
-        await page.reload();
-        break;
-      default:
-        throw new StagehandError(
-          `Error in OperatorHandler: Cannot execute unknown action: ${method}`,
-        );
-    }
-  }
-}
diff --git a/lib/index.ts b/lib/index.ts
deleted file mode 100644
index a12b63a72..000000000
--- a/lib/index.ts
+++ /dev/null
@@ -1,887 +0,0 @@
-import { Browserbase } from "@browserbasehq/sdk";
-import { chromium } from "@playwright/test";
-import dotenv from "dotenv";
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { z } from "zod";
-import { BrowserResult } from "../types/browser";
-import { EnhancedContext } from "../types/context";
-import { LogLine } from "../types/log";
-import { AvailableModel } from "../types/model";
-import { BrowserContext, Page } from "../types/page";
-import {
-  ActOptions,
-  ActResult,
-  ConstructorParams,
-  ExtractOptions,
-  ExtractResult,
-  InitResult,
-  LocalBrowserLaunchOptions,
-  ObserveOptions,
-  ObserveResult,
-  AgentConfig,
-  StagehandMetrics,
-  StagehandFunctionName,
-  HistoryEntry,
-} from "../types/stagehand";
-import { StagehandContext } from "./StagehandContext";
-import { StagehandPage } from "./StagehandPage";
-import { StagehandAPI } from "./api";
-import { scriptContent } from "./dom/build/scriptContent";
-import { LLMClient } from "./llm/LLMClient";
-import { LLMProvider } from "./llm/LLMProvider";
-import { isRunningInBun } from "./utils";
-import { ApiResponse, ErrorResponse } from "@/types/api";
-import { AgentExecuteOptions, AgentResult } from "../types/agent";
-import { StagehandAgentHandler } from "./handlers/agentHandler";
-import { StagehandOperatorHandler } from "./handlers/operatorHandler";
-import { StagehandLogger } from "./logger";
-
-import {
-  StagehandError,
-  StagehandNotInitializedError,
-  StagehandEnvironmentError,
-  MissingEnvironmentVariableError,
-  UnsupportedModelError,
-} from "../types/stagehandErrors";
-
-dotenv.config({ path: ".env" });
-
-const DEFAULT_MODEL_NAME = "gpt-4o";
-
-// Initialize the global logger
-let globalLogger: StagehandLogger;
-
-const defaultLogger = async (logLine: LogLine, disablePino?: boolean) => {
-  if (!globalLogger) {
-    globalLogger = new StagehandLogger(
-      {
-        pretty: true,
-        usePino: !disablePino,
-      },
-      undefined,
-    );
-  }
-  globalLogger.log(logLine);
-};
-
-async function getBrowser(
-  apiKey: string | undefined,
-  projectId: string | undefined,
-  env: "LOCAL" | "BROWSERBASE" = "LOCAL",
-  headless: boolean = false,
-  logger: (message: LogLine) => void,
-  browserbaseSessionCreateParams?: Browserbase.Sessions.SessionCreateParams,
-  browserbaseSessionID?: string,
-  localBrowserLaunchOptions?: LocalBrowserLaunchOptions,
-): Promise<BrowserResult> {
-  if (env === "BROWSERBASE") {
-    if (!apiKey) {
-      throw new MissingEnvironmentVariableError(
-        "BROWSERBASE_API_KEY",
-        "Browserbase",
-      );
-    }
-    if (!projectId) {
-      throw new MissingEnvironmentVariableError(
-        "BROWSERBASE_PROJECT_ID",
-        "Browserbase",
-      );
-    }
-
-    let debugUrl: string | undefined = undefined;
-    let sessionUrl: string | undefined = undefined;
-    let sessionId: string;
-    let connectUrl: string;
-
-    const browserbase = new Browserbase({
-      apiKey,
-    });
-
-    if (browserbaseSessionID) {
-      // Validate the session status
-      try {
-        const session =
-          await browserbase.sessions.retrieve(browserbaseSessionID);
-
-        if (session.status !== "RUNNING") {
-          throw new StagehandError(
-            `Session ${browserbaseSessionID} is not running (status: ${session.status})`,
-          );
-        }
-
-        sessionId = browserbaseSessionID;
-        connectUrl = session.connectUrl;
-
-        logger({
-          category: "init",
-          message: "resuming existing browserbase session...",
-          level: 1,
-          auxiliary: {
-            sessionId: {
-              value: sessionId,
-              type: "string",
-            },
-          },
-        });
-      } catch (error) {
-        logger({
-          category: "init",
-          message: "failed to resume session",
-          level: 0,
-          auxiliary: {
-            error: {
-              value: error.message,
-              type: "string",
-            },
-            trace: {
-              value: error.stack,
-              type: "string",
-            },
-          },
-        });
-        throw error;
-      }
-    } else {
-      // Create new session (existing code)
-      logger({
-        category: "init",
-        message: "creating new browserbase session...",
-        level: 1,
-      });
-
-      if (!projectId) {
-        throw new StagehandError(
-          "BROWSERBASE_PROJECT_ID is required for new Browserbase sessions.",
-        );
-      }
-
-      const session = await browserbase.sessions.create({
-        projectId,
-        ...browserbaseSessionCreateParams,
-        userMetadata: {
-          ...(browserbaseSessionCreateParams?.userMetadata || {}),
-          stagehand: "true",
-        },
-      });
-
-      sessionId = session.id;
-      connectUrl = session.connectUrl;
-      logger({
-        category: "init",
-        message: "created new browserbase session",
-        level: 1,
-        auxiliary: {
-          sessionId: {
-            value: sessionId,
-            type: "string",
-          },
-        },
-      });
-    }
-    if (!connectUrl.includes("connect.connect")) {
-      logger({
-        category: "init",
-        message: "connecting to browserbase session",
-        level: 1,
-        auxiliary: {
-          connectUrl: {
-            value: connectUrl,
-            type: "string",
-          },
-        },
-      });
-    }
-    const browser = await chromium.connectOverCDP(connectUrl);
-
-    const { debuggerUrl } = await browserbase.sessions.debug(sessionId);
-
-    debugUrl = debuggerUrl;
-    sessionUrl = `https://www.browserbase.com/sessions/${sessionId}`;
-
-    logger({
-      category: "init",
-      message: browserbaseSessionID
-        ? "browserbase session resumed"
-        : "browserbase session started",
-      auxiliary: {
-        sessionUrl: {
-          value: sessionUrl,
-          type: "string",
-        },
-        debugUrl: {
-          value: debugUrl,
-          type: "string",
-        },
-        sessionId: {
-          value: sessionId,
-          type: "string",
-        },
-      },
-    });
-
-    const context = browser.contexts()[0];
-
-    return { browser, context, debugUrl, sessionUrl, sessionId, env };
-  } else {
-    if (localBrowserLaunchOptions?.cdpUrl) {
-      if (!localBrowserLaunchOptions.cdpUrl.includes("connect.connect")) {
-        logger({
-          category: "init",
-          message: "connecting to local browser via CDP URL",
-          level: 1,
-          auxiliary: {
-            cdpUrl: {
-              value: localBrowserLaunchOptions.cdpUrl,
-              type: "string",
-            },
-          },
-        });
-      }
-
-      const browser = await chromium.connectOverCDP(
-        localBrowserLaunchOptions.cdpUrl,
-      );
-      const context = browser.contexts()[0];
-      return { browser, context, env: "LOCAL" };
-    }
-
-    let userDataDir = localBrowserLaunchOptions?.userDataDir;
-    if (!userDataDir) {
-      const tmpDirPath = path.join(os.tmpdir(), "stagehand");
-      if (!fs.existsSync(tmpDirPath)) {
-        fs.mkdirSync(tmpDirPath, { recursive: true });
-      }
-
-      const tmpDir = fs.mkdtempSync(path.join(tmpDirPath, "ctx_"));
-      fs.mkdirSync(path.join(tmpDir, "userdir/Default"), { recursive: true });
-
-      const defaultPreferences = {
-        plugins: {
-          always_open_pdf_externally: true,
-        },
-      };
-
-      fs.writeFileSync(
-        path.join(tmpDir, "userdir/Default/Preferences"),
-        JSON.stringify(defaultPreferences),
-      );
-      userDataDir = path.join(tmpDir, "userdir");
-    }
-
-    let downloadsPath = localBrowserLaunchOptions?.downloadsPath;
-    if (!downloadsPath) {
-      downloadsPath = path.join(process.cwd(), "downloads");
-      fs.mkdirSync(downloadsPath, { recursive: true });
-    }
-
-    const context = await chromium.launchPersistentContext(userDataDir, {
-      acceptDownloads: localBrowserLaunchOptions?.acceptDownloads ?? true,
-      headless: localBrowserLaunchOptions?.headless ?? headless,
-      viewport: {
-        width: localBrowserLaunchOptions?.viewport?.width ?? 1024,
-        height: localBrowserLaunchOptions?.viewport?.height ?? 768,
-      },
-      locale: localBrowserLaunchOptions?.locale ?? "en-US",
-      timezoneId: localBrowserLaunchOptions?.timezoneId ?? "America/New_York",
-      deviceScaleFactor: localBrowserLaunchOptions?.deviceScaleFactor ?? 1,
-      args: localBrowserLaunchOptions?.args ?? [
-        "--enable-webgl",
-        "--use-gl=swiftshader",
-        "--enable-accelerated-2d-canvas",
-        "--disable-blink-features=AutomationControlled",
-        "--disable-web-security",
-      ],
-      bypassCSP: localBrowserLaunchOptions?.bypassCSP ?? true,
-      proxy: localBrowserLaunchOptions?.proxy,
-      geolocation: localBrowserLaunchOptions?.geolocation,
-      hasTouch: localBrowserLaunchOptions?.hasTouch ?? true,
-      ignoreHTTPSErrors: localBrowserLaunchOptions?.ignoreHTTPSErrors ?? true,
-      permissions: localBrowserLaunchOptions?.permissions,
-      recordHar: localBrowserLaunchOptions?.recordHar,
-      recordVideo: localBrowserLaunchOptions?.recordVideo,
-      tracesDir: localBrowserLaunchOptions?.tracesDir,
-      extraHTTPHeaders: localBrowserLaunchOptions?.extraHTTPHeaders,
-      chromiumSandbox: localBrowserLaunchOptions?.chromiumSandbox ?? false,
-      devtools: localBrowserLaunchOptions?.devtools ?? false,
-      env: localBrowserLaunchOptions?.env,
-      executablePath: localBrowserLaunchOptions?.executablePath,
-      handleSIGHUP: localBrowserLaunchOptions?.handleSIGHUP ?? true,
-      handleSIGINT: localBrowserLaunchOptions?.handleSIGINT ?? true,
-      handleSIGTERM: localBrowserLaunchOptions?.handleSIGTERM ?? true,
-      ignoreDefaultArgs: localBrowserLaunchOptions?.ignoreDefaultArgs,
-    });
-
-    if (localBrowserLaunchOptions?.cookies) {
-      context.addCookies(localBrowserLaunchOptions.cookies);
-    }
-
-    logger({
-      category: "init",
-      message: "local browser started successfully.",
-    });
-
-    await applyStealthScripts(context);
-
-    return { context, contextPath: userDataDir, env: "LOCAL" };
-  }
-}
-
-async function applyStealthScripts(context: BrowserContext) {
-  await context.addInitScript(() => {
-    // Override the navigator.webdriver property
-    Object.defineProperty(navigator, "webdriver", {
-      get: () => undefined,
-    });
-
-    // Mock languages and plugins to mimic a real browser
-    Object.defineProperty(navigator, "languages", {
-      get: () => ["en-US", "en"],
-    });
-
-    Object.defineProperty(navigator, "plugins", {
-      get: () => [1, 2, 3, 4, 5],
-    });
-
-    // Remove Playwright-specific properties
-    delete window.__playwright;
-    delete window.__pw_manual;
-    delete window.__PW_inspect;
-
-    // Redefine the headless property
-    Object.defineProperty(navigator, "headless", {
-      get: () => false,
-    });
-
-    // Override the permissions API
-    const originalQuery = window.navigator.permissions.query;
-    window.navigator.permissions.query = (parameters) =>
-      parameters.name === "notifications"
-        ? Promise.resolve({
-            state: Notification.permission,
-          } as PermissionStatus)
-        : originalQuery(parameters);
-  });
-}
-
-export class Stagehand {
-  private stagehandPage!: StagehandPage;
-  private stagehandContext!: StagehandContext;
-  public browserbaseSessionID?: string;
-  public readonly domSettleTimeoutMs: number;
-  public readonly debugDom: boolean;
-  public readonly headless: boolean;
-  public verbose: 0 | 1 | 2;
-  public llmProvider: LLMProvider;
-  public enableCaching: boolean;
-  private apiKey: string | undefined;
-  private projectId: string | undefined;
-  private externalLogger?: (logLine: LogLine) => void;
-  private browserbaseSessionCreateParams?: Browserbase.Sessions.SessionCreateParams;
-  public variables: { [key: string]: unknown };
-  private contextPath?: string;
-  public llmClient: LLMClient;
-  public readonly userProvidedInstructions?: string;
-  private usingAPI: boolean;
-  private modelName: AvailableModel;
-  public apiClient: StagehandAPI | undefined;
-  public readonly waitForCaptchaSolves: boolean;
-  private localBrowserLaunchOptions?: LocalBrowserLaunchOptions;
-  public readonly selfHeal: boolean;
-  private cleanupCalled = false;
-  public readonly actTimeoutMs: number;
-  public readonly logInferenceToFile?: boolean;
-  private stagehandLogger: StagehandLogger;
-  private disablePino: boolean;
-  private _env: "LOCAL" | "BROWSERBASE";
-
-  protected setActivePage(page: StagehandPage): void {
-    this.stagehandPage = page;
-  }
-
-  public get page(): Page {
-    if (!this.stagehandContext) {
-      throw new StagehandNotInitializedError("page");
-    }
-    return this.stagehandPage.page;
-  }
-
-  public stagehandMetrics: StagehandMetrics = {
-    actPromptTokens: 0,
-    actCompletionTokens: 0,
-    actInferenceTimeMs: 0,
-    extractPromptTokens: 0,
-    extractCompletionTokens: 0,
-    extractInferenceTimeMs: 0,
-    observePromptTokens: 0,
-    observeCompletionTokens: 0,
-    observeInferenceTimeMs: 0,
-    totalPromptTokens: 0,
-    totalCompletionTokens: 0,
-    totalInferenceTimeMs: 0,
-  };
-
-  public get metrics(): StagehandMetrics {
-    return this.stagehandMetrics;
-  }
-
-  public updateMetrics(
-    functionName: StagehandFunctionName,
-    promptTokens: number,
-    completionTokens: number,
-    inferenceTimeMs: number,
-  ): void {
-    switch (functionName) {
-      case StagehandFunctionName.ACT:
-        this.stagehandMetrics.actPromptTokens += promptTokens;
-        this.stagehandMetrics.actCompletionTokens += completionTokens;
-        this.stagehandMetrics.actInferenceTimeMs += inferenceTimeMs;
-        break;
-
-      case StagehandFunctionName.EXTRACT:
-        this.stagehandMetrics.extractPromptTokens += promptTokens;
-        this.stagehandMetrics.extractCompletionTokens += completionTokens;
-        this.stagehandMetrics.extractInferenceTimeMs += inferenceTimeMs;
-        break;
-
-      case StagehandFunctionName.OBSERVE:
-        this.stagehandMetrics.observePromptTokens += promptTokens;
-        this.stagehandMetrics.observeCompletionTokens += completionTokens;
-        this.stagehandMetrics.observeInferenceTimeMs += inferenceTimeMs;
-        break;
-    }
-    this.updateTotalMetrics(promptTokens, completionTokens, inferenceTimeMs);
-  }
-
-  private updateTotalMetrics(
-    promptTokens: number,
-    completionTokens: number,
-    inferenceTimeMs: number,
-  ): void {
-    this.stagehandMetrics.totalPromptTokens += promptTokens;
-    this.stagehandMetrics.totalCompletionTokens += completionTokens;
-    this.stagehandMetrics.totalInferenceTimeMs += inferenceTimeMs;
-  }
-
-  constructor(
-    {
-      env,
-      apiKey,
-      projectId,
-      verbose,
-      llmProvider,
-      llmClient,
-      logger,
-      browserbaseSessionCreateParams,
-      domSettleTimeoutMs,
-      enableCaching,
-      browserbaseSessionID,
-      modelName,
-      modelClientOptions,
-      systemPrompt,
-      useAPI,
-      localBrowserLaunchOptions,
-      waitForCaptchaSolves = false,
-      logInferenceToFile = false,
-      selfHeal = false,
-      disablePino,
-    }: ConstructorParams = {
-      env: "BROWSERBASE",
-    },
-  ) {
-    this.externalLogger =
-      logger || ((logLine: LogLine) => defaultLogger(logLine, disablePino));
-
-    // Initialize the Stagehand logger
-    this.stagehandLogger = new StagehandLogger(
-      {
-        pretty: true,
-        // use pino if pino is enabled, and there is no custom logger
-        usePino: !logger && !disablePino,
-      },
-      this.externalLogger,
-    );
-
-    this.enableCaching =
-      enableCaching ??
-      (process.env.ENABLE_CACHING && process.env.ENABLE_CACHING === "true");
-
-    this.llmProvider =
-      llmProvider || new LLMProvider(this.logger, this.enableCaching);
-
-    this.apiKey = apiKey ?? process.env.BROWSERBASE_API_KEY;
-    this.projectId = projectId ?? process.env.BROWSERBASE_PROJECT_ID;
-
-    // Store the environment value
-    this._env = env ?? "BROWSERBASE";
-
-    if (this._env === "BROWSERBASE") {
-      if (!this.apiKey) {
-        throw new MissingEnvironmentVariableError(
-          "BROWSERBASE_API_KEY",
-          "Browserbase",
-        );
-      } else if (!this.projectId) {
-        throw new MissingEnvironmentVariableError(
-          "BROWSERBASE_PROJECT_ID",
-          "Browserbase",
-        );
-      }
-    }
-
-    this.verbose = verbose ?? 0;
-    // Update logger verbosity level
-    this.stagehandLogger.setVerbosity(this.verbose);
-
-    if (llmClient) {
-      this.llmClient = llmClient;
-    } else {
-      try {
-        // try to set a default LLM client
-        this.llmClient = this.llmProvider.getClient(
-          modelName ?? DEFAULT_MODEL_NAME,
-          modelClientOptions,
-        );
-      } catch {
-        this.llmClient = undefined;
-      }
-    }
-
-    this.domSettleTimeoutMs = domSettleTimeoutMs ?? 30_000;
-    this.headless = localBrowserLaunchOptions?.headless ?? false;
-    this.browserbaseSessionCreateParams = browserbaseSessionCreateParams;
-    this.browserbaseSessionID = browserbaseSessionID;
-    this.userProvidedInstructions = systemPrompt;
-    this.usingAPI = useAPI ?? false;
-    this.modelName = modelName ?? DEFAULT_MODEL_NAME;
-    if (this.usingAPI && env === "LOCAL") {
-      throw new StagehandEnvironmentError("LOCAL", "BROWSERBASE", "API mode");
-    } else if (this.usingAPI && !process.env.STAGEHAND_API_URL) {
-      throw new MissingEnvironmentVariableError(
-        "STAGEHAND_API_URL",
-        "API mode",
-      );
-    } else if (
-      this.usingAPI &&
-      this.llmClient &&
-      this.llmClient.type !== "openai" &&
-      this.llmClient.type !== "anthropic" &&
-      this.llmClient.type !== "google"
-    ) {
-      throw new UnsupportedModelError(
-        ["openai", "anthropic", "google"],
-        "API mode",
-      );
-    }
-    this.waitForCaptchaSolves = waitForCaptchaSolves;
-    this.localBrowserLaunchOptions = localBrowserLaunchOptions;
-
-    if (this.usingAPI) {
-      this.registerSignalHandlers();
-    }
-    this.logInferenceToFile = logInferenceToFile;
-    this.selfHeal = selfHeal;
-    this.disablePino = disablePino;
-  }
-
-  private registerSignalHandlers() {
-    const cleanup = async (signal: string) => {
-      if (this.cleanupCalled) return;
-      this.cleanupCalled = true;
-
-      this.stagehandLogger.info(
-        `[${signal}] received. Ending Browserbase session...`,
-      );
-      try {
-        await this.close();
-      } catch (err) {
-        this.stagehandLogger.error("Error ending Browserbase session:", {
-          error: String(err),
-        });
-      } finally {
-        // Exit explicitly once cleanup is done
-        process.exit(0);
-      }
-    };
-
-    process.once("SIGINT", () => void cleanup("SIGINT"));
-    process.once("SIGTERM", () => void cleanup("SIGTERM"));
-  }
-
-  public get logger(): (logLine: LogLine) => void {
-    return (logLine: LogLine) => {
-      this.log(logLine);
-    };
-  }
-
-  public get env(): "LOCAL" | "BROWSERBASE" {
-    if (this._env === "BROWSERBASE") {
-      if (!this.apiKey) {
-        throw new MissingEnvironmentVariableError(
-          "BROWSERBASE_API_KEY",
-          "Browserbase",
-        );
-      } else if (!this.projectId) {
-        throw new MissingEnvironmentVariableError(
-          "BROWSERBASE_PROJECT_ID",
-          "Browserbase",
-        );
-      }
-      return "BROWSERBASE";
-    } else {
-      return "LOCAL";
-    }
-  }
-
-  public get context(): EnhancedContext {
-    if (!this.stagehandContext) {
-      throw new StagehandNotInitializedError("context");
-    }
-    return this.stagehandContext.context;
-  }
-
-  async init(): Promise<InitResult> {
-    if (isRunningInBun()) {
-      throw new StagehandError(
-        "Playwright does not currently support the Bun runtime environment. " +
-          "Please use Node.js instead. For more information, see: " +
-          "https://github.com/microsoft/playwright/issues/27139",
-      );
-    }
-
-    if (this.usingAPI) {
-      this.apiClient = new StagehandAPI({
-        apiKey: this.apiKey,
-        projectId: this.projectId,
-        logger: this.logger,
-      });
-      const modelApiKey =
-        LLMProvider.getModelProvider(this.modelName) === "openai"
-          ? process.env.OPENAI_API_KEY || this.llmClient.clientOptions.apiKey
-          : LLMProvider.getModelProvider(this.modelName) === "anthropic"
-            ? process.env.ANTHROPIC_API_KEY ||
-              this.llmClient.clientOptions.apiKey
-            : LLMProvider.getModelProvider(this.modelName) === "google"
-              ? process.env.GOOGLE_API_KEY ||
-                this.llmClient.clientOptions.apiKey
-              : undefined;
-
-      const { sessionId } = await this.apiClient.init({
-        modelName: this.modelName,
-        modelApiKey: modelApiKey,
-        domSettleTimeoutMs: this.domSettleTimeoutMs,
-        verbose: this.verbose,
-        debugDom: this.debugDom,
-        systemPrompt: this.userProvidedInstructions,
-        selfHeal: this.selfHeal,
-        waitForCaptchaSolves: this.waitForCaptchaSolves,
-        actionTimeoutMs: this.actTimeoutMs,
-        browserbaseSessionCreateParams: this.browserbaseSessionCreateParams,
-        browserbaseSessionID: this.browserbaseSessionID,
-      });
-      this.browserbaseSessionID = sessionId;
-    }
-
-    const { context, debugUrl, sessionUrl, contextPath, sessionId } =
-      await getBrowser(
-        this.apiKey,
-        this.projectId,
-        this.env,
-        this.headless,
-        this.logger,
-        this.browserbaseSessionCreateParams,
-        this.browserbaseSessionID,
-        this.localBrowserLaunchOptions,
-      ).catch((e) => {
-        this.stagehandLogger.error("Error in init:", { error: String(e) });
-        const br: BrowserResult = {
-          context: undefined,
-          debugUrl: undefined,
-          sessionUrl: undefined,
-          sessionId: undefined,
-          env: this.env,
-        };
-        return br;
-      });
-    this.contextPath = contextPath;
-
-    this.stagehandContext = await StagehandContext.init(context, this);
-
-    const defaultPage = (await this.stagehandContext.getStagehandPages())[0];
-    this.stagehandPage = defaultPage;
-
-    if (this.headless) {
-      await this.page.setViewportSize({ width: 1280, height: 720 });
-    }
-
-    await this.context.addInitScript({
-      content: scriptContent,
-    });
-
-    this.browserbaseSessionID = sessionId;
-
-    return { debugUrl, sessionUrl, sessionId };
-  }
-
-  log(logObj: LogLine): void {
-    logObj.level = logObj.level ?? 1;
-
-    // Use our Pino-based logger
-    this.stagehandLogger.log(logObj);
-  }
-
-  /** @deprecated Use stagehand.page.act() instead. This will be removed in the next major release. */
-  async act(options: ActOptions): Promise<ActResult> {
-    return await this.stagehandPage.act(options);
-  }
-
-  /** @deprecated Use stagehand.page.extract() instead. This will be removed in the next major release. */
-  async extract<T extends z.AnyZodObject>(
-    options: ExtractOptions<T>,
-  ): Promise<ExtractResult<T>> {
-    return await this.stagehandPage.extract(options);
-  }
-
-  /** @deprecated Use stagehand.page.observe() instead. This will be removed in the next major release. */
-  async observe(options?: ObserveOptions): Promise<ObserveResult[]> {
-    return await this.stagehandPage.observe(options);
-  }
-
-  async close(): Promise<void> {
-    if (this.apiClient) {
-      const response = await this.apiClient.end();
-      const body: ApiResponse<unknown> = await response.json();
-      if (!body.success) {
-        if (response.status == 409) {
-          this.log({
-            category: "close",
-            message:
-              "Warning: attempted to end a session that is not currently active",
-            level: 0,
-          });
-        } else {
-          throw new StagehandError((body as ErrorResponse).message);
-        }
-      }
-      return;
-    } else {
-      await this.context.close();
-    }
-
-    if (this.contextPath) {
-      try {
-        fs.rmSync(this.contextPath, { recursive: true, force: true });
-      } catch (e) {
-        console.error("Error deleting context directory:", e);
-      }
-    }
-  }
-
-  /**
-   * Create an agent instance that can be executed with different instructions
-   * @returns An agent instance with execute() method
-   */
-  agent(options?: AgentConfig): {
-    execute: (
-      instructionOrOptions: string | AgentExecuteOptions,
-    ) => Promise<AgentResult>;
-  } {
-    if (!options || !options.provider) {
-      // use open operator agent
-      return {
-        execute: async (instructionOrOptions: string | AgentExecuteOptions) => {
-          return new StagehandOperatorHandler(
-            this.stagehandPage,
-            this.logger,
-            this.llmClient,
-          ).execute(instructionOrOptions);
-        },
-      };
-    }
-
-    const agentHandler = new StagehandAgentHandler(
-      this.stagehandPage,
-      this.logger,
-      {
-        modelName: options.model,
-        clientOptions: options.options,
-        userProvidedInstructions:
-          options.instructions ??
-          `You are a helpful assistant that can use a web browser.
-      You are currently on the following page: ${this.stagehandPage.page.url()}.
-      Do not ask follow up questions, the user will trust your judgement.`,
-        agentType: options.provider,
-      },
-    );
-
-    this.log({
-      category: "agent",
-      message: "Creating agent instance",
-      level: 1,
-    });
-
-    return {
-      execute: async (instructionOrOptions: string | AgentExecuteOptions) => {
-        const executeOptions: AgentExecuteOptions =
-          typeof instructionOrOptions === "string"
-            ? { instruction: instructionOrOptions }
-            : instructionOrOptions;
-
-        if (!executeOptions.instruction) {
-          throw new StagehandError(
-            "Instruction is required for agent execution",
-          );
-        }
-
-        if (this.usingAPI) {
-          if (!this.apiClient) {
-            throw new StagehandNotInitializedError("API client");
-          }
-
-          if (!options.options) {
-            options.options = {};
-          }
-
-          if (options.provider === "anthropic") {
-            options.options.apiKey = process.env.ANTHROPIC_API_KEY;
-          } else if (options.provider === "openai") {
-            options.options.apiKey = process.env.OPENAI_API_KEY;
-          } else if (options.provider === "google") {
-            options.options.apiKey = process.env.GOOGLE_API_KEY;
-          }
-
-          if (!options.options.apiKey) {
-            throw new StagehandError(
-              `API key not found for \`${options.provider}\` provider. Please set the ${options.provider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY"} environment variable or pass an apiKey in the options object.`,
-            );
-          }
-
-          return await this.apiClient.agentExecute(options, executeOptions);
-        }
-
-        return await agentHandler.execute(executeOptions);
-      },
-    };
-  }
-
-  public get history(): ReadonlyArray<HistoryEntry> {
-    if (!this.stagehandPage) {
-      throw new StagehandNotInitializedError("history()");
-    }
-
-    return this.stagehandPage.history;
-  }
-}
-
-export * from "../types/browser";
-export * from "../types/log";
-export * from "../types/model";
-export * from "../types/page";
-export * from "../types/playwright";
-export * from "../types/stagehand";
-export * from "../types/operator";
-export * from "../types/agent";
-export * from "./llm/LLMClient";
-export * from "../types/stagehandErrors";
-export * from "../types/stagehandApiErrors";
diff --git a/lib/inference.ts b/lib/inference.ts
deleted file mode 100644
index 82565ceaf..000000000
--- a/lib/inference.ts
+++ /dev/null
@@ -1,499 +0,0 @@
-import { z } from "zod";
-import { LogLine } from "../types/log";
-import { ChatMessage, LLMClient } from "./llm/LLMClient";
-import {
-  buildExtractSystemPrompt,
-  buildExtractUserPrompt,
-  buildMetadataPrompt,
-  buildMetadataSystemPrompt,
-  buildObserveSystemPrompt,
-  buildObserveUserMessage,
-  buildRefineSystemPrompt,
-  buildRefineUserPrompt,
-} from "./prompt";
-import {
-  appendSummary,
-  writeTimestampedTxtFile,
-} from "@/lib/inferenceLogUtils";
-
-/**
- * Replaces <|VARIABLE|> placeholders in a text with user-provided values.
- */
-export function fillInVariables(
-  text: string,
-  variables: Record<string, string>,
-) {
-  let processedText = text;
-  Object.entries(variables).forEach(([key, value]) => {
-    const placeholder = `<|${key.toUpperCase()}|>`;
-    processedText = processedText.replace(placeholder, value);
-  });
-  return processedText;
-}
-
-/** Simple usage shape if your LLM returns usage tokens. */
-interface LLMUsage {
-  prompt_tokens: number;
-  completion_tokens: number;
-  total_tokens: number;
-}
-
-/**
- * For calls that use a schema: the LLMClient may return { data: T; usage?: LLMUsage }
- */
-export interface LLMParsedResponse<T> {
-  data: T;
-  usage?: LLMUsage;
-}
-
-export async function extract({
-  instruction,
-  previouslyExtractedContent,
-  domElements,
-  schema,
-  llmClient,
-  chunksSeen,
-  chunksTotal,
-  requestId,
-  logger,
-  isUsingTextExtract,
-  userProvidedInstructions,
-  logInferenceToFile = false,
-}: {
-  instruction: string;
-  previouslyExtractedContent: object;
-  domElements: string;
-  schema: z.ZodObject<z.ZodRawShape>;
-  llmClient: LLMClient;
-  chunksSeen: number;
-  chunksTotal: number;
-  requestId: string;
-  isUsingTextExtract?: boolean;
-  userProvidedInstructions?: string;
-  logger: (message: LogLine) => void;
-  logInferenceToFile?: boolean;
-}) {
-  const metadataSchema = z.object({
-    progress: z
-      .string()
-      .describe(
-        "progress of what has been extracted so far, as concise as possible",
-      ),
-    completed: z
-      .boolean()
-      .describe(
-        "true if the goal is now accomplished. Use this conservatively, only when sure that the goal has been completed.",
-      ),
-  });
-
-  type ExtractionResponse = z.infer<typeof schema>;
-  type MetadataResponse = z.infer<typeof metadataSchema>;
-
-  const isUsingAnthropic = llmClient.type === "anthropic";
-
-  const extractCallMessages: ChatMessage[] = [
-    buildExtractSystemPrompt(
-      isUsingAnthropic,
-      isUsingTextExtract,
-      userProvidedInstructions,
-    ),
-    buildExtractUserPrompt(instruction, domElements, isUsingAnthropic),
-  ];
-
-  let extractCallFile = "";
-  let extractCallTimestamp = "";
-  if (logInferenceToFile) {
-    const { fileName, timestamp } = writeTimestampedTxtFile(
-      "extract_summary",
-      "extract_call",
-      {
-        requestId,
-        modelCall: "extract",
-        messages: extractCallMessages,
-      },
-    );
-    extractCallFile = fileName;
-    extractCallTimestamp = timestamp;
-  }
-
-  const extractStartTime = Date.now();
-  const extractionResponse =
-    await llmClient.createChatCompletion<ExtractionResponse>({
-      options: {
-        messages: extractCallMessages,
-        response_model: {
-          schema,
-          name: "Extraction",
-        },
-        temperature: 0.1,
-        top_p: 1,
-        frequency_penalty: 0,
-        presence_penalty: 0,
-        requestId,
-      },
-      logger,
-    });
-  const extractEndTime = Date.now();
-
-  const { data: extractedData, usage: extractUsage } =
-    extractionResponse as LLMParsedResponse<ExtractionResponse>;
-
-  let extractResponseFile = "";
-  if (logInferenceToFile) {
-    const { fileName } = writeTimestampedTxtFile(
-      "extract_summary",
-      "extract_response",
-      {
-        requestId,
-        modelResponse: "extract",
-        rawResponse: extractedData,
-      },
-    );
-    extractResponseFile = fileName;
-
-    appendSummary("extract", {
-      extract_inference_type: "extract",
-      timestamp: extractCallTimestamp,
-      LLM_input_file: extractCallFile,
-      LLM_output_file: extractResponseFile,
-      prompt_tokens: extractUsage?.prompt_tokens ?? 0,
-      completion_tokens: extractUsage?.completion_tokens ?? 0,
-      inference_time_ms: extractEndTime - extractStartTime,
-    });
-  }
-
-  const refineCallMessages: ChatMessage[] = [
-    buildRefineSystemPrompt(),
-    buildRefineUserPrompt(
-      instruction,
-      previouslyExtractedContent,
-      extractedData,
-    ),
-  ];
-
-  let refineCallFile = "";
-  let refineCallTimestamp = "";
-  if (logInferenceToFile) {
-    const { fileName, timestamp } = writeTimestampedTxtFile(
-      "extract_summary",
-      "refine_call",
-      {
-        requestId,
-        modelCall: "refine",
-        messages: refineCallMessages,
-      },
-    );
-    refineCallFile = fileName;
-    refineCallTimestamp = timestamp;
-  }
-
-  const refineStartTime = Date.now();
-  const refinedResponse =
-    await llmClient.createChatCompletion<ExtractionResponse>({
-      options: {
-        messages: refineCallMessages,
-        response_model: {
-          schema,
-          name: "RefinedExtraction",
-        },
-        temperature: 0.1,
-        top_p: 1,
-        frequency_penalty: 0,
-        presence_penalty: 0,
-        requestId,
-      },
-      logger,
-    });
-  const refineEndTime = Date.now();
-
-  const { data: refinedResponseData, usage: refinedResponseUsage } =
-    refinedResponse as LLMParsedResponse<ExtractionResponse>;
-
-  let refineResponseFile = "";
-  if (logInferenceToFile) {
-    const { fileName } = writeTimestampedTxtFile(
-      "extract_summary",
-      "refine_response",
-      {
-        requestId,
-        modelResponse: "refine",
-        rawResponse: refinedResponseData,
-      },
-    );
-    refineResponseFile = fileName;
-
-    appendSummary("extract", {
-      extract_inference_type: "refine",
-      timestamp: refineCallTimestamp,
-      LLM_input_file: refineCallFile,
-      LLM_output_file: refineResponseFile,
-      prompt_tokens: refinedResponseUsage?.prompt_tokens ?? 0,
-      completion_tokens: refinedResponseUsage?.completion_tokens ?? 0,
-      inference_time_ms: refineEndTime - refineStartTime,
-    });
-  }
-
-  const metadataCallMessages: ChatMessage[] = [
-    buildMetadataSystemPrompt(),
-    buildMetadataPrompt(
-      instruction,
-      refinedResponseData,
-      chunksSeen,
-      chunksTotal,
-    ),
-  ];
-
-  let metadataCallFile = "";
-  let metadataCallTimestamp = "";
-  if (logInferenceToFile) {
-    const { fileName, timestamp } = writeTimestampedTxtFile(
-      "extract_summary",
-      "metadata_call",
-      {
-        requestId,
-        modelCall: "metadata",
-        messages: metadataCallMessages,
-      },
-    );
-    metadataCallFile = fileName;
-    metadataCallTimestamp = timestamp;
-  }
-
-  const metadataStartTime = Date.now();
-  const metadataResponse =
-    await llmClient.createChatCompletion<MetadataResponse>({
-      options: {
-        messages: metadataCallMessages,
-        response_model: {
-          name: "Metadata",
-          schema: metadataSchema,
-        },
-        temperature: 0.1,
-        top_p: 1,
-        frequency_penalty: 0,
-        presence_penalty: 0,
-        requestId,
-      },
-      logger,
-    });
-  const metadataEndTime = Date.now();
-
-  const {
-    data: {
-      completed: metadataResponseCompleted,
-      progress: metadataResponseProgress,
-    },
-    usage: metadataResponseUsage,
-  } = metadataResponse as LLMParsedResponse<MetadataResponse>;
-
-  let metadataResponseFile = "";
-  if (logInferenceToFile) {
-    const { fileName } = writeTimestampedTxtFile(
-      "extract_summary",
-      "metadata_response",
-      {
-        requestId,
-        modelResponse: "metadata",
-        completed: metadataResponseCompleted,
-        progress: metadataResponseProgress,
-      },
-    );
-    metadataResponseFile = fileName;
-
-    appendSummary("extract", {
-      extract_inference_type: "metadata",
-      timestamp: metadataCallTimestamp,
-      LLM_input_file: metadataCallFile,
-      LLM_output_file: metadataResponseFile,
-      prompt_tokens: metadataResponseUsage?.prompt_tokens ?? 0,
-      completion_tokens: metadataResponseUsage?.completion_tokens ?? 0,
-      inference_time_ms: metadataEndTime - metadataStartTime,
-    });
-  }
-
-  const totalPromptTokens =
-    (extractUsage?.prompt_tokens ?? 0) +
-    (refinedResponseUsage?.prompt_tokens ?? 0) +
-    (metadataResponseUsage?.prompt_tokens ?? 0);
-
-  const totalCompletionTokens =
-    (extractUsage?.completion_tokens ?? 0) +
-    (refinedResponseUsage?.completion_tokens ?? 0) +
-    (metadataResponseUsage?.completion_tokens ?? 0);
-
-  const totalInferenceTimeMs =
-    extractEndTime -
-    extractStartTime +
-    (refineEndTime - refineStartTime) +
-    (metadataEndTime - metadataStartTime);
-
-  return {
-    ...refinedResponseData,
-    metadata: {
-      completed: metadataResponseCompleted,
-      progress: metadataResponseProgress,
-    },
-    prompt_tokens: totalPromptTokens,
-    completion_tokens: totalCompletionTokens,
-    inference_time_ms: totalInferenceTimeMs,
-  };
-}
-
-export async function observe({
-  instruction,
-  domElements,
-  llmClient,
-  requestId,
-  isUsingAccessibilityTree,
-  userProvidedInstructions,
-  logger,
-  returnAction = false,
-  logInferenceToFile = false,
-  fromAct,
-}: {
-  instruction: string;
-  domElements: string;
-  llmClient: LLMClient;
-  requestId: string;
-  userProvidedInstructions?: string;
-  logger: (message: LogLine) => void;
-  isUsingAccessibilityTree?: boolean;
-  returnAction?: boolean;
-  logInferenceToFile?: boolean;
-  fromAct?: boolean;
-}) {
-  const observeSchema = z.object({
-    elements: z
-      .array(
-        z.object({
-          elementId: z.number().describe("the number of the element"),
-          description: z
-            .string()
-            .describe(
-              isUsingAccessibilityTree
-                ? "a description of the accessible element and its purpose"
-                : "a description of the element and what it is relevant for",
-            ),
-          ...(returnAction
-            ? {
-                method: z
-                  .string()
-                  .describe(
-                    "the candidate method/action to interact with the element. Select one of the available Playwright interaction methods.",
-                  ),
-                arguments: z.array(
-                  z
-                    .string()
-                    .describe(
-                      "the arguments to pass to the method. For example, for a click, the arguments are empty, but for a fill, the arguments are the value to fill in.",
-                    ),
-                ),
-              }
-            : {}),
-        }),
-      )
-      .describe(
-        isUsingAccessibilityTree
-          ? "an array of accessible elements that match the instruction"
-          : "an array of elements that match the instruction",
-      ),
-  });
-
-  type ObserveResponse = z.infer<typeof observeSchema>;
-
-  const messages: ChatMessage[] = [
-    buildObserveSystemPrompt(
-      userProvidedInstructions,
-      isUsingAccessibilityTree,
-    ),
-    buildObserveUserMessage(instruction, domElements, isUsingAccessibilityTree),
-  ];
-
-  const filePrefix = fromAct ? "act" : "observe";
-  let callTimestamp = "";
-  let callFile = "";
-  if (logInferenceToFile) {
-    const { fileName, timestamp } = writeTimestampedTxtFile(
-      `${filePrefix}_summary`,
-      `${filePrefix}_call`,
-      {
-        requestId,
-        modelCall: filePrefix,
-        messages,
-      },
-    );
-    callFile = fileName;
-    callTimestamp = timestamp;
-  }
-
-  const start = Date.now();
-  const rawResponse = await llmClient.createChatCompletion<ObserveResponse>({
-    options: {
-      messages,
-      response_model: {
-        schema: observeSchema,
-        name: "Observation",
-      },
-      temperature: 0.1,
-      top_p: 1,
-      frequency_penalty: 0,
-      presence_penalty: 0,
-      requestId,
-    },
-    logger,
-  });
-  const end = Date.now();
-  const usageTimeMs = end - start;
-
-  const { data: observeData, usage: observeUsage } =
-    rawResponse as LLMParsedResponse<ObserveResponse>;
-  const promptTokens = observeUsage?.prompt_tokens ?? 0;
-  const completionTokens = observeUsage?.completion_tokens ?? 0;
-
-  let responseFile = "";
-  if (logInferenceToFile) {
-    const { fileName: responseFileName } = writeTimestampedTxtFile(
-      `${filePrefix}_summary`,
-      `${filePrefix}_response`,
-      {
-        requestId,
-        modelResponse: filePrefix,
-        rawResponse: observeData,
-      },
-    );
-    responseFile = responseFileName;
-
-    appendSummary(filePrefix, {
-      [`${filePrefix}_inference_type`]: filePrefix,
-      timestamp: callTimestamp,
-      LLM_input_file: callFile,
-      LLM_output_file: responseFile,
-      prompt_tokens: promptTokens,
-      completion_tokens: completionTokens,
-      inference_time_ms: usageTimeMs,
-    });
-  }
-
-  const parsedElements =
-    observeData.elements?.map((el) => {
-      const base = {
-        elementId: Number(el.elementId),
-        description: String(el.description),
-      };
-      if (returnAction) {
-        return {
-          ...base,
-          method: String(el.method),
-          arguments: el.arguments,
-        };
-      }
-      return base;
-    }) ?? [];
-
-  return {
-    elements: parsedElements,
-    prompt_tokens: promptTokens,
-    completion_tokens: completionTokens,
-    inference_time_ms: usageTimeMs,
-  };
-}
diff --git a/lib/llm/LLMProvider.ts b/lib/llm/LLMProvider.ts
deleted file mode 100644
index f4fc51e64..000000000
--- a/lib/llm/LLMProvider.ts
+++ /dev/null
@@ -1,137 +0,0 @@
-import { LogLine } from "../../types/log";
-import {
-  AvailableModel,
-  ClientOptions,
-  ModelProvider,
-} from "../../types/model";
-import { LLMCache } from "../cache/LLMCache";
-import { AnthropicClient } from "./AnthropicClient";
-import { CerebrasClient } from "./CerebrasClient";
-import { GoogleClient } from "./GoogleClient";
-import { GroqClient } from "./GroqClient";
-import { LLMClient } from "./LLMClient";
-import { OpenAIClient } from "./OpenAIClient";
-import {
-  UnsupportedModelError,
-  UnsupportedModelProviderError,
-} from "@/types/stagehandErrors";
-
-const modelToProviderMap: { [key in AvailableModel]: ModelProvider } = {
-  "gpt-4o": "openai",
-  "gpt-4o-mini": "openai",
-  "gpt-4o-2024-08-06": "openai",
-  "gpt-4.5-preview": "openai",
-  "o1-mini": "openai",
-  "o1-preview": "openai",
-  "o3-mini": "openai",
-  "claude-3-5-sonnet-latest": "anthropic",
-  "claude-3-5-sonnet-20240620": "anthropic",
-  "claude-3-5-sonnet-20241022": "anthropic",
-  "claude-3-7-sonnet-20250219": "anthropic",
-  "claude-3-7-sonnet-latest": "anthropic",
-  "cerebras-llama-3.3-70b": "cerebras",
-  "cerebras-llama-3.1-8b": "cerebras",
-  "groq-llama-3.3-70b-versatile": "groq",
-  "groq-llama-3.3-70b-specdec": "groq",
-  "gemini-1.5-flash": "google",
-  "gemini-1.5-pro": "google",
-  "gemini-1.5-flash-8b": "google",
-  "gemini-2.0-flash-lite": "google",
-  "gemini-2.0-flash": "google",
-  "gemini-2.5-flash-preview-04-17": "google",
-  "gemini-2.5-pro-preview-03-25": "google",
-};
-
-export class LLMProvider {
-  private logger: (message: LogLine) => void;
-  private enableCaching: boolean;
-  private cache: LLMCache | undefined;
-
-  constructor(logger: (message: LogLine) => void, enableCaching: boolean) {
-    this.logger = logger;
-    this.enableCaching = enableCaching;
-    this.cache = enableCaching ? new LLMCache(logger) : undefined;
-  }
-
-  cleanRequestCache(requestId: string): void {
-    if (!this.enableCaching) {
-      return;
-    }
-
-    this.logger({
-      category: "llm_cache",
-      message: "cleaning up cache",
-      level: 1,
-      auxiliary: {
-        requestId: {
-          value: requestId,
-          type: "string",
-        },
-      },
-    });
-    this.cache.deleteCacheForRequestId(requestId);
-  }
-
-  getClient(
-    modelName: AvailableModel,
-    clientOptions?: ClientOptions,
-  ): LLMClient {
-    const provider = modelToProviderMap[modelName];
-    if (!provider) {
-      throw new UnsupportedModelError(Object.keys(modelToProviderMap));
-    }
-
-    switch (provider) {
-      case "openai":
-        return new OpenAIClient({
-          logger: this.logger,
-          enableCaching: this.enableCaching,
-          cache: this.cache,
-          modelName,
-          clientOptions,
-        });
-      case "anthropic":
-        return new AnthropicClient({
-          logger: this.logger,
-          enableCaching: this.enableCaching,
-          cache: this.cache,
-          modelName,
-          clientOptions,
-        });
-      case "cerebras":
-        return new CerebrasClient({
-          logger: this.logger,
-          enableCaching: this.enableCaching,
-          cache: this.cache,
-          modelName,
-          clientOptions,
-        });
-      case "groq":
-        return new GroqClient({
-          logger: this.logger,
-          enableCaching: this.enableCaching,
-          cache: this.cache,
-          modelName,
-          clientOptions,
-        });
-      case "google":
-        return new GoogleClient({
-          logger: this.logger,
-          enableCaching: this.enableCaching,
-          cache: this.cache,
-          modelName,
-          clientOptions,
-        });
-      default:
-        throw new UnsupportedModelProviderError([
-          ...new Set(Object.values(modelToProviderMap)),
-        ]);
-    }
-  }
-
-  static getModelProvider(modelName: AvailableModel): ModelProvider {
-    const provider = modelToProviderMap[modelName];
-
-    return provider;
-  }
-}
diff --git a/lib/prompt.ts b/lib/prompt.ts
deleted file mode 100644
index 1c414d8aa..000000000
--- a/lib/prompt.ts
+++ /dev/null
@@ -1,235 +0,0 @@
-import { ChatMessage } from "./llm/LLMClient";
-
-export function buildUserInstructionsString(
-  userProvidedInstructions?: string,
-): string {
-  if (!userProvidedInstructions) {
-    return "";
-  }
-
-  return `\n\n# Custom Instructions Provided by the User
-    
-Please keep the user's instructions in mind when performing actions. If the user's instructions are not relevant to the current task, ignore them.
-
-User Instructions:
-${userProvidedInstructions}`;
-}
-
-// extract
-export function buildExtractSystemPrompt(
-  isUsingPrintExtractedDataTool: boolean = false,
-  useTextExtract: boolean = false,
-  userProvidedInstructions?: string,
-): ChatMessage {
-  const baseContent = `You are extracting content on behalf of a user.
-  If a user asks you to extract a 'list' of information, or 'all' information, 
-  YOU MUST EXTRACT ALL OF THE INFORMATION THAT THE USER REQUESTS.
-   
-  You will be given:
-1. An instruction
-2. `;
-
-  const contentDetail = useTextExtract
-    ? `A text representation of a webpage to extract information from.`
-    : `A list of DOM elements to extract from.`;
-
-  const instructions = `
-Print the exact text from the ${
-    useTextExtract ? "text-rendered webpage" : "DOM elements"
-  } with all symbols, characters, and endlines as is.
-Print null or an empty string if no new information is found.
-  `.trim();
-
-  const toolInstructions = isUsingPrintExtractedDataTool
-    ? `
-ONLY print the content using the print_extracted_data tool provided.
-ONLY print the content using the print_extracted_data tool provided.
-  `.trim()
-    : "";
-
-  const additionalInstructions = useTextExtract
-    ? `Once you are given the text-rendered webpage, 
-    you must thoroughly and meticulously analyze it. Be very careful to ensure that you
-    do not miss any important information.`
-    : "If a user is attempting to extract links or URLs, you MUST respond with ONLY the IDs of the link elements. \n" +
-      "Do not attempt to extract links directly from the text unless absolutely necessary. ";
-
-  const userInstructions = buildUserInstructionsString(
-    userProvidedInstructions,
-  );
-
-  const content =
-    `${baseContent}${contentDetail}\n\n${instructions}\n${toolInstructions}${
-      additionalInstructions ? `\n\n${additionalInstructions}` : ""
-    }${userInstructions ? `\n\n${userInstructions}` : ""}`.replace(/\s+/g, " ");
-
-  return {
-    role: "system",
-    content,
-  };
-}
-
-export function buildExtractUserPrompt(
-  instruction: string,
-  domElements: string,
-  isUsingPrintExtractedDataTool: boolean = false,
-): ChatMessage {
-  let content = `Instruction: ${instruction}
-DOM: ${domElements}`;
-
-  if (isUsingPrintExtractedDataTool) {
-    content += `
-ONLY print the content using the print_extracted_data tool provided.
-ONLY print the content using the print_extracted_data tool provided.`;
-  }
-
-  return {
-    role: "user",
-    content,
-  };
-}
-
-const refineSystemPrompt = `You are tasked with refining and filtering information for the final output based on newly extracted and previously extracted content. Your responsibilities are:
-1. Remove exact duplicates for elements in arrays and objects.
-2. For text fields, append or update relevant text if the new content is an extension, replacement, or continuation.
-3. For non-text fields (e.g., numbers, booleans), update with new values if they differ.
-4. Add any completely new fields or objects ONLY IF they correspond to the provided schema.
-
-Return the updated content that includes both the previous content and the new, non-duplicate, or extended information.`;
-
-export function buildRefineSystemPrompt(): ChatMessage {
-  return {
-    role: "system",
-    content: refineSystemPrompt,
-  };
-}
-
-export function buildRefineUserPrompt(
-  instruction: string,
-  previouslyExtractedContent: object,
-  newlyExtractedContent: object,
-): ChatMessage {
-  return {
-    role: "user",
-    content: `Instruction: ${instruction}
-Previously extracted content: ${JSON.stringify(previouslyExtractedContent, null, 2)}
-Newly extracted content: ${JSON.stringify(newlyExtractedContent, null, 2)}
-Refined content:`,
-  };
-}
-
-const metadataSystemPrompt = `You are an AI assistant tasked with evaluating the progress and completion status of an extraction task.
-Analyze the extraction response and determine if the task is completed or if more information is needed.
-Strictly abide by the following criteria:
-1. Once the instruction has been satisfied by the current extraction response, ALWAYS set completion status to true and stop processing, regardless of remaining chunks.
-2. Only set completion status to false if BOTH of these conditions are true:
-   - The instruction has not been satisfied yet
-   - There are still chunks left to process (chunksTotal > chunksSeen)`;
-
-export function buildMetadataSystemPrompt(): ChatMessage {
-  return {
-    role: "system",
-    content: metadataSystemPrompt,
-  };
-}
-
-export function buildMetadataPrompt(
-  instruction: string,
-  extractionResponse: object,
-  chunksSeen: number,
-  chunksTotal: number,
-): ChatMessage {
-  return {
-    role: "user",
-    content: `Instruction: ${instruction}
-Extracted content: ${JSON.stringify(extractionResponse, null, 2)}
-chunksSeen: ${chunksSeen}
-chunksTotal: ${chunksTotal}`,
-  };
-}
-
-// observe
-export function buildObserveSystemPrompt(
-  userProvidedInstructions?: string,
-  isUsingAccessibilityTree = false,
-): ChatMessage {
-  const observeSystemPrompt = `
-You are helping the user automate the browser by finding elements based on what the user wants to observe in the page.
-
-You will be given:
-1. a instruction of elements to observe
-2. ${
-    isUsingAccessibilityTree
-      ? "a hierarchical accessibility tree showing the semantic structure of the page. The tree is a hybrid of the DOM and the accessibility tree."
-      : "a numbered list of possible elements"
-  }
-
-Return an array of elements that match the instruction if they exist, otherwise return an empty array.`;
-  const content = observeSystemPrompt.replace(/\s+/g, " ");
-
-  return {
-    role: "system",
-    content: [content, buildUserInstructionsString(userProvidedInstructions)]
-      .filter(Boolean)
-      .join("\n\n"),
-  };
-}
-
-export function buildObserveUserMessage(
-  instruction: string,
-  domElements: string,
-  isUsingAccessibilityTree = false,
-): ChatMessage {
-  return {
-    role: "user",
-    content: `instruction: ${instruction}
-${isUsingAccessibilityTree ? "Accessibility Tree" : "DOM"}: ${domElements}`,
-  };
-}
-
-/**
- * Builds the instruction for the observeAct method to find the most relevant element for an action
- */
-export function buildActObservePrompt(
-  action: string,
-  supportedActions: string[],
-  variables?: Record<string, string>,
-): string {
-  // Base instruction
-  let instruction = `Find the most relevant element to perform an action on given the following action: ${action}. 
-  Provide an action for this element such as ${supportedActions.join(", ")}, or any other playwright locator method. Remember that to users, buttons and links look the same in most cases.
-  If the action is completely unrelated to a potential action to be taken on the page, return an empty array. 
-  ONLY return one action. If multiple actions are relevant, return the most relevant one. 
-  If the user is asking to scroll to a position on the page, e.g., 'halfway' or 0.75, etc, you must return the argument formatted as the correct percentage, e.g., '50%' or '75%', etc.
-  If the user is asking to scroll to the next chunk/previous chunk, choose the nextChunk/prevChunk method. No arguments are required here.
-  If the action implies a key press, e.g., 'press enter', 'press a', 'press space', etc., always choose the press method with the appropriate key as argument — e.g. 'a', 'Enter', 'Space'. Do not choose a click action on an on-screen keyboard. Capitalize the first character like 'Enter', 'Tab', 'Escape' only for special keys.`;
-
-  // Add variable names (not values) to the instruction if any
-  if (variables && Object.keys(variables).length > 0) {
-    const variablesPrompt = `The following variables are available to use in the action: ${Object.keys(variables).join(", ")}. Fill the argument variables with the variable name.`;
-    instruction += ` ${variablesPrompt}`;
-  }
-
-  return instruction;
-}
-
-export function buildOperatorSystemPrompt(goal: string): ChatMessage {
-  return {
-    role: "system",
-    content: `You are a general-purpose agent whose job is to accomplish the user's goal across multiple model calls by running actions on the page.
-
-You will be given a goal and a list of steps that have been taken so far. Your job is to determine if either the user's goal has been completed or if there are still steps that need to be taken.
-
-# Your current goal
-${goal}
-
-# Important guidelines
-1. Break down complex actions into individual atomic steps
-2. For \`act\` commands, use only one action at a time, such as:
-   - Single click on a specific element
-   - Type into a single input field
-   - Select a single option
-3. Avoid combining multiple actions in one instruction
-4. If multiple actions are needed, they should be separate steps`,
-  };
-}
diff --git a/lib/utils.ts b/lib/utils.ts
deleted file mode 100644
index 0887bcb11..000000000
--- a/lib/utils.ts
+++ /dev/null
@@ -1,444 +0,0 @@
-import crypto from "crypto";
-import { z } from "zod";
-import { ObserveResult, Page } from ".";
-import { LogLine } from "../types/log";
-import { TextAnnotation } from "../types/textannotation";
-
-// This is a heuristic for the width of a character in pixels. It seems to work
-// better than attempting to calculate character widths dynamically, which sometimes
-// results in collisions when placing characters on the "canvas".
-const HEURISTIC_CHAR_WIDTH = 5;
-
-export function generateId(operation: string) {
-  return crypto.createHash("sha256").update(operation).digest("hex");
-}
-
-/**
- * `formatText` converts a list of text annotations into a formatted text representation.
- * Each annotation represents a piece of text at a certain position on a webpage.
- * The formatting attempts to reconstruct a textual "screenshot" of the page by:
- * - Grouping annotations into lines based on their vertical positions.
- * - Adjusting spacing to reflect line gaps.
- * - Attempting to preserve relative positions and formatting.
- *
- * The output is a text block, optionally surrounded by lines of dashes, that aims
- * to closely mirror the visual layout of the text on the page.
- *
- * @param textAnnotations - An array of TextAnnotations describing text and their positions.
- * @param pageWidth - The width of the page in pixels, used to normalize positions.
- * @returns A string representing the text layout of the page.
- */
-export function formatText(
-  textAnnotations: TextAnnotation[],
-  pageWidth: number,
-): string {
-  // **1: Sort annotations by vertical position (y-coordinate).**
-  //    The topmost annotations appear first, the bottommost last.
-  const sortedAnnotations = [...textAnnotations].sort(
-    (a, b) => a.bottom_left.y - b.bottom_left.y,
-  );
-
-  // **2: Group annotations by line based on their y-coordinate.**
-  //    We use an epsilon so that very close y-values are treated as the same line.
-  const epsilon = 1;
-  const lineMap: Map<number, TextAnnotation[]> = new Map();
-
-  for (const annotation of sortedAnnotations) {
-    let foundLineY: number | undefined;
-    // **3: Check if this annotation belongs to any existing line group.**
-    for (const key of lineMap.keys()) {
-      if (Math.abs(key - annotation.bottom_left.y) < epsilon) {
-        foundLineY = key;
-        break;
-      }
-    }
-
-    // If found, push into that line; otherwise, create a new line entry.
-    if (foundLineY !== undefined) {
-      lineMap.get(foundLineY)!.push(annotation);
-    } else {
-      lineMap.set(annotation.bottom_left.y, [annotation]);
-    }
-  }
-
-  // **4: Get all unique y-coordinates for lines and sort them top-to-bottom.**
-  const lineYs = Array.from(lineMap.keys()).sort((a, b) => a - b);
-
-  // **5: Build an array of "final lines" (TextAnnotations[]) by grouping words for each line.**
-  const finalLines: TextAnnotation[][] = [];
-
-  for (const lineY of lineYs) {
-    const lineAnnotations = lineMap.get(lineY)!;
-
-    // **6: Sort annotations in the current line left-to-right by x-coordinate.**
-    lineAnnotations.sort((a, b) => a.bottom_left.x - b.bottom_left.x);
-
-    // **7: Group annotations into word clusters (sentences/phrases).**
-    const groupedLineAnnotations = groupWordsInSentence(lineAnnotations);
-
-    // **8: Push the grouped annotations for this line into finalLines.**
-    finalLines.push(groupedLineAnnotations);
-  }
-
-  // -------------------------
-  // **First Pass**: Calculate the width of the longest line (in characters) up front.
-  // We will use this to set the width of the canvas, which will reduce likelihood of collisions.
-  // -------------------------
-  let maxLineWidthInChars = 0;
-
-  for (const line of finalLines) {
-    let lineMaxEnd = 0;
-    for (const ann of line) {
-      // Convert normalized X to character index
-      const startXInChars = Math.round(
-        ann.bottom_left_normalized.x * (pageWidth / HEURISTIC_CHAR_WIDTH),
-      );
-      // Each annotation spans ann.text.length characters
-      const endXInChars = startXInChars + ann.text.length;
-
-      if (endXInChars > lineMaxEnd) {
-        lineMaxEnd = endXInChars;
-      }
-    }
-    // Track the largest width across all lines
-    if (lineMaxEnd > maxLineWidthInChars) {
-      maxLineWidthInChars = lineMaxEnd;
-    }
-  }
-
-  // **9: Add a 20-char buffer to ensure we don’t cut off text.**
-  maxLineWidthInChars += 20;
-
-  // **10: Determine the canvas width based on the measured maxLineWidthInChars.**
-  const canvasWidth = Math.max(maxLineWidthInChars, 1);
-
-  // **11: Compute the baseline (lowest y) of each line to measure vertical spacing.**
-  const lineBaselines = finalLines.map((line) =>
-    Math.min(...line.map((a) => a.bottom_left.y)),
-  );
-
-  // **12: Compute the gaps between consecutive lines.**
-  const verticalGaps: number[] = [];
-  for (let i = 1; i < lineBaselines.length; i++) {
-    verticalGaps.push(lineBaselines[i] - lineBaselines[i - 1]);
-  }
-
-  // **13: Estimate a "normal" line spacing via the median of these gaps.**
-  const normalLineSpacing = verticalGaps.length > 0 ? median(verticalGaps) : 0;
-
-  // **14: Create a 2D character canvas (array of arrays), filled with spaces.**
-  let canvas: string[][] = [];
-
-  // **15: lineIndex tracks which row of the canvas we’re on; start at -1 so the first line is index 0.**
-  let lineIndex = -1;
-
-  // **16: Render each line of text into our canvas.**
-  for (let i = 0; i < finalLines.length; i++) {
-    if (i === 0) {
-      // **17: For the very first line, just increment lineIndex once.**
-      lineIndex++;
-      ensureLineExists(canvas, lineIndex, canvasWidth);
-    } else {
-      // **18: For subsequent lines, figure out how many blank lines to insert
-      //       based on the gap between this line’s baseline and the previous line’s baseline.**
-      const gap = lineBaselines[i] - lineBaselines[i - 1];
-
-      let extraLines = 0;
-      // **19: If the gap is significantly larger than the "normal" spacing,
-      //       insert blank lines proportionally.**
-      if (normalLineSpacing > 0 && gap > 1.2 * normalLineSpacing) {
-        extraLines = Math.max(Math.round(gap / normalLineSpacing) - 1, 0);
-      }
-
-      // **20: Insert the calculated extra blank lines.**
-      for (let e = 0; e < extraLines; e++) {
-        lineIndex++;
-        ensureLineExists(canvas, lineIndex, canvasWidth);
-      }
-
-      // **21: Move to the next line (row) in the canvas for this line’s text.**
-      lineIndex++;
-      ensureLineExists(canvas, lineIndex, canvasWidth);
-    }
-
-    // **22: Place each annotation’s text in the correct horizontal position for this line.**
-    const lineAnnotations = finalLines[i];
-    for (const annotation of lineAnnotations) {
-      const text = annotation.text;
-
-      // **23: Calculate the starting x-position in the canvas by converting normalized x to char space.**
-      const startXInChars = Math.round(
-        annotation.bottom_left_normalized.x *
-          (pageWidth / HEURISTIC_CHAR_WIDTH),
-      );
-
-      // **24: Place each character of the annotation in the canvas.**
-      for (let j = 0; j < text.length; j++) {
-        const xPos = startXInChars + j;
-        // **25: Don’t write beyond the right edge of the canvas.**
-        if (xPos < canvasWidth) {
-          canvas[lineIndex][xPos] = text[j];
-        }
-      }
-    }
-  }
-
-  // **26: Trim trailing whitespace from each line to clean up the output.**
-  canvas = canvas.map((row) => {
-    const lineStr = row.join("");
-    return Array.from(lineStr.trimEnd());
-  });
-
-  // **27: Combine all rows into a single string, separating rows with newlines.**
-  let pageText = canvas.map((line) => line.join("")).join("\n");
-  pageText = pageText.trimEnd();
-
-  // **28: Surround the rendered text with lines of dashes for clarity.**
-  pageText =
-    "-".repeat(canvasWidth) + "\n" + pageText + "\n" + "-".repeat(canvasWidth);
-
-  // **29: Return the final formatted text.**
-  return pageText;
-}
-
-/**
- * `ensureLineExists` ensures that a specified line index exists in the canvas.
- * If the canvas is not long enough, it extends it by adding new empty lines (filled with spaces).
- * This function is used to dynamically grow the canvas as we progress through the lines.
- *
- * @param canvas - The 2D character canvas array.
- * @param lineIndex - The desired line index that must exist.
- * @param width - The width of each line in characters.
- */
-function ensureLineExists(
-  canvas: string[][],
-  lineIndex: number,
-  width: number,
-) {
-  // loop until the canvas has at least lineIndex+1 lines.
-  // each new line is filled with spaces to match the required width.
-  while (lineIndex >= canvas.length) {
-    canvas.push(new Array(width).fill(" "));
-  }
-}
-
-/**
- * `groupWordsInSentence` groups annotations within a single line into logical "words" or "sentences".
- * It uses a set of heuristics involving horizontal proximity and similar height
- * to decide when to join multiple annotations into a single grouped annotation.
- *
- * @param lineAnnotations - An array of annotations from a single line of text.
- * @returns An array of grouped annotations, where each represents one concatenated piece of text.
- */
-function groupWordsInSentence(
-  lineAnnotations: TextAnnotation[],
-): TextAnnotation[] {
-  const groupedAnnotations: TextAnnotation[] = [];
-  let currentGroup: TextAnnotation[] = [];
-
-  for (const annotation of lineAnnotations) {
-    // if the current group is empty, start a new group with this annotation
-    if (currentGroup.length === 0) {
-      currentGroup.push(annotation);
-      continue;
-    }
-
-    // determine horizontal grouping criteria
-    // use a padding factor to allow slight spaces between words
-    const padding = 1;
-    const lastAnn = currentGroup[currentGroup.length - 1];
-    const characterWidth = (lastAnn.width / lastAnn.text.length) * padding;
-    const isWithinHorizontalRange =
-      annotation.bottom_left.x <=
-      lastAnn.bottom_left.x + lastAnn.width + characterWidth;
-
-    // check if the annotation can be grouped with the current group.
-    // conditions:
-    // 1. the height difference from the group's first annotation is ≤ 4 units
-    // 2. the annotation is horizontally close to the last annotation in the group
-    if (
-      Math.abs(annotation.height - currentGroup[0].height) <= 4 &&
-      isWithinHorizontalRange
-    ) {
-      // if it meets the criteria, add to the current group
-      currentGroup.push(annotation);
-    } else {
-      // if it doesn't meet criteria:
-      // 1. finalize the current group into a single grouped annotation,
-      // 2. add it to groupedAnnotations,
-      // 3. start a new group with the current annotation
-      if (currentGroup.length > 0) {
-        const groupedAnnotation = createGroupedAnnotation(currentGroup);
-        if (groupedAnnotation.text.length > 0) {
-          groupedAnnotations.push(groupedAnnotation);
-          currentGroup = [annotation];
-        }
-      }
-    }
-  }
-
-  // after processing all annotations, if there's a remaining group, finalize it too
-  if (currentGroup.length > 0) {
-    const groupedAnnotation = createGroupedAnnotation(currentGroup);
-    groupedAnnotations.push(groupedAnnotation);
-  }
-
-  // return the final array of grouped annotations representing words or phrases
-  return groupedAnnotations;
-}
-
-/**
- * `createGroupedAnnotation` combines a group of annotations into a single annotation by concatenating their text.
- * It also attempts to preserve formatting, such as marking bold text if the median height suggests emphasis.
- *
- * @param group - An array of annotations that should be merged into a single text element.
- * @returns A new TextAnnotation representing the combined text and averaged metrics from the group.
- */
-function createGroupedAnnotation(group: TextAnnotation[]): TextAnnotation {
-  // initialize an empty string to build the combined text.
-  let text = "";
-
-  // concatenate the text from each annotation in the group.
-  // insert a space between words, except when punctuation directly follows a word
-  for (const word of group) {
-    if (
-      [".", ",", '"', "'", ":", ";", "!", "?", "{", "}", "’", "”"].includes(
-        word.text,
-      )
-    ) {
-      text += word.text;
-    } else {
-      text += text !== "" ? " " + word.text : word.text;
-    }
-  }
-
-  // determine if the combined text qualifies as a "word" (contains alphanumeric chars)
-  // and whether its median height suggests emphasizing it (e.g., bold text).
-  const isWord = /[a-zA-Z0-9]/.test(text);
-  const medianHeight = median(group.map((word) => word.height));
-
-  // if it's considered a word and tall enough, surround it with `**` for bold formatting.
-  if (isWord && medianHeight > 25) {
-    text = "**" + text + "**";
-  }
-
-  // return a new annotation that represents the merged group.
-  // use the first annotation's coordinates and normalized positions as references,
-  // and sum the widths of all annotations to get the total width.
-  return {
-    text: text,
-    bottom_left: {
-      x: group[0].bottom_left.x,
-      y: group[0].bottom_left.y,
-    },
-    bottom_left_normalized: {
-      x: group[0].bottom_left_normalized.x,
-      y: group[0].bottom_left_normalized.y,
-    },
-    width: group.reduce((sum, a) => sum + a.width, 0),
-    height: group[0].height,
-  };
-}
-
-function median(values: number[]): number {
-  if (values.length === 0) return 0;
-  const sorted = [...values].sort((a, b) => a - b);
-  const middle = Math.floor(sorted.length / 2);
-
-  if (sorted.length % 2 === 0) {
-    return (sorted[middle - 1] + sorted[middle]) / 2;
-  } else {
-    return sorted[middle];
-  }
-}
-
-export function logLineToString(logLine: LogLine): string {
-  try {
-    const timestamp = logLine.timestamp || new Date().toISOString();
-    if (logLine.auxiliary?.error) {
-      return `${timestamp}::[stagehand:${logLine.category}] ${logLine.message}\n ${logLine.auxiliary.error.value}\n ${logLine.auxiliary.trace.value}`;
-    }
-    return `${timestamp}::[stagehand:${logLine.category}] ${logLine.message} ${
-      logLine.auxiliary ? JSON.stringify(logLine.auxiliary) : ""
-    }`;
-  } catch (error) {
-    console.error(`Error logging line:`, error);
-    return "error logging line";
-  }
-}
-
-export function validateZodSchema(schema: z.ZodTypeAny, data: unknown) {
-  try {
-    schema.parse(data);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function drawObserveOverlay(page: Page, results: ObserveResult[]) {
-  // Convert single xpath to array for consistent handling
-  const xpathList = results.map((result) => result.selector);
-
-  // Filter out empty xpaths
-  const validXpaths = xpathList.filter((xpath) => xpath !== "xpath=");
-
-  await page.evaluate((selectors) => {
-    selectors.forEach((selector) => {
-      let element;
-      if (selector.startsWith("xpath=")) {
-        const xpath = selector.substring(6);
-        element = document.evaluate(
-          xpath,
-          document,
-          null,
-          XPathResult.FIRST_ORDERED_NODE_TYPE,
-          null,
-        ).singleNodeValue;
-      } else {
-        element = document.querySelector(selector);
-      }
-
-      if (element instanceof HTMLElement) {
-        const overlay = document.createElement("div");
-        overlay.setAttribute("stagehandObserve", "true");
-        const rect = element.getBoundingClientRect();
-        overlay.style.position = "absolute";
-        overlay.style.left = rect.left + "px";
-        overlay.style.top = rect.top + "px";
-        overlay.style.width = rect.width + "px";
-        overlay.style.height = rect.height + "px";
-        overlay.style.backgroundColor = "rgba(255, 255, 0, 0.3)";
-        overlay.style.pointerEvents = "none";
-        overlay.style.zIndex = "10000";
-        document.body.appendChild(overlay);
-      }
-    });
-  }, validXpaths);
-}
-
-export async function clearOverlays(page: Page) {
-  // remove existing stagehandObserve attributes
-  await page.evaluate(() => {
-    const elements = document.querySelectorAll('[stagehandObserve="true"]');
-    elements.forEach((el) => {
-      const parent = el.parentNode;
-      while (el.firstChild) {
-        parent?.insertBefore(el.firstChild, el);
-      }
-      parent?.removeChild(el);
-    });
-  });
-}
-
-/**
- * Detects if the code is running in the Bun runtime environment.
- * @returns {boolean} True if running in Bun, false otherwise.
- */
-export function isRunningInBun(): boolean {
-  return (
-    typeof process !== "undefined" &&
-    typeof process.versions !== "undefined" &&
-    "bun" in process.versions
-  );
-}
diff --git a/media/dark_discord.svg b/media/dark_discord.svg
new file mode 100644
index 000000000..9b50d53f9
--- /dev/null
+++ b/media/dark_discord.svg
@@ -0,0 +1,36 @@
+<svg width="270" height="32" viewBox="0 0 270 32" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_1_220)">
+<path d="M0 4C0 1.79086 1.79086 0 4 0H265.447C267.656 0 269.447 1.79086 269.447 4V28C269.447 30.2091 267.656 32 265.447 32H3.99999C1.79085 32 0 30.2091 0 28V4Z" fill="white"/>
+<g clip-path="url(#clip1_1_220)">
+<mask id="mask0_1_220" style="mask-type:luminance" maskUnits="userSpaceOnUse" x="8" y="7" width="88" height="18">
+<path d="M95.6 7.52939H8V24.4706H95.6V7.52939Z" fill="white"/>
+</mask>
+<g mask="url(#mask0_1_220)">
+<path d="M26.5387 8.94821C25.1221 8.28539 23.6073 7.80368 22.0237 7.52939C21.8292 7.88102 21.602 8.35397 21.4453 8.7302C19.7619 8.47703 18.0939 8.47703 16.4414 8.7302C16.2848 8.35397 16.0524 7.88102 15.8562 7.52939C14.2708 7.80368 12.7543 8.28716 11.3377 8.95172C8.48023 13.2696 7.70564 17.4803 8.09294 21.6312C9.98812 23.0465 11.8248 23.9062 13.6305 24.4688C14.0763 23.8552 14.4739 23.203 14.8165 22.5156C14.1641 22.2677 13.5392 21.9618 12.9488 21.6066C13.1055 21.4906 13.2587 21.3693 13.4067 21.2444C17.0077 22.9287 20.9203 22.9287 24.4783 21.2444C24.6281 21.3693 24.7813 21.4906 24.9362 21.6066C24.344 21.9635 23.7175 22.2694 23.0651 22.5173C23.4076 23.203 23.8036 23.857 24.2511 24.4706C26.0585 23.908 27.8969 23.0483 29.7921 21.6312C30.2465 16.8193 29.0158 12.6473 26.5387 8.94821ZM15.307 19.0785C14.2261 19.0785 13.3396 18.0693 13.3396 16.8404C13.3396 15.6114 14.2071 14.6005 15.307 14.6005C16.407 14.6005 17.2935 15.6097 17.2745 16.8404C17.2762 18.0693 16.407 19.0785 15.307 19.0785ZM22.578 19.0785C21.497 19.0785 20.6105 18.0693 20.6105 16.8404C20.6105 15.6114 21.478 14.6005 22.578 14.6005C23.6779 14.6005 24.5644 15.6097 24.5455 16.8404C24.5455 18.0693 23.6779 19.0785 22.578 19.0785Z" fill="#23272A"/>
+<path d="M37.4088 11.8512H42.1079C43.2407 11.8512 44.1977 12.0323 44.9828 12.3927C45.7658 12.7531 46.3529 13.2559 46.742 13.8994C47.1308 14.5429 47.327 15.2795 47.327 16.1094C47.327 16.9216 47.1239 17.6583 46.7177 18.3175C46.3115 18.9786 45.6935 19.5008 44.8622 19.8858C44.0309 20.2708 43.0013 20.4642 41.7707 20.4642H37.4088V11.8512ZM41.7224 18.2754C42.485 18.2754 43.0721 18.0802 43.4816 17.6916C43.8914 17.3013 44.0963 16.7704 44.0963 16.0971C44.0963 15.4729 43.9136 14.9754 43.5488 14.6026C43.184 14.2299 42.6314 14.0418 41.8928 14.0418H40.4228V18.2754H41.7224Z" fill="#23272A"/>
+<path d="M54.3623 20.4537C53.7116 20.2814 53.1245 20.0317 52.6031 19.703V17.6601C52.9973 17.9712 53.5256 18.2279 54.1883 18.4301C54.851 18.6305 55.4915 18.7307 56.111 18.7307C56.4002 18.7307 56.6189 18.6921 56.7668 18.6147C56.915 18.5373 56.9891 18.4442 56.9891 18.3369C56.9891 18.2139 56.9495 18.1119 56.8685 18.0292C56.7875 17.9466 56.6309 17.878 56.3987 17.82L54.9527 17.4877C54.1247 17.2908 53.5376 17.0183 53.1884 16.6685C52.8389 16.3203 52.6649 15.8632 52.6649 15.2971C52.6649 14.8207 52.8164 14.4075 53.123 14.0541C53.4275 13.7008 53.8613 13.4283 54.4241 13.2366C54.9872 13.0432 55.6445 12.9465 56.4002 12.9465C57.0749 12.9465 57.6929 13.0204 58.256 13.1681C58.8188 13.3158 59.2835 13.5039 59.6537 13.7342V15.6663C59.2748 15.436 58.841 15.255 58.3454 15.1178C57.8513 14.9824 57.3437 14.9156 56.8202 14.9156C56.0645 14.9156 55.6877 15.0475 55.6877 15.3094C55.6877 15.4325 55.7462 15.5239 55.8632 15.5855C55.9802 15.647 56.1953 15.7103 56.507 15.7771L57.7118 15.9986C58.4987 16.1375 59.0855 16.3819 59.471 16.73C59.8568 17.0781 60.0494 17.5932 60.0494 18.2754C60.0494 19.0226 59.7311 19.6151 59.0924 20.0546C58.4537 20.4941 57.5483 20.7139 56.3744 20.7139C55.6841 20.7121 55.013 20.626 54.3623 20.4537Z" fill="#23272A"/>
+<path d="M62.8934 20.1952C62.2034 19.8506 61.6817 19.3829 61.334 18.7922C60.9863 18.2015 60.8108 17.5369 60.8108 16.7985C60.8108 16.0601 60.9914 15.399 61.3529 14.8171C61.7144 14.2352 62.2445 13.7781 62.9435 13.4458C63.6422 13.1135 64.4771 12.9482 65.4497 12.9482C66.6545 12.9482 67.6547 13.2067 68.45 13.7235V15.9757C68.1695 15.7788 67.8422 15.6188 67.4687 15.4957C67.0952 15.3727 66.6959 15.3111 66.269 15.3111C65.522 15.3111 64.9385 15.45 64.5167 15.7296C64.0949 16.0091 63.8834 16.373 63.8834 16.8249C63.8834 17.2679 64.088 17.6301 64.4978 17.9149C64.9076 18.198 65.5013 18.3404 66.281 18.3404C66.6821 18.3404 67.0781 18.2806 67.4687 18.1628C67.8578 18.0432 68.1935 17.8973 68.474 17.725V19.9033C67.5911 20.4448 66.5669 20.7156 65.4014 20.7156C64.4204 20.712 63.5837 20.5398 62.8934 20.1952Z" fill="#23272A"/>
+<path d="M71.4554 20.1952C70.76 19.8507 70.2299 19.3795 69.8648 18.78C69.5 18.1804 69.3158 17.5124 69.3158 16.7739C69.3158 16.0356 69.4982 15.3762 69.8648 14.7978C70.2314 14.2194 70.7582 13.7658 71.4503 13.437C72.1403 13.1083 72.965 12.9448 73.9202 12.9448C74.8757 12.9448 75.7001 13.1083 76.3904 13.437C77.0807 13.7658 77.6075 14.2159 77.969 14.7908C78.3305 15.3657 78.5111 16.025 78.5111 16.7722C78.5111 17.5106 78.3305 18.1787 77.969 18.7782C77.6075 19.3777 77.0789 19.8489 76.3835 20.1935C75.6881 20.5381 74.867 20.7104 73.9187 20.7104C72.9701 20.7104 72.149 20.5398 71.4554 20.1952ZM75.1166 18.0117C75.4094 17.7128 75.5573 17.3172 75.5573 16.8249C75.5573 16.3327 75.4109 15.9406 75.1166 15.6505C74.8241 15.3587 74.4245 15.2127 73.9187 15.2127C73.4039 15.2127 73.001 15.3587 72.7067 15.6505C72.4142 15.9424 72.2678 16.3327 72.2678 16.8249C72.2678 17.3172 72.4142 17.7128 72.7067 18.0117C72.9995 18.3105 73.4039 18.4617 73.9187 18.4617C74.4245 18.46 74.8241 18.3105 75.1166 18.0117Z" fill="#23272A"/>
+<path d="M85.751 13.4019V16.0601C85.4447 15.8544 85.0487 15.7524 84.5582 15.7524C83.9159 15.7524 83.4203 15.9511 83.0759 16.3485C82.73 16.7458 82.5578 17.3646 82.5578 18.2015V20.466H79.6058V13.2665H82.4978V15.5556C82.6577 14.7187 82.9178 14.1016 83.2757 13.7025C83.6321 13.3052 84.0932 13.1065 84.6545 13.1065C85.0796 13.1065 85.4447 13.205 85.751 13.4019Z" fill="#23272A"/>
+<path d="M95.5592 11.6051V20.466H92.6069V18.8538C92.3573 19.4604 91.9787 19.9228 91.4693 20.2392C90.9596 20.5539 90.3296 20.7121 89.5826 20.7121C88.9148 20.7121 88.3331 20.5469 87.8354 20.2146C87.338 19.8823 86.9543 19.427 86.684 18.8485C86.4155 18.2701 86.2793 17.6161 86.2793 16.8847C86.2709 16.1305 86.4137 15.4536 86.708 14.8541C87.0008 14.2546 87.4154 13.7869 87.9491 13.4511C88.4828 13.1153 89.0921 12.9466 89.7755 12.9466C91.1819 12.9466 92.1251 13.5707 92.6069 14.8172V11.6051H95.5592ZM92.1665 17.9625C92.4677 17.6636 92.6174 17.275 92.6174 16.8004C92.6174 16.3415 92.471 15.967 92.1785 15.6804C91.8857 15.3939 91.4846 15.2497 90.9803 15.2497C90.4829 15.2497 90.0854 15.3956 89.7875 15.6874C89.4896 15.9793 89.3417 16.3573 89.3417 16.825C89.3417 17.2926 89.4896 17.6741 89.7875 17.9695C90.0854 18.2648 90.4778 18.4125 90.9683 18.4125C91.4657 18.4108 91.865 18.2613 92.1665 17.9625Z" fill="#23272A"/>
+<path d="M49.8146 14.033C50.6273 14.033 51.2864 13.4284 51.2864 12.6827C51.2864 11.937 50.6273 11.3325 49.8146 11.3325C49.0016 11.3325 48.3428 11.937 48.3428 12.6827C48.3428 13.4284 49.0016 14.033 49.8146 14.033Z" fill="#23272A"/>
+<path d="M48.3416 14.9631C49.2434 15.3604 50.3624 15.378 51.2849 14.9631V20.5046H48.3416V14.9631Z" fill="#23272A"/>
+</g>
+</g>
+<mask id="path-14-inside-1_1_220" fill="white">
+<path d="M103.6 0H269.447V32H103.6V0Z"/>
+</mask>
+<path d="M103.6 0H269.447V32H103.6V0Z" fill="#FFDC83"/>
+<path d="M103.6 32H104.6V0H103.6H102.6V32H103.6Z" fill="#635943" mask="url(#path-14-inside-1_1_220)"/>
+<path d="M114.89 20.151C113.901 20.151 113.112 19.8383 112.524 19.213C111.936 18.5877 111.628 17.7523 111.6 16.707L112.776 16.595C112.804 17.407 112.991 18.009 113.336 18.401C113.681 18.7837 114.199 18.975 114.89 18.975C116.281 18.975 116.976 18.1817 116.976 16.595V9.98699H118.18V16.595C118.18 17.6963 117.881 18.5643 117.284 19.199C116.696 19.8337 115.898 20.151 114.89 20.151ZM123.635 20.095C122.953 20.095 122.356 19.9363 121.843 19.619C121.339 19.3017 120.947 18.8537 120.667 18.275C120.387 17.687 120.247 17.001 120.247 16.217C120.247 15.433 120.387 14.7517 120.667 14.173C120.947 13.585 121.339 13.1323 121.843 12.815C122.356 12.4977 122.953 12.339 123.635 12.339C124.307 12.339 124.899 12.4977 125.413 12.815C125.926 13.1323 126.323 13.585 126.603 14.173C126.883 14.7517 127.023 15.433 127.023 16.217C127.023 17.001 126.883 17.687 126.603 18.275C126.323 18.8537 125.926 19.3017 125.413 19.619C124.899 19.9363 124.307 20.095 123.635 20.095ZM123.635 18.975C124.316 18.975 124.843 18.7323 125.217 18.247C125.599 17.7523 125.791 17.0757 125.791 16.217C125.791 15.3583 125.599 14.6863 125.217 14.201C124.843 13.7063 124.316 13.459 123.635 13.459C122.953 13.459 122.421 13.7017 122.039 14.187C121.665 14.6723 121.479 15.349 121.479 16.217C121.479 17.085 121.665 17.7617 122.039 18.247C122.421 18.7323 122.953 18.975 123.635 18.975ZM128.949 18.891H131.931V13.543H129.089V12.507H133.107V18.891H135.669V19.927H128.949V18.891ZM131.819 9.97299H133.051V11.345H131.819V9.97299ZM137.568 12.507H138.646L138.674 13.837C138.86 13.3423 139.154 12.969 139.556 12.717C139.957 12.465 140.424 12.339 140.956 12.339C141.768 12.339 142.384 12.6003 142.804 13.123C143.233 13.6457 143.448 14.3223 143.448 15.153V19.927H142.272V15.489C142.272 14.789 142.146 14.2617 141.894 13.907C141.651 13.5523 141.254 13.375 140.704 13.375C140.116 13.375 139.64 13.5617 139.276 13.935C138.921 14.299 138.744 14.817 138.744 15.489V19.927H137.568V12.507ZM157.213 20.095C156.531 20.095 155.934 19.9363 155.421 19.619C154.917 19.3017 154.525 18.8537 154.245 18.275C153.965 17.687 153.825 17.001 153.825 16.217C153.825 15.433 153.965 14.7517 154.245 14.173C154.525 13.585 154.917 13.1323 155.421 12.815C155.934 12.4977 156.531 12.339 157.213 12.339C157.885 12.339 158.477 12.4977 158.991 12.815C159.504 13.1323 159.901 13.585 160.181 14.173C160.461 14.7517 160.601 15.433 160.601 16.217C160.601 17.001 160.461 17.687 160.181 18.275C159.901 18.8537 159.504 19.3017 158.991 19.619C158.477 19.9363 157.885 20.095 157.213 20.095ZM157.213 18.975C157.894 18.975 158.421 18.7323 158.795 18.247C159.177 17.7523 159.369 17.0757 159.369 16.217C159.369 15.3583 159.177 14.6863 158.795 14.201C158.421 13.7063 157.894 13.459 157.213 13.459C156.531 13.459 155.999 13.7017 155.617 14.187C155.243 14.6723 155.057 15.349 155.057 16.217C155.057 17.085 155.243 17.7617 155.617 18.247C155.999 18.7323 156.531 18.975 157.213 18.975ZM165.089 20.095C164.352 20.095 163.764 19.8477 163.325 19.353C162.887 18.849 162.667 18.1583 162.667 17.281V12.507H163.843V16.959C163.843 17.6777 163.969 18.2097 164.221 18.555C164.483 18.891 164.879 19.059 165.411 19.059C165.99 19.059 166.447 18.8723 166.783 18.499C167.119 18.1163 167.287 17.5937 167.287 16.931V12.507H168.463V19.927H167.343V18.723C167.138 19.1617 166.844 19.5023 166.461 19.745C166.079 19.9783 165.621 20.095 165.089 20.095ZM171.062 18.891H172.994V13.543H171.062V12.507H173.974L174.058 13.935C174.31 12.983 174.902 12.507 175.836 12.507H177.362V13.571H175.85C175.308 13.571 174.893 13.7343 174.604 14.061C174.314 14.3783 174.17 14.8403 174.17 15.447V18.891H176.522V19.927H171.062V18.891ZM190.987 20.095C190.305 20.095 189.703 19.9363 189.181 19.619C188.667 19.3017 188.271 18.849 187.991 18.261C187.711 17.673 187.571 16.9917 187.571 16.217C187.571 15.4423 187.711 14.761 187.991 14.173C188.271 13.585 188.667 13.1323 189.181 12.815C189.703 12.4977 190.305 12.339 190.987 12.339C191.817 12.339 192.503 12.563 193.045 13.011C193.595 13.459 193.945 14.0937 194.095 14.915L192.863 14.999C192.751 14.5137 192.527 14.1357 192.191 13.865C191.864 13.5943 191.463 13.459 190.987 13.459C190.305 13.459 189.769 13.7063 189.377 14.201C188.994 14.6863 188.803 15.3583 188.803 16.217C188.803 17.0757 188.994 17.7523 189.377 18.247C189.769 18.7323 190.305 18.975 190.987 18.975C191.481 18.975 191.897 18.8303 192.233 18.541C192.578 18.2517 192.807 17.8363 192.919 17.295L194.151 17.379C193.992 18.2097 193.628 18.8723 193.059 19.367C192.499 19.8523 191.808 20.095 190.987 20.095ZM199.185 20.095C198.504 20.095 197.907 19.9363 197.393 19.619C196.889 19.3017 196.497 18.8537 196.217 18.275C195.937 17.687 195.797 17.001 195.797 16.217C195.797 15.433 195.937 14.7517 196.217 14.173C196.497 13.585 196.889 13.1323 197.393 12.815C197.907 12.4977 198.504 12.339 199.185 12.339C199.857 12.339 200.45 12.4977 200.963 12.815C201.477 13.1323 201.873 13.585 202.153 14.173C202.433 14.7517 202.573 15.433 202.573 16.217C202.573 17.001 202.433 17.687 202.153 18.275C201.873 18.8537 201.477 19.3017 200.963 19.619C200.45 19.9363 199.857 20.095 199.185 20.095ZM199.185 18.975C199.867 18.975 200.394 18.7323 200.767 18.247C201.15 17.7523 201.341 17.0757 201.341 16.217C201.341 15.3583 201.15 14.6863 200.767 14.201C200.394 13.7063 199.867 13.459 199.185 13.459C198.504 13.459 197.972 13.7017 197.589 14.187C197.216 14.6723 197.029 15.349 197.029 16.217C197.029 17.085 197.216 17.7617 197.589 18.247C197.972 18.7323 198.504 18.975 199.185 18.975ZM203.94 12.507H205.018L205.046 13.599C205.177 13.1977 205.368 12.8897 205.62 12.675C205.872 12.451 206.171 12.339 206.516 12.339C207.281 12.339 207.748 12.8243 207.916 13.795C208.037 13.3377 208.238 12.983 208.518 12.731C208.798 12.4697 209.129 12.339 209.512 12.339C210.109 12.339 210.543 12.549 210.814 12.969C211.085 13.389 211.22 14.075 211.22 15.027V19.927H210.044V15.167C210.044 14.523 209.974 14.0657 209.834 13.795C209.694 13.515 209.475 13.375 209.176 13.375C208.868 13.375 208.621 13.529 208.434 13.837C208.257 14.1357 208.168 14.5883 208.168 15.195V19.927H206.992V15.167C206.992 14.5323 206.922 14.075 206.782 13.795C206.651 13.515 206.432 13.375 206.124 13.375C205.816 13.375 205.569 13.529 205.382 13.837C205.205 14.1357 205.116 14.5883 205.116 15.195V19.927H203.94V12.507ZM212.334 12.507H213.412L213.44 13.599C213.571 13.1977 213.762 12.8897 214.014 12.675C214.266 12.451 214.565 12.339 214.91 12.339C215.676 12.339 216.142 12.8243 216.31 13.795C216.432 13.3377 216.632 12.983 216.912 12.731C217.192 12.4697 217.524 12.339 217.906 12.339C218.504 12.339 218.938 12.549 219.208 12.969C219.479 13.389 219.614 14.075 219.614 15.027V19.927H218.438V15.167C218.438 14.523 218.368 14.0657 218.228 13.795C218.088 13.515 217.869 13.375 217.57 13.375C217.262 13.375 217.015 13.529 216.828 13.837C216.651 14.1357 216.562 14.5883 216.562 15.195V19.927H215.386V15.167C215.386 14.5323 215.316 14.075 215.176 13.795C215.046 13.515 214.826 13.375 214.518 13.375C214.21 13.375 213.963 13.529 213.776 13.837C213.599 14.1357 213.51 14.5883 213.51 15.195V19.927H212.334V12.507ZM223.851 20.095C223.114 20.095 222.526 19.8477 222.087 19.353C221.648 18.849 221.429 18.1583 221.429 17.281V12.507H222.605V16.959C222.605 17.6777 222.731 18.2097 222.983 18.555C223.244 18.891 223.641 19.059 224.173 19.059C224.752 19.059 225.209 18.8723 225.545 18.499C225.881 18.1163 226.049 17.5937 226.049 16.931V12.507H227.225V19.927H226.105V18.723C225.9 19.1617 225.606 19.5023 225.223 19.745C224.84 19.9783 224.383 20.095 223.851 20.095ZM229.907 12.507H230.985L231.013 13.837C231.2 13.3423 231.494 12.969 231.895 12.717C232.297 12.465 232.763 12.339 233.295 12.339C234.107 12.339 234.723 12.6003 235.143 13.123C235.573 13.6457 235.787 14.3223 235.787 15.153V19.927H234.611V15.489C234.611 14.789 234.485 14.2617 234.233 13.907C233.991 13.5523 233.594 13.375 233.043 13.375C232.455 13.375 231.979 13.5617 231.615 13.935C231.261 14.299 231.083 14.817 231.083 15.489V19.927H229.907V12.507ZM238.078 18.891H241.06V13.543H238.218V12.507H242.236V18.891H244.798V19.927H238.078V18.891ZM240.948 9.97299H242.18V11.345H240.948V9.97299ZM250.645 19.927C249.926 19.927 249.389 19.759 249.035 19.423C248.68 19.087 248.503 18.5737 248.503 17.883V13.543H246.053V12.507H248.503V10.547H249.679V12.507H252.633V13.543H249.679V17.883C249.679 18.2283 249.758 18.485 249.917 18.653C250.075 18.8117 250.318 18.891 250.645 18.891H252.633V19.927H250.645ZM255.679 20.991H256.533C256.785 20.991 256.972 20.949 257.093 20.865C257.224 20.7903 257.326 20.6643 257.401 20.487L257.667 19.787H257.261L254.503 12.507H255.791L258.045 18.695L260.159 12.507H261.447L258.437 20.865C258.297 21.2663 258.087 21.5603 257.807 21.747C257.527 21.9337 257.14 22.027 256.645 22.027H255.679V20.991Z" fill="#100D0D"/>
+</g>
+<path d="M4 0.5H265.447C267.38 0.500144 268.947 2.06709 268.947 4V28C268.947 29.9329 267.38 31.4999 265.447 31.5H4C2.067 31.5 0.5 29.933 0.5 28V4C0.5 2.067 2.067 0.5 4 0.5Z" stroke="#635943"/>
+<defs>
+<clipPath id="clip0_1_220">
+<path d="M0 4C0 1.79086 1.79086 0 4 0H265.447C267.656 0 269.447 1.79086 269.447 4V28C269.447 30.2091 267.656 32 265.447 32H3.99999C1.79085 32 0 30.2091 0 28V4Z" fill="white"/>
+</clipPath>
+<clipPath id="clip1_1_220">
+<rect width="87.6" height="24" fill="white" transform="translate(8 4)"/>
+</clipPath>
+</defs>
+</svg>
diff --git a/media/dark_license.svg b/media/dark_license.svg
new file mode 100644
index 000000000..cbf804ea1
--- /dev/null
+++ b/media/dark_license.svg
@@ -0,0 +1,18 @@
+<svg width="113" height="32" viewBox="0 0 113 32" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_1_197)">
+<rect width="112.316" height="32" rx="4" fill="white"/>
+<path d="M8 10.953H9.20396V19.745H14.16V20.893H8V10.953ZM16.1146 19.857H19.0966V14.509H16.2546V13.473H20.2726V19.857H22.8346V20.893H16.1146V19.857ZM18.9846 10.939H20.2166V12.311H18.9846V10.939ZM27.7851 21.061C27.1038 21.061 26.5018 20.9023 25.9791 20.585C25.4658 20.2677 25.0691 19.815 24.7891 19.227C24.5091 18.639 24.3691 17.9577 24.3691 17.183C24.3691 16.4083 24.5091 15.727 24.7891 15.139C25.0691 14.551 25.4658 14.0983 25.9791 13.781C26.5018 13.4637 27.1038 13.305 27.7851 13.305C28.6158 13.305 29.3018 13.529 29.8431 13.977C30.3938 14.425 30.7438 15.0597 30.8931 15.881L29.6611 15.965C29.5491 15.4797 29.3251 15.1017 28.9891 14.831C28.6624 14.5603 28.2611 14.425 27.7851 14.425C27.1038 14.425 26.5671 14.6723 26.1751 15.167C25.7924 15.6523 25.6011 16.3243 25.6011 17.183C25.6011 18.0417 25.7924 18.7183 26.1751 19.213C26.5671 19.6983 27.1038 19.941 27.7851 19.941C28.2798 19.941 28.6951 19.7963 29.0311 19.507C29.3764 19.2177 29.6051 18.8023 29.7171 18.261L30.9491 18.345C30.7904 19.1757 30.4264 19.8383 29.8571 20.333C29.2971 20.8183 28.6064 21.061 27.7851 21.061ZM36.1096 21.061C35.419 21.061 34.817 20.9023 34.3036 20.585C33.7903 20.2677 33.3936 19.8197 33.1136 19.241C32.843 18.653 32.7076 17.967 32.7076 17.183C32.7076 16.4083 32.843 15.727 33.1136 15.139C33.3936 14.551 33.7856 14.0983 34.2896 13.781C34.7936 13.4637 35.3816 13.305 36.0536 13.305C36.6976 13.305 37.267 13.459 37.7616 13.767C38.2656 14.0657 38.653 14.509 38.9236 15.097C39.2036 15.685 39.3436 16.385 39.3436 17.197V17.547H33.9396C33.977 18.331 34.1823 18.9283 34.5556 19.339C34.9383 19.7403 35.4563 19.941 36.1096 19.941C36.5856 19.941 36.9776 19.8337 37.2856 19.619C37.603 19.395 37.827 19.087 37.9576 18.695L39.2176 18.793C39.0216 19.4743 38.6436 20.025 38.0836 20.445C37.533 20.8557 36.875 21.061 36.1096 21.061ZM38.0556 16.511C37.9996 15.8203 37.7943 15.3023 37.4396 14.957C37.085 14.6023 36.623 14.425 36.0536 14.425C35.475 14.425 34.999 14.6023 34.6256 14.957C34.2616 15.3117 34.033 15.8297 33.9396 16.511H38.0556ZM41.5222 13.473H42.6002L42.6282 14.803C42.8148 14.3083 43.1088 13.935 43.5102 13.683C43.9115 13.431 44.3782 13.305 44.9102 13.305C45.7222 13.305 46.3382 13.5663 46.7582 14.089C47.1875 14.6117 47.4022 15.2883 47.4022 16.119V20.893H46.2262V16.455C46.2262 15.755 46.1002 15.2277 45.8482 14.873C45.6055 14.5183 45.2088 14.341 44.6582 14.341C44.0702 14.341 43.5942 14.5277 43.2302 14.901C42.8755 15.265 42.6982 15.783 42.6982 16.455V20.893H41.5222V13.473ZM52.9127 21.061C52.2874 21.061 51.7367 20.9537 51.2607 20.739C50.794 20.515 50.4254 20.2163 50.1547 19.843C49.884 19.4603 49.73 19.031 49.6927 18.555L50.9247 18.471C50.9994 18.9377 51.2047 19.3017 51.5407 19.563C51.8767 19.815 52.334 19.941 52.9127 19.941C53.4727 19.941 53.902 19.8617 54.2007 19.703C54.4994 19.535 54.6487 19.2877 54.6487 18.961C54.6487 18.737 54.5974 18.5597 54.4947 18.429C54.392 18.289 54.2007 18.1723 53.9207 18.079C53.65 17.9763 53.2394 17.8783 52.6887 17.785C51.9794 17.6637 51.4194 17.505 51.0087 17.309C50.6074 17.113 50.318 16.875 50.1407 16.595C49.9727 16.315 49.8887 15.965 49.8887 15.545C49.8887 14.8823 50.136 14.3457 50.6307 13.935C51.1254 13.515 51.816 13.305 52.7027 13.305C53.5707 13.305 54.2567 13.529 54.7607 13.977C55.274 14.425 55.5914 14.9943 55.7127 15.685L54.4807 15.769C54.3967 15.3583 54.196 15.0317 53.8787 14.789C53.5707 14.5463 53.174 14.425 52.6887 14.425C52.166 14.425 51.7694 14.5277 51.4987 14.733C51.228 14.9383 51.0927 15.209 51.0927 15.545C51.0927 15.797 51.1534 15.9977 51.2747 16.147C51.396 16.287 51.5827 16.4037 51.8347 16.497C52.096 16.581 52.4647 16.665 52.9407 16.749C53.706 16.8703 54.2987 17.0243 54.7187 17.211C55.1387 17.3977 55.4327 17.631 55.6007 17.911C55.7687 18.1817 55.8527 18.5317 55.8527 18.961C55.8527 19.605 55.5774 20.1183 55.0267 20.501C54.476 20.8743 53.7714 21.061 52.9127 21.061ZM61.2932 21.061C60.6026 21.061 60.0006 20.9023 59.4872 20.585C58.9739 20.2677 58.5772 19.8197 58.2972 19.241C58.0266 18.653 57.8912 17.967 57.8912 17.183C57.8912 16.4083 58.0266 15.727 58.2972 15.139C58.5772 14.551 58.9692 14.0983 59.4732 13.781C59.9772 13.4637 60.5652 13.305 61.2372 13.305C61.8812 13.305 62.4506 13.459 62.9452 13.767C63.4492 14.0657 63.8366 14.509 64.1072 15.097C64.3872 15.685 64.5272 16.385 64.5272 17.197V17.547H59.1232C59.1606 18.331 59.3659 18.9283 59.7392 19.339C60.1219 19.7403 60.6399 19.941 61.2932 19.941C61.7692 19.941 62.1612 19.8337 62.4692 19.619C62.7866 19.395 63.0106 19.087 63.1412 18.695L64.4012 18.793C64.2052 19.4743 63.8272 20.025 63.2672 20.445C62.7166 20.8557 62.0586 21.061 61.2932 21.061ZM63.2392 16.511C63.1832 15.8203 62.9779 15.3023 62.6232 14.957C62.2686 14.6023 61.8066 14.425 61.2372 14.425C60.6586 14.425 60.1826 14.6023 59.8092 14.957C59.4452 15.3117 59.2166 15.8297 59.1232 16.511H63.2392Z" fill="#100D0D"/>
+<mask id="path-5-inside-1_1_197" fill="white">
+<path d="M72.5272 0H112.316V32H72.5272V0Z"/>
+</mask>
+<path d="M72.5272 0H112.316V32H72.5272V0Z" fill="#FFDC83"/>
+<path d="M72.5272 32H73.5272V0H72.5272H71.5272V32H72.5272Z" fill="#635943" mask="url(#path-5-inside-1_1_197)"/>
+<path d="M81.7312 12.64V20.97H80.5272V11.03H82.3472L83.8872 17.946L85.4272 11.03H87.2472V20.97H86.0432V12.64L84.4192 19.85H83.3552L81.7312 12.64ZM89.2017 19.822H91.6797V12.178H89.2017V11.03H95.3617V12.178H92.8837V19.822H95.3617V20.97H89.2017V19.822ZM100.074 12.178H97.0362V11.03H104.316V12.178H101.278V20.97H100.074V12.178Z" fill="#100D0D"/>
+</g>
+<rect x="0.5" y="0.5" width="111.316" height="31" rx="3.5" stroke="#635943"/>
+<defs>
+<clipPath id="clip0_1_197">
+<rect width="112.316" height="32" rx="4" fill="white"/>
+</clipPath>
+</defs>
+</svg>
diff --git a/media/dark_logo.png b/media/dark_logo.png
new file mode 100644
index 000000000..4b7da66e9
Binary files /dev/null and b/media/dark_logo.png differ
diff --git a/media/director_icon.svg b/media/director_icon.svg
new file mode 100644
index 000000000..601255860
--- /dev/null
+++ b/media/director_icon.svg
@@ -0,0 +1,13 @@
+<svg width="113" height="112" viewBox="0 0 113 112" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_1822_378)">
+<rect width="112" height="112" transform="translate(0.544922)" fill="#26A3F3"/>
+<rect width="112" height="112" transform="translate(0.544922)" fill="#53B6F5"/>
+<path d="M65.9594 65.6619L33.7169 82.004C31.9262 82.9116 29.99 81.0628 30.8139 79.2321L45.1531 47.3707C45.4023 46.8168 45.8764 46.3958 46.4558 46.2137L63.4711 40.8662C64.8063 40.4466 66.1761 41.4078 66.2356 42.8061L67.1236 63.673C67.1591 64.5069 66.7039 65.2846 65.9594 65.6619Z" fill="white" stroke="white" stroke-width="3.19249"/>
+<path d="M87.1314 25.7928C87.8949 26.5821 88.3463 27.9558 87.641 29.28L87.6431 29.2807L67.4981 67.3215C67.178 67.9261 66.7006 68.4313 66.1191 68.7848L65.863 68.9263L29.5678 87.3132L29.5671 87.3111C28.2631 87.9819 26.9169 87.544 26.1331 86.7953C25.3429 86.04 24.8425 84.701 25.4695 83.3585L25.4702 83.3578L42.6873 45.9385C43.0544 45.1409 43.6873 44.4956 44.4778 44.1134L83.6684 25.1624L83.6677 25.1631C85.0126 24.5085 86.3679 25.0041 87.1314 25.7928ZM60.764 54.1904C60.5588 53.1645 59.8181 52.3341 58.8354 52.0076L58.6351 51.9496L46.0757 48.7552L30.8239 81.9042L63.0428 65.5828L60.764 54.1904Z" fill="black"/>
+</g>
+<defs>
+<clipPath id="clip0_1822_378">
+<rect width="112" height="112" fill="white" transform="translate(0.544922)"/>
+</clipPath>
+</defs>
+</svg>
diff --git a/media/light_discord.svg b/media/light_discord.svg
new file mode 100644
index 000000000..ec0bcf462
--- /dev/null
+++ b/media/light_discord.svg
@@ -0,0 +1,37 @@
+<svg width="270" height="32" viewBox="0 0 270 32" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_25_2)">
+<path d="M0 4C0 1.79086 1.79086 0 4 0H265.447C267.656 0 269.447 1.79086 269.447 4V28C269.447 30.2091 267.656 32 265.447 32H3.99999C1.79085 32 0 30.2091 0 28V4Z" fill="white"/>
+<path d="M0 4C0 1.79086 1.79086 0 4 0H103.6V32H3.99999C1.79086 32 0 30.2091 0 28V4Z" fill="black"/>
+<g clip-path="url(#clip1_25_2)">
+<mask id="mask0_25_2" style="mask-type:luminance" maskUnits="userSpaceOnUse" x="8" y="7" width="88" height="18">
+<path d="M95.6 7.52939H8V24.4706H95.6V7.52939Z" fill="white"/>
+</mask>
+<g mask="url(#mask0_25_2)">
+<path d="M26.5387 8.94821C25.1221 8.28539 23.6073 7.80368 22.0237 7.52939C21.8292 7.88102 21.602 8.35397 21.4453 8.7302C19.7619 8.47703 18.0939 8.47703 16.4414 8.7302C16.2848 8.35397 16.0524 7.88102 15.8562 7.52939C14.2708 7.80368 12.7543 8.28716 11.3377 8.95172C8.48023 13.2696 7.70564 17.4803 8.09294 21.6312C9.98812 23.0465 11.8248 23.9062 13.6305 24.4688C14.0763 23.8552 14.4739 23.203 14.8165 22.5156C14.1641 22.2677 13.5392 21.9618 12.9488 21.6066C13.1055 21.4906 13.2587 21.3693 13.4067 21.2444C17.0077 22.9287 20.9203 22.9287 24.4783 21.2444C24.6281 21.3693 24.7812 21.4906 24.9362 21.6066C24.344 21.9635 23.7175 22.2694 23.0651 22.5173C23.4076 23.203 23.8036 23.857 24.2511 24.4706C26.0585 23.908 27.8969 23.0483 29.7921 21.6312C30.2465 16.8193 29.0158 12.6473 26.5387 8.94821ZM15.307 19.0785C14.2261 19.0785 13.3396 18.0693 13.3396 16.8404C13.3396 15.6114 14.2071 14.6005 15.307 14.6005C16.407 14.6005 17.2935 15.6097 17.2745 16.8404C17.2762 18.0693 16.407 19.0785 15.307 19.0785ZM22.578 19.0785C21.497 19.0785 20.6105 18.0693 20.6105 16.8404C20.6105 15.6114 21.478 14.6005 22.578 14.6005C23.6779 14.6005 24.5644 15.6097 24.5455 16.8404C24.5455 18.0693 23.6779 19.0785 22.578 19.0785Z" fill="#FFDC83"/>
+<path d="M37.4088 11.8512H42.1079C43.2407 11.8512 44.1977 12.0323 44.9828 12.3927C45.7658 12.7531 46.3529 13.2559 46.742 13.8994C47.1308 14.5429 47.327 15.2795 47.327 16.1094C47.327 16.9216 47.1239 17.6583 46.7177 18.3175C46.3115 18.9786 45.6935 19.5008 44.8622 19.8858C44.0309 20.2708 43.0013 20.4642 41.7707 20.4642H37.4088V11.8512ZM41.7224 18.2754C42.485 18.2754 43.0721 18.0802 43.4816 17.6917C43.8914 17.3014 44.0963 16.7704 44.0963 16.0971C44.0963 15.4729 43.9136 14.9754 43.5488 14.6026C43.184 14.2299 42.6314 14.0418 41.8928 14.0418H40.4228V18.2754H41.7224Z" fill="#FFDC83"/>
+<path d="M54.3623 20.4537C53.7116 20.2814 53.1245 20.0318 52.6031 19.703V17.6601C52.9973 17.9712 53.5256 18.2279 54.1883 18.4301C54.851 18.6305 55.4915 18.7307 56.111 18.7307C56.4002 18.7307 56.6189 18.6921 56.7668 18.6147C56.915 18.5374 56.9891 18.4442 56.9891 18.3369C56.9891 18.2139 56.9495 18.1119 56.8685 18.0293C56.7875 17.9466 56.6309 17.8781 56.3987 17.82L54.9527 17.4878C54.1247 17.2909 53.5376 17.0183 53.1884 16.6685C52.8389 16.3204 52.6649 15.8633 52.6649 15.2972C52.6649 14.8207 52.8164 14.4076 53.123 14.0542C53.4275 13.7008 53.8613 13.4283 54.4241 13.2366C54.9872 13.0433 55.6445 12.9466 56.4002 12.9466C57.0749 12.9466 57.6929 13.0204 58.256 13.1681C58.8188 13.3158 59.2835 13.5039 59.6537 13.7342V15.6664C59.2748 15.4361 58.841 15.255 58.3454 15.1178C57.8513 14.9825 57.3437 14.9156 56.8202 14.9156C56.0645 14.9156 55.6877 15.0475 55.6877 15.3095C55.6877 15.4325 55.7462 15.524 55.8632 15.5855C55.9802 15.647 56.1953 15.7103 56.507 15.7771L57.7118 15.9986C58.4987 16.1375 59.0855 16.3819 59.471 16.73C59.8568 17.0781 60.0494 17.5933 60.0494 18.2754C60.0494 19.0226 59.7311 19.6151 59.0924 20.0546C58.4537 20.4941 57.5483 20.7139 56.3744 20.7139C55.6841 20.7122 55.013 20.626 54.3623 20.4537Z" fill="#FFDC83"/>
+<path d="M62.8934 20.1952C62.2034 19.8506 61.6817 19.3829 61.334 18.7922C60.9863 18.2015 60.8108 17.5369 60.8108 16.7985C60.8108 16.0601 60.9914 15.3991 61.3529 14.8171C61.7144 14.2352 62.2445 13.7781 62.9435 13.4458C63.6422 13.1135 64.4771 12.9482 65.4497 12.9482C66.6545 12.9482 67.6547 13.2067 68.45 13.7236V15.9757C68.1695 15.7788 67.8422 15.6188 67.4687 15.4958C67.0952 15.3727 66.6959 15.3111 66.269 15.3111C65.522 15.3111 64.9385 15.45 64.5167 15.7296C64.0949 16.0091 63.8834 16.373 63.8834 16.8249C63.8834 17.2679 64.088 17.6301 64.4978 17.9149C64.9076 18.198 65.5013 18.3404 66.281 18.3404C66.6821 18.3404 67.0781 18.2806 67.4687 18.1628C67.8578 18.0433 68.1935 17.8973 68.474 17.725V19.9033C67.5911 20.4448 66.5669 20.7156 65.4014 20.7156C64.4204 20.7121 63.5837 20.5398 62.8934 20.1952Z" fill="#FFDC83"/>
+<path d="M71.4554 20.1952C70.76 19.8506 70.2299 19.3795 69.8648 18.7799C69.5 18.1804 69.3158 17.5124 69.3158 16.7739C69.3158 16.0355 69.4982 15.3762 69.8648 14.7978C70.2314 14.2194 70.7582 13.7658 71.4503 13.437C72.1403 13.1083 72.965 12.9448 73.9202 12.9448C74.8757 12.9448 75.7001 13.1083 76.3904 13.437C77.0807 13.7658 77.6075 14.2159 77.969 14.7908C78.3305 15.3657 78.5111 16.025 78.5111 16.7722C78.5111 17.5106 78.3305 18.1787 77.969 18.7782C77.6075 19.3777 77.0789 19.8489 76.3835 20.1935C75.6881 20.5381 74.867 20.7104 73.9187 20.7104C72.9701 20.7104 72.149 20.5398 71.4554 20.1952ZM75.1166 18.0116C75.4094 17.7128 75.5573 17.3172 75.5573 16.8249C75.5573 16.3327 75.4109 15.9406 75.1166 15.6505C74.8241 15.3587 74.4245 15.2127 73.9187 15.2127C73.4039 15.2127 73.001 15.3587 72.7067 15.6505C72.4142 15.9424 72.2678 16.3327 72.2678 16.8249C72.2678 17.3172 72.4142 17.7128 72.7067 18.0116C72.9995 18.3105 73.4039 18.4617 73.9187 18.4617C74.4245 18.46 74.8241 18.3105 75.1166 18.0116Z" fill="#FFDC83"/>
+<path d="M85.751 13.4019V16.0601C85.4447 15.8544 85.0487 15.7524 84.5582 15.7524C83.9159 15.7524 83.4203 15.9511 83.0759 16.3485C82.73 16.7458 82.5578 17.3646 82.5578 18.2015V20.466H79.6058V13.2665H82.4978V15.5556C82.6577 14.7187 82.9178 14.1016 83.2757 13.7025C83.6321 13.3052 84.0932 13.1065 84.6545 13.1065C85.0796 13.1065 85.4447 13.205 85.751 13.4019Z" fill="#FFDC83"/>
+<path d="M95.5592 11.6051V20.466H92.6069V18.8538C92.3573 19.4604 91.9787 19.9228 91.4693 20.2392C90.9596 20.5539 90.3296 20.7121 89.5826 20.7121C88.9148 20.7121 88.3331 20.5469 87.8354 20.2146C87.338 19.8823 86.9543 19.427 86.684 18.8485C86.4155 18.2701 86.2793 17.6161 86.2793 16.8847C86.2709 16.1305 86.4137 15.4536 86.708 14.8541C87.0008 14.2546 87.4154 13.7869 87.9491 13.4511C88.4828 13.1153 89.0921 12.9466 89.7755 12.9466C91.1819 12.9466 92.1251 13.5707 92.6069 14.8172V11.6051H95.5592ZM92.1665 17.9625C92.4677 17.6636 92.6174 17.275 92.6174 16.8004C92.6174 16.3415 92.471 15.967 92.1785 15.6804C91.8857 15.3939 91.4846 15.2497 90.9803 15.2497C90.4829 15.2497 90.0854 15.3956 89.7875 15.6874C89.4896 15.9793 89.3417 16.3573 89.3417 16.825C89.3417 17.2926 89.4896 17.6741 89.7875 17.9695C90.0854 18.2648 90.4778 18.4125 90.9683 18.4125C91.4657 18.4108 91.865 18.2613 92.1665 17.9625Z" fill="#FFDC83"/>
+<path d="M49.8146 14.033C50.6273 14.033 51.2864 13.4284 51.2864 12.6827C51.2864 11.937 50.6273 11.3325 49.8146 11.3325C49.0016 11.3325 48.3428 11.937 48.3428 12.6827C48.3428 13.4284 49.0016 14.033 49.8146 14.033Z" fill="#FFDC83"/>
+<path d="M48.3416 14.9631C49.2434 15.3604 50.3624 15.378 51.2849 14.9631V20.5046H48.3416V14.9631Z" fill="#FFDC83"/>
+</g>
+</g>
+<mask id="path-14-inside-1_25_2" fill="white">
+<path d="M103.6 0H269.447V32H103.6V0Z"/>
+</mask>
+<path d="M103.6 0H269.447V32H103.6V0Z" fill="#FFDC83"/>
+<path d="M103.6 32H104.6V0H103.6H102.6V32H103.6Z" fill="#635943" mask="url(#path-14-inside-1_25_2)"/>
+<path d="M114.89 20.151C113.901 20.151 113.112 19.8383 112.524 19.213C111.936 18.5877 111.628 17.7523 111.6 16.707L112.776 16.595C112.804 17.407 112.991 18.009 113.336 18.401C113.681 18.7837 114.199 18.975 114.89 18.975C116.281 18.975 116.976 18.1817 116.976 16.595V9.98699H118.18V16.595C118.18 17.6963 117.881 18.5643 117.284 19.199C116.696 19.8337 115.898 20.151 114.89 20.151ZM123.635 20.095C122.953 20.095 122.356 19.9363 121.843 19.619C121.339 19.3017 120.947 18.8537 120.667 18.275C120.387 17.687 120.247 17.001 120.247 16.217C120.247 15.433 120.387 14.7517 120.667 14.173C120.947 13.585 121.339 13.1323 121.843 12.815C122.356 12.4977 122.953 12.339 123.635 12.339C124.307 12.339 124.899 12.4977 125.413 12.815C125.926 13.1323 126.323 13.585 126.603 14.173C126.883 14.7517 127.023 15.433 127.023 16.217C127.023 17.001 126.883 17.687 126.603 18.275C126.323 18.8537 125.926 19.3017 125.413 19.619C124.899 19.9363 124.307 20.095 123.635 20.095ZM123.635 18.975C124.316 18.975 124.843 18.7323 125.217 18.247C125.599 17.7523 125.791 17.0757 125.791 16.217C125.791 15.3583 125.599 14.6863 125.217 14.201C124.843 13.7063 124.316 13.459 123.635 13.459C122.953 13.459 122.421 13.7017 122.039 14.187C121.665 14.6723 121.479 15.349 121.479 16.217C121.479 17.085 121.665 17.7617 122.039 18.247C122.421 18.7323 122.953 18.975 123.635 18.975ZM128.949 18.891H131.931V13.543H129.089V12.507H133.107V18.891H135.669V19.927H128.949V18.891ZM131.819 9.97299H133.051V11.345H131.819V9.97299ZM137.568 12.507H138.646L138.674 13.837C138.86 13.3423 139.154 12.969 139.556 12.717C139.957 12.465 140.424 12.339 140.956 12.339C141.768 12.339 142.384 12.6003 142.804 13.123C143.233 13.6457 143.448 14.3223 143.448 15.153V19.927H142.272V15.489C142.272 14.789 142.146 14.2617 141.894 13.907C141.651 13.5523 141.254 13.375 140.704 13.375C140.116 13.375 139.64 13.5617 139.276 13.935C138.921 14.299 138.744 14.817 138.744 15.489V19.927H137.568V12.507ZM157.213 20.095C156.531 20.095 155.934 19.9363 155.421 19.619C154.917 19.3017 154.525 18.8537 154.245 18.275C153.965 17.687 153.825 17.001 153.825 16.217C153.825 15.433 153.965 14.7517 154.245 14.173C154.525 13.585 154.917 13.1323 155.421 12.815C155.934 12.4977 156.531 12.339 157.213 12.339C157.885 12.339 158.477 12.4977 158.991 12.815C159.504 13.1323 159.901 13.585 160.181 14.173C160.461 14.7517 160.601 15.433 160.601 16.217C160.601 17.001 160.461 17.687 160.181 18.275C159.901 18.8537 159.504 19.3017 158.991 19.619C158.477 19.9363 157.885 20.095 157.213 20.095ZM157.213 18.975C157.894 18.975 158.421 18.7323 158.795 18.247C159.177 17.7523 159.369 17.0757 159.369 16.217C159.369 15.3583 159.177 14.6863 158.795 14.201C158.421 13.7063 157.894 13.459 157.213 13.459C156.531 13.459 155.999 13.7017 155.617 14.187C155.243 14.6723 155.057 15.349 155.057 16.217C155.057 17.085 155.243 17.7617 155.617 18.247C155.999 18.7323 156.531 18.975 157.213 18.975ZM165.089 20.095C164.352 20.095 163.764 19.8477 163.325 19.353C162.887 18.849 162.667 18.1583 162.667 17.281V12.507H163.843V16.959C163.843 17.6777 163.969 18.2097 164.221 18.555C164.483 18.891 164.879 19.059 165.411 19.059C165.99 19.059 166.447 18.8723 166.783 18.499C167.119 18.1163 167.287 17.5937 167.287 16.931V12.507H168.463V19.927H167.343V18.723C167.138 19.1617 166.844 19.5023 166.461 19.745C166.079 19.9783 165.621 20.095 165.089 20.095ZM171.062 18.891H172.994V13.543H171.062V12.507H173.974L174.058 13.935C174.31 12.983 174.902 12.507 175.836 12.507H177.362V13.571H175.85C175.308 13.571 174.893 13.7343 174.604 14.061C174.314 14.3783 174.17 14.8403 174.17 15.447V18.891H176.522V19.927H171.062V18.891ZM190.987 20.095C190.305 20.095 189.703 19.9363 189.181 19.619C188.667 19.3017 188.271 18.849 187.991 18.261C187.711 17.673 187.571 16.9917 187.571 16.217C187.571 15.4423 187.711 14.761 187.991 14.173C188.271 13.585 188.667 13.1323 189.181 12.815C189.703 12.4977 190.305 12.339 190.987 12.339C191.817 12.339 192.503 12.563 193.045 13.011C193.595 13.459 193.945 14.0937 194.095 14.915L192.863 14.999C192.751 14.5137 192.527 14.1357 192.191 13.865C191.864 13.5943 191.463 13.459 190.987 13.459C190.305 13.459 189.769 13.7063 189.377 14.201C188.994 14.6863 188.803 15.3583 188.803 16.217C188.803 17.0757 188.994 17.7523 189.377 18.247C189.769 18.7323 190.305 18.975 190.987 18.975C191.481 18.975 191.897 18.8303 192.233 18.541C192.578 18.2517 192.807 17.8363 192.919 17.295L194.151 17.379C193.992 18.2097 193.628 18.8723 193.059 19.367C192.499 19.8523 191.808 20.095 190.987 20.095ZM199.185 20.095C198.504 20.095 197.907 19.9363 197.393 19.619C196.889 19.3017 196.497 18.8537 196.217 18.275C195.937 17.687 195.797 17.001 195.797 16.217C195.797 15.433 195.937 14.7517 196.217 14.173C196.497 13.585 196.889 13.1323 197.393 12.815C197.907 12.4977 198.504 12.339 199.185 12.339C199.857 12.339 200.45 12.4977 200.963 12.815C201.477 13.1323 201.873 13.585 202.153 14.173C202.433 14.7517 202.573 15.433 202.573 16.217C202.573 17.001 202.433 17.687 202.153 18.275C201.873 18.8537 201.477 19.3017 200.963 19.619C200.45 19.9363 199.857 20.095 199.185 20.095ZM199.185 18.975C199.867 18.975 200.394 18.7323 200.767 18.247C201.15 17.7523 201.341 17.0757 201.341 16.217C201.341 15.3583 201.15 14.6863 200.767 14.201C200.394 13.7063 199.867 13.459 199.185 13.459C198.504 13.459 197.972 13.7017 197.589 14.187C197.216 14.6723 197.029 15.349 197.029 16.217C197.029 17.085 197.216 17.7617 197.589 18.247C197.972 18.7323 198.504 18.975 199.185 18.975ZM203.94 12.507H205.018L205.046 13.599C205.177 13.1977 205.368 12.8897 205.62 12.675C205.872 12.451 206.171 12.339 206.516 12.339C207.281 12.339 207.748 12.8243 207.916 13.795C208.037 13.3377 208.238 12.983 208.518 12.731C208.798 12.4697 209.129 12.339 209.512 12.339C210.109 12.339 210.543 12.549 210.814 12.969C211.085 13.389 211.22 14.075 211.22 15.027V19.927H210.044V15.167C210.044 14.523 209.974 14.0657 209.834 13.795C209.694 13.515 209.475 13.375 209.176 13.375C208.868 13.375 208.621 13.529 208.434 13.837C208.257 14.1357 208.168 14.5883 208.168 15.195V19.927H206.992V15.167C206.992 14.5323 206.922 14.075 206.782 13.795C206.651 13.515 206.432 13.375 206.124 13.375C205.816 13.375 205.569 13.529 205.382 13.837C205.205 14.1357 205.116 14.5883 205.116 15.195V19.927H203.94V12.507ZM212.334 12.507H213.412L213.44 13.599C213.571 13.1977 213.762 12.8897 214.014 12.675C214.266 12.451 214.565 12.339 214.91 12.339C215.676 12.339 216.142 12.8243 216.31 13.795C216.432 13.3377 216.632 12.983 216.912 12.731C217.192 12.4697 217.524 12.339 217.906 12.339C218.504 12.339 218.938 12.549 219.208 12.969C219.479 13.389 219.614 14.075 219.614 15.027V19.927H218.438V15.167C218.438 14.523 218.368 14.0657 218.228 13.795C218.088 13.515 217.869 13.375 217.57 13.375C217.262 13.375 217.015 13.529 216.828 13.837C216.651 14.1357 216.562 14.5883 216.562 15.195V19.927H215.386V15.167C215.386 14.5323 215.316 14.075 215.176 13.795C215.046 13.515 214.826 13.375 214.518 13.375C214.21 13.375 213.963 13.529 213.776 13.837C213.599 14.1357 213.51 14.5883 213.51 15.195V19.927H212.334V12.507ZM223.851 20.095C223.114 20.095 222.526 19.8477 222.087 19.353C221.648 18.849 221.429 18.1583 221.429 17.281V12.507H222.605V16.959C222.605 17.6777 222.731 18.2097 222.983 18.555C223.244 18.891 223.641 19.059 224.173 19.059C224.752 19.059 225.209 18.8723 225.545 18.499C225.881 18.1163 226.049 17.5937 226.049 16.931V12.507H227.225V19.927H226.105V18.723C225.9 19.1617 225.606 19.5023 225.223 19.745C224.84 19.9783 224.383 20.095 223.851 20.095ZM229.907 12.507H230.985L231.013 13.837C231.2 13.3423 231.494 12.969 231.895 12.717C232.297 12.465 232.763 12.339 233.295 12.339C234.107 12.339 234.723 12.6003 235.143 13.123C235.573 13.6457 235.787 14.3223 235.787 15.153V19.927H234.611V15.489C234.611 14.789 234.485 14.2617 234.233 13.907C233.991 13.5523 233.594 13.375 233.043 13.375C232.455 13.375 231.979 13.5617 231.615 13.935C231.261 14.299 231.083 14.817 231.083 15.489V19.927H229.907V12.507ZM238.078 18.891H241.06V13.543H238.218V12.507H242.236V18.891H244.798V19.927H238.078V18.891ZM240.948 9.97299H242.18V11.345H240.948V9.97299ZM250.645 19.927C249.926 19.927 249.389 19.759 249.035 19.423C248.68 19.087 248.503 18.5737 248.503 17.883V13.543H246.053V12.507H248.503V10.547H249.679V12.507H252.633V13.543H249.679V17.883C249.679 18.2283 249.758 18.485 249.917 18.653C250.075 18.8117 250.318 18.891 250.645 18.891H252.633V19.927H250.645ZM255.679 20.991H256.533C256.785 20.991 256.972 20.949 257.093 20.865C257.224 20.7903 257.326 20.6643 257.401 20.487L257.667 19.787H257.261L254.503 12.507H255.791L258.045 18.695L260.159 12.507H261.447L258.437 20.865C258.297 21.2663 258.087 21.5603 257.807 21.747C257.527 21.9337 257.14 22.027 256.645 22.027H255.679V20.991Z" fill="#100D0D"/>
+</g>
+<path d="M4 0.5H265.447C267.38 0.500144 268.947 2.06709 268.947 4V28C268.947 29.9329 267.38 31.4999 265.447 31.5H4C2.067 31.5 0.5 29.933 0.5 28V4C0.5 2.067 2.067 0.5 4 0.5Z" stroke="#635943"/>
+<defs>
+<clipPath id="clip0_25_2">
+<path d="M0 4C0 1.79086 1.79086 0 4 0H265.447C267.656 0 269.447 1.79086 269.447 4V28C269.447 30.2091 267.656 32 265.447 32H3.99999C1.79085 32 0 30.2091 0 28V4Z" fill="white"/>
+</clipPath>
+<clipPath id="clip1_25_2">
+<rect width="87.6" height="24" fill="white" transform="translate(8 4)"/>
+</clipPath>
+</defs>
+</svg>
diff --git a/media/light_license.svg b/media/light_license.svg
new file mode 100644
index 000000000..a92773ef8
--- /dev/null
+++ b/media/light_license.svg
@@ -0,0 +1,18 @@
+<svg width="113" height="32" viewBox="0 0 113 32" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_25_20)">
+<rect width="112.316" height="32" rx="4" fill="black"/>
+<path d="M8 10.953H9.20396V19.745H14.16V20.893H8V10.953ZM16.1146 19.857H19.0966V14.509H16.2546V13.473H20.2726V19.857H22.8346V20.893H16.1146V19.857ZM18.9846 10.939H20.2166V12.311H18.9846V10.939ZM27.7851 21.061C27.1038 21.061 26.5018 20.9023 25.9791 20.585C25.4658 20.2677 25.0691 19.815 24.7891 19.227C24.5091 18.639 24.3691 17.9577 24.3691 17.183C24.3691 16.4083 24.5091 15.727 24.7891 15.139C25.0691 14.551 25.4658 14.0983 25.9791 13.781C26.5018 13.4637 27.1038 13.305 27.7851 13.305C28.6158 13.305 29.3018 13.529 29.8431 13.977C30.3938 14.425 30.7438 15.0597 30.8931 15.881L29.6611 15.965C29.5491 15.4797 29.3251 15.1017 28.9891 14.831C28.6624 14.5603 28.2611 14.425 27.7851 14.425C27.1038 14.425 26.5671 14.6723 26.1751 15.167C25.7924 15.6523 25.6011 16.3243 25.6011 17.183C25.6011 18.0417 25.7924 18.7183 26.1751 19.213C26.5671 19.6983 27.1038 19.941 27.7851 19.941C28.2798 19.941 28.6951 19.7963 29.0311 19.507C29.3764 19.2177 29.6051 18.8023 29.7171 18.261L30.9491 18.345C30.7904 19.1757 30.4264 19.8383 29.8571 20.333C29.2971 20.8183 28.6064 21.061 27.7851 21.061ZM36.1096 21.061C35.419 21.061 34.817 20.9023 34.3036 20.585C33.7903 20.2677 33.3936 19.8197 33.1136 19.241C32.843 18.653 32.7076 17.967 32.7076 17.183C32.7076 16.4083 32.843 15.727 33.1136 15.139C33.3936 14.551 33.7856 14.0983 34.2896 13.781C34.7936 13.4637 35.3816 13.305 36.0536 13.305C36.6976 13.305 37.267 13.459 37.7616 13.767C38.2656 14.0657 38.653 14.509 38.9236 15.097C39.2036 15.685 39.3436 16.385 39.3436 17.197V17.547H33.9396C33.977 18.331 34.1823 18.9283 34.5556 19.339C34.9383 19.7403 35.4563 19.941 36.1096 19.941C36.5856 19.941 36.9776 19.8337 37.2856 19.619C37.603 19.395 37.827 19.087 37.9576 18.695L39.2176 18.793C39.0216 19.4743 38.6436 20.025 38.0836 20.445C37.533 20.8557 36.875 21.061 36.1096 21.061ZM38.0556 16.511C37.9996 15.8203 37.7943 15.3023 37.4396 14.957C37.085 14.6023 36.623 14.425 36.0536 14.425C35.475 14.425 34.999 14.6023 34.6256 14.957C34.2616 15.3117 34.033 15.8297 33.9396 16.511H38.0556ZM41.5222 13.473H42.6002L42.6282 14.803C42.8148 14.3083 43.1088 13.935 43.5102 13.683C43.9115 13.431 44.3782 13.305 44.9102 13.305C45.7222 13.305 46.3382 13.5663 46.7582 14.089C47.1875 14.6117 47.4022 15.2883 47.4022 16.119V20.893H46.2262V16.455C46.2262 15.755 46.1002 15.2277 45.8482 14.873C45.6055 14.5183 45.2088 14.341 44.6582 14.341C44.0702 14.341 43.5942 14.5277 43.2302 14.901C42.8755 15.265 42.6982 15.783 42.6982 16.455V20.893H41.5222V13.473ZM52.9127 21.061C52.2874 21.061 51.7367 20.9537 51.2607 20.739C50.794 20.515 50.4254 20.2163 50.1547 19.843C49.884 19.4603 49.73 19.031 49.6927 18.555L50.9247 18.471C50.9994 18.9377 51.2047 19.3017 51.5407 19.563C51.8767 19.815 52.334 19.941 52.9127 19.941C53.4727 19.941 53.902 19.8617 54.2007 19.703C54.4994 19.535 54.6487 19.2877 54.6487 18.961C54.6487 18.737 54.5974 18.5597 54.4947 18.429C54.392 18.289 54.2007 18.1723 53.9207 18.079C53.65 17.9763 53.2394 17.8783 52.6887 17.785C51.9794 17.6637 51.4194 17.505 51.0087 17.309C50.6074 17.113 50.318 16.875 50.1407 16.595C49.9727 16.315 49.8887 15.965 49.8887 15.545C49.8887 14.8823 50.136 14.3457 50.6307 13.935C51.1254 13.515 51.816 13.305 52.7027 13.305C53.5707 13.305 54.2567 13.529 54.7607 13.977C55.274 14.425 55.5914 14.9943 55.7127 15.685L54.4807 15.769C54.3967 15.3583 54.196 15.0317 53.8787 14.789C53.5707 14.5463 53.174 14.425 52.6887 14.425C52.166 14.425 51.7694 14.5277 51.4987 14.733C51.228 14.9383 51.0927 15.209 51.0927 15.545C51.0927 15.797 51.1534 15.9977 51.2747 16.147C51.396 16.287 51.5827 16.4037 51.8347 16.497C52.096 16.581 52.4647 16.665 52.9407 16.749C53.706 16.8703 54.2987 17.0243 54.7187 17.211C55.1387 17.3977 55.4327 17.631 55.6007 17.911C55.7687 18.1817 55.8527 18.5317 55.8527 18.961C55.8527 19.605 55.5774 20.1183 55.0267 20.501C54.476 20.8743 53.7714 21.061 52.9127 21.061ZM61.2932 21.061C60.6026 21.061 60.0006 20.9023 59.4872 20.585C58.9739 20.2677 58.5772 19.8197 58.2972 19.241C58.0266 18.653 57.8912 17.967 57.8912 17.183C57.8912 16.4083 58.0266 15.727 58.2972 15.139C58.5772 14.551 58.9692 14.0983 59.4732 13.781C59.9772 13.4637 60.5652 13.305 61.2372 13.305C61.8812 13.305 62.4506 13.459 62.9452 13.767C63.4492 14.0657 63.8366 14.509 64.1072 15.097C64.3872 15.685 64.5272 16.385 64.5272 17.197V17.547H59.1232C59.1606 18.331 59.3659 18.9283 59.7392 19.339C60.1219 19.7403 60.6399 19.941 61.2932 19.941C61.7692 19.941 62.1612 19.8337 62.4692 19.619C62.7866 19.395 63.0106 19.087 63.1412 18.695L64.4012 18.793C64.2052 19.4743 63.8272 20.025 63.2672 20.445C62.7166 20.8557 62.0586 21.061 61.2932 21.061ZM63.2392 16.511C63.1832 15.8203 62.9779 15.3023 62.6232 14.957C62.2686 14.6023 61.8066 14.425 61.2372 14.425C60.6586 14.425 60.1826 14.6023 59.8092 14.957C59.4452 15.3117 59.2166 15.8297 59.1232 16.511H63.2392Z" fill="#FFDC83"/>
+<mask id="path-5-inside-1_25_20" fill="white">
+<path d="M72.5272 0H112.316V32H72.5272V0Z"/>
+</mask>
+<path d="M72.5272 0H112.316V32H72.5272V0Z" fill="#FFDC83"/>
+<path d="M72.5272 32H73.5272V0H72.5272H71.5272V32H72.5272Z" fill="#635943" mask="url(#path-5-inside-1_25_20)"/>
+<path d="M81.7312 12.64V20.97H80.5272V11.03H82.3472L83.8872 17.946L85.4272 11.03H87.2472V20.97H86.0432V12.64L84.4192 19.85H83.3552L81.7312 12.64ZM89.2017 19.822H91.6797V12.178H89.2017V11.03H95.3617V12.178H92.8837V19.822H95.3617V20.97H89.2017V19.822ZM100.074 12.178H97.0362V11.03H104.316V12.178H101.278V20.97H100.074V12.178Z" fill="#100D0D"/>
+</g>
+<rect x="0.5" y="0.5" width="111.316" height="31" rx="3.5" stroke="#635943"/>
+<defs>
+<clipPath id="clip0_25_20">
+<rect width="112.316" height="32" rx="4" fill="white"/>
+</clipPath>
+</defs>
+</svg>
diff --git a/media/light_logo.png b/media/light_logo.png
new file mode 100644
index 000000000..b07691e70
Binary files /dev/null and b/media/light_logo.png differ
diff --git a/package-lock.json b/package-lock.json
deleted file mode 100644
index 53cd79748..000000000
--- a/package-lock.json
+++ /dev/null
@@ -1,10453 +0,0 @@
-{
-  "name": "@browserbasehq/stagehand",
-  "version": "2.0.0",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "@browserbasehq/stagehand",
-      "version": "2.0.0",
-      "license": "MIT",
-      "dependencies": {
-        "@anthropic-ai/sdk": "0.39.0",
-        "@browserbasehq/sdk": "^2.4.0",
-        "@google/genai": "^0.8.0",
-        "openai": "^4.87.1",
-        "pino": "^9.6.0",
-        "pino-pretty": "^13.0.0",
-        "ws": "^8.18.0",
-        "zod-to-json-schema": "^3.23.5"
-      },
-      "devDependencies": {
-        "@ai-sdk/anthropic": "^1.2.6",
-        "@ai-sdk/cerebras": "^0.2.6",
-        "@ai-sdk/google": "^1.2.6",
-        "@ai-sdk/groq": "^1.2.4",
-        "@ai-sdk/openai": "^1.0.14",
-        "@ai-sdk/togetherai": "^0.2.6",
-        "@changesets/changelog-github": "^0.5.0",
-        "@changesets/cli": "^2.27.9",
-        "@eslint/js": "^9.16.0",
-        "@langchain/core": "^0.3.40",
-        "@langchain/openai": "^0.4.4",
-        "@types/adm-zip": "^0.5.7",
-        "@types/cheerio": "^0.22.35",
-        "@types/express": "^4.17.21",
-        "@types/node": "^20.11.30",
-        "@types/ws": "^8.5.13",
-        "adm-zip": "^0.5.16",
-        "ai": "^4.3.0",
-        "autoevals": "^0.0.64",
-        "braintrust": "^0.0.171",
-        "chalk": "^5.4.1",
-        "cheerio": "^1.0.0",
-        "chromium-bidi": "^0.10.0",
-        "esbuild": "^0.21.4",
-        "eslint": "^9.16.0",
-        "express": "^4.21.0",
-        "globals": "^15.13.0",
-        "multer": "^1.4.5-lts.1",
-        "prettier": "^3.2.5",
-        "string-comparison": "^1.3.0",
-        "tsup": "^8.2.1",
-        "tsx": "^4.10.5",
-        "typescript": "^5.2.2",
-        "typescript-eslint": "^8.17.0"
-      },
-      "peerDependencies": {
-        "@playwright/test": "^1.42.1",
-        "deepmerge": "^4.3.1",
-        "dotenv": "^16.4.5",
-        "zod": "^3.23.8"
-      }
-    },
-    "node_modules/@ai-sdk/anthropic": {
-      "version": "1.2.6",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/anthropic/-/anthropic-1.2.6.tgz",
-      "integrity": "sha512-Mt8ZSkhwnKHfwPPIviv3xgRE/nch2Mu4Fdh7oJDJvPDRJ6tNidCJd3TMwdlrlzPskF7hxCmXmd36yBgZZgt4cA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "1.1.0",
-        "@ai-sdk/provider-utils": "2.2.4"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.0.0"
-      }
-    },
-    "node_modules/@ai-sdk/anthropic/node_modules/@ai-sdk/provider": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-1.1.0.tgz",
-      "integrity": "sha512-0M+qjp+clUD0R1E5eWQFhxEvWLNaOtGQRUaBn8CUABnSKredagq92hUS9VjOzGsTm37xLfpaxl97AVtbeOsHew==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "json-schema": "^0.4.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@ai-sdk/anthropic/node_modules/@ai-sdk/provider-utils": {
-      "version": "2.2.4",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-2.2.4.tgz",
-      "integrity": "sha512-13sEGBxB6kgaMPGOgCLYibF6r8iv8mgjhuToFrOTU09bBxbFQd8ZoARarCfJN6VomCUbUvMKwjTBLb1vQnN+WA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "1.1.0",
-        "nanoid": "^3.3.8",
-        "secure-json-parse": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.23.8"
-      }
-    },
-    "node_modules/@ai-sdk/cerebras": {
-      "version": "0.2.6",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/cerebras/-/cerebras-0.2.6.tgz",
-      "integrity": "sha512-XpVqq5462HyQPT55Ptpdb0pwti3fbLOZGDeWgxkSwJTzC+fCzDLZFLJKDCINhiMzD+8CAQPQ/qm9+inFZaF0Og==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/openai-compatible": "0.2.6",
-        "@ai-sdk/provider": "1.1.0",
-        "@ai-sdk/provider-utils": "2.2.4"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.0.0"
-      }
-    },
-    "node_modules/@ai-sdk/cerebras/node_modules/@ai-sdk/provider": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-1.1.0.tgz",
-      "integrity": "sha512-0M+qjp+clUD0R1E5eWQFhxEvWLNaOtGQRUaBn8CUABnSKredagq92hUS9VjOzGsTm37xLfpaxl97AVtbeOsHew==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "json-schema": "^0.4.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@ai-sdk/cerebras/node_modules/@ai-sdk/provider-utils": {
-      "version": "2.2.4",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-2.2.4.tgz",
-      "integrity": "sha512-13sEGBxB6kgaMPGOgCLYibF6r8iv8mgjhuToFrOTU09bBxbFQd8ZoARarCfJN6VomCUbUvMKwjTBLb1vQnN+WA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "1.1.0",
-        "nanoid": "^3.3.8",
-        "secure-json-parse": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.23.8"
-      }
-    },
-    "node_modules/@ai-sdk/google": {
-      "version": "1.2.6",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/google/-/google-1.2.6.tgz",
-      "integrity": "sha512-e6vl+hmz7xZzWmsZZkLv89TZc19Vjgqj+RgvJNg03npRiuG4f1R/He1PD/JX6f0az//Y55CcozCcaj4vnMz6gQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "1.1.0",
-        "@ai-sdk/provider-utils": "2.2.4"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.0.0"
-      }
-    },
-    "node_modules/@ai-sdk/google/node_modules/@ai-sdk/provider": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-1.1.0.tgz",
-      "integrity": "sha512-0M+qjp+clUD0R1E5eWQFhxEvWLNaOtGQRUaBn8CUABnSKredagq92hUS9VjOzGsTm37xLfpaxl97AVtbeOsHew==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "json-schema": "^0.4.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@ai-sdk/google/node_modules/@ai-sdk/provider-utils": {
-      "version": "2.2.4",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-2.2.4.tgz",
-      "integrity": "sha512-13sEGBxB6kgaMPGOgCLYibF6r8iv8mgjhuToFrOTU09bBxbFQd8ZoARarCfJN6VomCUbUvMKwjTBLb1vQnN+WA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "1.1.0",
-        "nanoid": "^3.3.8",
-        "secure-json-parse": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.23.8"
-      }
-    },
-    "node_modules/@ai-sdk/groq": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/groq/-/groq-1.2.4.tgz",
-      "integrity": "sha512-jeO/tO8lGpk7L/zpPPSeZ6tMYwcXq2LbPEgmvTDhdrSj4AwYhL9WiEmZerixsKzNuOxjAzP0QZOns1SpsGaC2A==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "1.1.0",
-        "@ai-sdk/provider-utils": "2.2.4"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.0.0"
-      }
-    },
-    "node_modules/@ai-sdk/groq/node_modules/@ai-sdk/provider": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-1.1.0.tgz",
-      "integrity": "sha512-0M+qjp+clUD0R1E5eWQFhxEvWLNaOtGQRUaBn8CUABnSKredagq92hUS9VjOzGsTm37xLfpaxl97AVtbeOsHew==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "json-schema": "^0.4.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@ai-sdk/groq/node_modules/@ai-sdk/provider-utils": {
-      "version": "2.2.4",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-2.2.4.tgz",
-      "integrity": "sha512-13sEGBxB6kgaMPGOgCLYibF6r8iv8mgjhuToFrOTU09bBxbFQd8ZoARarCfJN6VomCUbUvMKwjTBLb1vQnN+WA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "1.1.0",
-        "nanoid": "^3.3.8",
-        "secure-json-parse": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.23.8"
-      }
-    },
-    "node_modules/@ai-sdk/openai": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/openai/-/openai-1.2.3.tgz",
-      "integrity": "sha512-iIJKMjKYZN3XWVECDassufz3X7rq/b5BQ6Uhnp03i06T8E4QwCamwtLitJXtrqQ+OxL33Ugn3EIZKGaSBo/+qw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "1.0.10",
-        "@ai-sdk/provider-utils": "2.1.12"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.0.0"
-      }
-    },
-    "node_modules/@ai-sdk/openai-compatible": {
-      "version": "0.2.6",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/openai-compatible/-/openai-compatible-0.2.6.tgz",
-      "integrity": "sha512-UOPEWIqG3l5K9O+p7gqiCOWzx66JtmG9v9Mab+S4E7WE34EN6u1QS1pX+RDlRDhZ0/8gNJif0r4Xlc+Ti03yNA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "1.1.0",
-        "@ai-sdk/provider-utils": "2.2.4"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.0.0"
-      }
-    },
-    "node_modules/@ai-sdk/openai-compatible/node_modules/@ai-sdk/provider": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-1.1.0.tgz",
-      "integrity": "sha512-0M+qjp+clUD0R1E5eWQFhxEvWLNaOtGQRUaBn8CUABnSKredagq92hUS9VjOzGsTm37xLfpaxl97AVtbeOsHew==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "json-schema": "^0.4.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@ai-sdk/openai-compatible/node_modules/@ai-sdk/provider-utils": {
-      "version": "2.2.4",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-2.2.4.tgz",
-      "integrity": "sha512-13sEGBxB6kgaMPGOgCLYibF6r8iv8mgjhuToFrOTU09bBxbFQd8ZoARarCfJN6VomCUbUvMKwjTBLb1vQnN+WA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "1.1.0",
-        "nanoid": "^3.3.8",
-        "secure-json-parse": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.23.8"
-      }
-    },
-    "node_modules/@ai-sdk/provider": {
-      "version": "1.0.10",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-1.0.10.tgz",
-      "integrity": "sha512-pco8Zl9U0xwXI+nCLc0woMtxbvjU8hRmGTseAUiPHFLYAAL8trRPCukg69IDeinOvIeo1SmXxAIdWWPZOLb4Cg==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "json-schema": "^0.4.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@ai-sdk/provider-utils": {
-      "version": "2.1.12",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-2.1.12.tgz",
-      "integrity": "sha512-NLm2Ypkv419jR5TNOvZ057ciSYFKzSDEIIwE8cRyeR1Y5RbuX+auZveqGg6GWsDzvUnn6Xra7BJmr0422v60UA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "1.0.10",
-        "eventsource-parser": "^3.0.0",
-        "nanoid": "^3.3.8",
-        "secure-json-parse": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.0.0"
-      },
-      "peerDependenciesMeta": {
-        "zod": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@ai-sdk/react": {
-      "version": "1.2.6",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/react/-/react-1.2.6.tgz",
-      "integrity": "sha512-5BFChNbcYtcY9MBStcDev7WZRHf0NpTrk8yfSoedWctB3jfWkFd1HECBvdc8w3mUQshF2MumLHtAhRO7IFtGGQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider-utils": "2.2.4",
-        "@ai-sdk/ui-utils": "1.2.5",
-        "swr": "^2.2.5",
-        "throttleit": "2.1.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "react": "^18 || ^19 || ^19.0.0-rc",
-        "zod": "^3.23.8"
-      },
-      "peerDependenciesMeta": {
-        "zod": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@ai-sdk/react/node_modules/@ai-sdk/provider": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-1.1.0.tgz",
-      "integrity": "sha512-0M+qjp+clUD0R1E5eWQFhxEvWLNaOtGQRUaBn8CUABnSKredagq92hUS9VjOzGsTm37xLfpaxl97AVtbeOsHew==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "json-schema": "^0.4.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@ai-sdk/react/node_modules/@ai-sdk/provider-utils": {
-      "version": "2.2.4",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-2.2.4.tgz",
-      "integrity": "sha512-13sEGBxB6kgaMPGOgCLYibF6r8iv8mgjhuToFrOTU09bBxbFQd8ZoARarCfJN6VomCUbUvMKwjTBLb1vQnN+WA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "1.1.0",
-        "nanoid": "^3.3.8",
-        "secure-json-parse": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.23.8"
-      }
-    },
-    "node_modules/@ai-sdk/solid": {
-      "version": "0.0.54",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/solid/-/solid-0.0.54.tgz",
-      "integrity": "sha512-96KWTVK+opdFeRubqrgaJXoNiDP89gNxFRWUp0PJOotZW816AbhUf4EnDjBjXTLjXL1n0h8tGSE9sZsRkj9wQQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider-utils": "1.0.22",
-        "@ai-sdk/ui-utils": "0.0.50"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "solid-js": "^1.7.7"
-      },
-      "peerDependenciesMeta": {
-        "solid-js": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@ai-sdk/solid/node_modules/@ai-sdk/provider": {
-      "version": "0.0.26",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-0.0.26.tgz",
-      "integrity": "sha512-dQkfBDs2lTYpKM8389oopPdQgIU007GQyCbuPPrV+K6MtSII3HBfE0stUIMXUb44L+LK1t6GXPP7wjSzjO6uKg==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "json-schema": "^0.4.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@ai-sdk/solid/node_modules/@ai-sdk/provider-utils": {
-      "version": "1.0.22",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-1.0.22.tgz",
-      "integrity": "sha512-YHK2rpj++wnLVc9vPGzGFP3Pjeld2MwhKinetA0zKXOoHAT/Jit5O8kZsxcSlJPu9wvcGT1UGZEjZrtO7PfFOQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "0.0.26",
-        "eventsource-parser": "^1.1.2",
-        "nanoid": "^3.3.7",
-        "secure-json-parse": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.0.0"
-      },
-      "peerDependenciesMeta": {
-        "zod": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@ai-sdk/solid/node_modules/@ai-sdk/ui-utils": {
-      "version": "0.0.50",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/ui-utils/-/ui-utils-0.0.50.tgz",
-      "integrity": "sha512-Z5QYJVW+5XpSaJ4jYCCAVG7zIAuKOOdikhgpksneNmKvx61ACFaf98pmOd+xnjahl0pIlc/QIe6O4yVaJ1sEaw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "0.0.26",
-        "@ai-sdk/provider-utils": "1.0.22",
-        "json-schema": "^0.4.0",
-        "secure-json-parse": "^2.7.0",
-        "zod-to-json-schema": "^3.23.3"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.0.0"
-      },
-      "peerDependenciesMeta": {
-        "zod": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@ai-sdk/solid/node_modules/eventsource-parser": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-1.1.2.tgz",
-      "integrity": "sha512-v0eOBUbiaFojBu2s2NPBfYUoRR9GjcDNvCXVaqEf5vVfpIAh9f8RCo4vXTP8c63QRKCFwoLpMpTdPwwhEKVgzA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=14.18"
-      }
-    },
-    "node_modules/@ai-sdk/svelte": {
-      "version": "0.0.57",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/svelte/-/svelte-0.0.57.tgz",
-      "integrity": "sha512-SyF9ItIR9ALP9yDNAD+2/5Vl1IT6kchgyDH8xkmhysfJI6WrvJbtO1wdQ0nylvPLcsPoYu+cAlz1krU4lFHcYw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider-utils": "1.0.22",
-        "@ai-sdk/ui-utils": "0.0.50",
-        "sswr": "^2.1.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "svelte": "^3.0.0 || ^4.0.0 || ^5.0.0"
-      },
-      "peerDependenciesMeta": {
-        "svelte": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@ai-sdk/svelte/node_modules/@ai-sdk/provider": {
-      "version": "0.0.26",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-0.0.26.tgz",
-      "integrity": "sha512-dQkfBDs2lTYpKM8389oopPdQgIU007GQyCbuPPrV+K6MtSII3HBfE0stUIMXUb44L+LK1t6GXPP7wjSzjO6uKg==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "json-schema": "^0.4.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@ai-sdk/svelte/node_modules/@ai-sdk/provider-utils": {
-      "version": "1.0.22",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-1.0.22.tgz",
-      "integrity": "sha512-YHK2rpj++wnLVc9vPGzGFP3Pjeld2MwhKinetA0zKXOoHAT/Jit5O8kZsxcSlJPu9wvcGT1UGZEjZrtO7PfFOQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "0.0.26",
-        "eventsource-parser": "^1.1.2",
-        "nanoid": "^3.3.7",
-        "secure-json-parse": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.0.0"
-      },
-      "peerDependenciesMeta": {
-        "zod": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@ai-sdk/svelte/node_modules/@ai-sdk/ui-utils": {
-      "version": "0.0.50",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/ui-utils/-/ui-utils-0.0.50.tgz",
-      "integrity": "sha512-Z5QYJVW+5XpSaJ4jYCCAVG7zIAuKOOdikhgpksneNmKvx61ACFaf98pmOd+xnjahl0pIlc/QIe6O4yVaJ1sEaw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "0.0.26",
-        "@ai-sdk/provider-utils": "1.0.22",
-        "json-schema": "^0.4.0",
-        "secure-json-parse": "^2.7.0",
-        "zod-to-json-schema": "^3.23.3"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.0.0"
-      },
-      "peerDependenciesMeta": {
-        "zod": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@ai-sdk/svelte/node_modules/eventsource-parser": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-1.1.2.tgz",
-      "integrity": "sha512-v0eOBUbiaFojBu2s2NPBfYUoRR9GjcDNvCXVaqEf5vVfpIAh9f8RCo4vXTP8c63QRKCFwoLpMpTdPwwhEKVgzA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=14.18"
-      }
-    },
-    "node_modules/@ai-sdk/togetherai": {
-      "version": "0.2.6",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/togetherai/-/togetherai-0.2.6.tgz",
-      "integrity": "sha512-AV3CABMKlIniCe5owr6H/kSirfk3Y/MeBAetrNJxRDhmrxa5VXzbWeMxS5xeS8crqFXWJPPLcwPiwOuFtpQMrA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/openai-compatible": "0.2.6",
-        "@ai-sdk/provider": "1.1.0",
-        "@ai-sdk/provider-utils": "2.2.4"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.0.0"
-      }
-    },
-    "node_modules/@ai-sdk/togetherai/node_modules/@ai-sdk/provider": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-1.1.0.tgz",
-      "integrity": "sha512-0M+qjp+clUD0R1E5eWQFhxEvWLNaOtGQRUaBn8CUABnSKredagq92hUS9VjOzGsTm37xLfpaxl97AVtbeOsHew==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "json-schema": "^0.4.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@ai-sdk/togetherai/node_modules/@ai-sdk/provider-utils": {
-      "version": "2.2.4",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-2.2.4.tgz",
-      "integrity": "sha512-13sEGBxB6kgaMPGOgCLYibF6r8iv8mgjhuToFrOTU09bBxbFQd8ZoARarCfJN6VomCUbUvMKwjTBLb1vQnN+WA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "1.1.0",
-        "nanoid": "^3.3.8",
-        "secure-json-parse": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.23.8"
-      }
-    },
-    "node_modules/@ai-sdk/ui-utils": {
-      "version": "1.2.5",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/ui-utils/-/ui-utils-1.2.5.tgz",
-      "integrity": "sha512-XDgqnJcaCkDez7qolvk+PDbs/ceJvgkNkxkOlc9uDWqxfDJxtvCZ+14MP/1qr4IBwGIgKVHzMDYDXvqVhSWLzg==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "1.1.0",
-        "@ai-sdk/provider-utils": "2.2.4",
-        "zod-to-json-schema": "^3.24.1"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.23.8"
-      }
-    },
-    "node_modules/@ai-sdk/ui-utils/node_modules/@ai-sdk/provider": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-1.1.0.tgz",
-      "integrity": "sha512-0M+qjp+clUD0R1E5eWQFhxEvWLNaOtGQRUaBn8CUABnSKredagq92hUS9VjOzGsTm37xLfpaxl97AVtbeOsHew==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "json-schema": "^0.4.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@ai-sdk/ui-utils/node_modules/@ai-sdk/provider-utils": {
-      "version": "2.2.4",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-2.2.4.tgz",
-      "integrity": "sha512-13sEGBxB6kgaMPGOgCLYibF6r8iv8mgjhuToFrOTU09bBxbFQd8ZoARarCfJN6VomCUbUvMKwjTBLb1vQnN+WA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "1.1.0",
-        "nanoid": "^3.3.8",
-        "secure-json-parse": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.23.8"
-      }
-    },
-    "node_modules/@ai-sdk/vue": {
-      "version": "0.0.59",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/vue/-/vue-0.0.59.tgz",
-      "integrity": "sha512-+ofYlnqdc8c4F6tM0IKF0+7NagZRAiqBJpGDJ+6EYhDW8FHLUP/JFBgu32SjxSxC6IKFZxEnl68ZoP/Z38EMlw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider-utils": "1.0.22",
-        "@ai-sdk/ui-utils": "0.0.50",
-        "swrv": "^1.0.4"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "vue": "^3.3.4"
-      },
-      "peerDependenciesMeta": {
-        "vue": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@ai-sdk/vue/node_modules/@ai-sdk/provider": {
-      "version": "0.0.26",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-0.0.26.tgz",
-      "integrity": "sha512-dQkfBDs2lTYpKM8389oopPdQgIU007GQyCbuPPrV+K6MtSII3HBfE0stUIMXUb44L+LK1t6GXPP7wjSzjO6uKg==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "json-schema": "^0.4.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@ai-sdk/vue/node_modules/@ai-sdk/provider-utils": {
-      "version": "1.0.22",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-1.0.22.tgz",
-      "integrity": "sha512-YHK2rpj++wnLVc9vPGzGFP3Pjeld2MwhKinetA0zKXOoHAT/Jit5O8kZsxcSlJPu9wvcGT1UGZEjZrtO7PfFOQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "0.0.26",
-        "eventsource-parser": "^1.1.2",
-        "nanoid": "^3.3.7",
-        "secure-json-parse": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.0.0"
-      },
-      "peerDependenciesMeta": {
-        "zod": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@ai-sdk/vue/node_modules/@ai-sdk/ui-utils": {
-      "version": "0.0.50",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/ui-utils/-/ui-utils-0.0.50.tgz",
-      "integrity": "sha512-Z5QYJVW+5XpSaJ4jYCCAVG7zIAuKOOdikhgpksneNmKvx61ACFaf98pmOd+xnjahl0pIlc/QIe6O4yVaJ1sEaw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "0.0.26",
-        "@ai-sdk/provider-utils": "1.0.22",
-        "json-schema": "^0.4.0",
-        "secure-json-parse": "^2.7.0",
-        "zod-to-json-schema": "^3.23.3"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.0.0"
-      },
-      "peerDependenciesMeta": {
-        "zod": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@ai-sdk/vue/node_modules/eventsource-parser": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-1.1.2.tgz",
-      "integrity": "sha512-v0eOBUbiaFojBu2s2NPBfYUoRR9GjcDNvCXVaqEf5vVfpIAh9f8RCo4vXTP8c63QRKCFwoLpMpTdPwwhEKVgzA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=14.18"
-      }
-    },
-    "node_modules/@ampproject/remapping": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz",
-      "integrity": "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "peer": true,
-      "dependencies": {
-        "@jridgewell/gen-mapping": "^0.3.5",
-        "@jridgewell/trace-mapping": "^0.3.24"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@anthropic-ai/sdk": {
-      "version": "0.39.0",
-      "resolved": "https://registry.npmjs.org/@anthropic-ai/sdk/-/sdk-0.39.0.tgz",
-      "integrity": "sha512-eMyDIPRZbt1CCLErRCi3exlAvNkBtRe+kW5vvJyef93PmNr/clstYgHhtvmkxN82nlKgzyGPCyGxrm0JQ1ZIdg==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "^18.11.18",
-        "@types/node-fetch": "^2.6.4",
-        "abort-controller": "^3.0.0",
-        "agentkeepalive": "^4.2.1",
-        "form-data-encoder": "1.7.2",
-        "formdata-node": "^4.3.2",
-        "node-fetch": "^2.6.7"
-      }
-    },
-    "node_modules/@anthropic-ai/sdk/node_modules/@types/node": {
-      "version": "18.19.80",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.80.tgz",
-      "integrity": "sha512-kEWeMwMeIvxYkeg1gTc01awpwLbfMRZXdIhwRcakd/KlK53jmRC26LqcbIt7fnAQTu5GzlnWmzA3H6+l1u6xxQ==",
-      "license": "MIT",
-      "dependencies": {
-        "undici-types": "~5.26.4"
-      }
-    },
-    "node_modules/@anthropic-ai/sdk/node_modules/undici-types": {
-      "version": "5.26.5",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
-      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
-      "license": "MIT"
-    },
-    "node_modules/@asteasolutions/zod-to-openapi": {
-      "version": "6.4.0",
-      "resolved": "https://registry.npmjs.org/@asteasolutions/zod-to-openapi/-/zod-to-openapi-6.4.0.tgz",
-      "integrity": "sha512-8cxfF7AHHx2PqnN4Cd8/O8CBu/nVYJP9DpnfVLW3BFb66VJDnqI/CczZnkqMc3SNh6J9GiX7JbJ5T4BSP4HZ2Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "openapi3-ts": "^4.1.2"
-      },
-      "peerDependencies": {
-        "zod": "^3.20.2"
-      }
-    },
-    "node_modules/@babel/helper-string-parser": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.25.9.tgz",
-      "integrity": "sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.9.tgz",
-      "integrity": "sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/parser": {
-      "version": "7.26.10",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.26.10.tgz",
-      "integrity": "sha512-6aQR2zGE/QFi8JpDLjUZEPYOs7+mhKXm86VaKFiLP35JQwQb6bwUE+XbvkH0EptsYhbNBSUGaUBLKqxH1xSgsA==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@babel/types": "^7.26.10"
-      },
-      "bin": {
-        "parser": "bin/babel-parser.js"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@babel/runtime": {
-      "version": "7.26.10",
-      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.26.10.tgz",
-      "integrity": "sha512-2WJMeRQPHKSPemqk/awGrAiuFfzBmOIPXKizAsVhWH9YJqLZ0H+HS4c8loHGgW6utJ3E/ejXQUsiGaQy2NZ9Fw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "regenerator-runtime": "^0.14.0"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/types": {
-      "version": "7.26.10",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.26.10.tgz",
-      "integrity": "sha512-emqcG3vHrpxUKTrxcblR36dcrcoRDvKmnL/dCL6ZsHaShW80qxCAcNhzQZrpeM765VzEos+xOi4s+r4IXzTwdQ==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@babel/helper-string-parser": "^7.25.9",
-        "@babel/helper-validator-identifier": "^7.25.9"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@braintrust/core": {
-      "version": "0.0.34",
-      "resolved": "https://registry.npmjs.org/@braintrust/core/-/core-0.0.34.tgz",
-      "integrity": "sha512-FwlBlQXDASNtCJa4VL+9roYax7W+yeK4YrpMK/D0G5gMy4vQF6MtPnkJnHVI6S1IdLa+TFBOqfzQJiKZyukhVQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@asteasolutions/zod-to-openapi": "^6.3.1",
-        "uuid": "^9.0.1",
-        "zod": "^3.22.4"
-      }
-    },
-    "node_modules/@braintrust/core/node_modules/uuid": {
-      "version": "9.0.1",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-9.0.1.tgz",
-      "integrity": "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==",
-      "dev": true,
-      "funding": [
-        "https://github.com/sponsors/broofa",
-        "https://github.com/sponsors/ctavan"
-      ],
-      "license": "MIT",
-      "bin": {
-        "uuid": "dist/bin/uuid"
-      }
-    },
-    "node_modules/@browserbasehq/sdk": {
-      "version": "2.4.0",
-      "resolved": "https://registry.npmjs.org/@browserbasehq/sdk/-/sdk-2.4.0.tgz",
-      "integrity": "sha512-o1+6C4MQCpZ9+8je1IUF9UvWLuSzLcBjE1kPfu2sw7MgRFNFJS1NcWCiEmjZe71ke4CNojZWaU7XTNxh8z2PUw==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@types/node": "^18.11.18",
-        "@types/node-fetch": "^2.6.4",
-        "abort-controller": "^3.0.0",
-        "agentkeepalive": "^4.2.1",
-        "form-data-encoder": "1.7.2",
-        "formdata-node": "^4.3.2",
-        "node-fetch": "^2.6.7"
-      }
-    },
-    "node_modules/@browserbasehq/sdk/node_modules/@types/node": {
-      "version": "18.19.80",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.80.tgz",
-      "integrity": "sha512-kEWeMwMeIvxYkeg1gTc01awpwLbfMRZXdIhwRcakd/KlK53jmRC26LqcbIt7fnAQTu5GzlnWmzA3H6+l1u6xxQ==",
-      "license": "MIT",
-      "dependencies": {
-        "undici-types": "~5.26.4"
-      }
-    },
-    "node_modules/@browserbasehq/sdk/node_modules/undici-types": {
-      "version": "5.26.5",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
-      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
-      "license": "MIT"
-    },
-    "node_modules/@cfworker/json-schema": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/@cfworker/json-schema/-/json-schema-4.1.1.tgz",
-      "integrity": "sha512-gAmrUZSGtKc3AiBL71iNWxDsyUC5uMaKKGdvzYsBoTW/xi42JQHl7eKV2OYzCUqvc+D2RCcf7EXY2iCyFIk6og==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@changesets/apply-release-plan": {
-      "version": "7.0.10",
-      "resolved": "https://registry.npmjs.org/@changesets/apply-release-plan/-/apply-release-plan-7.0.10.tgz",
-      "integrity": "sha512-wNyeIJ3yDsVspYvHnEz1xQDq18D9ifed3lI+wxRQRK4pArUcuHgCTrHv0QRnnwjhVCQACxZ+CBih3wgOct6UXw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@changesets/config": "^3.1.1",
-        "@changesets/get-version-range-type": "^0.4.0",
-        "@changesets/git": "^3.0.2",
-        "@changesets/should-skip-package": "^0.1.2",
-        "@changesets/types": "^6.1.0",
-        "@manypkg/get-packages": "^1.1.3",
-        "detect-indent": "^6.0.0",
-        "fs-extra": "^7.0.1",
-        "lodash.startcase": "^4.4.0",
-        "outdent": "^0.5.0",
-        "prettier": "^2.7.1",
-        "resolve-from": "^5.0.0",
-        "semver": "^7.5.3"
-      }
-    },
-    "node_modules/@changesets/apply-release-plan/node_modules/prettier": {
-      "version": "2.8.8",
-      "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.8.tgz",
-      "integrity": "sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "prettier": "bin-prettier.js"
-      },
-      "engines": {
-        "node": ">=10.13.0"
-      },
-      "funding": {
-        "url": "https://github.com/prettier/prettier?sponsor=1"
-      }
-    },
-    "node_modules/@changesets/assemble-release-plan": {
-      "version": "6.0.6",
-      "resolved": "https://registry.npmjs.org/@changesets/assemble-release-plan/-/assemble-release-plan-6.0.6.tgz",
-      "integrity": "sha512-Frkj8hWJ1FRZiY3kzVCKzS0N5mMwWKwmv9vpam7vt8rZjLL1JMthdh6pSDVSPumHPshTTkKZ0VtNbE0cJHZZUg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@changesets/errors": "^0.2.0",
-        "@changesets/get-dependents-graph": "^2.1.3",
-        "@changesets/should-skip-package": "^0.1.2",
-        "@changesets/types": "^6.1.0",
-        "@manypkg/get-packages": "^1.1.3",
-        "semver": "^7.5.3"
-      }
-    },
-    "node_modules/@changesets/changelog-git": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/@changesets/changelog-git/-/changelog-git-0.2.1.tgz",
-      "integrity": "sha512-x/xEleCFLH28c3bQeQIyeZf8lFXyDFVn1SgcBiR2Tw/r4IAWlk1fzxCEZ6NxQAjF2Nwtczoen3OA2qR+UawQ8Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@changesets/types": "^6.1.0"
-      }
-    },
-    "node_modules/@changesets/changelog-github": {
-      "version": "0.5.1",
-      "resolved": "https://registry.npmjs.org/@changesets/changelog-github/-/changelog-github-0.5.1.tgz",
-      "integrity": "sha512-BVuHtF+hrhUScSoHnJwTELB4/INQxVFc+P/Qdt20BLiBFIHFJDDUaGsZw+8fQeJTRP5hJZrzpt3oZWh0G19rAQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@changesets/get-github-info": "^0.6.0",
-        "@changesets/types": "^6.1.0",
-        "dotenv": "^8.1.0"
-      }
-    },
-    "node_modules/@changesets/changelog-github/node_modules/dotenv": {
-      "version": "8.6.0",
-      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-8.6.0.tgz",
-      "integrity": "sha512-IrPdXQsk2BbzvCBGBOTmmSH5SodmqZNt4ERAZDmW4CT+tL8VtvinqywuANaFu4bOMWki16nqf0e4oC0QIaDr/g==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/@changesets/cli": {
-      "version": "2.28.1",
-      "resolved": "https://registry.npmjs.org/@changesets/cli/-/cli-2.28.1.tgz",
-      "integrity": "sha512-PiIyGRmSc6JddQJe/W1hRPjiN4VrMvb2VfQ6Uydy2punBioQrsxppyG5WafinKcW1mT0jOe/wU4k9Zy5ff21AA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@changesets/apply-release-plan": "^7.0.10",
-        "@changesets/assemble-release-plan": "^6.0.6",
-        "@changesets/changelog-git": "^0.2.1",
-        "@changesets/config": "^3.1.1",
-        "@changesets/errors": "^0.2.0",
-        "@changesets/get-dependents-graph": "^2.1.3",
-        "@changesets/get-release-plan": "^4.0.8",
-        "@changesets/git": "^3.0.2",
-        "@changesets/logger": "^0.1.1",
-        "@changesets/pre": "^2.0.2",
-        "@changesets/read": "^0.6.3",
-        "@changesets/should-skip-package": "^0.1.2",
-        "@changesets/types": "^6.1.0",
-        "@changesets/write": "^0.4.0",
-        "@manypkg/get-packages": "^1.1.3",
-        "ansi-colors": "^4.1.3",
-        "ci-info": "^3.7.0",
-        "enquirer": "^2.4.1",
-        "external-editor": "^3.1.0",
-        "fs-extra": "^7.0.1",
-        "mri": "^1.2.0",
-        "p-limit": "^2.2.0",
-        "package-manager-detector": "^0.2.0",
-        "picocolors": "^1.1.0",
-        "resolve-from": "^5.0.0",
-        "semver": "^7.5.3",
-        "spawndamnit": "^3.0.1",
-        "term-size": "^2.1.0"
-      },
-      "bin": {
-        "changeset": "bin.js"
-      }
-    },
-    "node_modules/@changesets/config": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/@changesets/config/-/config-3.1.1.tgz",
-      "integrity": "sha512-bd+3Ap2TKXxljCggI0mKPfzCQKeV/TU4yO2h2C6vAihIo8tzseAn2e7klSuiyYYXvgu53zMN1OeYMIQkaQoWnA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@changesets/errors": "^0.2.0",
-        "@changesets/get-dependents-graph": "^2.1.3",
-        "@changesets/logger": "^0.1.1",
-        "@changesets/types": "^6.1.0",
-        "@manypkg/get-packages": "^1.1.3",
-        "fs-extra": "^7.0.1",
-        "micromatch": "^4.0.8"
-      }
-    },
-    "node_modules/@changesets/errors": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/@changesets/errors/-/errors-0.2.0.tgz",
-      "integrity": "sha512-6BLOQUscTpZeGljvyQXlWOItQyU71kCdGz7Pi8H8zdw6BI0g3m43iL4xKUVPWtG+qrrL9DTjpdn8eYuCQSRpow==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "extendable-error": "^0.1.5"
-      }
-    },
-    "node_modules/@changesets/get-dependents-graph": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/@changesets/get-dependents-graph/-/get-dependents-graph-2.1.3.tgz",
-      "integrity": "sha512-gphr+v0mv2I3Oxt19VdWRRUxq3sseyUpX9DaHpTUmLj92Y10AGy+XOtV+kbM6L/fDcpx7/ISDFK6T8A/P3lOdQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@changesets/types": "^6.1.0",
-        "@manypkg/get-packages": "^1.1.3",
-        "picocolors": "^1.1.0",
-        "semver": "^7.5.3"
-      }
-    },
-    "node_modules/@changesets/get-github-info": {
-      "version": "0.6.0",
-      "resolved": "https://registry.npmjs.org/@changesets/get-github-info/-/get-github-info-0.6.0.tgz",
-      "integrity": "sha512-v/TSnFVXI8vzX9/w3DU2Ol+UlTZcu3m0kXTjTT4KlAdwSvwutcByYwyYn9hwerPWfPkT2JfpoX0KgvCEi8Q/SA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "dataloader": "^1.4.0",
-        "node-fetch": "^2.5.0"
-      }
-    },
-    "node_modules/@changesets/get-release-plan": {
-      "version": "4.0.8",
-      "resolved": "https://registry.npmjs.org/@changesets/get-release-plan/-/get-release-plan-4.0.8.tgz",
-      "integrity": "sha512-MM4mq2+DQU1ZT7nqxnpveDMTkMBLnwNX44cX7NSxlXmr7f8hO6/S2MXNiXG54uf/0nYnefv0cfy4Czf/ZL/EKQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@changesets/assemble-release-plan": "^6.0.6",
-        "@changesets/config": "^3.1.1",
-        "@changesets/pre": "^2.0.2",
-        "@changesets/read": "^0.6.3",
-        "@changesets/types": "^6.1.0",
-        "@manypkg/get-packages": "^1.1.3"
-      }
-    },
-    "node_modules/@changesets/get-version-range-type": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/@changesets/get-version-range-type/-/get-version-range-type-0.4.0.tgz",
-      "integrity": "sha512-hwawtob9DryoGTpixy1D3ZXbGgJu1Rhr+ySH2PvTLHvkZuQ7sRT4oQwMh0hbqZH1weAooedEjRsbrWcGLCeyVQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@changesets/git": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/@changesets/git/-/git-3.0.2.tgz",
-      "integrity": "sha512-r1/Kju9Y8OxRRdvna+nxpQIsMsRQn9dhhAZt94FLDeu0Hij2hnOozW8iqnHBgvu+KdnJppCveQwK4odwfw/aWQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@changesets/errors": "^0.2.0",
-        "@manypkg/get-packages": "^1.1.3",
-        "is-subdir": "^1.1.1",
-        "micromatch": "^4.0.8",
-        "spawndamnit": "^3.0.1"
-      }
-    },
-    "node_modules/@changesets/logger": {
-      "version": "0.1.1",
-      "resolved": "https://registry.npmjs.org/@changesets/logger/-/logger-0.1.1.tgz",
-      "integrity": "sha512-OQtR36ZlnuTxKqoW4Sv6x5YIhOmClRd5pWsjZsddYxpWs517R0HkyiefQPIytCVh4ZcC5x9XaG8KTdd5iRQUfg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "picocolors": "^1.1.0"
-      }
-    },
-    "node_modules/@changesets/parse": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/@changesets/parse/-/parse-0.4.1.tgz",
-      "integrity": "sha512-iwksMs5Bf/wUItfcg+OXrEpravm5rEd9Bf4oyIPL4kVTmJQ7PNDSd6MDYkpSJR1pn7tz/k8Zf2DhTCqX08Ou+Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@changesets/types": "^6.1.0",
-        "js-yaml": "^3.13.1"
-      }
-    },
-    "node_modules/@changesets/pre": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/@changesets/pre/-/pre-2.0.2.tgz",
-      "integrity": "sha512-HaL/gEyFVvkf9KFg6484wR9s0qjAXlZ8qWPDkTyKF6+zqjBe/I2mygg3MbpZ++hdi0ToqNUF8cjj7fBy0dg8Ug==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@changesets/errors": "^0.2.0",
-        "@changesets/types": "^6.1.0",
-        "@manypkg/get-packages": "^1.1.3",
-        "fs-extra": "^7.0.1"
-      }
-    },
-    "node_modules/@changesets/read": {
-      "version": "0.6.3",
-      "resolved": "https://registry.npmjs.org/@changesets/read/-/read-0.6.3.tgz",
-      "integrity": "sha512-9H4p/OuJ3jXEUTjaVGdQEhBdqoT2cO5Ts95JTFsQyawmKzpL8FnIeJSyhTDPW1MBRDnwZlHFEM9SpPwJDY5wIg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@changesets/git": "^3.0.2",
-        "@changesets/logger": "^0.1.1",
-        "@changesets/parse": "^0.4.1",
-        "@changesets/types": "^6.1.0",
-        "fs-extra": "^7.0.1",
-        "p-filter": "^2.1.0",
-        "picocolors": "^1.1.0"
-      }
-    },
-    "node_modules/@changesets/should-skip-package": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/@changesets/should-skip-package/-/should-skip-package-0.1.2.tgz",
-      "integrity": "sha512-qAK/WrqWLNCP22UDdBTMPH5f41elVDlsNyat180A33dWxuUDyNpg6fPi/FyTZwRriVjg0L8gnjJn2F9XAoF0qw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@changesets/types": "^6.1.0",
-        "@manypkg/get-packages": "^1.1.3"
-      }
-    },
-    "node_modules/@changesets/types": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/@changesets/types/-/types-6.1.0.tgz",
-      "integrity": "sha512-rKQcJ+o1nKNgeoYRHKOS07tAMNd3YSN0uHaJOZYjBAgxfV7TUE7JE+z4BzZdQwb5hKaYbayKN5KrYV7ODb2rAA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@changesets/write": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/@changesets/write/-/write-0.4.0.tgz",
-      "integrity": "sha512-CdTLvIOPiCNuH71pyDu3rA+Q0n65cmAbXnwWH84rKGiFumFzkmHNT8KHTMEchcxN+Kl8I54xGUhJ7l3E7X396Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@changesets/types": "^6.1.0",
-        "fs-extra": "^7.0.1",
-        "human-id": "^4.1.1",
-        "prettier": "^2.7.1"
-      }
-    },
-    "node_modules/@changesets/write/node_modules/prettier": {
-      "version": "2.8.8",
-      "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.8.tgz",
-      "integrity": "sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "prettier": "bin-prettier.js"
-      },
-      "engines": {
-        "node": ">=10.13.0"
-      },
-      "funding": {
-        "url": "https://github.com/prettier/prettier?sponsor=1"
-      }
-    },
-    "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "aix"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/android-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
-      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/android-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
-      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/android-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
-      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
-      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/darwin-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
-      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
-      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
-      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
-      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
-      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
-      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-loong64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
-      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
-      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
-      "cpu": [
-        "mips64el"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
-      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-s390x": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
-      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
-      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/netbsd-arm64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.1.tgz",
-      "integrity": "sha512-O96poM2XGhLtpTh+s4+nP7YCCAfb4tJNRVZHfIE7dgmax+yMP2WgMd2OecBuaATHKTHsLWHQeuaxMRnCsH8+5g==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/openbsd-arm64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.1.tgz",
-      "integrity": "sha512-Na9T3szbXezdzM/Kfs3GcRQNjHzM6GzFBeU1/6IV/npKP5ORtp9zbQjvkDJ47s6BCgaAZnnnu/cY1x342+MvZg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/sunos-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
-      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/win32-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
-      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/win32-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
-      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/win32-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
-      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@eslint-community/eslint-utils": {
-      "version": "4.5.0",
-      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.5.0.tgz",
-      "integrity": "sha512-RoV8Xs9eNwiDvhv7M+xcL4PWyRyIXRY/FLp3buU4h1EYfdF7unWUy3dOjPqb3C7rMUewIcqwW850PgS8h1o1yg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "eslint-visitor-keys": "^3.4.3"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
-      }
-    },
-    "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": {
-      "version": "3.4.3",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
-      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/@eslint-community/regexpp": {
-      "version": "4.12.1",
-      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz",
-      "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
-      }
-    },
-    "node_modules/@eslint/config-array": {
-      "version": "0.19.2",
-      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.19.2.tgz",
-      "integrity": "sha512-GNKqxfHG2ySmJOBSHg7LxeUx4xpuCoFjacmlCoYWEbaPXLwvfIjixRI12xCQZeULksQb23uiA8F40w5TojpV7w==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@eslint/object-schema": "^2.1.6",
-        "debug": "^4.3.1",
-        "minimatch": "^3.1.2"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@eslint/config-array/node_modules/brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/@eslint/config-array/node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/@eslint/config-helpers": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.1.0.tgz",
-      "integrity": "sha512-kLrdPDJE1ckPo94kmPPf9Hfd0DU0Jw6oKYrhe+pwSC0iTUInmTa+w6fw8sGgcfkFJGNdWOUeOaDM4quW4a7OkA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@eslint/core": {
-      "version": "0.12.0",
-      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.12.0.tgz",
-      "integrity": "sha512-cmrR6pytBuSMTaBweKoGMwu3EiHiEC+DoyupPmlZ0HxBJBtIxwe+j/E4XPIKNx+Q74c8lXKPwYawBf5glsTkHg==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@types/json-schema": "^7.0.15"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@eslint/eslintrc": {
-      "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.0.tgz",
-      "integrity": "sha512-yaVPAiNAalnCZedKLdR21GOGILMLKPyqSLWaAjQFvYA2i/ciDi8ArYVr69Anohb6cH2Ukhqti4aFnYyPm8wdwQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ajv": "^6.12.4",
-        "debug": "^4.3.2",
-        "espree": "^10.0.1",
-        "globals": "^14.0.0",
-        "ignore": "^5.2.0",
-        "import-fresh": "^3.2.1",
-        "js-yaml": "^4.1.0",
-        "minimatch": "^3.1.2",
-        "strip-json-comments": "^3.1.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/@eslint/eslintrc/node_modules/brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/@eslint/eslintrc/node_modules/globals": {
-      "version": "14.0.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
-      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/@eslint/eslintrc/node_modules/js-yaml": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "argparse": "^2.0.1"
-      },
-      "bin": {
-        "js-yaml": "bin/js-yaml.js"
-      }
-    },
-    "node_modules/@eslint/eslintrc/node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/@eslint/js": {
-      "version": "9.22.0",
-      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.22.0.tgz",
-      "integrity": "sha512-vLFajx9o8d1/oL2ZkpMYbkLv8nDB6yaIwFNt7nI4+I80U/z03SxmfOMsLbvWr3p7C+Wnoh//aOu2pQW8cS0HCQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@eslint/object-schema": {
-      "version": "2.1.6",
-      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.6.tgz",
-      "integrity": "sha512-RBMg5FRL0I0gs51M/guSAj5/e14VQ4tpZnQNWwuDT66P14I43ItmPfIZRhO9fUVIPOAQXU47atlywZ/czoqFPA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@eslint/plugin-kit": {
-      "version": "0.2.7",
-      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.2.7.tgz",
-      "integrity": "sha512-JubJ5B2pJ4k4yGxaNLdbjrnk9d/iDz6/q8wOilpIowd6PJPgaxCuHBnBszq7Ce2TyMrywm5r4PnKm6V3iiZF+g==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@eslint/core": "^0.12.0",
-        "levn": "^0.4.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@google/genai": {
-      "version": "0.8.0",
-      "resolved": "https://registry.npmjs.org/@google/genai/-/genai-0.8.0.tgz",
-      "integrity": "sha512-Zs+OGyZKyMbFofGJTR9/jTQSv8kITh735N3tEuIZj4VlMQXTC0soCFahysJ9NaeenRlD7xGb6fyqmX+FwrpU6Q==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "google-auth-library": "^9.14.2",
-        "ws": "^8.18.0"
-      },
-      "engines": {
-        "node": ">=18.0.0"
-      }
-    },
-    "node_modules/@humanfs/core": {
-      "version": "0.19.1",
-      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
-      "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=18.18.0"
-      }
-    },
-    "node_modules/@humanfs/node": {
-      "version": "0.16.6",
-      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.6.tgz",
-      "integrity": "sha512-YuI2ZHQL78Q5HbhDiBA1X4LmYdXCKCMQIfw0pw7piHJwyREFebJUvrQN4cMssyES6x+vfUbx1CIpaQUKYdQZOw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@humanfs/core": "^0.19.1",
-        "@humanwhocodes/retry": "^0.3.0"
-      },
-      "engines": {
-        "node": ">=18.18.0"
-      }
-    },
-    "node_modules/@humanfs/node/node_modules/@humanwhocodes/retry": {
-      "version": "0.3.1",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.3.1.tgz",
-      "integrity": "sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=18.18"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/nzakas"
-      }
-    },
-    "node_modules/@humanwhocodes/module-importer": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
-      "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=12.22"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/nzakas"
-      }
-    },
-    "node_modules/@humanwhocodes/retry": {
-      "version": "0.4.2",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.2.tgz",
-      "integrity": "sha512-xeO57FpIu4p1Ri3Jq/EXq4ClRm86dVF2z/+kvFnyqVYRavTZmaFaUBbWCOuuTh0o/g7DSsk6kc2vrS4Vl5oPOQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=18.18"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/nzakas"
-      }
-    },
-    "node_modules/@isaacs/cliui": {
-      "version": "8.0.2",
-      "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
-      "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "string-width": "^5.1.2",
-        "string-width-cjs": "npm:string-width@^4.2.0",
-        "strip-ansi": "^7.0.1",
-        "strip-ansi-cjs": "npm:strip-ansi@^6.0.1",
-        "wrap-ansi": "^8.1.0",
-        "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@isaacs/cliui/node_modules/ansi-regex": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
-      "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
-      }
-    },
-    "node_modules/@isaacs/cliui/node_modules/emoji-regex": {
-      "version": "9.2.2",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
-      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@isaacs/cliui/node_modules/string-width": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
-      "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "eastasianwidth": "^0.2.0",
-        "emoji-regex": "^9.2.2",
-        "strip-ansi": "^7.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/@isaacs/cliui/node_modules/strip-ansi": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
-      "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
-      }
-    },
-    "node_modules/@jridgewell/gen-mapping": {
-      "version": "0.3.8",
-      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.8.tgz",
-      "integrity": "sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/set-array": "^1.2.1",
-        "@jridgewell/sourcemap-codec": "^1.4.10",
-        "@jridgewell/trace-mapping": "^0.3.24"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@jridgewell/resolve-uri": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
-      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@jridgewell/set-array": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz",
-      "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
-      "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.25",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz",
-      "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/resolve-uri": "^3.1.0",
-        "@jridgewell/sourcemap-codec": "^1.4.14"
-      }
-    },
-    "node_modules/@kwsites/file-exists": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@kwsites/file-exists/-/file-exists-1.1.1.tgz",
-      "integrity": "sha512-m9/5YGR18lIwxSFDwfE3oA7bWuq9kdau6ugN4H2rJeyhFQZcG9AgSHkQtSD15a8WvTgfz9aikZMrKPHvbpqFiw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^4.1.1"
-      }
-    },
-    "node_modules/@kwsites/promise-deferred": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@kwsites/promise-deferred/-/promise-deferred-1.1.1.tgz",
-      "integrity": "sha512-GaHYm+c0O9MjZRu0ongGBRbinu8gVAMd2UZjji6jVmqKtZluZnptXGWhz1E8j8D2HJ3f/yMxKAUC0b+57wncIw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@langchain/core": {
-      "version": "0.3.42",
-      "resolved": "https://registry.npmjs.org/@langchain/core/-/core-0.3.42.tgz",
-      "integrity": "sha512-pT/jC5lqWK3YGDq8dQwgKoa6anqAhMtG1x5JbnrOj9NdaLeBbCKBDQ+/Ykzk3nZ8o+0UMsaXNZo7IVL83VVjHg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@cfworker/json-schema": "^4.0.2",
-        "ansi-styles": "^5.0.0",
-        "camelcase": "6",
-        "decamelize": "1.2.0",
-        "js-tiktoken": "^1.0.12",
-        "langsmith": ">=0.2.8 <0.4.0",
-        "mustache": "^4.2.0",
-        "p-queue": "^6.6.2",
-        "p-retry": "4",
-        "uuid": "^10.0.0",
-        "zod": "^3.22.4",
-        "zod-to-json-schema": "^3.22.3"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@langchain/openai": {
-      "version": "0.4.4",
-      "resolved": "https://registry.npmjs.org/@langchain/openai/-/openai-0.4.4.tgz",
-      "integrity": "sha512-UZybJeMd8+UX7Kn47kuFYfqKdBCeBUWNqDtmAr6ZUIMMnlsNIb6MkrEEhGgAEjGCpdT4CU8U/DyyddTz+JayOQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "js-tiktoken": "^1.0.12",
-        "openai": "^4.77.0",
-        "zod": "^3.22.4",
-        "zod-to-json-schema": "^3.22.3"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@langchain/core": ">=0.3.39 <0.4.0"
-      }
-    },
-    "node_modules/@manypkg/find-root": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@manypkg/find-root/-/find-root-1.1.0.tgz",
-      "integrity": "sha512-mki5uBvhHzO8kYYix/WRy2WX8S3B5wdVSc9D6KcU5lQNglP2yt58/VfLuAK49glRXChosY8ap2oJ1qgma3GUVA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/runtime": "^7.5.5",
-        "@types/node": "^12.7.1",
-        "find-up": "^4.1.0",
-        "fs-extra": "^8.1.0"
-      }
-    },
-    "node_modules/@manypkg/find-root/node_modules/@types/node": {
-      "version": "12.20.55",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-12.20.55.tgz",
-      "integrity": "sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@manypkg/find-root/node_modules/fs-extra": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz",
-      "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "graceful-fs": "^4.2.0",
-        "jsonfile": "^4.0.0",
-        "universalify": "^0.1.0"
-      },
-      "engines": {
-        "node": ">=6 <7 || >=8"
-      }
-    },
-    "node_modules/@manypkg/get-packages": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/@manypkg/get-packages/-/get-packages-1.1.3.tgz",
-      "integrity": "sha512-fo+QhuU3qE/2TQMQmbVMqaQ6EWbMhi4ABWP+O4AM1NqPBuy0OrApV5LO6BrrgnhtAHS2NH6RrVk9OL181tTi8A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/runtime": "^7.5.5",
-        "@changesets/types": "^4.0.1",
-        "@manypkg/find-root": "^1.1.0",
-        "fs-extra": "^8.1.0",
-        "globby": "^11.0.0",
-        "read-yaml-file": "^1.1.0"
-      }
-    },
-    "node_modules/@manypkg/get-packages/node_modules/@changesets/types": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/@changesets/types/-/types-4.1.0.tgz",
-      "integrity": "sha512-LDQvVDv5Kb50ny2s25Fhm3d9QSZimsoUGBsUioj6MC3qbMUCuC8GPIvk/M6IvXx3lYhAs0lwWUQLb+VIEUCECw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@manypkg/get-packages/node_modules/fs-extra": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz",
-      "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "graceful-fs": "^4.2.0",
-        "jsonfile": "^4.0.0",
-        "universalify": "^0.1.0"
-      },
-      "engines": {
-        "node": ">=6 <7 || >=8"
-      }
-    },
-    "node_modules/@next/env": {
-      "version": "14.2.24",
-      "resolved": "https://registry.npmjs.org/@next/env/-/env-14.2.24.tgz",
-      "integrity": "sha512-LAm0Is2KHTNT6IT16lxT+suD0u+VVfYNQqM+EJTKuFRRuY2z+zj01kueWXPCxbMBDt0B5vONYzabHGUNbZYAhA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@nodelib/fs.scandir": {
-      "version": "2.1.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
-      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@nodelib/fs.stat": "2.0.5",
-        "run-parallel": "^1.1.9"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@nodelib/fs.stat": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
-      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@nodelib/fs.walk": {
-      "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
-      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@nodelib/fs.scandir": "2.1.5",
-        "fastq": "^1.6.0"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@opentelemetry/api": {
-      "version": "1.9.0",
-      "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz",
-      "integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=8.0.0"
-      }
-    },
-    "node_modules/@pkgjs/parseargs": {
-      "version": "0.11.0",
-      "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
-      "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "engines": {
-        "node": ">=14"
-      }
-    },
-    "node_modules/@playwright/test": {
-      "version": "1.51.0",
-      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.51.0.tgz",
-      "integrity": "sha512-dJ0dMbZeHhI+wb77+ljx/FeC8VBP6j/rj9OAojO08JI80wTZy6vRk9KvHKiDCUh4iMpEiseMgqRBIeW+eKX6RA==",
-      "license": "Apache-2.0",
-      "peer": true,
-      "dependencies": {
-        "playwright": "1.51.0"
-      },
-      "bin": {
-        "playwright": "cli.js"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@rollup/rollup-android-arm-eabi": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.35.0.tgz",
-      "integrity": "sha512-uYQ2WfPaqz5QtVgMxfN6NpLD+no0MYHDBywl7itPYd3K5TjjSghNKmX8ic9S8NU8w81NVhJv/XojcHptRly7qQ==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ]
-    },
-    "node_modules/@rollup/rollup-android-arm64": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.35.0.tgz",
-      "integrity": "sha512-FtKddj9XZudurLhdJnBl9fl6BwCJ3ky8riCXjEw3/UIbjmIY58ppWwPEvU3fNu+W7FUsAsB1CdH+7EQE6CXAPA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ]
-    },
-    "node_modules/@rollup/rollup-darwin-arm64": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.35.0.tgz",
-      "integrity": "sha512-Uk+GjOJR6CY844/q6r5DR/6lkPFOw0hjfOIzVx22THJXMxktXG6CbejseJFznU8vHcEBLpiXKY3/6xc+cBm65Q==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
-    },
-    "node_modules/@rollup/rollup-darwin-x64": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.35.0.tgz",
-      "integrity": "sha512-3IrHjfAS6Vkp+5bISNQnPogRAW5GAV1n+bNCrDwXmfMHbPl5EhTmWtfmwlJxFRUCBZ+tZ/OxDyU08aF6NI/N5Q==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
-    },
-    "node_modules/@rollup/rollup-freebsd-arm64": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.35.0.tgz",
-      "integrity": "sha512-sxjoD/6F9cDLSELuLNnY0fOrM9WA0KrM0vWm57XhrIMf5FGiN8D0l7fn+bpUeBSU7dCgPV2oX4zHAsAXyHFGcQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ]
-    },
-    "node_modules/@rollup/rollup-freebsd-x64": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.35.0.tgz",
-      "integrity": "sha512-2mpHCeRuD1u/2kruUiHSsnjWtHjqVbzhBkNVQ1aVD63CcexKVcQGwJ2g5VphOd84GvxfSvnnlEyBtQCE5hxVVw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.35.0.tgz",
-      "integrity": "sha512-mrA0v3QMy6ZSvEuLs0dMxcO2LnaCONs1Z73GUDBHWbY8tFFocM6yl7YyMu7rz4zS81NDSqhrUuolyZXGi8TEqg==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.35.0.tgz",
-      "integrity": "sha512-DnYhhzcvTAKNexIql8pFajr0PiDGrIsBYPRvCKlA5ixSS3uwo/CWNZxB09jhIapEIg945KOzcYEAGGSmTSpk7A==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm64-gnu": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.35.0.tgz",
-      "integrity": "sha512-uagpnH2M2g2b5iLsCTZ35CL1FgyuzzJQ8L9VtlJ+FckBXroTwNOaD0z0/UF+k5K3aNQjbm8LIVpxykUOQt1m/A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm64-musl": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.35.0.tgz",
-      "integrity": "sha512-XQxVOCd6VJeHQA/7YcqyV0/88N6ysSVzRjJ9I9UA/xXpEsjvAgDTgH3wQYz5bmr7SPtVK2TsP2fQ2N9L4ukoUg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-loongarch64-gnu": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.35.0.tgz",
-      "integrity": "sha512-5pMT5PzfgwcXEwOaSrqVsz/LvjDZt+vQ8RT/70yhPU06PTuq8WaHhfT1LW+cdD7mW6i/J5/XIkX/1tCAkh1W6g==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-powerpc64le-gnu": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.35.0.tgz",
-      "integrity": "sha512-c+zkcvbhbXF98f4CtEIP1EBA/lCic5xB0lToneZYvMeKu5Kamq3O8gqrxiYYLzlZH6E3Aq+TSW86E4ay8iD8EA==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.35.0.tgz",
-      "integrity": "sha512-s91fuAHdOwH/Tad2tzTtPX7UZyytHIRR6V4+2IGlV0Cej5rkG0R61SX4l4y9sh0JBibMiploZx3oHKPnQBKe4g==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-s390x-gnu": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.35.0.tgz",
-      "integrity": "sha512-hQRkPQPLYJZYGP+Hj4fR9dDBMIM7zrzJDWFEMPdTnTy95Ljnv0/4w/ixFw3pTBMEuuEuoqtBINYND4M7ujcuQw==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-x64-gnu": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.35.0.tgz",
-      "integrity": "sha512-Pim1T8rXOri+0HmV4CdKSGrqcBWX0d1HoPnQ0uw0bdp1aP5SdQVNBy8LjYncvnLgu3fnnCt17xjWGd4cqh8/hA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-x64-musl": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.35.0.tgz",
-      "integrity": "sha512-QysqXzYiDvQWfUiTm8XmJNO2zm9yC9P/2Gkrwg2dH9cxotQzunBHYr6jk4SujCTqnfGxduOmQcI7c2ryuW8XVg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-arm64-msvc": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.35.0.tgz",
-      "integrity": "sha512-OUOlGqPkVJCdJETKOCEf1mw848ZyJ5w50/rZ/3IBQVdLfR5jk/6Sr5m3iO2tdPgwo0x7VcncYuOvMhBWZq8ayg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-ia32-msvc": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.35.0.tgz",
-      "integrity": "sha512-2/lsgejMrtwQe44glq7AFFHLfJBPafpsTa6JvP2NGef/ifOa4KBoglVf7AKN7EV9o32evBPRqfg96fEHzWo5kw==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-x64-msvc": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.35.0.tgz",
-      "integrity": "sha512-PIQeY5XDkrOysbQblSW7v3l1MDZzkTEzAfTPkj5VAu3FW8fS4ynyLg2sINp0fp3SjZ8xkRYpLqoKcYqAkhU1dw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@sveltejs/acorn-typescript": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/@sveltejs/acorn-typescript/-/acorn-typescript-1.0.5.tgz",
-      "integrity": "sha512-IwQk4yfwLdibDlrXVE04jTZYlLnwsTT2PIOQQGNLWfjavGifnk1JD1LcZjZaBTRcxZu2FfPfNLOE04DSu9lqtQ==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "peerDependencies": {
-        "acorn": "^8.9.0"
-      }
-    },
-    "node_modules/@types/adm-zip": {
-      "version": "0.5.7",
-      "resolved": "https://registry.npmjs.org/@types/adm-zip/-/adm-zip-0.5.7.tgz",
-      "integrity": "sha512-DNEs/QvmyRLurdQPChqq0Md4zGvPwHerAJYWk9l2jCbD1VPpnzRJorOdiq4zsw09NFbYnhfsoEhWtxIzXpn2yw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/body-parser": {
-      "version": "1.19.5",
-      "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.5.tgz",
-      "integrity": "sha512-fB3Zu92ucau0iQ0JMCFQE7b/dv8Ot07NI3KaZIkIUNXq82k4eBAqUaneXfleGY9JWskeS9y+u0nXMyspcuQrCg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/connect": "*",
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/cheerio": {
-      "version": "0.22.35",
-      "resolved": "https://registry.npmjs.org/@types/cheerio/-/cheerio-0.22.35.tgz",
-      "integrity": "sha512-yD57BchKRvTV+JD53UZ6PD8KWY5g5rvvMLRnZR3EQBCZXiDT/HR+pKpMzFGlWNhFrXlo7VPZXtKvIEwZkAWOIA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/connect": {
-      "version": "3.4.38",
-      "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz",
-      "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/diff-match-patch": {
-      "version": "1.0.36",
-      "resolved": "https://registry.npmjs.org/@types/diff-match-patch/-/diff-match-patch-1.0.36.tgz",
-      "integrity": "sha512-xFdR6tkm0MWvBfO8xXCSsinYxHcqkQUlcHeSpMC2ukzOb6lwQAfDmW+Qt0AvlGd8HpsS28qKsB+oPeJn9I39jg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/estree": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz",
-      "integrity": "sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/express": {
-      "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.21.tgz",
-      "integrity": "sha512-ejlPM315qwLpaQlQDTjPdsUFSc6ZsP4AN6AlWnogPjQ7CVi7PYF3YVz+CY3jE2pwYf7E/7HlDAN0rV2GxTG0HQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/body-parser": "*",
-        "@types/express-serve-static-core": "^4.17.33",
-        "@types/qs": "*",
-        "@types/serve-static": "*"
-      }
-    },
-    "node_modules/@types/express-serve-static-core": {
-      "version": "4.19.6",
-      "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.19.6.tgz",
-      "integrity": "sha512-N4LZ2xG7DatVqhCZzOGb1Yi5lMbXSZcmdLDe9EzSndPV2HpWYWzRbaerl2n27irrm94EPpprqa8KpskPT085+A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*",
-        "@types/qs": "*",
-        "@types/range-parser": "*",
-        "@types/send": "*"
-      }
-    },
-    "node_modules/@types/http-errors": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.4.tgz",
-      "integrity": "sha512-D0CFMMtydbJAegzOyHjtiKPLlvnm3iTZyZRSZoLq2mRhDdmLfIWOCYPfQJ4cu2erKghU++QvjcUjp/5h7hESpA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/json-schema": {
-      "version": "7.0.15",
-      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
-      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/mime": {
-      "version": "1.3.5",
-      "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.5.tgz",
-      "integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/node": {
-      "version": "20.17.24",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.17.24.tgz",
-      "integrity": "sha512-d7fGCyB96w9BnWQrOsJtpyiSaBcAYYr75bnK6ZRjDbql2cGLj/3GsL5OYmLPNq76l7Gf2q4Rv9J2o6h5CrD9sA==",
-      "license": "MIT",
-      "dependencies": {
-        "undici-types": "~6.19.2"
-      }
-    },
-    "node_modules/@types/node-fetch": {
-      "version": "2.6.12",
-      "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.6.12.tgz",
-      "integrity": "sha512-8nneRWKCg3rMtF69nLQJnOYUcbafYeFSjqkw3jCRLsqkWFlHaoQrr5mXmofFGOx3DKn7UfmBMyov8ySvLRVldA==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*",
-        "form-data": "^4.0.0"
-      }
-    },
-    "node_modules/@types/qs": {
-      "version": "6.9.18",
-      "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.18.tgz",
-      "integrity": "sha512-kK7dgTYDyGqS+e2Q4aK9X3D7q234CIZ1Bv0q/7Z5IwRDoADNU81xXJK/YVyLbLTZCoIwUoDoffFeF+p/eIklAA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/range-parser": {
-      "version": "1.2.7",
-      "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz",
-      "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/retry": {
-      "version": "0.12.0",
-      "resolved": "https://registry.npmjs.org/@types/retry/-/retry-0.12.0.tgz",
-      "integrity": "sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/send": {
-      "version": "0.17.4",
-      "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.4.tgz",
-      "integrity": "sha512-x2EM6TJOybec7c52BX0ZspPodMsQUd5L6PRwOunVyVUhXiBSKf3AezDL8Dgvgt5o0UfKNfuA0eMLr2wLT4AiBA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/mime": "^1",
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/serve-static": {
-      "version": "1.15.7",
-      "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.7.tgz",
-      "integrity": "sha512-W8Ym+h8nhuRwaKPaDw34QUkwsGi6Rc4yYqvKFo5rm2FUEhCFbzVWrxXUxuKK8TASjWsysJY0nsmNCGhCOIsrOw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/http-errors": "*",
-        "@types/node": "*",
-        "@types/send": "*"
-      }
-    },
-    "node_modules/@types/uuid": {
-      "version": "10.0.0",
-      "resolved": "https://registry.npmjs.org/@types/uuid/-/uuid-10.0.0.tgz",
-      "integrity": "sha512-7gqG38EyHgyP1S+7+xomFtL+ZNHcKv6DwNaCZmJmo1vgMugyF3TCnXVg4t1uk89mLNwnLtnY3TpOpCOyp1/xHQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/ws": {
-      "version": "8.18.0",
-      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.0.tgz",
-      "integrity": "sha512-8svvI3hMyvN0kKCJMvTJP/x6Y/EoQbepff882wL+Sn5QsXb3etnamgrJq4isrBxSJj5L2AuXcI0+bgkoAXGUJw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@typescript-eslint/eslint-plugin": {
-      "version": "8.26.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.26.1.tgz",
-      "integrity": "sha512-2X3mwqsj9Bd3Ciz508ZUtoQQYpOhU/kWoUqIf49H8Z0+Vbh6UF/y0OEYp0Q0axOGzaBGs7QxRwq0knSQ8khQNA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@eslint-community/regexpp": "^4.10.0",
-        "@typescript-eslint/scope-manager": "8.26.1",
-        "@typescript-eslint/type-utils": "8.26.1",
-        "@typescript-eslint/utils": "8.26.1",
-        "@typescript-eslint/visitor-keys": "8.26.1",
-        "graphemer": "^1.4.0",
-        "ignore": "^5.3.1",
-        "natural-compare": "^1.4.0",
-        "ts-api-utils": "^2.0.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "@typescript-eslint/parser": "^8.0.0 || ^8.0.0-alpha.0",
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <5.9.0"
-      }
-    },
-    "node_modules/@typescript-eslint/parser": {
-      "version": "8.26.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.26.1.tgz",
-      "integrity": "sha512-w6HZUV4NWxqd8BdeFf81t07d7/YV9s7TCWrQQbG5uhuvGUAW+fq1usZ1Hmz9UPNLniFnD8GLSsDpjP0hm1S4lQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/scope-manager": "8.26.1",
-        "@typescript-eslint/types": "8.26.1",
-        "@typescript-eslint/typescript-estree": "8.26.1",
-        "@typescript-eslint/visitor-keys": "8.26.1",
-        "debug": "^4.3.4"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <5.9.0"
-      }
-    },
-    "node_modules/@typescript-eslint/scope-manager": {
-      "version": "8.26.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.26.1.tgz",
-      "integrity": "sha512-6EIvbE5cNER8sqBu6V7+KeMZIC1664d2Yjt+B9EWUXrsyWpxx4lEZrmvxgSKRC6gX+efDL/UY9OpPZ267io3mg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/types": "8.26.1",
-        "@typescript-eslint/visitor-keys": "8.26.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      }
-    },
-    "node_modules/@typescript-eslint/type-utils": {
-      "version": "8.26.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.26.1.tgz",
-      "integrity": "sha512-Kcj/TagJLwoY/5w9JGEFV0dclQdyqw9+VMndxOJKtoFSjfZhLXhYjzsQEeyza03rwHx2vFEGvrJWJBXKleRvZg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/typescript-estree": "8.26.1",
-        "@typescript-eslint/utils": "8.26.1",
-        "debug": "^4.3.4",
-        "ts-api-utils": "^2.0.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <5.9.0"
-      }
-    },
-    "node_modules/@typescript-eslint/types": {
-      "version": "8.26.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.26.1.tgz",
-      "integrity": "sha512-n4THUQW27VmQMx+3P+B0Yptl7ydfceUj4ON/AQILAASwgYdZ/2dhfymRMh5egRUrvK5lSmaOm77Ry+lmXPOgBQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      }
-    },
-    "node_modules/@typescript-eslint/typescript-estree": {
-      "version": "8.26.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.26.1.tgz",
-      "integrity": "sha512-yUwPpUHDgdrv1QJ7YQal3cMVBGWfnuCdKbXw1yyjArax3353rEJP1ZA+4F8nOlQ3RfS2hUN/wze3nlY+ZOhvoA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/types": "8.26.1",
-        "@typescript-eslint/visitor-keys": "8.26.1",
-        "debug": "^4.3.4",
-        "fast-glob": "^3.3.2",
-        "is-glob": "^4.0.3",
-        "minimatch": "^9.0.4",
-        "semver": "^7.6.0",
-        "ts-api-utils": "^2.0.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "typescript": ">=4.8.4 <5.9.0"
-      }
-    },
-    "node_modules/@typescript-eslint/utils": {
-      "version": "8.26.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.26.1.tgz",
-      "integrity": "sha512-V4Urxa/XtSUroUrnI7q6yUTD3hDtfJ2jzVfeT3VK0ciizfK2q/zGC0iDh1lFMUZR8cImRrep6/q0xd/1ZGPQpg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@eslint-community/eslint-utils": "^4.4.0",
-        "@typescript-eslint/scope-manager": "8.26.1",
-        "@typescript-eslint/types": "8.26.1",
-        "@typescript-eslint/typescript-estree": "8.26.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <5.9.0"
-      }
-    },
-    "node_modules/@typescript-eslint/visitor-keys": {
-      "version": "8.26.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.26.1.tgz",
-      "integrity": "sha512-AjOC3zfnxd6S4Eiy3jwktJPclqhFHNyd8L6Gycf9WUPoKZpgM5PjkxY1X7uSy61xVpiJDhhk7XT2NVsN3ALTWg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/types": "8.26.1",
-        "eslint-visitor-keys": "^4.2.0"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      }
-    },
-    "node_modules/@vercel/functions": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/@vercel/functions/-/functions-1.6.0.tgz",
-      "integrity": "sha512-R6FKQrYT5MZs5IE1SqeCJWxMuBdHawFcCZboKKw8p7s+6/mcd55Gx6tWmyKnQTyrSEA04NH73Tc9CbqpEle8RA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">= 16"
-      },
-      "peerDependencies": {
-        "@aws-sdk/credential-provider-web-identity": "*"
-      },
-      "peerDependenciesMeta": {
-        "@aws-sdk/credential-provider-web-identity": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@vue/compiler-core": {
-      "version": "3.5.13",
-      "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.13.tgz",
-      "integrity": "sha512-oOdAkwqUfW1WqpwSYJce06wvt6HljgY3fGeM9NcVA1HaYOij3mZG9Rkysn0OHuyUAGMbEbARIpsG+LPVlBJ5/Q==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@babel/parser": "^7.25.3",
-        "@vue/shared": "3.5.13",
-        "entities": "^4.5.0",
-        "estree-walker": "^2.0.2",
-        "source-map-js": "^1.2.0"
-      }
-    },
-    "node_modules/@vue/compiler-dom": {
-      "version": "3.5.13",
-      "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.13.tgz",
-      "integrity": "sha512-ZOJ46sMOKUjO3e94wPdCzQ6P1Lx/vhp2RSvfaab88Ajexs0AHeV0uasYhi99WPaogmBlRHNRuly8xV75cNTMDA==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@vue/compiler-core": "3.5.13",
-        "@vue/shared": "3.5.13"
-      }
-    },
-    "node_modules/@vue/compiler-sfc": {
-      "version": "3.5.13",
-      "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.13.tgz",
-      "integrity": "sha512-6VdaljMpD82w6c2749Zhf5T9u5uLBWKnVue6XWxprDobftnletJ8+oel7sexFfM3qIxNmVE7LSFGTpv6obNyaQ==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@babel/parser": "^7.25.3",
-        "@vue/compiler-core": "3.5.13",
-        "@vue/compiler-dom": "3.5.13",
-        "@vue/compiler-ssr": "3.5.13",
-        "@vue/shared": "3.5.13",
-        "estree-walker": "^2.0.2",
-        "magic-string": "^0.30.11",
-        "postcss": "^8.4.48",
-        "source-map-js": "^1.2.0"
-      }
-    },
-    "node_modules/@vue/compiler-ssr": {
-      "version": "3.5.13",
-      "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.13.tgz",
-      "integrity": "sha512-wMH6vrYHxQl/IybKJagqbquvxpWCuVYpoUJfCqFZwa/JY1GdATAQ+TgVtgrwwMZ0D07QhA99rs/EAAWfvG6KpA==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@vue/compiler-dom": "3.5.13",
-        "@vue/shared": "3.5.13"
-      }
-    },
-    "node_modules/@vue/reactivity": {
-      "version": "3.5.13",
-      "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.13.tgz",
-      "integrity": "sha512-NaCwtw8o48B9I6L1zl2p41OHo/2Z4wqYGGIK1Khu5T7yxrn+ATOixn/Udn2m+6kZKB/J7cuT9DbWWhRxqixACg==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@vue/shared": "3.5.13"
-      }
-    },
-    "node_modules/@vue/runtime-core": {
-      "version": "3.5.13",
-      "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.13.tgz",
-      "integrity": "sha512-Fj4YRQ3Az0WTZw1sFe+QDb0aXCerigEpw418pw1HBUKFtnQHWzwojaukAs2X/c9DQz4MQ4bsXTGlcpGxU/RCIw==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@vue/reactivity": "3.5.13",
-        "@vue/shared": "3.5.13"
-      }
-    },
-    "node_modules/@vue/runtime-dom": {
-      "version": "3.5.13",
-      "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.13.tgz",
-      "integrity": "sha512-dLaj94s93NYLqjLiyFzVs9X6dWhTdAlEAciC3Moq7gzAc13VJUdCnjjRurNM6uTLFATRHexHCTu/Xp3eW6yoog==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@vue/reactivity": "3.5.13",
-        "@vue/runtime-core": "3.5.13",
-        "@vue/shared": "3.5.13",
-        "csstype": "^3.1.3"
-      }
-    },
-    "node_modules/@vue/server-renderer": {
-      "version": "3.5.13",
-      "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.13.tgz",
-      "integrity": "sha512-wAi4IRJV/2SAW3htkTlB+dHeRmpTiVIK1OGLWV1yeStVSebSQQOwGwIq0D3ZIoBj2C2qpgz5+vX9iEBkTdk5YA==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@vue/compiler-ssr": "3.5.13",
-        "@vue/shared": "3.5.13"
-      },
-      "peerDependencies": {
-        "vue": "3.5.13"
-      }
-    },
-    "node_modules/@vue/shared": {
-      "version": "3.5.13",
-      "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.13.tgz",
-      "integrity": "sha512-/hnE/qP5ZoGpol0a5mDi45bOd7t3tjYJBjsgCsivow7D48cJeV5l05RD82lPqi7gRiphZM37rnhW1l6ZoCNNnQ==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true
-    },
-    "node_modules/abort-controller": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
-      "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==",
-      "license": "MIT",
-      "dependencies": {
-        "event-target-shim": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=6.5"
-      }
-    },
-    "node_modules/accepts": {
-      "version": "1.3.8",
-      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
-      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "mime-types": "~2.1.34",
-        "negotiator": "0.6.3"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/acorn": {
-      "version": "8.14.1",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.1.tgz",
-      "integrity": "sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "acorn": "bin/acorn"
-      },
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/acorn-jsx": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
-      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
-      "dev": true,
-      "license": "MIT",
-      "peerDependencies": {
-        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
-      }
-    },
-    "node_modules/adm-zip": {
-      "version": "0.5.16",
-      "resolved": "https://registry.npmjs.org/adm-zip/-/adm-zip-0.5.16.tgz",
-      "integrity": "sha512-TGw5yVi4saajsSEgz25grObGHEUaDrniwvA2qwSC060KfqGPdglhvPMA2lPIoxs3PQIItj2iag35fONcQqgUaQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12.0"
-      }
-    },
-    "node_modules/agent-base": {
-      "version": "7.1.3",
-      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.3.tgz",
-      "integrity": "sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/agentkeepalive": {
-      "version": "4.6.0",
-      "resolved": "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-4.6.0.tgz",
-      "integrity": "sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ==",
-      "license": "MIT",
-      "dependencies": {
-        "humanize-ms": "^1.2.1"
-      },
-      "engines": {
-        "node": ">= 8.0.0"
-      }
-    },
-    "node_modules/ai": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ai/-/ai-4.3.0.tgz",
-      "integrity": "sha512-PxyQYKhWaU3LiZEpeKRaekVonZIbWdKAwgnqm0CSAxy1MFufmYEC5SM5Mc9uiK2DoHcbAL3d1jyaQ2fSDAJL8w==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "1.1.0",
-        "@ai-sdk/provider-utils": "2.2.4",
-        "@ai-sdk/react": "1.2.6",
-        "@ai-sdk/ui-utils": "1.2.5",
-        "@opentelemetry/api": "1.9.0",
-        "jsondiffpatch": "0.6.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "react": "^18 || ^19 || ^19.0.0-rc",
-        "zod": "^3.23.8"
-      },
-      "peerDependenciesMeta": {
-        "react": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/ai/node_modules/@ai-sdk/provider": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-1.1.0.tgz",
-      "integrity": "sha512-0M+qjp+clUD0R1E5eWQFhxEvWLNaOtGQRUaBn8CUABnSKredagq92hUS9VjOzGsTm37xLfpaxl97AVtbeOsHew==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "json-schema": "^0.4.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/ai/node_modules/@ai-sdk/provider-utils": {
-      "version": "2.2.4",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-2.2.4.tgz",
-      "integrity": "sha512-13sEGBxB6kgaMPGOgCLYibF6r8iv8mgjhuToFrOTU09bBxbFQd8ZoARarCfJN6VomCUbUvMKwjTBLb1vQnN+WA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "1.1.0",
-        "nanoid": "^3.3.8",
-        "secure-json-parse": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.23.8"
-      }
-    },
-    "node_modules/ajv": {
-      "version": "6.12.6",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
-      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fast-deep-equal": "^3.1.1",
-        "fast-json-stable-stringify": "^2.0.0",
-        "json-schema-traverse": "^0.4.1",
-        "uri-js": "^4.2.2"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
-      }
-    },
-    "node_modules/ansi-colors": {
-      "version": "4.1.3",
-      "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz",
-      "integrity": "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/ansi-styles": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
-      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/any-promise": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz",
-      "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/append-field": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/append-field/-/append-field-1.0.0.tgz",
-      "integrity": "sha512-klpgFSWLW1ZEs8svjfb7g4qWY0YS5imI82dTg+QahUvJ8YqAY0P10Uk8tTyh9ZGuYEZEMaeJYCF5BFuX552hsw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/argparse": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
-      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
-      "dev": true,
-      "license": "Python-2.0"
-    },
-    "node_modules/aria-query": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.2.tgz",
-      "integrity": "sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "peer": true,
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/array-flatten": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
-      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/array-union": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz",
-      "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/asynckit": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
-      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
-      "license": "MIT"
-    },
-    "node_modules/atomic-sleep": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/atomic-sleep/-/atomic-sleep-1.0.0.tgz",
-      "integrity": "sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8.0.0"
-      }
-    },
-    "node_modules/autoevals": {
-      "version": "0.0.64",
-      "resolved": "https://registry.npmjs.org/autoevals/-/autoevals-0.0.64.tgz",
-      "integrity": "sha512-mEv5G3Dfu5s0KH9K5M38DqXNbNBAo/1KknoE+uIRqeAdJcLAf9v6WnVE2u7SHAIRxeVZ5lVOT5fjvFqanbjEUA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@braintrust/core": "0.0.34",
-        "compute-cosine-similarity": "^1.1.0",
-        "js-levenshtein": "^1.1.6",
-        "js-yaml": "^4.1.0",
-        "linear-sum-assignment": "^1.0.7",
-        "mustache": "^4.2.0",
-        "openai": "4.23.0",
-        "zod": "^3.22.4",
-        "zod-to-json-schema": "^3.22.5"
-      }
-    },
-    "node_modules/autoevals/node_modules/@types/node": {
-      "version": "18.19.80",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.80.tgz",
-      "integrity": "sha512-kEWeMwMeIvxYkeg1gTc01awpwLbfMRZXdIhwRcakd/KlK53jmRC26LqcbIt7fnAQTu5GzlnWmzA3H6+l1u6xxQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "undici-types": "~5.26.4"
-      }
-    },
-    "node_modules/autoevals/node_modules/js-yaml": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "argparse": "^2.0.1"
-      },
-      "bin": {
-        "js-yaml": "bin/js-yaml.js"
-      }
-    },
-    "node_modules/autoevals/node_modules/openai": {
-      "version": "4.23.0",
-      "resolved": "https://registry.npmjs.org/openai/-/openai-4.23.0.tgz",
-      "integrity": "sha512-ey2CXh1OTcTUa0AWZWuTpgA9t5GuAG3DVU1MofCRUI7fQJij8XJ3Sr0VtgxoAE69C9wbHBMCux8Z/IQZfSwHiA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@types/node": "^18.11.18",
-        "@types/node-fetch": "^2.6.4",
-        "abort-controller": "^3.0.0",
-        "agentkeepalive": "^4.2.1",
-        "digest-fetch": "^1.3.0",
-        "form-data-encoder": "1.7.2",
-        "formdata-node": "^4.3.2",
-        "node-fetch": "^2.6.7",
-        "web-streams-polyfill": "^3.2.1"
-      },
-      "bin": {
-        "openai": "bin/cli"
-      }
-    },
-    "node_modules/autoevals/node_modules/undici-types": {
-      "version": "5.26.5",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
-      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/autoevals/node_modules/web-streams-polyfill": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
-      "integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/axobject-query": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-4.1.0.tgz",
-      "integrity": "sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "peer": true,
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/balanced-match": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/base-64": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/base-64/-/base-64-0.1.0.tgz",
-      "integrity": "sha512-Y5gU45svrR5tI2Vt/X9GPd3L0HNIKzGu202EjxrXMpuc2V2CiKgemAbUUsqYmZJvPtCXoUKjNZwBJzsNScUbXA==",
-      "dev": true
-    },
-    "node_modules/base64-js": {
-      "version": "1.5.1",
-      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
-      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/better-path-resolve": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/better-path-resolve/-/better-path-resolve-1.0.0.tgz",
-      "integrity": "sha512-pbnl5XzGBdrFU/wT4jqmJVPn2B6UHPBOhzMQkY/SPUPB6QtUXtmBHBIwCbXJol93mOpGMnQyP/+BB19q04xj7g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-windows": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/bignumber.js": {
-      "version": "9.2.1",
-      "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.2.1.tgz",
-      "integrity": "sha512-+NzaKgOUvInq9TIUZ1+DRspzf/HApkCwD4btfuasFTdrfnOxqx853TgDpMolp+uv4RpRp7bPcEU2zKr9+fRmyw==",
-      "license": "MIT",
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/binary-search": {
-      "version": "1.3.6",
-      "resolved": "https://registry.npmjs.org/binary-search/-/binary-search-1.3.6.tgz",
-      "integrity": "sha512-nbE1WxOTTrUWIfsfZ4aHGYu5DOuNkbxGokjV6Z2kxfJK3uaAb8zNK1muzOeipoLHZjInT4Br88BHpzevc681xA==",
-      "dev": true,
-      "license": "CC0-1.0"
-    },
-    "node_modules/body-parser": {
-      "version": "1.20.3",
-      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz",
-      "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "bytes": "3.1.2",
-        "content-type": "~1.0.5",
-        "debug": "2.6.9",
-        "depd": "2.0.0",
-        "destroy": "1.2.0",
-        "http-errors": "2.0.0",
-        "iconv-lite": "0.4.24",
-        "on-finished": "2.4.1",
-        "qs": "6.13.0",
-        "raw-body": "2.5.2",
-        "type-is": "~1.6.18",
-        "unpipe": "1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.8",
-        "npm": "1.2.8000 || >= 1.4.16"
-      }
-    },
-    "node_modules/body-parser/node_modules/debug": {
-      "version": "2.6.9",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
-      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "2.0.0"
-      }
-    },
-    "node_modules/body-parser/node_modules/iconv-lite": {
-      "version": "0.4.24",
-      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
-      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "safer-buffer": ">= 2.1.2 < 3"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/body-parser/node_modules/ms": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
-      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/boolbase": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz",
-      "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/brace-expansion": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0"
-      }
-    },
-    "node_modules/braces": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
-      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fill-range": "^7.1.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/braintrust": {
-      "version": "0.0.171",
-      "resolved": "https://registry.npmjs.org/braintrust/-/braintrust-0.0.171.tgz",
-      "integrity": "sha512-esL1xU9k+Ef9poUMQlFwpF7+DMzCMAihrAfcCCBWHSj8+wWGjPuAbIlegnfrT5Um8YQmiHZLnrYmChfCNVe+Ww==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@ai-sdk/provider": "^0.0.11",
-        "@braintrust/core": "0.0.67",
-        "@next/env": "^14.2.3",
-        "@vercel/functions": "^1.0.2",
-        "ai": "^3.2.16",
-        "argparse": "^2.0.1",
-        "chalk": "^4.1.2",
-        "cli-progress": "^3.12.0",
-        "dotenv": "^16.4.5",
-        "esbuild": "^0.18.20",
-        "eventsource-parser": "^1.1.2",
-        "graceful-fs": "^4.2.11",
-        "minimatch": "^9.0.3",
-        "mustache": "^4.2.0",
-        "pluralize": "^8.0.0",
-        "simple-git": "^3.21.0",
-        "slugify": "^1.6.6",
-        "source-map": "^0.7.4",
-        "uuid": "^9.0.1",
-        "zod": "^3.22.4",
-        "zod-to-json-schema": "^3.22.5"
-      },
-      "bin": {
-        "braintrust": "dist/cli.js"
-      },
-      "peerDependencies": {
-        "zod": "^3.0.0"
-      }
-    },
-    "node_modules/braintrust/node_modules/@ai-sdk/provider": {
-      "version": "0.0.11",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-0.0.11.tgz",
-      "integrity": "sha512-VTipPQ92Moa5Ovg/nZIc8yNoIFfukZjUHZcQMduJbiUh3CLQyrBAKTEV9AwjPy8wgVxj3+GZjon0yyOJKhfp5g==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "json-schema": "0.4.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/braintrust/node_modules/@ai-sdk/provider-utils": {
-      "version": "1.0.22",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-1.0.22.tgz",
-      "integrity": "sha512-YHK2rpj++wnLVc9vPGzGFP3Pjeld2MwhKinetA0zKXOoHAT/Jit5O8kZsxcSlJPu9wvcGT1UGZEjZrtO7PfFOQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "0.0.26",
-        "eventsource-parser": "^1.1.2",
-        "nanoid": "^3.3.7",
-        "secure-json-parse": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.0.0"
-      },
-      "peerDependenciesMeta": {
-        "zod": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/braintrust/node_modules/@ai-sdk/provider-utils/node_modules/@ai-sdk/provider": {
-      "version": "0.0.26",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-0.0.26.tgz",
-      "integrity": "sha512-dQkfBDs2lTYpKM8389oopPdQgIU007GQyCbuPPrV+K6MtSII3HBfE0stUIMXUb44L+LK1t6GXPP7wjSzjO6uKg==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "json-schema": "^0.4.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/braintrust/node_modules/@ai-sdk/react": {
-      "version": "0.0.70",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/react/-/react-0.0.70.tgz",
-      "integrity": "sha512-GnwbtjW4/4z7MleLiW+TOZC2M29eCg1tOUpuEiYFMmFNZK8mkrqM0PFZMo6UsYeUYMWqEOOcPOU9OQVJMJh7IQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider-utils": "1.0.22",
-        "@ai-sdk/ui-utils": "0.0.50",
-        "swr": "^2.2.5",
-        "throttleit": "2.1.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "react": "^18 || ^19 || ^19.0.0-rc",
-        "zod": "^3.0.0"
-      },
-      "peerDependenciesMeta": {
-        "react": {
-          "optional": true
-        },
-        "zod": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/braintrust/node_modules/@ai-sdk/ui-utils": {
-      "version": "0.0.50",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/ui-utils/-/ui-utils-0.0.50.tgz",
-      "integrity": "sha512-Z5QYJVW+5XpSaJ4jYCCAVG7zIAuKOOdikhgpksneNmKvx61ACFaf98pmOd+xnjahl0pIlc/QIe6O4yVaJ1sEaw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "0.0.26",
-        "@ai-sdk/provider-utils": "1.0.22",
-        "json-schema": "^0.4.0",
-        "secure-json-parse": "^2.7.0",
-        "zod-to-json-schema": "^3.23.3"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "zod": "^3.0.0"
-      },
-      "peerDependenciesMeta": {
-        "zod": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/braintrust/node_modules/@ai-sdk/ui-utils/node_modules/@ai-sdk/provider": {
-      "version": "0.0.26",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-0.0.26.tgz",
-      "integrity": "sha512-dQkfBDs2lTYpKM8389oopPdQgIU007GQyCbuPPrV+K6MtSII3HBfE0stUIMXUb44L+LK1t6GXPP7wjSzjO6uKg==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "json-schema": "^0.4.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/braintrust/node_modules/@braintrust/core": {
-      "version": "0.0.67",
-      "resolved": "https://registry.npmjs.org/@braintrust/core/-/core-0.0.67.tgz",
-      "integrity": "sha512-aCWOIgGKeYeEQmU8FcPyfp0phaLpt4iaDcealooaI7Lw/Loz2LeHu5FdzVzu34B7zw3ZOkzyrr0I4X/YFdTy1w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@asteasolutions/zod-to-openapi": "^6.3.1",
-        "uuid": "^9.0.1",
-        "zod": "^3.22.4"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/android-arm": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.18.20.tgz",
-      "integrity": "sha512-fyi7TDI/ijKKNZTUJAQqiG5T7YjJXgnzkURqmGj13C6dCqckZBLdl4h7bkhHt/t0WP+zO9/zwroDvANaOqO5Sw==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/android-arm64": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.18.20.tgz",
-      "integrity": "sha512-Nz4rJcchGDtENV0eMKUNa6L12zz2zBDXuhj/Vjh18zGqB44Bi7MBMSXjgunJgjRhCmKOjnPuZp4Mb6OKqtMHLQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/android-x64": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.18.20.tgz",
-      "integrity": "sha512-8GDdlePJA8D6zlZYJV/jnrRAi6rOiNaCC/JclcXpB+KIuvfBN4owLtgzY2bsxnx666XjJx2kDPUmnTtR8qKQUg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/darwin-arm64": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.18.20.tgz",
-      "integrity": "sha512-bxRHW5kHU38zS2lPTPOyuyTm+S+eobPUnTNkdJEfAddYgEcll4xkT8DB9d2008DtTbl7uJag2HuE5NZAZgnNEA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/darwin-x64": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.18.20.tgz",
-      "integrity": "sha512-pc5gxlMDxzm513qPGbCbDukOdsGtKhfxD1zJKXjCCcU7ju50O7MeAZ8c4krSJcOIJGFR+qx21yMMVYwiQvyTyQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.18.20.tgz",
-      "integrity": "sha512-yqDQHy4QHevpMAaxhhIwYPMv1NECwOvIpGCZkECn8w2WFHXjEwrBn3CeNIYsibZ/iZEUemj++M26W3cNR5h+Tw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/freebsd-x64": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.18.20.tgz",
-      "integrity": "sha512-tgWRPPuQsd3RmBZwarGVHZQvtzfEBOreNuxEMKFcd5DaDn2PbBxfwLcj4+aenoh7ctXcbXmOQIn8HI6mCSw5MQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/linux-arm": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.18.20.tgz",
-      "integrity": "sha512-/5bHkMWnq1EgKr1V+Ybz3s1hWXok7mDFUMQ4cG10AfW3wL02PSZi5kFpYKrptDsgb2WAJIvRcDm+qIvXf/apvg==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/linux-arm64": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.18.20.tgz",
-      "integrity": "sha512-2YbscF+UL7SQAVIpnWvYwM+3LskyDmPhe31pE7/aoTMFKKzIc9lLbyGUpmmb8a8AixOL61sQ/mFh3jEjHYFvdA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/linux-ia32": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.18.20.tgz",
-      "integrity": "sha512-P4etWwq6IsReT0E1KHU40bOnzMHoH73aXp96Fs8TIT6z9Hu8G6+0SHSw9i2isWrD2nbx2qo5yUqACgdfVGx7TA==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/linux-loong64": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.18.20.tgz",
-      "integrity": "sha512-nXW8nqBTrOpDLPgPY9uV+/1DjxoQ7DoB2N8eocyq8I9XuqJ7BiAMDMf9n1xZM9TgW0J8zrquIb/A7s3BJv7rjg==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/linux-mips64el": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.18.20.tgz",
-      "integrity": "sha512-d5NeaXZcHp8PzYy5VnXV3VSd2D328Zb+9dEq5HE6bw6+N86JVPExrA6O68OPwobntbNJ0pzCpUFZTo3w0GyetQ==",
-      "cpu": [
-        "mips64el"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/linux-ppc64": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.18.20.tgz",
-      "integrity": "sha512-WHPyeScRNcmANnLQkq6AfyXRFr5D6N2sKgkFo2FqguP44Nw2eyDlbTdZwd9GYk98DZG9QItIiTlFLHJHjxP3FA==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/linux-riscv64": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.18.20.tgz",
-      "integrity": "sha512-WSxo6h5ecI5XH34KC7w5veNnKkju3zBRLEQNY7mv5mtBmrP/MjNBCAlsM2u5hDBlS3NGcTQpoBvRzqBcRtpq1A==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/linux-s390x": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.18.20.tgz",
-      "integrity": "sha512-+8231GMs3mAEth6Ja1iK0a1sQ3ohfcpzpRLH8uuc5/KVDFneH6jtAJLFGafpzpMRO6DzJ6AvXKze9LfFMrIHVQ==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/linux-x64": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.18.20.tgz",
-      "integrity": "sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/netbsd-x64": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.18.20.tgz",
-      "integrity": "sha512-iO1c++VP6xUBUmltHZoMtCUdPlnPGdBom6IrO4gyKPFFVBKioIImVooR5I83nTew5UOYrk3gIJhbZh8X44y06A==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/openbsd-x64": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.18.20.tgz",
-      "integrity": "sha512-e5e4YSsuQfX4cxcygw/UCPIEP6wbIL+se3sxPdCiMbFLBWu0eiZOJ7WoD+ptCLrmjZBK1Wk7I6D/I3NglUGOxg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/sunos-x64": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.18.20.tgz",
-      "integrity": "sha512-kDbFRFp0YpTQVVrqUd5FTYmWo45zGaXe0X8E1G/LKFC0v8x0vWrhOWSLITcCn63lmZIxfOMXtCfti/RxN/0wnQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/win32-arm64": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.18.20.tgz",
-      "integrity": "sha512-ddYFR6ItYgoaq4v4JmQQaAI5s7npztfV4Ag6NrhiaW0RrnOXqBkgwZLofVTlq1daVTQNhtI5oieTvkRPfZrePg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/win32-ia32": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.18.20.tgz",
-      "integrity": "sha512-Wv7QBi3ID/rROT08SABTS7eV4hX26sVduqDOTe1MvGMjNd3EjOz4b7zeexIR62GTIEKrfJXKL9LFxTYgkyeu7g==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/@esbuild/win32-x64": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.18.20.tgz",
-      "integrity": "sha512-kTdfRcSiDfQca/y9QIkng02avJ+NCaQvrMejlsB3RRv5sE9rRoeBPISaZpKxHELzRxZyLvNts1P27W3wV+8geQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/braintrust/node_modules/ai": {
-      "version": "3.4.33",
-      "resolved": "https://registry.npmjs.org/ai/-/ai-3.4.33.tgz",
-      "integrity": "sha512-plBlrVZKwPoRTmM8+D1sJac9Bq8eaa2jiZlHLZIWekKWI1yMWYZvCCEezY9ASPwRhULYDJB2VhKOBUUeg3S5JQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@ai-sdk/provider": "0.0.26",
-        "@ai-sdk/provider-utils": "1.0.22",
-        "@ai-sdk/react": "0.0.70",
-        "@ai-sdk/solid": "0.0.54",
-        "@ai-sdk/svelte": "0.0.57",
-        "@ai-sdk/ui-utils": "0.0.50",
-        "@ai-sdk/vue": "0.0.59",
-        "@opentelemetry/api": "1.9.0",
-        "eventsource-parser": "1.1.2",
-        "json-schema": "^0.4.0",
-        "jsondiffpatch": "0.6.0",
-        "secure-json-parse": "^2.7.0",
-        "zod-to-json-schema": "^3.23.3"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "openai": "^4.42.0",
-        "react": "^18 || ^19 || ^19.0.0-rc",
-        "sswr": "^2.1.0",
-        "svelte": "^3.0.0 || ^4.0.0 || ^5.0.0",
-        "zod": "^3.0.0"
-      },
-      "peerDependenciesMeta": {
-        "openai": {
-          "optional": true
-        },
-        "react": {
-          "optional": true
-        },
-        "sswr": {
-          "optional": true
-        },
-        "svelte": {
-          "optional": true
-        },
-        "zod": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/braintrust/node_modules/ai/node_modules/@ai-sdk/provider": {
-      "version": "0.0.26",
-      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-0.0.26.tgz",
-      "integrity": "sha512-dQkfBDs2lTYpKM8389oopPdQgIU007GQyCbuPPrV+K6MtSII3HBfE0stUIMXUb44L+LK1t6GXPP7wjSzjO6uKg==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "json-schema": "^0.4.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/braintrust/node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/braintrust/node_modules/chalk": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.1.0",
-        "supports-color": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
-      }
-    },
-    "node_modules/braintrust/node_modules/esbuild": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.18.20.tgz",
-      "integrity": "sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "optionalDependencies": {
-        "@esbuild/android-arm": "0.18.20",
-        "@esbuild/android-arm64": "0.18.20",
-        "@esbuild/android-x64": "0.18.20",
-        "@esbuild/darwin-arm64": "0.18.20",
-        "@esbuild/darwin-x64": "0.18.20",
-        "@esbuild/freebsd-arm64": "0.18.20",
-        "@esbuild/freebsd-x64": "0.18.20",
-        "@esbuild/linux-arm": "0.18.20",
-        "@esbuild/linux-arm64": "0.18.20",
-        "@esbuild/linux-ia32": "0.18.20",
-        "@esbuild/linux-loong64": "0.18.20",
-        "@esbuild/linux-mips64el": "0.18.20",
-        "@esbuild/linux-ppc64": "0.18.20",
-        "@esbuild/linux-riscv64": "0.18.20",
-        "@esbuild/linux-s390x": "0.18.20",
-        "@esbuild/linux-x64": "0.18.20",
-        "@esbuild/netbsd-x64": "0.18.20",
-        "@esbuild/openbsd-x64": "0.18.20",
-        "@esbuild/sunos-x64": "0.18.20",
-        "@esbuild/win32-arm64": "0.18.20",
-        "@esbuild/win32-ia32": "0.18.20",
-        "@esbuild/win32-x64": "0.18.20"
-      }
-    },
-    "node_modules/braintrust/node_modules/eventsource-parser": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-1.1.2.tgz",
-      "integrity": "sha512-v0eOBUbiaFojBu2s2NPBfYUoRR9GjcDNvCXVaqEf5vVfpIAh9f8RCo4vXTP8c63QRKCFwoLpMpTdPwwhEKVgzA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=14.18"
-      }
-    },
-    "node_modules/braintrust/node_modules/uuid": {
-      "version": "9.0.1",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-9.0.1.tgz",
-      "integrity": "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==",
-      "dev": true,
-      "funding": [
-        "https://github.com/sponsors/broofa",
-        "https://github.com/sponsors/ctavan"
-      ],
-      "license": "MIT",
-      "bin": {
-        "uuid": "dist/bin/uuid"
-      }
-    },
-    "node_modules/buffer-equal-constant-time": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz",
-      "integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==",
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/buffer-from": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
-      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/bundle-require": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/bundle-require/-/bundle-require-5.1.0.tgz",
-      "integrity": "sha512-3WrrOuZiyaaZPWiEt4G3+IffISVC9HYlWueJEBWED4ZH4aIAC2PnkdnuRrR94M+w6yGWn4AglWtJtBI8YqvgoA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "load-tsconfig": "^0.2.3"
-      },
-      "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      },
-      "peerDependencies": {
-        "esbuild": ">=0.18"
-      }
-    },
-    "node_modules/busboy": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/busboy/-/busboy-1.6.0.tgz",
-      "integrity": "sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA==",
-      "dev": true,
-      "dependencies": {
-        "streamsearch": "^1.1.0"
-      },
-      "engines": {
-        "node": ">=10.16.0"
-      }
-    },
-    "node_modules/bytes": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
-      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/cac": {
-      "version": "6.7.14",
-      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
-      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/call-bind-apply-helpers": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
-      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "function-bind": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/call-bound": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
-      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.2",
-        "get-intrinsic": "^1.3.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/callsites": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
-      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/camelcase": {
-      "version": "6.3.0",
-      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz",
-      "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/chalk": {
-      "version": "5.4.1",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.4.1.tgz",
-      "integrity": "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^12.17.0 || ^14.13 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
-      }
-    },
-    "node_modules/chardet": {
-      "version": "0.7.0",
-      "resolved": "https://registry.npmjs.org/chardet/-/chardet-0.7.0.tgz",
-      "integrity": "sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/charenc": {
-      "version": "0.0.2",
-      "resolved": "https://registry.npmjs.org/charenc/-/charenc-0.0.2.tgz",
-      "integrity": "sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/cheerio": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0.tgz",
-      "integrity": "sha512-quS9HgjQpdaXOvsZz82Oz7uxtXiy6UIsIQcpBj7HRw2M63Skasm9qlDocAM7jNuaxdhpPU7c4kJN+gA5MCu4ww==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "cheerio-select": "^2.1.0",
-        "dom-serializer": "^2.0.0",
-        "domhandler": "^5.0.3",
-        "domutils": "^3.1.0",
-        "encoding-sniffer": "^0.2.0",
-        "htmlparser2": "^9.1.0",
-        "parse5": "^7.1.2",
-        "parse5-htmlparser2-tree-adapter": "^7.0.0",
-        "parse5-parser-stream": "^7.1.2",
-        "undici": "^6.19.5",
-        "whatwg-mimetype": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=18.17"
-      },
-      "funding": {
-        "url": "https://github.com/cheeriojs/cheerio?sponsor=1"
-      }
-    },
-    "node_modules/cheerio-select": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/cheerio-select/-/cheerio-select-2.1.0.tgz",
-      "integrity": "sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "boolbase": "^1.0.0",
-        "css-select": "^5.1.0",
-        "css-what": "^6.1.0",
-        "domelementtype": "^2.3.0",
-        "domhandler": "^5.0.3",
-        "domutils": "^3.0.1"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/fb55"
-      }
-    },
-    "node_modules/cheminfo-types": {
-      "version": "1.8.1",
-      "resolved": "https://registry.npmjs.org/cheminfo-types/-/cheminfo-types-1.8.1.tgz",
-      "integrity": "sha512-FRcpVkox+cRovffgqNdDFQ1eUav+i/Vq/CUd1hcfEl2bevntFlzznL+jE8g4twl6ElB7gZjCko6pYpXyMn+6dA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/chokidar": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
-      "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "readdirp": "^4.0.1"
-      },
-      "engines": {
-        "node": ">= 14.16.0"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/chromium-bidi": {
-      "version": "0.10.2",
-      "resolved": "https://registry.npmjs.org/chromium-bidi/-/chromium-bidi-0.10.2.tgz",
-      "integrity": "sha512-hxx/MvrxMvCHriN9xb1xuVg9vthybieAe5Jikr/9iYnSdv6Q5n1WUmNG32nKoSxkG+P35lGV0hJkzXQg2bCbrQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "mitt": "3.0.1",
-        "zod": "3.23.8"
-      },
-      "peerDependencies": {
-        "devtools-protocol": "*"
-      }
-    },
-    "node_modules/chromium-bidi/node_modules/zod": {
-      "version": "3.23.8",
-      "resolved": "https://registry.npmjs.org/zod/-/zod-3.23.8.tgz",
-      "integrity": "sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/colinhacks"
-      }
-    },
-    "node_modules/ci-info": {
-      "version": "3.9.0",
-      "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.9.0.tgz",
-      "integrity": "sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/sibiraj-s"
-        }
-      ],
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/cli-progress": {
-      "version": "3.12.0",
-      "resolved": "https://registry.npmjs.org/cli-progress/-/cli-progress-3.12.0.tgz",
-      "integrity": "sha512-tRkV3HJ1ASwm19THiiLIXLO7Im7wlTuKnvkYaTkyoAPefqjNg7W7DHKUlGRxy9vxDvbyCYQkQozvptuMkGCg8A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "string-width": "^4.2.3"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/clsx": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
-      "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/color-convert": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-name": "~1.1.4"
-      },
-      "engines": {
-        "node": ">=7.0.0"
-      }
-    },
-    "node_modules/color-name": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/colorette": {
-      "version": "2.0.20",
-      "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz",
-      "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==",
-      "license": "MIT"
-    },
-    "node_modules/combined-stream": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
-      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
-      "license": "MIT",
-      "dependencies": {
-        "delayed-stream": "~1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/commander": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz",
-      "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/compute-cosine-similarity": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/compute-cosine-similarity/-/compute-cosine-similarity-1.1.0.tgz",
-      "integrity": "sha512-FXhNx0ILLjGi9Z9+lglLzM12+0uoTnYkHm7GiadXDAr0HGVLm25OivUS1B/LPkbzzvlcXz/1EvWg9ZYyJSdhTw==",
-      "dev": true,
-      "dependencies": {
-        "compute-dot": "^1.1.0",
-        "compute-l2norm": "^1.1.0",
-        "validate.io-array": "^1.0.5",
-        "validate.io-function": "^1.0.2"
-      }
-    },
-    "node_modules/compute-dot": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/compute-dot/-/compute-dot-1.1.0.tgz",
-      "integrity": "sha512-L5Ocet4DdMrXboss13K59OK23GXjiSia7+7Ukc7q4Bl+RVpIXK2W9IHMbWDZkh+JUEvJAwOKRaJDiFUa1LTnJg==",
-      "dev": true,
-      "dependencies": {
-        "validate.io-array": "^1.0.3",
-        "validate.io-function": "^1.0.2"
-      }
-    },
-    "node_modules/compute-l2norm": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/compute-l2norm/-/compute-l2norm-1.1.0.tgz",
-      "integrity": "sha512-6EHh1Elj90eU28SXi+h2PLnTQvZmkkHWySpoFz+WOlVNLz3DQoC4ISUHSV9n5jMxPHtKGJ01F4uu2PsXBB8sSg==",
-      "dev": true,
-      "dependencies": {
-        "validate.io-array": "^1.0.3",
-        "validate.io-function": "^1.0.2"
-      }
-    },
-    "node_modules/concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/concat-stream": {
-      "version": "1.6.2",
-      "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz",
-      "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==",
-      "dev": true,
-      "engines": [
-        "node >= 0.8"
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "buffer-from": "^1.0.0",
-        "inherits": "^2.0.3",
-        "readable-stream": "^2.2.2",
-        "typedarray": "^0.0.6"
-      }
-    },
-    "node_modules/consola": {
-      "version": "3.4.0",
-      "resolved": "https://registry.npmjs.org/consola/-/consola-3.4.0.tgz",
-      "integrity": "sha512-EiPU8G6dQG0GFHNR8ljnZFki/8a+cQwEQ+7wpxdChl02Q8HXlwEZWD5lqAF8vC2sEC3Tehr8hy7vErz88LHyUA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^14.18.0 || >=16.10.0"
-      }
-    },
-    "node_modules/console-table-printer": {
-      "version": "2.12.1",
-      "resolved": "https://registry.npmjs.org/console-table-printer/-/console-table-printer-2.12.1.tgz",
-      "integrity": "sha512-wKGOQRRvdnd89pCeH96e2Fn4wkbenSP6LMHfjfyNLMbGuHEFbMqQNuxXqd0oXG9caIOQ1FTvc5Uijp9/4jujnQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "simple-wcswidth": "^1.0.1"
-      }
-    },
-    "node_modules/content-disposition": {
-      "version": "0.5.4",
-      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
-      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "safe-buffer": "5.2.1"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/content-type": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
-      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/cookie": {
-      "version": "0.7.1",
-      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz",
-      "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/cookie-signature": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
-      "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/core-util-is": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
-      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/cross-spawn": {
-      "version": "7.0.6",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
-      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "path-key": "^3.1.0",
-        "shebang-command": "^2.0.0",
-        "which": "^2.0.1"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/crypt": {
-      "version": "0.0.2",
-      "resolved": "https://registry.npmjs.org/crypt/-/crypt-0.0.2.tgz",
-      "integrity": "sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/css-select": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.1.0.tgz",
-      "integrity": "sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "boolbase": "^1.0.0",
-        "css-what": "^6.1.0",
-        "domhandler": "^5.0.2",
-        "domutils": "^3.0.1",
-        "nth-check": "^2.0.1"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/fb55"
-      }
-    },
-    "node_modules/css-what": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.1.0.tgz",
-      "integrity": "sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">= 6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/fb55"
-      }
-    },
-    "node_modules/csstype": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
-      "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true
-    },
-    "node_modules/dataloader": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/dataloader/-/dataloader-1.4.0.tgz",
-      "integrity": "sha512-68s5jYdlvasItOJnCuI2Q9s4q98g0pCyL3HrcKJu8KNugUl8ahgmZYg38ysLTgQjjXX3H8CJLkAvWrclWfcalw==",
-      "dev": true,
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/dateformat": {
-      "version": "4.6.3",
-      "resolved": "https://registry.npmjs.org/dateformat/-/dateformat-4.6.3.tgz",
-      "integrity": "sha512-2P0p0pFGzHS5EMnhdxQi7aJN+iMheud0UhG4dlE1DLAlvL8JHjJJTX/CSm4JXwV0Ka5nGk3zC5mcb5bUQUxxMA==",
-      "license": "MIT",
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/debug": {
-      "version": "4.4.0",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
-      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/decamelize": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz",
-      "integrity": "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/deep-is": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
-      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/deepmerge": {
-      "version": "4.3.1",
-      "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz",
-      "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==",
-      "license": "MIT",
-      "peer": true,
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/delayed-stream": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
-      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/depd": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
-      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/dequal": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
-      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/destroy": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
-      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8",
-        "npm": "1.2.8000 || >= 1.4.16"
-      }
-    },
-    "node_modules/detect-indent": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/detect-indent/-/detect-indent-6.1.0.tgz",
-      "integrity": "sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/devtools-protocol": {
-      "version": "0.0.1430640",
-      "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1430640.tgz",
-      "integrity": "sha512-p+uQCEoQcS5f9Zx4O0PLHz2/fPNFWA0x2tXO8rd/4U8/3/dGpl6R1gKPFHjS5Gq0L+mn7AmXYh5ude5txiAe+Q==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "peer": true
-    },
-    "node_modules/diff-match-patch": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/diff-match-patch/-/diff-match-patch-1.0.5.tgz",
-      "integrity": "sha512-IayShXAgj/QMXgB0IWmKx+rOPuGMhqm5w6jvFxmVenXKIzRqTAAsbBPT3kWQeGANj3jGgvcvv4yK6SxqYmikgw==",
-      "dev": true,
-      "license": "Apache-2.0"
-    },
-    "node_modules/digest-fetch": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/digest-fetch/-/digest-fetch-1.3.0.tgz",
-      "integrity": "sha512-CGJuv6iKNM7QyZlM2T3sPAdZWd/p9zQiRNS9G+9COUCwzWFTs0Xp8NF5iePx7wtvhDykReiRRrSeNb4oMmB8lA==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "base-64": "^0.1.0",
-        "md5": "^2.3.0"
-      }
-    },
-    "node_modules/dir-glob": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz",
-      "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "path-type": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/dom-serializer": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz",
-      "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "domelementtype": "^2.3.0",
-        "domhandler": "^5.0.2",
-        "entities": "^4.2.0"
-      },
-      "funding": {
-        "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1"
-      }
-    },
-    "node_modules/domelementtype": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz",
-      "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fb55"
-        }
-      ],
-      "license": "BSD-2-Clause"
-    },
-    "node_modules/domhandler": {
-      "version": "5.0.3",
-      "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz",
-      "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "domelementtype": "^2.3.0"
-      },
-      "engines": {
-        "node": ">= 4"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/domhandler?sponsor=1"
-      }
-    },
-    "node_modules/domutils": {
-      "version": "3.2.2",
-      "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.2.2.tgz",
-      "integrity": "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "dom-serializer": "^2.0.0",
-        "domelementtype": "^2.3.0",
-        "domhandler": "^5.0.3"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/domutils?sponsor=1"
-      }
-    },
-    "node_modules/dotenv": {
-      "version": "16.4.7",
-      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.4.7.tgz",
-      "integrity": "sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ==",
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://dotenvx.com"
-      }
-    },
-    "node_modules/dunder-proto": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
-      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "gopd": "^1.2.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/eastasianwidth": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
-      "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/ecdsa-sig-formatter": {
-      "version": "1.0.11",
-      "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz",
-      "integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "safe-buffer": "^5.0.1"
-      }
-    },
-    "node_modules/ee-first": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
-      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/encodeurl": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
-      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/encoding-sniffer": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/encoding-sniffer/-/encoding-sniffer-0.2.0.tgz",
-      "integrity": "sha512-ju7Wq1kg04I3HtiYIOrUrdfdDvkyO9s5XM8QAj/bN61Yo/Vb4vgJxy5vi4Yxk01gWHbrofpPtpxM8bKger9jhg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "iconv-lite": "^0.6.3",
-        "whatwg-encoding": "^3.1.1"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/encoding-sniffer?sponsor=1"
-      }
-    },
-    "node_modules/end-of-stream": {
-      "version": "1.4.4",
-      "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz",
-      "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==",
-      "license": "MIT",
-      "dependencies": {
-        "once": "^1.4.0"
-      }
-    },
-    "node_modules/enquirer": {
-      "version": "2.4.1",
-      "resolved": "https://registry.npmjs.org/enquirer/-/enquirer-2.4.1.tgz",
-      "integrity": "sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-colors": "^4.1.1",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8.6"
-      }
-    },
-    "node_modules/entities": {
-      "version": "4.5.0",
-      "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
-      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=0.12"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/entities?sponsor=1"
-      }
-    },
-    "node_modules/es-define-property": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
-      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-errors": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
-      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-object-atoms": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
-      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-set-tostringtag": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
-      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.6",
-        "has-tostringtag": "^1.0.2",
-        "hasown": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/esbuild": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
-      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.21.5",
-        "@esbuild/android-arm": "0.21.5",
-        "@esbuild/android-arm64": "0.21.5",
-        "@esbuild/android-x64": "0.21.5",
-        "@esbuild/darwin-arm64": "0.21.5",
-        "@esbuild/darwin-x64": "0.21.5",
-        "@esbuild/freebsd-arm64": "0.21.5",
-        "@esbuild/freebsd-x64": "0.21.5",
-        "@esbuild/linux-arm": "0.21.5",
-        "@esbuild/linux-arm64": "0.21.5",
-        "@esbuild/linux-ia32": "0.21.5",
-        "@esbuild/linux-loong64": "0.21.5",
-        "@esbuild/linux-mips64el": "0.21.5",
-        "@esbuild/linux-ppc64": "0.21.5",
-        "@esbuild/linux-riscv64": "0.21.5",
-        "@esbuild/linux-s390x": "0.21.5",
-        "@esbuild/linux-x64": "0.21.5",
-        "@esbuild/netbsd-x64": "0.21.5",
-        "@esbuild/openbsd-x64": "0.21.5",
-        "@esbuild/sunos-x64": "0.21.5",
-        "@esbuild/win32-arm64": "0.21.5",
-        "@esbuild/win32-ia32": "0.21.5",
-        "@esbuild/win32-x64": "0.21.5"
-      }
-    },
-    "node_modules/escape-html": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
-      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/escape-string-regexp": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
-      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/eslint": {
-      "version": "9.22.0",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.22.0.tgz",
-      "integrity": "sha512-9V/QURhsRN40xuHXWjV64yvrzMjcz7ZyNoF2jJFmy9j/SLk0u1OLSZgXi28MrXjymnjEGSR80WCdab3RGMDveQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@eslint-community/eslint-utils": "^4.2.0",
-        "@eslint-community/regexpp": "^4.12.1",
-        "@eslint/config-array": "^0.19.2",
-        "@eslint/config-helpers": "^0.1.0",
-        "@eslint/core": "^0.12.0",
-        "@eslint/eslintrc": "^3.3.0",
-        "@eslint/js": "9.22.0",
-        "@eslint/plugin-kit": "^0.2.7",
-        "@humanfs/node": "^0.16.6",
-        "@humanwhocodes/module-importer": "^1.0.1",
-        "@humanwhocodes/retry": "^0.4.2",
-        "@types/estree": "^1.0.6",
-        "@types/json-schema": "^7.0.15",
-        "ajv": "^6.12.4",
-        "chalk": "^4.0.0",
-        "cross-spawn": "^7.0.6",
-        "debug": "^4.3.2",
-        "escape-string-regexp": "^4.0.0",
-        "eslint-scope": "^8.3.0",
-        "eslint-visitor-keys": "^4.2.0",
-        "espree": "^10.3.0",
-        "esquery": "^1.5.0",
-        "esutils": "^2.0.2",
-        "fast-deep-equal": "^3.1.3",
-        "file-entry-cache": "^8.0.0",
-        "find-up": "^5.0.0",
-        "glob-parent": "^6.0.2",
-        "ignore": "^5.2.0",
-        "imurmurhash": "^0.1.4",
-        "is-glob": "^4.0.0",
-        "json-stable-stringify-without-jsonify": "^1.0.1",
-        "lodash.merge": "^4.6.2",
-        "minimatch": "^3.1.2",
-        "natural-compare": "^1.4.0",
-        "optionator": "^0.9.3"
-      },
-      "bin": {
-        "eslint": "bin/eslint.js"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://eslint.org/donate"
-      },
-      "peerDependencies": {
-        "jiti": "*"
-      },
-      "peerDependenciesMeta": {
-        "jiti": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/eslint-scope": {
-      "version": "8.3.0",
-      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.3.0.tgz",
-      "integrity": "sha512-pUNxi75F8MJ/GdeKtVLSbYg4ZI34J6C0C7sbL4YOp2exGwen7ZsuBqKzUhXd0qMQ362yET3z+uPwKeg/0C2XCQ==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "esrecurse": "^4.3.0",
-        "estraverse": "^5.2.0"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/eslint-visitor-keys": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.0.tgz",
-      "integrity": "sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/eslint/node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/eslint/node_modules/brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/eslint/node_modules/chalk": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.1.0",
-        "supports-color": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
-      }
-    },
-    "node_modules/eslint/node_modules/find-up": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
-      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "locate-path": "^6.0.0",
-        "path-exists": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/eslint/node_modules/locate-path": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
-      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-locate": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/eslint/node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/eslint/node_modules/p-limit": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
-      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "yocto-queue": "^0.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/eslint/node_modules/p-locate": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
-      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-limit": "^3.0.2"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/esm-env": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/esm-env/-/esm-env-1.2.2.tgz",
-      "integrity": "sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true
-    },
-    "node_modules/espree": {
-      "version": "10.3.0",
-      "resolved": "https://registry.npmjs.org/espree/-/espree-10.3.0.tgz",
-      "integrity": "sha512-0QYC8b24HWY8zjRnDTL6RiHfDbAWn63qb4LMj1Z4b076A4une81+z03Kg7l7mn/48PUTqoLptSXez8oknU8Clg==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "acorn": "^8.14.0",
-        "acorn-jsx": "^5.3.2",
-        "eslint-visitor-keys": "^4.2.0"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/esprima": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
-      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "bin": {
-        "esparse": "bin/esparse.js",
-        "esvalidate": "bin/esvalidate.js"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/esquery": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz",
-      "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "estraverse": "^5.1.0"
-      },
-      "engines": {
-        "node": ">=0.10"
-      }
-    },
-    "node_modules/esrap": {
-      "version": "1.4.5",
-      "resolved": "https://registry.npmjs.org/esrap/-/esrap-1.4.5.tgz",
-      "integrity": "sha512-CjNMjkBWWZeHn+VX+gS8YvFwJ5+NDhg8aWZBSFJPR8qQduDNjbJodA2WcwCm7uQa5Rjqj+nZvVmceg1RbHFB9g==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@jridgewell/sourcemap-codec": "^1.4.15"
-      }
-    },
-    "node_modules/esrecurse": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
-      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "estraverse": "^5.2.0"
-      },
-      "engines": {
-        "node": ">=4.0"
-      }
-    },
-    "node_modules/estraverse": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
-      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=4.0"
-      }
-    },
-    "node_modules/estree-walker": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
-      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true
-    },
-    "node_modules/esutils": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
-      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/etag": {
-      "version": "1.8.1",
-      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
-      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/event-target-shim": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz",
-      "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/eventemitter3": {
-      "version": "4.0.7",
-      "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz",
-      "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/eventsource-parser": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.0.0.tgz",
-      "integrity": "sha512-T1C0XCUimhxVQzW4zFipdx0SficT651NnkR0ZSH3yQwh+mFMdLfgjABVi4YtMTtaL4s168593DaoaRLMqryavA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18.0.0"
-      }
-    },
-    "node_modules/express": {
-      "version": "4.21.2",
-      "resolved": "https://registry.npmjs.org/express/-/express-4.21.2.tgz",
-      "integrity": "sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "accepts": "~1.3.8",
-        "array-flatten": "1.1.1",
-        "body-parser": "1.20.3",
-        "content-disposition": "0.5.4",
-        "content-type": "~1.0.4",
-        "cookie": "0.7.1",
-        "cookie-signature": "1.0.6",
-        "debug": "2.6.9",
-        "depd": "2.0.0",
-        "encodeurl": "~2.0.0",
-        "escape-html": "~1.0.3",
-        "etag": "~1.8.1",
-        "finalhandler": "1.3.1",
-        "fresh": "0.5.2",
-        "http-errors": "2.0.0",
-        "merge-descriptors": "1.0.3",
-        "methods": "~1.1.2",
-        "on-finished": "2.4.1",
-        "parseurl": "~1.3.3",
-        "path-to-regexp": "0.1.12",
-        "proxy-addr": "~2.0.7",
-        "qs": "6.13.0",
-        "range-parser": "~1.2.1",
-        "safe-buffer": "5.2.1",
-        "send": "0.19.0",
-        "serve-static": "1.16.2",
-        "setprototypeof": "1.2.0",
-        "statuses": "2.0.1",
-        "type-is": "~1.6.18",
-        "utils-merge": "1.0.1",
-        "vary": "~1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.10.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/express/node_modules/debug": {
-      "version": "2.6.9",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
-      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "2.0.0"
-      }
-    },
-    "node_modules/express/node_modules/ms": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
-      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/extend": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
-      "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
-      "license": "MIT"
-    },
-    "node_modules/extendable-error": {
-      "version": "0.1.7",
-      "resolved": "https://registry.npmjs.org/extendable-error/-/extendable-error-0.1.7.tgz",
-      "integrity": "sha512-UOiS2in6/Q0FK0R0q6UY9vYpQ21mr/Qn1KOnte7vsACuNJf514WvCCUHSRCPcgjPT2bAhNIJdlE6bVap1GKmeg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/external-editor": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-3.1.0.tgz",
-      "integrity": "sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "chardet": "^0.7.0",
-        "iconv-lite": "^0.4.24",
-        "tmp": "^0.0.33"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/external-editor/node_modules/iconv-lite": {
-      "version": "0.4.24",
-      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
-      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "safer-buffer": ">= 2.1.2 < 3"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/fast-copy": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/fast-copy/-/fast-copy-3.0.2.tgz",
-      "integrity": "sha512-dl0O9Vhju8IrcLndv2eU4ldt1ftXMqqfgN4H1cpmGV7P6jeB9FwpN9a2c8DPGE1Ys88rNUJVYDHq73CGAGOPfQ==",
-      "license": "MIT"
-    },
-    "node_modules/fast-deep-equal": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
-      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/fast-glob": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
-      "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@nodelib/fs.stat": "^2.0.2",
-        "@nodelib/fs.walk": "^1.2.3",
-        "glob-parent": "^5.1.2",
-        "merge2": "^1.3.0",
-        "micromatch": "^4.0.8"
-      },
-      "engines": {
-        "node": ">=8.6.0"
-      }
-    },
-    "node_modules/fast-glob/node_modules/glob-parent": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
-      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "is-glob": "^4.0.1"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/fast-json-stable-stringify": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
-      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/fast-levenshtein": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
-      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/fast-redact": {
-      "version": "3.5.0",
-      "resolved": "https://registry.npmjs.org/fast-redact/-/fast-redact-3.5.0.tgz",
-      "integrity": "sha512-dwsoQlS7h9hMeYUq1W++23NDcBLV4KqONnITDV9DjfS3q1SgDGVrBdvvTLUotWtPSD7asWDV9/CmsZPy8Hf70A==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/fast-safe-stringify": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/fast-safe-stringify/-/fast-safe-stringify-2.1.1.tgz",
-      "integrity": "sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==",
-      "license": "MIT"
-    },
-    "node_modules/fastq": {
-      "version": "1.19.1",
-      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz",
-      "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "reusify": "^1.0.4"
-      }
-    },
-    "node_modules/fft.js": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/fft.js/-/fft.js-4.0.4.tgz",
-      "integrity": "sha512-f9c00hphOgeQTlDyavwTtu6RiK8AIFjD6+jvXkNkpeQ7rirK3uFWVpalkoS4LAwbdX7mfZ8aoBfFVQX1Re/8aw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/file-entry-cache": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
-      "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "flat-cache": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=16.0.0"
-      }
-    },
-    "node_modules/fill-range": {
-      "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
-      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "to-regex-range": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/finalhandler": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz",
-      "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "debug": "2.6.9",
-        "encodeurl": "~2.0.0",
-        "escape-html": "~1.0.3",
-        "on-finished": "2.4.1",
-        "parseurl": "~1.3.3",
-        "statuses": "2.0.1",
-        "unpipe": "~1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/finalhandler/node_modules/debug": {
-      "version": "2.6.9",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
-      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "2.0.0"
-      }
-    },
-    "node_modules/finalhandler/node_modules/ms": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
-      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/find-up": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz",
-      "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "locate-path": "^5.0.0",
-        "path-exists": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/flat-cache": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
-      "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "flatted": "^3.2.9",
-        "keyv": "^4.5.4"
-      },
-      "engines": {
-        "node": ">=16"
-      }
-    },
-    "node_modules/flatted": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz",
-      "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/foreground-child": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
-      "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "cross-spawn": "^7.0.6",
-        "signal-exit": "^4.0.1"
-      },
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/form-data": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.2.tgz",
-      "integrity": "sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w==",
-      "license": "MIT",
-      "dependencies": {
-        "asynckit": "^0.4.0",
-        "combined-stream": "^1.0.8",
-        "es-set-tostringtag": "^2.1.0",
-        "mime-types": "^2.1.12"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/form-data-encoder": {
-      "version": "1.7.2",
-      "resolved": "https://registry.npmjs.org/form-data-encoder/-/form-data-encoder-1.7.2.tgz",
-      "integrity": "sha512-qfqtYan3rxrnCk1VYaA4H+Ms9xdpPqvLZa6xmMgFvhO32x7/3J/ExcTd6qpxM0vH2GdMI+poehyBZvqfMTto8A==",
-      "license": "MIT"
-    },
-    "node_modules/formdata-node": {
-      "version": "4.4.1",
-      "resolved": "https://registry.npmjs.org/formdata-node/-/formdata-node-4.4.1.tgz",
-      "integrity": "sha512-0iirZp3uVDjVGt9p49aTaqjk84TrglENEDuqfdlZQ1roC9CWlPk6Avf8EEnZNcAqPonwkG35x4n3ww/1THYAeQ==",
-      "license": "MIT",
-      "dependencies": {
-        "node-domexception": "1.0.0",
-        "web-streams-polyfill": "4.0.0-beta.3"
-      },
-      "engines": {
-        "node": ">= 12.20"
-      }
-    },
-    "node_modules/forwarded": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
-      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/fresh": {
-      "version": "0.5.2",
-      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
-      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/fs-extra": {
-      "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-7.0.1.tgz",
-      "integrity": "sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "graceful-fs": "^4.1.2",
-        "jsonfile": "^4.0.0",
-        "universalify": "^0.1.0"
-      },
-      "engines": {
-        "node": ">=6 <7 || >=8"
-      }
-    },
-    "node_modules/fsevents": {
-      "version": "2.3.2",
-      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
-      "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
-      "hasInstallScript": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
-      }
-    },
-    "node_modules/function-bind": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
-      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/gaxios": {
-      "version": "6.7.1",
-      "resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
-      "integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "extend": "^3.0.2",
-        "https-proxy-agent": "^7.0.1",
-        "is-stream": "^2.0.0",
-        "node-fetch": "^2.6.9",
-        "uuid": "^9.0.1"
-      },
-      "engines": {
-        "node": ">=14"
-      }
-    },
-    "node_modules/gaxios/node_modules/uuid": {
-      "version": "9.0.1",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-9.0.1.tgz",
-      "integrity": "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==",
-      "funding": [
-        "https://github.com/sponsors/broofa",
-        "https://github.com/sponsors/ctavan"
-      ],
-      "license": "MIT",
-      "bin": {
-        "uuid": "dist/bin/uuid"
-      }
-    },
-    "node_modules/gcp-metadata": {
-      "version": "6.1.1",
-      "resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.1.tgz",
-      "integrity": "sha512-a4tiq7E0/5fTjxPAaH4jpjkSv/uCaU2p5KC6HVGrvl0cDjA8iBZv4vv1gyzlmK0ZUKqwpOyQMKzZQe3lTit77A==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "gaxios": "^6.1.1",
-        "google-logging-utils": "^0.0.2",
-        "json-bigint": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=14"
-      }
-    },
-    "node_modules/get-intrinsic": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
-      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.2",
-        "es-define-property": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.1.1",
-        "function-bind": "^1.1.2",
-        "get-proto": "^1.0.1",
-        "gopd": "^1.2.0",
-        "has-symbols": "^1.1.0",
-        "hasown": "^2.0.2",
-        "math-intrinsics": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/get-proto": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
-      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
-      "license": "MIT",
-      "dependencies": {
-        "dunder-proto": "^1.0.1",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/get-tsconfig": {
-      "version": "4.10.0",
-      "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.10.0.tgz",
-      "integrity": "sha512-kGzZ3LWWQcGIAmg6iWvXn0ei6WDtV26wzHRMwDSzmAbcXrTEXxHy6IehI6/4eT6VRKyMP1eF1VqwrVUmE/LR7A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "resolve-pkg-maps": "^1.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
-      }
-    },
-    "node_modules/glob": {
-      "version": "10.4.5",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
-      "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "foreground-child": "^3.1.0",
-        "jackspeak": "^3.1.2",
-        "minimatch": "^9.0.4",
-        "minipass": "^7.1.2",
-        "package-json-from-dist": "^1.0.0",
-        "path-scurry": "^1.11.1"
-      },
-      "bin": {
-        "glob": "dist/esm/bin.mjs"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/glob-parent": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
-      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "is-glob": "^4.0.3"
-      },
-      "engines": {
-        "node": ">=10.13.0"
-      }
-    },
-    "node_modules/globals": {
-      "version": "15.15.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-15.15.0.tgz",
-      "integrity": "sha512-7ACyT3wmyp3I61S4fG682L0VA2RGD9otkqGJIwNUMF1SWUombIIk+af1unuDYgMm082aHYwD+mzJvv9Iu8dsgg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/globby": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz",
-      "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "array-union": "^2.1.0",
-        "dir-glob": "^3.0.1",
-        "fast-glob": "^3.2.9",
-        "ignore": "^5.2.0",
-        "merge2": "^1.4.1",
-        "slash": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/google-auth-library": {
-      "version": "9.15.1",
-      "resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz",
-      "integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "base64-js": "^1.3.0",
-        "ecdsa-sig-formatter": "^1.0.11",
-        "gaxios": "^6.1.1",
-        "gcp-metadata": "^6.1.0",
-        "gtoken": "^7.0.0",
-        "jws": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=14"
-      }
-    },
-    "node_modules/google-logging-utils": {
-      "version": "0.0.2",
-      "resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-0.0.2.tgz",
-      "integrity": "sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ==",
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=14"
-      }
-    },
-    "node_modules/gopd": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
-      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/graceful-fs": {
-      "version": "4.2.11",
-      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
-      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/graphemer": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz",
-      "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/gtoken": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
-      "integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
-      "license": "MIT",
-      "dependencies": {
-        "gaxios": "^6.0.0",
-        "jws": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=14.0.0"
-      }
-    },
-    "node_modules/has-flag": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/has-symbols": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
-      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-tostringtag": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
-      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
-      "license": "MIT",
-      "dependencies": {
-        "has-symbols": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/hasown": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
-      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
-      "license": "MIT",
-      "dependencies": {
-        "function-bind": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/help-me": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/help-me/-/help-me-5.0.0.tgz",
-      "integrity": "sha512-7xgomUX6ADmcYzFik0HzAxh/73YlKR9bmFzf51CZwR+b6YtzU2m0u49hQCqV6SvlqIqsaxovfwdvbnsw3b/zpg==",
-      "license": "MIT"
-    },
-    "node_modules/htmlparser2": {
-      "version": "9.1.0",
-      "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-9.1.0.tgz",
-      "integrity": "sha512-5zfg6mHUoaer/97TxnGpxmbR7zJtPwIYFMZ/H5ucTlPZhKvtum05yiPK3Mgai3a0DyVxv7qYqoweaEd2nrYQzQ==",
-      "dev": true,
-      "funding": [
-        "https://github.com/fb55/htmlparser2?sponsor=1",
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fb55"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "domelementtype": "^2.3.0",
-        "domhandler": "^5.0.3",
-        "domutils": "^3.1.0",
-        "entities": "^4.5.0"
-      }
-    },
-    "node_modules/http-errors": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
-      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "depd": "2.0.0",
-        "inherits": "2.0.4",
-        "setprototypeof": "1.2.0",
-        "statuses": "2.0.1",
-        "toidentifier": "1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/https-proxy-agent": {
-      "version": "7.0.6",
-      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
-      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
-      "license": "MIT",
-      "dependencies": {
-        "agent-base": "^7.1.2",
-        "debug": "4"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/human-id": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/human-id/-/human-id-4.1.1.tgz",
-      "integrity": "sha512-3gKm/gCSUipeLsRYZbbdA1BD83lBoWUkZ7G9VFrhWPAU76KwYo5KR8V28bpoPm/ygy0x5/GCbpRQdY7VLYCoIg==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "human-id": "dist/cli.js"
-      }
-    },
-    "node_modules/humanize-ms": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz",
-      "integrity": "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.0.0"
-      }
-    },
-    "node_modules/iconv-lite": {
-      "version": "0.6.3",
-      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
-      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "safer-buffer": ">= 2.1.2 < 3.0.0"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/ignore": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
-      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4"
-      }
-    },
-    "node_modules/import-fresh": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
-      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "parent-module": "^1.0.0",
-        "resolve-from": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/import-fresh/node_modules/resolve-from": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
-      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/imurmurhash": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
-      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.8.19"
-      }
-    },
-    "node_modules/inherits": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/install": {
-      "version": "0.13.0",
-      "resolved": "https://registry.npmjs.org/install/-/install-0.13.0.tgz",
-      "integrity": "sha512-zDml/jzr2PKU9I8J/xyZBQn8rPCAY//UOYNmR01XwNwyfhEWObo2SWfSl1+0tm1u6PhxLwDnfsT/6jB7OUxqFA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/ipaddr.js": {
-      "version": "1.9.1",
-      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
-      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/is-any-array": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/is-any-array/-/is-any-array-2.0.1.tgz",
-      "integrity": "sha512-UtilS7hLRu++wb/WBAw9bNuP1Eg04Ivn1vERJck8zJthEvXCBEBpGR/33u/xLKWEQf95803oalHrVDptcAvFdQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/is-buffer": {
-      "version": "1.1.6",
-      "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz",
-      "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/is-extglob": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
-      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-fullwidth-code-point": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
-      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/is-glob": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
-      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-extglob": "^2.1.1"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-number": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
-      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.12.0"
-      }
-    },
-    "node_modules/is-reference": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-3.0.3.tgz",
-      "integrity": "sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@types/estree": "^1.0.6"
-      }
-    },
-    "node_modules/is-stream": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
-      "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/is-subdir": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/is-subdir/-/is-subdir-1.2.0.tgz",
-      "integrity": "sha512-2AT6j+gXe/1ueqbW6fLZJiIw3F8iXGJtt0yDrZaBhAZEG1raiTxKWU+IPqMCzQAXOUCKdA4UDMgacKH25XG2Cw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "better-path-resolve": "1.0.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/is-windows": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz",
-      "integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/isarray": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
-      "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/isexe": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/jackspeak": {
-      "version": "3.4.3",
-      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz",
-      "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "@isaacs/cliui": "^8.0.2"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      },
-      "optionalDependencies": {
-        "@pkgjs/parseargs": "^0.11.0"
-      }
-    },
-    "node_modules/joycon": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/joycon/-/joycon-3.1.1.tgz",
-      "integrity": "sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/js-levenshtein": {
-      "version": "1.1.6",
-      "resolved": "https://registry.npmjs.org/js-levenshtein/-/js-levenshtein-1.1.6.tgz",
-      "integrity": "sha512-X2BB11YZtrRqY4EnQcLX5Rh373zbK4alC1FW7D7MBhL2gtcC17cTnr6DmfHZeS0s2rTHjUTMMHfG7gO8SSdw+g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/js-tiktoken": {
-      "version": "1.0.19",
-      "resolved": "https://registry.npmjs.org/js-tiktoken/-/js-tiktoken-1.0.19.tgz",
-      "integrity": "sha512-XC63YQeEcS47Y53gg950xiZ4IWmkfMe4p2V9OSaBt26q+p47WHn18izuXzSclCI73B7yGqtfRsT6jcZQI0y08g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "base64-js": "^1.5.1"
-      }
-    },
-    "node_modules/js-yaml": {
-      "version": "3.14.1",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz",
-      "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "argparse": "^1.0.7",
-        "esprima": "^4.0.0"
-      },
-      "bin": {
-        "js-yaml": "bin/js-yaml.js"
-      }
-    },
-    "node_modules/js-yaml/node_modules/argparse": {
-      "version": "1.0.10",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
-      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "sprintf-js": "~1.0.2"
-      }
-    },
-    "node_modules/json-bigint": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/json-bigint/-/json-bigint-1.0.0.tgz",
-      "integrity": "sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==",
-      "license": "MIT",
-      "dependencies": {
-        "bignumber.js": "^9.0.0"
-      }
-    },
-    "node_modules/json-buffer": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
-      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/json-schema": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.4.0.tgz",
-      "integrity": "sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==",
-      "dev": true,
-      "license": "(AFL-2.1 OR BSD-3-Clause)"
-    },
-    "node_modules/json-schema-traverse": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
-      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/json-stable-stringify-without-jsonify": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
-      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/jsondiffpatch": {
-      "version": "0.6.0",
-      "resolved": "https://registry.npmjs.org/jsondiffpatch/-/jsondiffpatch-0.6.0.tgz",
-      "integrity": "sha512-3QItJOXp2AP1uv7waBkao5nCvhEv+QmJAd38Ybq7wNI74Q+BBmnLn4EDKz6yI9xGAIQoUF87qHt+kc1IVxB4zQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/diff-match-patch": "^1.0.36",
-        "chalk": "^5.3.0",
-        "diff-match-patch": "^1.0.5"
-      },
-      "bin": {
-        "jsondiffpatch": "bin/jsondiffpatch.js"
-      },
-      "engines": {
-        "node": "^18.0.0 || >=20.0.0"
-      }
-    },
-    "node_modules/jsonfile": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz",
-      "integrity": "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==",
-      "dev": true,
-      "license": "MIT",
-      "optionalDependencies": {
-        "graceful-fs": "^4.1.6"
-      }
-    },
-    "node_modules/jwa": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.0.tgz",
-      "integrity": "sha512-jrZ2Qx916EA+fq9cEAeCROWPTfCwi1IVHqT2tapuqLEVVDKFDENFw1oL+MwrTvH6msKxsd1YTDVw6uKEcsrLEA==",
-      "license": "MIT",
-      "dependencies": {
-        "buffer-equal-constant-time": "1.0.1",
-        "ecdsa-sig-formatter": "1.0.11",
-        "safe-buffer": "^5.0.1"
-      }
-    },
-    "node_modules/jws": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/jws/-/jws-4.0.0.tgz",
-      "integrity": "sha512-KDncfTmOZoOMTFG4mBlG0qUIOlc03fmzH+ru6RgYVZhPkyiy/92Owlt/8UEN+a4TXR1FQetfIpJE8ApdvdVxTg==",
-      "license": "MIT",
-      "dependencies": {
-        "jwa": "^2.0.0",
-        "safe-buffer": "^5.0.1"
-      }
-    },
-    "node_modules/keyv": {
-      "version": "4.5.4",
-      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
-      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "json-buffer": "3.0.1"
-      }
-    },
-    "node_modules/langsmith": {
-      "version": "0.3.13",
-      "resolved": "https://registry.npmjs.org/langsmith/-/langsmith-0.3.13.tgz",
-      "integrity": "sha512-iI5MO5FP1EFxU1jyQvB2cM4qKqXXwnsd124MKWWhBuV2O/EjdwzsyKPBVlBPFjAQbgCGtzqdJWbv9xld60hb+Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/uuid": "^10.0.0",
-        "chalk": "^4.1.2",
-        "console-table-printer": "^2.12.1",
-        "p-queue": "^6.6.2",
-        "p-retry": "4",
-        "semver": "^7.6.3",
-        "uuid": "^10.0.0"
-      },
-      "peerDependencies": {
-        "openai": "*"
-      },
-      "peerDependenciesMeta": {
-        "openai": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/langsmith/node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/langsmith/node_modules/chalk": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.1.0",
-        "supports-color": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
-      }
-    },
-    "node_modules/levn": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
-      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "prelude-ls": "^1.2.1",
-        "type-check": "~0.4.0"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/lilconfig": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
-      "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/antonk52"
-      }
-    },
-    "node_modules/linear-sum-assignment": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/linear-sum-assignment/-/linear-sum-assignment-1.0.7.tgz",
-      "integrity": "sha512-jfLoSGwZNyjfY8eK4ayhjfcIu3BfWvP6sWieYzYI3AWldwXVoWEz1gtrQL10v/8YltYLBunqNjeVFXPMUs+MJg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "cheminfo-types": "^1.7.3",
-        "install": "^0.13.0",
-        "ml-matrix": "^6.11.0",
-        "ml-spectra-processing": "^14.2.2"
-      }
-    },
-    "node_modules/lines-and-columns": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
-      "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/load-tsconfig": {
-      "version": "0.2.5",
-      "resolved": "https://registry.npmjs.org/load-tsconfig/-/load-tsconfig-0.2.5.tgz",
-      "integrity": "sha512-IXO6OCs9yg8tMKzfPZ1YmheJbZCiEsnBdcB03l0OcfK9prKnJb96siuHCr5Fl37/yo9DnKU+TLpxzTUspw9shg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      }
-    },
-    "node_modules/locate-character": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/locate-character/-/locate-character-3.0.0.tgz",
-      "integrity": "sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true
-    },
-    "node_modules/locate-path": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz",
-      "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-locate": "^4.1.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/lodash.merge": {
-      "version": "4.6.2",
-      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
-      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/lodash.startcase": {
-      "version": "4.4.0",
-      "resolved": "https://registry.npmjs.org/lodash.startcase/-/lodash.startcase-4.4.0.tgz",
-      "integrity": "sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/lru-cache": {
-      "version": "10.4.3",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
-      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/magic-string": {
-      "version": "0.30.17",
-      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz",
-      "integrity": "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@jridgewell/sourcemap-codec": "^1.5.0"
-      }
-    },
-    "node_modules/math-intrinsics": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
-      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/md5": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/md5/-/md5-2.3.0.tgz",
-      "integrity": "sha512-T1GITYmFaKuO91vxyoQMFETst+O71VUPEU3ze5GNzDm0OWdP8v1ziTaAEPUr/3kLsY3Sftgz242A1SetQiDL7g==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "charenc": "0.0.2",
-        "crypt": "0.0.2",
-        "is-buffer": "~1.1.6"
-      }
-    },
-    "node_modules/media-typer": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
-      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/merge-descriptors": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
-      "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/merge2": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
-      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/methods": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
-      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/micromatch": {
-      "version": "4.0.8",
-      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
-      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "braces": "^3.0.3",
-        "picomatch": "^2.3.1"
-      },
-      "engines": {
-        "node": ">=8.6"
-      }
-    },
-    "node_modules/mime": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
-      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "mime": "cli.js"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/mime-db": {
-      "version": "1.52.0",
-      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
-      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/mime-types": {
-      "version": "2.1.35",
-      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
-      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
-      "license": "MIT",
-      "dependencies": {
-        "mime-db": "1.52.0"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/minimatch": {
-      "version": "9.0.5",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
-      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=16 || 14 >=14.17"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/minimist": {
-      "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
-      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/minipass": {
-      "version": "7.1.2",
-      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
-      "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": ">=16 || 14 >=14.17"
-      }
-    },
-    "node_modules/mitt": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz",
-      "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/mkdirp": {
-      "version": "0.5.6",
-      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz",
-      "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "minimist": "^1.2.6"
-      },
-      "bin": {
-        "mkdirp": "bin/cmd.js"
-      }
-    },
-    "node_modules/ml-array-max": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/ml-array-max/-/ml-array-max-1.2.4.tgz",
-      "integrity": "sha512-BlEeg80jI0tW6WaPyGxf5Sa4sqvcyY6lbSn5Vcv44lp1I2GR6AWojfUvLnGTNsIXrZ8uqWmo8VcG1WpkI2ONMQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-any-array": "^2.0.0"
-      }
-    },
-    "node_modules/ml-array-min": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/ml-array-min/-/ml-array-min-1.2.3.tgz",
-      "integrity": "sha512-VcZ5f3VZ1iihtrGvgfh/q0XlMobG6GQ8FsNyQXD3T+IlstDv85g8kfV0xUG1QPRO/t21aukaJowDzMTc7j5V6Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-any-array": "^2.0.0"
-      }
-    },
-    "node_modules/ml-array-rescale": {
-      "version": "1.3.7",
-      "resolved": "https://registry.npmjs.org/ml-array-rescale/-/ml-array-rescale-1.3.7.tgz",
-      "integrity": "sha512-48NGChTouvEo9KBctDfHC3udWnQKNKEWN0ziELvY3KG25GR5cA8K8wNVzracsqSW1QEkAXjTNx+ycgAv06/1mQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-any-array": "^2.0.0",
-        "ml-array-max": "^1.2.4",
-        "ml-array-min": "^1.2.3"
-      }
-    },
-    "node_modules/ml-matrix": {
-      "version": "6.12.1",
-      "resolved": "https://registry.npmjs.org/ml-matrix/-/ml-matrix-6.12.1.tgz",
-      "integrity": "sha512-TJ+8eOFdp+INvzR4zAuwBQJznDUfktMtOB6g/hUcGh3rcyjxbz4Te57Pgri8Q9bhSQ7Zys4IYOGhFdnlgeB6Lw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-any-array": "^2.0.1",
-        "ml-array-rescale": "^1.3.7"
-      }
-    },
-    "node_modules/ml-spectra-processing": {
-      "version": "14.10.0",
-      "resolved": "https://registry.npmjs.org/ml-spectra-processing/-/ml-spectra-processing-14.10.0.tgz",
-      "integrity": "sha512-4fyF6tojgVgh6m9nmFvaIlGhrvHq+swn64IxQ44F4k4o7Qkl8xKOJWfQ4EsfoX66GqZn2PFfcn1xUGRNwB8+3w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "binary-search": "^1.3.6",
-        "cheminfo-types": "^1.8.1",
-        "fft.js": "^4.0.4",
-        "is-any-array": "^2.0.1",
-        "ml-matrix": "^6.12.0",
-        "ml-xsadd": "^3.0.1"
-      }
-    },
-    "node_modules/ml-xsadd": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/ml-xsadd/-/ml-xsadd-3.0.1.tgz",
-      "integrity": "sha512-Fz2q6dwgzGM8wYKGArTUTZDGa4lQFA2Vi6orjGeTVRy22ZnQFKlJuwS9n8NRviqz1KHAHAzdKJwbnYhdo38uYg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/mri": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/mri/-/mri-1.2.0.tgz",
-      "integrity": "sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "license": "MIT"
-    },
-    "node_modules/multer": {
-      "version": "1.4.5-lts.1",
-      "resolved": "https://registry.npmjs.org/multer/-/multer-1.4.5-lts.1.tgz",
-      "integrity": "sha512-ywPWvcDMeH+z9gQq5qYHCCy+ethsk4goepZ45GLD63fOu0YcNecQxi64nDs3qluZB+murG3/D4dJ7+dGctcCQQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "append-field": "^1.0.0",
-        "busboy": "^1.0.0",
-        "concat-stream": "^1.5.2",
-        "mkdirp": "^0.5.4",
-        "object-assign": "^4.1.1",
-        "type-is": "^1.6.4",
-        "xtend": "^4.0.0"
-      },
-      "engines": {
-        "node": ">= 6.0.0"
-      }
-    },
-    "node_modules/mustache": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/mustache/-/mustache-4.2.0.tgz",
-      "integrity": "sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "mustache": "bin/mustache"
-      }
-    },
-    "node_modules/mz": {
-      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz",
-      "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "any-promise": "^1.0.0",
-        "object-assign": "^4.0.1",
-        "thenify-all": "^1.0.0"
-      }
-    },
-    "node_modules/nanoid": {
-      "version": "3.3.9",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.9.tgz",
-      "integrity": "sha512-SppoicMGpZvbF1l3z4x7No3OlIjP7QJvC9XR7AhZr1kL133KHnKPztkKDc+Ir4aJ/1VhTySrtKhrsycmrMQfvg==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "MIT",
-      "bin": {
-        "nanoid": "bin/nanoid.cjs"
-      },
-      "engines": {
-        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
-      }
-    },
-    "node_modules/natural-compare": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
-      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/negotiator": {
-      "version": "0.6.3",
-      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
-      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/node-domexception": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz",
-      "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/jimmywarting"
-        },
-        {
-          "type": "github",
-          "url": "https://paypal.me/jimmywarting"
-        }
-      ],
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.5.0"
-      }
-    },
-    "node_modules/node-fetch": {
-      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
-      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
-      "license": "MIT",
-      "dependencies": {
-        "whatwg-url": "^5.0.0"
-      },
-      "engines": {
-        "node": "4.x || >=6.0.0"
-      },
-      "peerDependencies": {
-        "encoding": "^0.1.0"
-      },
-      "peerDependenciesMeta": {
-        "encoding": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/nth-check": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz",
-      "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "boolbase": "^1.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/nth-check?sponsor=1"
-      }
-    },
-    "node_modules/object-assign": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
-      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/object-inspect": {
-      "version": "1.13.4",
-      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
-      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/on-exit-leak-free": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/on-exit-leak-free/-/on-exit-leak-free-2.1.2.tgz",
-      "integrity": "sha512-0eJJY6hXLGf1udHwfNftBqH+g73EU4B504nZeKpz1sYRKafAghwxEJunB2O7rDZkL4PGfsMVnTXZ2EjibbqcsA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=14.0.0"
-      }
-    },
-    "node_modules/on-finished": {
-      "version": "2.4.1",
-      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
-      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ee-first": "1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/once": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
-      "license": "ISC",
-      "dependencies": {
-        "wrappy": "1"
-      }
-    },
-    "node_modules/openai": {
-      "version": "4.87.3",
-      "resolved": "https://registry.npmjs.org/openai/-/openai-4.87.3.tgz",
-      "integrity": "sha512-d2D54fzMuBYTxMW8wcNmhT1rYKcTfMJ8t+4KjH2KtvYenygITiGBgHoIrzHwnDQWW+C5oCA+ikIR2jgPCFqcKQ==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@types/node": "^18.11.18",
-        "@types/node-fetch": "^2.6.4",
-        "abort-controller": "^3.0.0",
-        "agentkeepalive": "^4.2.1",
-        "form-data-encoder": "1.7.2",
-        "formdata-node": "^4.3.2",
-        "node-fetch": "^2.6.7"
-      },
-      "bin": {
-        "openai": "bin/cli"
-      },
-      "peerDependencies": {
-        "ws": "^8.18.0",
-        "zod": "^3.23.8"
-      },
-      "peerDependenciesMeta": {
-        "ws": {
-          "optional": true
-        },
-        "zod": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/openai/node_modules/@types/node": {
-      "version": "18.19.80",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.80.tgz",
-      "integrity": "sha512-kEWeMwMeIvxYkeg1gTc01awpwLbfMRZXdIhwRcakd/KlK53jmRC26LqcbIt7fnAQTu5GzlnWmzA3H6+l1u6xxQ==",
-      "license": "MIT",
-      "dependencies": {
-        "undici-types": "~5.26.4"
-      }
-    },
-    "node_modules/openai/node_modules/undici-types": {
-      "version": "5.26.5",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
-      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
-      "license": "MIT"
-    },
-    "node_modules/openapi3-ts": {
-      "version": "4.4.0",
-      "resolved": "https://registry.npmjs.org/openapi3-ts/-/openapi3-ts-4.4.0.tgz",
-      "integrity": "sha512-9asTNB9IkKEzWMcHmVZE7Ts3kC9G7AFHfs8i7caD8HbI76gEjdkId4z/AkP83xdZsH7PLAnnbl47qZkXuxpArw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "yaml": "^2.5.0"
-      }
-    },
-    "node_modules/optionator": {
-      "version": "0.9.4",
-      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
-      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "deep-is": "^0.1.3",
-        "fast-levenshtein": "^2.0.6",
-        "levn": "^0.4.1",
-        "prelude-ls": "^1.2.1",
-        "type-check": "^0.4.0",
-        "word-wrap": "^1.2.5"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/os-tmpdir": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz",
-      "integrity": "sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/outdent": {
-      "version": "0.5.0",
-      "resolved": "https://registry.npmjs.org/outdent/-/outdent-0.5.0.tgz",
-      "integrity": "sha512-/jHxFIzoMXdqPzTaCpFzAAWhpkSjZPF4Vsn6jAfNpmbH/ymsmd7Qc6VE9BGn0L6YMj6uwpQLxCECpus4ukKS9Q==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/p-filter": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/p-filter/-/p-filter-2.1.0.tgz",
-      "integrity": "sha512-ZBxxZ5sL2HghephhpGAQdoskxplTwr7ICaehZwLIlfL6acuVgZPm8yBNuRAFBGEqtD/hmUeq9eqLg2ys9Xr/yw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-map": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/p-finally": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz",
-      "integrity": "sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/p-limit": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz",
-      "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-try": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/p-locate": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz",
-      "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-limit": "^2.2.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/p-map": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/p-map/-/p-map-2.1.0.tgz",
-      "integrity": "sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/p-queue": {
-      "version": "6.6.2",
-      "resolved": "https://registry.npmjs.org/p-queue/-/p-queue-6.6.2.tgz",
-      "integrity": "sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "eventemitter3": "^4.0.4",
-        "p-timeout": "^3.2.0"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/p-retry": {
-      "version": "4.6.2",
-      "resolved": "https://registry.npmjs.org/p-retry/-/p-retry-4.6.2.tgz",
-      "integrity": "sha512-312Id396EbJdvRONlngUx0NydfrIQ5lsYu0znKVUzVvArzEIt08V1qhtyESbGVd1FGX7UKtiFp5uwKZdM8wIuQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/retry": "0.12.0",
-        "retry": "^0.13.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/p-timeout": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/p-timeout/-/p-timeout-3.2.0.tgz",
-      "integrity": "sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-finally": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/p-try": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz",
-      "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/package-json-from-dist": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
-      "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
-      "dev": true,
-      "license": "BlueOak-1.0.0"
-    },
-    "node_modules/package-manager-detector": {
-      "version": "0.2.11",
-      "resolved": "https://registry.npmjs.org/package-manager-detector/-/package-manager-detector-0.2.11.tgz",
-      "integrity": "sha512-BEnLolu+yuz22S56CU1SUKq3XC3PkwD5wv4ikR4MfGvnRVcmzXR9DwSlW2fEamyTPyXHomBJRzgapeuBvRNzJQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "quansync": "^0.2.7"
-      }
-    },
-    "node_modules/parent-module": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
-      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "callsites": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/parse5": {
-      "version": "7.2.1",
-      "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.2.1.tgz",
-      "integrity": "sha512-BuBYQYlv1ckiPdQi/ohiivi9Sagc9JG+Ozs0r7b/0iK3sKmrb0b9FdWdBbOdx6hBCM/F9Ir82ofnBhtZOjCRPQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "entities": "^4.5.0"
-      },
-      "funding": {
-        "url": "https://github.com/inikulin/parse5?sponsor=1"
-      }
-    },
-    "node_modules/parse5-htmlparser2-tree-adapter": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.1.0.tgz",
-      "integrity": "sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "domhandler": "^5.0.3",
-        "parse5": "^7.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/inikulin/parse5?sponsor=1"
-      }
-    },
-    "node_modules/parse5-parser-stream": {
-      "version": "7.1.2",
-      "resolved": "https://registry.npmjs.org/parse5-parser-stream/-/parse5-parser-stream-7.1.2.tgz",
-      "integrity": "sha512-JyeQc9iwFLn5TbvvqACIF/VXG6abODeB3Fwmv/TGdLk2LfbWkaySGY72at4+Ty7EkPZj854u4CrICqNk2qIbow==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "parse5": "^7.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/inikulin/parse5?sponsor=1"
-      }
-    },
-    "node_modules/parseurl": {
-      "version": "1.3.3",
-      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
-      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/path-exists": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
-      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/path-key": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
-      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/path-scurry": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz",
-      "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "lru-cache": "^10.2.0",
-        "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0"
-      },
-      "engines": {
-        "node": ">=16 || 14 >=14.18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/path-to-regexp": {
-      "version": "0.1.12",
-      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz",
-      "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/path-type": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
-      "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/picocolors": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
-      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/picomatch": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8.6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
-      }
-    },
-    "node_modules/pify": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz",
-      "integrity": "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/pino": {
-      "version": "9.6.0",
-      "resolved": "https://registry.npmjs.org/pino/-/pino-9.6.0.tgz",
-      "integrity": "sha512-i85pKRCt4qMjZ1+L7sy2Ag4t1atFcdbEt76+7iRJn1g2BvsnRMGu9p8pivl9fs63M2kF/A0OacFZhTub+m/qMg==",
-      "license": "MIT",
-      "dependencies": {
-        "atomic-sleep": "^1.0.0",
-        "fast-redact": "^3.1.1",
-        "on-exit-leak-free": "^2.1.0",
-        "pino-abstract-transport": "^2.0.0",
-        "pino-std-serializers": "^7.0.0",
-        "process-warning": "^4.0.0",
-        "quick-format-unescaped": "^4.0.3",
-        "real-require": "^0.2.0",
-        "safe-stable-stringify": "^2.3.1",
-        "sonic-boom": "^4.0.1",
-        "thread-stream": "^3.0.0"
-      },
-      "bin": {
-        "pino": "bin.js"
-      }
-    },
-    "node_modules/pino-abstract-transport": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/pino-abstract-transport/-/pino-abstract-transport-2.0.0.tgz",
-      "integrity": "sha512-F63x5tizV6WCh4R6RHyi2Ml+M70DNRXt/+HANowMflpgGFMAym/VKm6G7ZOQRjqN7XbGxK1Lg9t6ZrtzOaivMw==",
-      "license": "MIT",
-      "dependencies": {
-        "split2": "^4.0.0"
-      }
-    },
-    "node_modules/pino-pretty": {
-      "version": "13.0.0",
-      "resolved": "https://registry.npmjs.org/pino-pretty/-/pino-pretty-13.0.0.tgz",
-      "integrity": "sha512-cQBBIVG3YajgoUjo1FdKVRX6t9XPxwB9lcNJVD5GCnNM4Y6T12YYx8c6zEejxQsU0wrg9TwmDulcE9LR7qcJqA==",
-      "license": "MIT",
-      "dependencies": {
-        "colorette": "^2.0.7",
-        "dateformat": "^4.6.3",
-        "fast-copy": "^3.0.2",
-        "fast-safe-stringify": "^2.1.1",
-        "help-me": "^5.0.0",
-        "joycon": "^3.1.1",
-        "minimist": "^1.2.6",
-        "on-exit-leak-free": "^2.1.0",
-        "pino-abstract-transport": "^2.0.0",
-        "pump": "^3.0.0",
-        "secure-json-parse": "^2.4.0",
-        "sonic-boom": "^4.0.1",
-        "strip-json-comments": "^3.1.1"
-      },
-      "bin": {
-        "pino-pretty": "bin.js"
-      }
-    },
-    "node_modules/pino-std-serializers": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/pino-std-serializers/-/pino-std-serializers-7.0.0.tgz",
-      "integrity": "sha512-e906FRY0+tV27iq4juKzSYPbUj2do2X2JX4EzSca1631EB2QJQUqGbDuERal7LCtOpxl6x3+nvo9NPZcmjkiFA==",
-      "license": "MIT"
-    },
-    "node_modules/pirates": {
-      "version": "4.0.6",
-      "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.6.tgz",
-      "integrity": "sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/playwright": {
-      "version": "1.51.0",
-      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.51.0.tgz",
-      "integrity": "sha512-442pTfGM0xxfCYxuBa/Pu6B2OqxqqaYq39JS8QDMGThUvIOCd6s0ANDog3uwA0cHavVlnTQzGCN7Id2YekDSXA==",
-      "license": "Apache-2.0",
-      "peer": true,
-      "dependencies": {
-        "playwright-core": "1.51.0"
-      },
-      "bin": {
-        "playwright": "cli.js"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "optionalDependencies": {
-        "fsevents": "2.3.2"
-      }
-    },
-    "node_modules/playwright-core": {
-      "version": "1.51.0",
-      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.51.0.tgz",
-      "integrity": "sha512-x47yPE3Zwhlil7wlNU/iktF7t2r/URR3VLbH6EknJd/04Qc/PSJ0EY3CMXipmglLG+zyRxW6HNo2EGbKLHPWMg==",
-      "license": "Apache-2.0",
-      "peer": true,
-      "bin": {
-        "playwright-core": "cli.js"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/pluralize": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/pluralize/-/pluralize-8.0.0.tgz",
-      "integrity": "sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/postcss": {
-      "version": "8.5.3",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.3.tgz",
-      "integrity": "sha512-dle9A3yYxlBSrt8Fu+IpjGT8SY8hN0mlaA6GY8t0P5PjIOZemULz/E2Bnm/2dcUOena75OTNkHI76uZBNUUq3A==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/postcss/"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/postcss"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "nanoid": "^3.3.8",
-        "picocolors": "^1.1.1",
-        "source-map-js": "^1.2.1"
-      },
-      "engines": {
-        "node": "^10 || ^12 || >=14"
-      }
-    },
-    "node_modules/postcss-load-config": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-6.0.1.tgz",
-      "integrity": "sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/postcss/"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "lilconfig": "^3.1.1"
-      },
-      "engines": {
-        "node": ">= 18"
-      },
-      "peerDependencies": {
-        "jiti": ">=1.21.0",
-        "postcss": ">=8.0.9",
-        "tsx": "^4.8.1",
-        "yaml": "^2.4.2"
-      },
-      "peerDependenciesMeta": {
-        "jiti": {
-          "optional": true
-        },
-        "postcss": {
-          "optional": true
-        },
-        "tsx": {
-          "optional": true
-        },
-        "yaml": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/prelude-ls": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
-      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/prettier": {
-      "version": "3.5.3",
-      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.5.3.tgz",
-      "integrity": "sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "prettier": "bin/prettier.cjs"
-      },
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/prettier/prettier?sponsor=1"
-      }
-    },
-    "node_modules/process-nextick-args": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
-      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/process-warning": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/process-warning/-/process-warning-4.0.1.tgz",
-      "integrity": "sha512-3c2LzQ3rY9d0hc1emcsHhfT9Jwz0cChib/QN89oME2R451w5fy3f0afAhERFZAwrbDU43wk12d0ORBpDVME50Q==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/proxy-addr": {
-      "version": "2.0.7",
-      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
-      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "forwarded": "0.2.0",
-        "ipaddr.js": "1.9.1"
-      },
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/pump": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.2.tgz",
-      "integrity": "sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw==",
-      "license": "MIT",
-      "dependencies": {
-        "end-of-stream": "^1.1.0",
-        "once": "^1.3.1"
-      }
-    },
-    "node_modules/punycode": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
-      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/qs": {
-      "version": "6.13.0",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz",
-      "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "side-channel": "^1.0.6"
-      },
-      "engines": {
-        "node": ">=0.6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/quansync": {
-      "version": "0.2.8",
-      "resolved": "https://registry.npmjs.org/quansync/-/quansync-0.2.8.tgz",
-      "integrity": "sha512-4+saucphJMazjt7iOM27mbFCk+D9dd/zmgMDCzRZ8MEoBfYp7lAvoN38et/phRQF6wOPMy/OROBGgoWeSKyluA==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "individual",
-          "url": "https://github.com/sponsors/antfu"
-        },
-        {
-          "type": "individual",
-          "url": "https://github.com/sponsors/sxzz"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/queue-microtask": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
-      "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/quick-format-unescaped": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/quick-format-unescaped/-/quick-format-unescaped-4.0.4.tgz",
-      "integrity": "sha512-tYC1Q1hgyRuHgloV/YXs2w15unPVh8qfu/qCTfhTYamaw7fyhumKa2yGpdSo87vY32rIclj+4fWYQXUMs9EHvg==",
-      "license": "MIT"
-    },
-    "node_modules/range-parser": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
-      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/raw-body": {
-      "version": "2.5.2",
-      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz",
-      "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "bytes": "3.1.2",
-        "http-errors": "2.0.0",
-        "iconv-lite": "0.4.24",
-        "unpipe": "1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/raw-body/node_modules/iconv-lite": {
-      "version": "0.4.24",
-      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
-      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "safer-buffer": ">= 2.1.2 < 3"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/react": {
-      "version": "19.0.0",
-      "resolved": "https://registry.npmjs.org/react/-/react-19.0.0.tgz",
-      "integrity": "sha512-V8AVnmPIICiWpGfm6GLzCR/W5FXLchHop40W4nXBmdlEceh16rCN8O8LNWm5bh5XUX91fh7KpA+W0TgMKmgTpQ==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/read-yaml-file": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/read-yaml-file/-/read-yaml-file-1.1.0.tgz",
-      "integrity": "sha512-VIMnQi/Z4HT2Fxuwg5KrY174U1VdUIASQVWXXyqtNRtxSr9IYkn1rsI6Tb6HsrHCmB7gVpNwX6JxPTHcH6IoTA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "graceful-fs": "^4.1.5",
-        "js-yaml": "^3.6.1",
-        "pify": "^4.0.1",
-        "strip-bom": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/readable-stream": {
-      "version": "2.3.8",
-      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
-      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "core-util-is": "~1.0.0",
-        "inherits": "~2.0.3",
-        "isarray": "~1.0.0",
-        "process-nextick-args": "~2.0.0",
-        "safe-buffer": "~5.1.1",
-        "string_decoder": "~1.1.1",
-        "util-deprecate": "~1.0.1"
-      }
-    },
-    "node_modules/readable-stream/node_modules/safe-buffer": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/readdirp": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz",
-      "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 14.18.0"
-      },
-      "funding": {
-        "type": "individual",
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/real-require": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/real-require/-/real-require-0.2.0.tgz",
-      "integrity": "sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 12.13.0"
-      }
-    },
-    "node_modules/regenerator-runtime": {
-      "version": "0.14.1",
-      "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz",
-      "integrity": "sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/resolve-from": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz",
-      "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/resolve-pkg-maps": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz",
-      "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
-      }
-    },
-    "node_modules/retry": {
-      "version": "0.13.1",
-      "resolved": "https://registry.npmjs.org/retry/-/retry-0.13.1.tgz",
-      "integrity": "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4"
-      }
-    },
-    "node_modules/reusify": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
-      "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "iojs": ">=1.0.0",
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/rollup": {
-      "version": "4.35.0",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.35.0.tgz",
-      "integrity": "sha512-kg6oI4g+vc41vePJyO6dHt/yl0Rz3Thv0kJeVQ3D1kS3E5XSuKbPc29G4IpT/Kv1KQwgHVcN+HtyS+HYLNSvQg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/estree": "1.0.6"
-      },
-      "bin": {
-        "rollup": "dist/bin/rollup"
-      },
-      "engines": {
-        "node": ">=18.0.0",
-        "npm": ">=8.0.0"
-      },
-      "optionalDependencies": {
-        "@rollup/rollup-android-arm-eabi": "4.35.0",
-        "@rollup/rollup-android-arm64": "4.35.0",
-        "@rollup/rollup-darwin-arm64": "4.35.0",
-        "@rollup/rollup-darwin-x64": "4.35.0",
-        "@rollup/rollup-freebsd-arm64": "4.35.0",
-        "@rollup/rollup-freebsd-x64": "4.35.0",
-        "@rollup/rollup-linux-arm-gnueabihf": "4.35.0",
-        "@rollup/rollup-linux-arm-musleabihf": "4.35.0",
-        "@rollup/rollup-linux-arm64-gnu": "4.35.0",
-        "@rollup/rollup-linux-arm64-musl": "4.35.0",
-        "@rollup/rollup-linux-loongarch64-gnu": "4.35.0",
-        "@rollup/rollup-linux-powerpc64le-gnu": "4.35.0",
-        "@rollup/rollup-linux-riscv64-gnu": "4.35.0",
-        "@rollup/rollup-linux-s390x-gnu": "4.35.0",
-        "@rollup/rollup-linux-x64-gnu": "4.35.0",
-        "@rollup/rollup-linux-x64-musl": "4.35.0",
-        "@rollup/rollup-win32-arm64-msvc": "4.35.0",
-        "@rollup/rollup-win32-ia32-msvc": "4.35.0",
-        "@rollup/rollup-win32-x64-msvc": "4.35.0",
-        "fsevents": "~2.3.2"
-      }
-    },
-    "node_modules/run-parallel": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
-      "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "queue-microtask": "^1.2.2"
-      }
-    },
-    "node_modules/safe-buffer": {
-      "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
-      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/safe-stable-stringify": {
-      "version": "2.5.0",
-      "resolved": "https://registry.npmjs.org/safe-stable-stringify/-/safe-stable-stringify-2.5.0.tgz",
-      "integrity": "sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/safer-buffer": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
-      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/secure-json-parse": {
-      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/secure-json-parse/-/secure-json-parse-2.7.0.tgz",
-      "integrity": "sha512-6aU+Rwsezw7VR8/nyvKTx8QpWH9FrcYiXXlqC4z5d5XQBDRqtbfsRjnwGyqbi3gddNtWHuEk9OANUotL26qKUw==",
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/semver": {
-      "version": "7.7.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.1.tgz",
-      "integrity": "sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/send": {
-      "version": "0.19.0",
-      "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz",
-      "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "debug": "2.6.9",
-        "depd": "2.0.0",
-        "destroy": "1.2.0",
-        "encodeurl": "~1.0.2",
-        "escape-html": "~1.0.3",
-        "etag": "~1.8.1",
-        "fresh": "0.5.2",
-        "http-errors": "2.0.0",
-        "mime": "1.6.0",
-        "ms": "2.1.3",
-        "on-finished": "2.4.1",
-        "range-parser": "~1.2.1",
-        "statuses": "2.0.1"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/send/node_modules/debug": {
-      "version": "2.6.9",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
-      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "2.0.0"
-      }
-    },
-    "node_modules/send/node_modules/debug/node_modules/ms": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
-      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/send/node_modules/encodeurl": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
-      "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/serve-static": {
-      "version": "1.16.2",
-      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz",
-      "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "encodeurl": "~2.0.0",
-        "escape-html": "~1.0.3",
-        "parseurl": "~1.3.3",
-        "send": "0.19.0"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/setprototypeof": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
-      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/shebang-command": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
-      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "shebang-regex": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/shebang-regex": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
-      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/side-channel": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
-      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3",
-        "side-channel-list": "^1.0.0",
-        "side-channel-map": "^1.0.1",
-        "side-channel-weakmap": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-list": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
-      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-map": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
-      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.5",
-        "object-inspect": "^1.13.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-weakmap": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
-      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.5",
-        "object-inspect": "^1.13.3",
-        "side-channel-map": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/signal-exit": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
-      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/simple-git": {
-      "version": "3.27.0",
-      "resolved": "https://registry.npmjs.org/simple-git/-/simple-git-3.27.0.tgz",
-      "integrity": "sha512-ivHoFS9Yi9GY49ogc6/YAi3Fl9ROnF4VyubNylgCkA+RVqLaKWnDSzXOVzya8csELIaWaYNutsEuAhZrtOjozA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@kwsites/file-exists": "^1.1.1",
-        "@kwsites/promise-deferred": "^1.1.1",
-        "debug": "^4.3.5"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/steveukx/git-js?sponsor=1"
-      }
-    },
-    "node_modules/simple-wcswidth": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/simple-wcswidth/-/simple-wcswidth-1.0.1.tgz",
-      "integrity": "sha512-xMO/8eNREtaROt7tJvWJqHBDTMFN4eiQ5I4JRMuilwfnFcV5W9u7RUkueNkdw0jPqGMX36iCywelS5yilTuOxg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/slash": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
-      "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/slugify": {
-      "version": "1.6.6",
-      "resolved": "https://registry.npmjs.org/slugify/-/slugify-1.6.6.tgz",
-      "integrity": "sha512-h+z7HKHYXj6wJU+AnS/+IH8Uh9fdcX1Lrhg1/VMdf9PwoBQXFcXiAdsy2tSK0P6gKwJLXp02r90ahUCqHk9rrw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8.0.0"
-      }
-    },
-    "node_modules/sonic-boom": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/sonic-boom/-/sonic-boom-4.2.0.tgz",
-      "integrity": "sha512-INb7TM37/mAcsGmc9hyyI6+QR3rR1zVRu36B0NeGXKnOOLiZOfER5SA+N7X7k3yUYRzLWafduTDvJAfDswwEww==",
-      "license": "MIT",
-      "dependencies": {
-        "atomic-sleep": "^1.0.0"
-      }
-    },
-    "node_modules/source-map": {
-      "version": "0.7.4",
-      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.4.tgz",
-      "integrity": "sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/source-map-js": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
-      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "peer": true,
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/spawndamnit": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/spawndamnit/-/spawndamnit-3.0.1.tgz",
-      "integrity": "sha512-MmnduQUuHCoFckZoWnXsTg7JaiLBJrKFj9UI2MbRPGaJeVpsLcVBu6P/IGZovziM/YBsellCmsprgNA+w0CzVg==",
-      "dev": true,
-      "license": "SEE LICENSE IN LICENSE",
-      "dependencies": {
-        "cross-spawn": "^7.0.5",
-        "signal-exit": "^4.0.1"
-      }
-    },
-    "node_modules/split2": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
-      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
-      "license": "ISC",
-      "engines": {
-        "node": ">= 10.x"
-      }
-    },
-    "node_modules/sprintf-js": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
-      "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==",
-      "dev": true,
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/sswr": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/sswr/-/sswr-2.2.0.tgz",
-      "integrity": "sha512-clTszLPZkmycALTHD1mXGU+mOtA/MIoLgS1KGTTzFNVm9rytQVykgRaP+z1zl572cz0bTqj4rFVoC2N+IGK4Sg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "swrev": "^4.0.0"
-      },
-      "peerDependencies": {
-        "svelte": "^4.0.0 || ^5.0.0"
-      }
-    },
-    "node_modules/statuses": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
-      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/streamsearch": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/streamsearch/-/streamsearch-1.1.0.tgz",
-      "integrity": "sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==",
-      "dev": true,
-      "engines": {
-        "node": ">=10.0.0"
-      }
-    },
-    "node_modules/string_decoder": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
-      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "safe-buffer": "~5.1.0"
-      }
-    },
-    "node_modules/string_decoder/node_modules/safe-buffer": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/string-comparison": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/string-comparison/-/string-comparison-1.3.0.tgz",
-      "integrity": "sha512-46aD+slEwybxAMPRII83ATbgMgTiz5P8mVd7Z6VJsCzSHFjdt1hkAVLeFxPIyEb11tc6ihpJTlIqoO0MCF6NPw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^16.0.0 || >=18.0.0"
-      }
-    },
-    "node_modules/string-width": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/string-width-cjs": {
-      "name": "string-width",
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/strip-ansi": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/strip-ansi-cjs": {
-      "name": "strip-ansi",
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/strip-bom": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
-      "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/strip-json-comments": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
-      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/sucrase": {
-      "version": "3.35.0",
-      "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.0.tgz",
-      "integrity": "sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/gen-mapping": "^0.3.2",
-        "commander": "^4.0.0",
-        "glob": "^10.3.10",
-        "lines-and-columns": "^1.1.6",
-        "mz": "^2.7.0",
-        "pirates": "^4.0.1",
-        "ts-interface-checker": "^0.1.9"
-      },
-      "bin": {
-        "sucrase": "bin/sucrase",
-        "sucrase-node": "bin/sucrase-node"
-      },
-      "engines": {
-        "node": ">=16 || 14 >=14.17"
-      }
-    },
-    "node_modules/supports-color": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/svelte": {
-      "version": "5.23.0",
-      "resolved": "https://registry.npmjs.org/svelte/-/svelte-5.23.0.tgz",
-      "integrity": "sha512-v0lL3NuKontiCxholEiAXCB+BYbndlKbwlDMK0DS86WgGELMJSpyqCSbJeMEMBDwOglnS7Ar2Rq0wwa/z2L8Vg==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@ampproject/remapping": "^2.3.0",
-        "@jridgewell/sourcemap-codec": "^1.5.0",
-        "@sveltejs/acorn-typescript": "^1.0.5",
-        "@types/estree": "^1.0.5",
-        "acorn": "^8.12.1",
-        "aria-query": "^5.3.1",
-        "axobject-query": "^4.1.0",
-        "clsx": "^2.1.1",
-        "esm-env": "^1.2.1",
-        "esrap": "^1.4.3",
-        "is-reference": "^3.0.3",
-        "locate-character": "^3.0.0",
-        "magic-string": "^0.30.11",
-        "zimmerframe": "^1.1.2"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/swr": {
-      "version": "2.3.3",
-      "resolved": "https://registry.npmjs.org/swr/-/swr-2.3.3.tgz",
-      "integrity": "sha512-dshNvs3ExOqtZ6kJBaAsabhPdHyeY4P2cKwRCniDVifBMoG/SVI7tfLWqPXriVspf2Rg4tPzXJTnwaihIeFw2A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "dequal": "^2.0.3",
-        "use-sync-external-store": "^1.4.0"
-      },
-      "peerDependencies": {
-        "react": "^16.11.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-      }
-    },
-    "node_modules/swrev": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/swrev/-/swrev-4.0.0.tgz",
-      "integrity": "sha512-LqVcOHSB4cPGgitD1riJ1Hh4vdmITOp+BkmfmXRh4hSF/t7EnS4iD+SOTmq7w5pPm/SiPeto4ADbKS6dHUDWFA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/swrv": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/swrv/-/swrv-1.1.0.tgz",
-      "integrity": "sha512-pjllRDr2s0iTwiE5Isvip51dZGR7GjLH1gCSVyE8bQnbAx6xackXsFdojau+1O5u98yHF5V73HQGOFxKUXO9gQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "peerDependencies": {
-        "vue": ">=3.2.26 < 4"
-      }
-    },
-    "node_modules/term-size": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/term-size/-/term-size-2.2.1.tgz",
-      "integrity": "sha512-wK0Ri4fOGjv/XPy8SBHZChl8CM7uMc5VML7SqiQ0zG7+J5Vr+RMQDoHa2CNT6KHUnTGIXH34UDMkPzAUyapBZg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/thenify": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz",
-      "integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "any-promise": "^1.0.0"
-      }
-    },
-    "node_modules/thenify-all": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz",
-      "integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "thenify": ">= 3.1.0 < 4"
-      },
-      "engines": {
-        "node": ">=0.8"
-      }
-    },
-    "node_modules/thread-stream": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/thread-stream/-/thread-stream-3.1.0.tgz",
-      "integrity": "sha512-OqyPZ9u96VohAyMfJykzmivOrY2wfMSf3C5TtFJVgN+Hm6aj+voFhlK+kZEIv2FBh1X6Xp3DlnCOfEQ3B2J86A==",
-      "license": "MIT",
-      "dependencies": {
-        "real-require": "^0.2.0"
-      }
-    },
-    "node_modules/throttleit": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/throttleit/-/throttleit-2.1.0.tgz",
-      "integrity": "sha512-nt6AMGKW1p/70DF/hGBdJB57B8Tspmbp5gfJ8ilhLnt7kkr2ye7hzD6NVG8GGErk2HWF34igrL2CXmNIkzKqKw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/tinyexec": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",
-      "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/tinyglobby": {
-      "version": "0.2.12",
-      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.12.tgz",
-      "integrity": "sha512-qkf4trmKSIiMTs/E63cxH+ojC2unam7rJ0WrauAzpT3ECNTxGRMlaXxVbfxMUC/w0LaYk6jQ4y/nGR9uBO3tww==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fdir": "^6.4.3",
-        "picomatch": "^4.0.2"
-      },
-      "engines": {
-        "node": ">=12.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/SuperchupuDev"
-      }
-    },
-    "node_modules/tinyglobby/node_modules/fdir": {
-      "version": "6.4.3",
-      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.3.tgz",
-      "integrity": "sha512-PMXmW2y1hDDfTSRc9gaXIuCCRpuoz3Kaz8cUelp3smouvfT632ozg2vrT6lJsHKKOF59YLbOGfAWGUcKEfRMQw==",
-      "dev": true,
-      "license": "MIT",
-      "peerDependencies": {
-        "picomatch": "^3 || ^4"
-      },
-      "peerDependenciesMeta": {
-        "picomatch": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/tinyglobby/node_modules/picomatch": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz",
-      "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
-      }
-    },
-    "node_modules/tmp": {
-      "version": "0.0.33",
-      "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz",
-      "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "os-tmpdir": "~1.0.2"
-      },
-      "engines": {
-        "node": ">=0.6.0"
-      }
-    },
-    "node_modules/to-regex-range": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
-      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-number": "^7.0.0"
-      },
-      "engines": {
-        "node": ">=8.0"
-      }
-    },
-    "node_modules/toidentifier": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
-      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.6"
-      }
-    },
-    "node_modules/tr46": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/tr46/-/tr46-5.1.0.tgz",
-      "integrity": "sha512-IUWnUK7ADYR5Sl1fZlO1INDUhVhatWl7BtJWsIhwJ0UAK7ilzzIa8uIqOO/aYVWHZPJkKbEL+362wrzoeRF7bw==",
-      "license": "MIT",
-      "dependencies": {
-        "punycode": "^2.3.1"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tree-kill": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/tree-kill/-/tree-kill-1.2.2.tgz",
-      "integrity": "sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "tree-kill": "cli.js"
-      }
-    },
-    "node_modules/ts-api-utils": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.0.1.tgz",
-      "integrity": "sha512-dnlgjFSVetynI8nzgJ+qF62efpglpWRk8isUEWZGWlJYySCTD6aKvbUDu+zbPeDakk3bg5H4XpitHukgfL1m9w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18.12"
-      },
-      "peerDependencies": {
-        "typescript": ">=4.8.4"
-      }
-    },
-    "node_modules/ts-interface-checker": {
-      "version": "0.1.13",
-      "resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz",
-      "integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==",
-      "dev": true,
-      "license": "Apache-2.0"
-    },
-    "node_modules/tsup": {
-      "version": "8.4.0",
-      "resolved": "https://registry.npmjs.org/tsup/-/tsup-8.4.0.tgz",
-      "integrity": "sha512-b+eZbPCjz10fRryaAA7C8xlIHnf8VnsaRqydheLIqwG/Mcpfk8Z5zp3HayX7GaTygkigHl5cBUs+IhcySiIexQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "bundle-require": "^5.1.0",
-        "cac": "^6.7.14",
-        "chokidar": "^4.0.3",
-        "consola": "^3.4.0",
-        "debug": "^4.4.0",
-        "esbuild": "^0.25.0",
-        "joycon": "^3.1.1",
-        "picocolors": "^1.1.1",
-        "postcss-load-config": "^6.0.1",
-        "resolve-from": "^5.0.0",
-        "rollup": "^4.34.8",
-        "source-map": "0.8.0-beta.0",
-        "sucrase": "^3.35.0",
-        "tinyexec": "^0.3.2",
-        "tinyglobby": "^0.2.11",
-        "tree-kill": "^1.2.2"
-      },
-      "bin": {
-        "tsup": "dist/cli-default.js",
-        "tsup-node": "dist/cli-node.js"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@microsoft/api-extractor": "^7.36.0",
-        "@swc/core": "^1",
-        "postcss": "^8.4.12",
-        "typescript": ">=4.5.0"
-      },
-      "peerDependenciesMeta": {
-        "@microsoft/api-extractor": {
-          "optional": true
-        },
-        "@swc/core": {
-          "optional": true
-        },
-        "postcss": {
-          "optional": true
-        },
-        "typescript": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/aix-ppc64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.1.tgz",
-      "integrity": "sha512-kfYGy8IdzTGy+z0vFGvExZtxkFlA4zAxgKEahG9KE1ScBjpQnFsNOX8KTU5ojNru5ed5CVoJYXFtoxaq5nFbjQ==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "aix"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/android-arm": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.1.tgz",
-      "integrity": "sha512-dp+MshLYux6j/JjdqVLnMglQlFu+MuVeNrmT5nk6q07wNhCdSnB7QZj+7G8VMUGh1q+vj2Bq8kRsuyA00I/k+Q==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/android-arm64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.1.tgz",
-      "integrity": "sha512-50tM0zCJW5kGqgG7fQ7IHvQOcAn9TKiVRuQ/lN0xR+T2lzEFvAi1ZcS8DiksFcEpf1t/GYOeOfCAgDHFpkiSmA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/android-x64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.1.tgz",
-      "integrity": "sha512-GCj6WfUtNldqUzYkN/ITtlhwQqGWu9S45vUXs7EIYf+7rCiiqH9bCloatO9VhxsL0Pji+PF4Lz2XXCES+Q8hDw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/darwin-arm64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.1.tgz",
-      "integrity": "sha512-5hEZKPf+nQjYoSr/elb62U19/l1mZDdqidGfmFutVUjjUZrOazAtwK+Kr+3y0C/oeJfLlxo9fXb1w7L+P7E4FQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/darwin-x64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.1.tgz",
-      "integrity": "sha512-hxVnwL2Dqs3fM1IWq8Iezh0cX7ZGdVhbTfnOy5uURtao5OIVCEyj9xIzemDi7sRvKsuSdtCAhMKarxqtlyVyfA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.1.tgz",
-      "integrity": "sha512-1MrCZs0fZa2g8E+FUo2ipw6jw5qqQiH+tERoS5fAfKnRx6NXH31tXBKI3VpmLijLH6yriMZsxJtaXUyFt/8Y4A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/freebsd-x64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.1.tgz",
-      "integrity": "sha512-0IZWLiTyz7nm0xuIs0q1Y3QWJC52R8aSXxe40VUxm6BB1RNmkODtW6LHvWRrGiICulcX7ZvyH6h5fqdLu4gkww==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/linux-arm": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.1.tgz",
-      "integrity": "sha512-NdKOhS4u7JhDKw9G3cY6sWqFcnLITn6SqivVArbzIaf3cemShqfLGHYMx8Xlm/lBit3/5d7kXvriTUGa5YViuQ==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/linux-arm64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.1.tgz",
-      "integrity": "sha512-jaN3dHi0/DDPelk0nLcXRm1q7DNJpjXy7yWaWvbfkPvI+7XNSc/lDOnCLN7gzsyzgu6qSAmgSvP9oXAhP973uQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/linux-ia32": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.1.tgz",
-      "integrity": "sha512-OJykPaF4v8JidKNGz8c/q1lBO44sQNUQtq1KktJXdBLn1hPod5rE/Hko5ugKKZd+D2+o1a9MFGUEIUwO2YfgkQ==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/linux-loong64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.1.tgz",
-      "integrity": "sha512-nGfornQj4dzcq5Vp835oM/o21UMlXzn79KobKlcs3Wz9smwiifknLy4xDCLUU0BWp7b/houtdrgUz7nOGnfIYg==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/linux-mips64el": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.1.tgz",
-      "integrity": "sha512-1osBbPEFYwIE5IVB/0g2X6i1qInZa1aIoj1TdL4AaAb55xIIgbg8Doq6a5BzYWgr+tEcDzYH67XVnTmUzL+nXg==",
-      "cpu": [
-        "mips64el"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/linux-ppc64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.1.tgz",
-      "integrity": "sha512-/6VBJOwUf3TdTvJZ82qF3tbLuWsscd7/1w+D9LH0W/SqUgM5/JJD0lrJ1fVIfZsqB6RFmLCe0Xz3fmZc3WtyVg==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/linux-riscv64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.1.tgz",
-      "integrity": "sha512-nSut/Mx5gnilhcq2yIMLMe3Wl4FK5wx/o0QuuCLMtmJn+WeWYoEGDN1ipcN72g1WHsnIbxGXd4i/MF0gTcuAjQ==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/linux-s390x": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.1.tgz",
-      "integrity": "sha512-cEECeLlJNfT8kZHqLarDBQso9a27o2Zd2AQ8USAEoGtejOrCYHNtKP8XQhMDJMtthdF4GBmjR2au3x1udADQQQ==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/linux-x64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.1.tgz",
-      "integrity": "sha512-xbfUhu/gnvSEg+EGovRc+kjBAkrvtk38RlerAzQxvMzlB4fXpCFCeUAYzJvrnhFtdeyVCDANSjJvOvGYoeKzFA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/netbsd-x64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.1.tgz",
-      "integrity": "sha512-X53z6uXip6KFXBQ+Krbx25XHV/NCbzryM6ehOAeAil7X7oa4XIq+394PWGnwaSQ2WRA0KI6PUO6hTO5zeF5ijA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/openbsd-x64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.1.tgz",
-      "integrity": "sha512-T3H78X2h1tszfRSf+txbt5aOp/e7TAz3ptVKu9Oyir3IAOFPGV6O9c2naym5TOriy1l0nNf6a4X5UXRZSGX/dw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/sunos-x64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.1.tgz",
-      "integrity": "sha512-2H3RUvcmULO7dIE5EWJH8eubZAI4xw54H1ilJnRNZdeo8dTADEZ21w6J22XBkXqGJbe0+wnNJtw3UXRoLJnFEg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/win32-arm64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.1.tgz",
-      "integrity": "sha512-GE7XvrdOzrb+yVKB9KsRMq+7a2U/K5Cf/8grVFRAGJmfADr/e/ODQ134RK2/eeHqYV5eQRFxb1hY7Nr15fv1NQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/win32-ia32": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.1.tgz",
-      "integrity": "sha512-uOxSJCIcavSiT6UnBhBzE8wy3n0hOkJsBOzy7HDAuTDE++1DJMRRVCPGisULScHL+a/ZwdXPpXD3IyFKjA7K8A==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/@esbuild/win32-x64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.1.tgz",
-      "integrity": "sha512-Y1EQdcfwMSeQN/ujR5VayLOJ1BHaK+ssyk0AEzPjC+t1lITgsnccPqFjb6V+LsTp/9Iov4ysfjxLaGJ9RPtkVg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsup/node_modules/esbuild": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.1.tgz",
-      "integrity": "sha512-BGO5LtrGC7vxnqucAe/rmvKdJllfGaYWdyABvyMoXQlfYMb2bbRuReWR5tEGE//4LcNJj9XrkovTqNYRFZHAMQ==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.25.1",
-        "@esbuild/android-arm": "0.25.1",
-        "@esbuild/android-arm64": "0.25.1",
-        "@esbuild/android-x64": "0.25.1",
-        "@esbuild/darwin-arm64": "0.25.1",
-        "@esbuild/darwin-x64": "0.25.1",
-        "@esbuild/freebsd-arm64": "0.25.1",
-        "@esbuild/freebsd-x64": "0.25.1",
-        "@esbuild/linux-arm": "0.25.1",
-        "@esbuild/linux-arm64": "0.25.1",
-        "@esbuild/linux-ia32": "0.25.1",
-        "@esbuild/linux-loong64": "0.25.1",
-        "@esbuild/linux-mips64el": "0.25.1",
-        "@esbuild/linux-ppc64": "0.25.1",
-        "@esbuild/linux-riscv64": "0.25.1",
-        "@esbuild/linux-s390x": "0.25.1",
-        "@esbuild/linux-x64": "0.25.1",
-        "@esbuild/netbsd-arm64": "0.25.1",
-        "@esbuild/netbsd-x64": "0.25.1",
-        "@esbuild/openbsd-arm64": "0.25.1",
-        "@esbuild/openbsd-x64": "0.25.1",
-        "@esbuild/sunos-x64": "0.25.1",
-        "@esbuild/win32-arm64": "0.25.1",
-        "@esbuild/win32-ia32": "0.25.1",
-        "@esbuild/win32-x64": "0.25.1"
-      }
-    },
-    "node_modules/tsup/node_modules/source-map": {
-      "version": "0.8.0-beta.0",
-      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.8.0-beta.0.tgz",
-      "integrity": "sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "whatwg-url": "^7.0.0"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/tsx": {
-      "version": "4.19.3",
-      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.19.3.tgz",
-      "integrity": "sha512-4H8vUNGNjQ4V2EOoGw005+c+dGuPSnhpPBPHBtsZdGZBk/iJb4kguGlPWaZTZ3q5nMtFOEsY0nRDlh9PJyd6SQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "esbuild": "~0.25.0",
-        "get-tsconfig": "^4.7.5"
-      },
-      "bin": {
-        "tsx": "dist/cli.mjs"
-      },
-      "engines": {
-        "node": ">=18.0.0"
-      },
-      "optionalDependencies": {
-        "fsevents": "~2.3.3"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/aix-ppc64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.1.tgz",
-      "integrity": "sha512-kfYGy8IdzTGy+z0vFGvExZtxkFlA4zAxgKEahG9KE1ScBjpQnFsNOX8KTU5ojNru5ed5CVoJYXFtoxaq5nFbjQ==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "aix"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/android-arm": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.1.tgz",
-      "integrity": "sha512-dp+MshLYux6j/JjdqVLnMglQlFu+MuVeNrmT5nk6q07wNhCdSnB7QZj+7G8VMUGh1q+vj2Bq8kRsuyA00I/k+Q==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/android-arm64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.1.tgz",
-      "integrity": "sha512-50tM0zCJW5kGqgG7fQ7IHvQOcAn9TKiVRuQ/lN0xR+T2lzEFvAi1ZcS8DiksFcEpf1t/GYOeOfCAgDHFpkiSmA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/android-x64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.1.tgz",
-      "integrity": "sha512-GCj6WfUtNldqUzYkN/ITtlhwQqGWu9S45vUXs7EIYf+7rCiiqH9bCloatO9VhxsL0Pji+PF4Lz2XXCES+Q8hDw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/darwin-arm64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.1.tgz",
-      "integrity": "sha512-5hEZKPf+nQjYoSr/elb62U19/l1mZDdqidGfmFutVUjjUZrOazAtwK+Kr+3y0C/oeJfLlxo9fXb1w7L+P7E4FQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/darwin-x64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.1.tgz",
-      "integrity": "sha512-hxVnwL2Dqs3fM1IWq8Iezh0cX7ZGdVhbTfnOy5uURtao5OIVCEyj9xIzemDi7sRvKsuSdtCAhMKarxqtlyVyfA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.1.tgz",
-      "integrity": "sha512-1MrCZs0fZa2g8E+FUo2ipw6jw5qqQiH+tERoS5fAfKnRx6NXH31tXBKI3VpmLijLH6yriMZsxJtaXUyFt/8Y4A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/freebsd-x64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.1.tgz",
-      "integrity": "sha512-0IZWLiTyz7nm0xuIs0q1Y3QWJC52R8aSXxe40VUxm6BB1RNmkODtW6LHvWRrGiICulcX7ZvyH6h5fqdLu4gkww==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/linux-arm": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.1.tgz",
-      "integrity": "sha512-NdKOhS4u7JhDKw9G3cY6sWqFcnLITn6SqivVArbzIaf3cemShqfLGHYMx8Xlm/lBit3/5d7kXvriTUGa5YViuQ==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/linux-arm64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.1.tgz",
-      "integrity": "sha512-jaN3dHi0/DDPelk0nLcXRm1q7DNJpjXy7yWaWvbfkPvI+7XNSc/lDOnCLN7gzsyzgu6qSAmgSvP9oXAhP973uQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/linux-ia32": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.1.tgz",
-      "integrity": "sha512-OJykPaF4v8JidKNGz8c/q1lBO44sQNUQtq1KktJXdBLn1hPod5rE/Hko5ugKKZd+D2+o1a9MFGUEIUwO2YfgkQ==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/linux-loong64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.1.tgz",
-      "integrity": "sha512-nGfornQj4dzcq5Vp835oM/o21UMlXzn79KobKlcs3Wz9smwiifknLy4xDCLUU0BWp7b/houtdrgUz7nOGnfIYg==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/linux-mips64el": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.1.tgz",
-      "integrity": "sha512-1osBbPEFYwIE5IVB/0g2X6i1qInZa1aIoj1TdL4AaAb55xIIgbg8Doq6a5BzYWgr+tEcDzYH67XVnTmUzL+nXg==",
-      "cpu": [
-        "mips64el"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/linux-ppc64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.1.tgz",
-      "integrity": "sha512-/6VBJOwUf3TdTvJZ82qF3tbLuWsscd7/1w+D9LH0W/SqUgM5/JJD0lrJ1fVIfZsqB6RFmLCe0Xz3fmZc3WtyVg==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/linux-riscv64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.1.tgz",
-      "integrity": "sha512-nSut/Mx5gnilhcq2yIMLMe3Wl4FK5wx/o0QuuCLMtmJn+WeWYoEGDN1ipcN72g1WHsnIbxGXd4i/MF0gTcuAjQ==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/linux-s390x": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.1.tgz",
-      "integrity": "sha512-cEECeLlJNfT8kZHqLarDBQso9a27o2Zd2AQ8USAEoGtejOrCYHNtKP8XQhMDJMtthdF4GBmjR2au3x1udADQQQ==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/linux-x64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.1.tgz",
-      "integrity": "sha512-xbfUhu/gnvSEg+EGovRc+kjBAkrvtk38RlerAzQxvMzlB4fXpCFCeUAYzJvrnhFtdeyVCDANSjJvOvGYoeKzFA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/netbsd-x64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.1.tgz",
-      "integrity": "sha512-X53z6uXip6KFXBQ+Krbx25XHV/NCbzryM6ehOAeAil7X7oa4XIq+394PWGnwaSQ2WRA0KI6PUO6hTO5zeF5ijA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/openbsd-x64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.1.tgz",
-      "integrity": "sha512-T3H78X2h1tszfRSf+txbt5aOp/e7TAz3ptVKu9Oyir3IAOFPGV6O9c2naym5TOriy1l0nNf6a4X5UXRZSGX/dw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/sunos-x64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.1.tgz",
-      "integrity": "sha512-2H3RUvcmULO7dIE5EWJH8eubZAI4xw54H1ilJnRNZdeo8dTADEZ21w6J22XBkXqGJbe0+wnNJtw3UXRoLJnFEg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/win32-arm64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.1.tgz",
-      "integrity": "sha512-GE7XvrdOzrb+yVKB9KsRMq+7a2U/K5Cf/8grVFRAGJmfADr/e/ODQ134RK2/eeHqYV5eQRFxb1hY7Nr15fv1NQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/win32-ia32": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.1.tgz",
-      "integrity": "sha512-uOxSJCIcavSiT6UnBhBzE8wy3n0hOkJsBOzy7HDAuTDE++1DJMRRVCPGisULScHL+a/ZwdXPpXD3IyFKjA7K8A==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/@esbuild/win32-x64": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.1.tgz",
-      "integrity": "sha512-Y1EQdcfwMSeQN/ujR5VayLOJ1BHaK+ssyk0AEzPjC+t1lITgsnccPqFjb6V+LsTp/9Iov4ysfjxLaGJ9RPtkVg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tsx/node_modules/esbuild": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.1.tgz",
-      "integrity": "sha512-BGO5LtrGC7vxnqucAe/rmvKdJllfGaYWdyABvyMoXQlfYMb2bbRuReWR5tEGE//4LcNJj9XrkovTqNYRFZHAMQ==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.25.1",
-        "@esbuild/android-arm": "0.25.1",
-        "@esbuild/android-arm64": "0.25.1",
-        "@esbuild/android-x64": "0.25.1",
-        "@esbuild/darwin-arm64": "0.25.1",
-        "@esbuild/darwin-x64": "0.25.1",
-        "@esbuild/freebsd-arm64": "0.25.1",
-        "@esbuild/freebsd-x64": "0.25.1",
-        "@esbuild/linux-arm": "0.25.1",
-        "@esbuild/linux-arm64": "0.25.1",
-        "@esbuild/linux-ia32": "0.25.1",
-        "@esbuild/linux-loong64": "0.25.1",
-        "@esbuild/linux-mips64el": "0.25.1",
-        "@esbuild/linux-ppc64": "0.25.1",
-        "@esbuild/linux-riscv64": "0.25.1",
-        "@esbuild/linux-s390x": "0.25.1",
-        "@esbuild/linux-x64": "0.25.1",
-        "@esbuild/netbsd-arm64": "0.25.1",
-        "@esbuild/netbsd-x64": "0.25.1",
-        "@esbuild/openbsd-arm64": "0.25.1",
-        "@esbuild/openbsd-x64": "0.25.1",
-        "@esbuild/sunos-x64": "0.25.1",
-        "@esbuild/win32-arm64": "0.25.1",
-        "@esbuild/win32-ia32": "0.25.1",
-        "@esbuild/win32-x64": "0.25.1"
-      }
-    },
-    "node_modules/tsx/node_modules/fsevents": {
-      "version": "2.3.3",
-      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
-      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
-      }
-    },
-    "node_modules/type-check": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
-      "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "prelude-ls": "^1.2.1"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/type-is": {
-      "version": "1.6.18",
-      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
-      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "media-typer": "0.3.0",
-        "mime-types": "~2.1.24"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/typedarray": {
-      "version": "0.0.6",
-      "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz",
-      "integrity": "sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/typescript": {
-      "version": "5.8.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.2.tgz",
-      "integrity": "sha512-aJn6wq13/afZp/jT9QZmwEjDqqvSGp1VT5GVg+f/t6/oVyrgXM6BY1h9BRh/O5p3PlUPAe+WuiEZOmb/49RqoQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "bin": {
-        "tsc": "bin/tsc",
-        "tsserver": "bin/tsserver"
-      },
-      "engines": {
-        "node": ">=14.17"
-      }
-    },
-    "node_modules/typescript-eslint": {
-      "version": "8.26.1",
-      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.26.1.tgz",
-      "integrity": "sha512-t/oIs9mYyrwZGRpDv3g+3K6nZ5uhKEMt2oNmAPwaY4/ye0+EH4nXIPYNtkYFS6QHm+1DFg34DbglYBz5P9Xysg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/eslint-plugin": "8.26.1",
-        "@typescript-eslint/parser": "8.26.1",
-        "@typescript-eslint/utils": "8.26.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <5.9.0"
-      }
-    },
-    "node_modules/undici": {
-      "version": "6.21.1",
-      "resolved": "https://registry.npmjs.org/undici/-/undici-6.21.1.tgz",
-      "integrity": "sha512-q/1rj5D0/zayJB2FraXdaWxbhWiNKDvu8naDT2dl1yTlvJp4BLtOcp2a5BvgGNQpYYJzau7tf1WgKv3b+7mqpQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18.17"
-      }
-    },
-    "node_modules/undici-types": {
-      "version": "6.19.8",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.19.8.tgz",
-      "integrity": "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==",
-      "license": "MIT"
-    },
-    "node_modules/universalify": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz",
-      "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4.0.0"
-      }
-    },
-    "node_modules/unpipe": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
-      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/uri-js": {
-      "version": "4.4.1",
-      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
-      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "punycode": "^2.1.0"
-      }
-    },
-    "node_modules/use-sync-external-store": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.4.0.tgz",
-      "integrity": "sha512-9WXSPC5fMv61vaupRkCKCxsPxBocVnwakBEkMIHHpkTTg6icbJtg6jzgtLDm4bl3cSHAca52rYWih0k4K3PfHw==",
-      "dev": true,
-      "license": "MIT",
-      "peerDependencies": {
-        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-      }
-    },
-    "node_modules/util-deprecate": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
-      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/utils-merge": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
-      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4.0"
-      }
-    },
-    "node_modules/uuid": {
-      "version": "10.0.0",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-10.0.0.tgz",
-      "integrity": "sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==",
-      "dev": true,
-      "funding": [
-        "https://github.com/sponsors/broofa",
-        "https://github.com/sponsors/ctavan"
-      ],
-      "license": "MIT",
-      "bin": {
-        "uuid": "dist/bin/uuid"
-      }
-    },
-    "node_modules/validate.io-array": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/validate.io-array/-/validate.io-array-1.0.6.tgz",
-      "integrity": "sha512-DeOy7CnPEziggrOO5CZhVKJw6S3Yi7e9e65R1Nl/RTN1vTQKnzjfvks0/8kQ40FP/dsjRAOd4hxmJ7uLa6vxkg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/validate.io-function": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/validate.io-function/-/validate.io-function-1.0.2.tgz",
-      "integrity": "sha512-LlFybRJEriSuBnUhQyG5bwglhh50EpTL2ul23MPIuR1odjO7XaMLFV8vHGwp7AZciFxtYOeiSCT5st+XSPONiQ==",
-      "dev": true
-    },
-    "node_modules/vary": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
-      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/vue": {
-      "version": "3.5.13",
-      "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.13.tgz",
-      "integrity": "sha512-wmeiSMxkZCSc+PM2w2VRsOYAZC8GdipNFRTsLSfodVqI9mbejKeXEGr8SckuLnrQPGe3oJN5c3K0vpoU9q/wCQ==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@vue/compiler-dom": "3.5.13",
-        "@vue/compiler-sfc": "3.5.13",
-        "@vue/runtime-dom": "3.5.13",
-        "@vue/server-renderer": "3.5.13",
-        "@vue/shared": "3.5.13"
-      },
-      "peerDependencies": {
-        "typescript": "*"
-      },
-      "peerDependenciesMeta": {
-        "typescript": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/web-streams-polyfill": {
-      "version": "4.0.0-beta.3",
-      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-4.0.0-beta.3.tgz",
-      "integrity": "sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/webidl-conversions": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-7.0.0.tgz",
-      "integrity": "sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==",
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/whatwg-encoding": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-3.1.1.tgz",
-      "integrity": "sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "iconv-lite": "0.6.3"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/whatwg-mimetype": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-4.0.0.tgz",
-      "integrity": "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/whatwg-url": {
-      "version": "14.2.0",
-      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-14.2.0.tgz",
-      "integrity": "sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==",
-      "license": "MIT",
-      "dependencies": {
-        "tr46": "^5.1.0",
-        "webidl-conversions": "^7.0.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/which": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
-      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "isexe": "^2.0.0"
-      },
-      "bin": {
-        "node-which": "bin/node-which"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/word-wrap": {
-      "version": "1.2.5",
-      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
-      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/wrap-ansi": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
-      "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^6.1.0",
-        "string-width": "^5.0.1",
-        "strip-ansi": "^7.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi-cjs": {
-      "name": "wrap-ansi",
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
-      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.0.0",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi-cjs/node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/ansi-regex": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
-      "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/ansi-styles": {
-      "version": "6.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz",
-      "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/emoji-regex": {
-      "version": "9.2.2",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
-      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/wrap-ansi/node_modules/string-width": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
-      "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "eastasianwidth": "^0.2.0",
-        "emoji-regex": "^9.2.2",
-        "strip-ansi": "^7.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/strip-ansi": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
-      "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
-      }
-    },
-    "node_modules/wrappy": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
-      "license": "ISC"
-    },
-    "node_modules/ws": {
-      "version": "8.18.1",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.1.tgz",
-      "integrity": "sha512-RKW2aJZMXeMxVpnZ6bck+RswznaxmzdULiBr6KY7XkTnW8uvt0iT9H5DkHUChXrc+uurzwa0rVI16n/Xzjdz1w==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.0.0"
-      },
-      "peerDependencies": {
-        "bufferutil": "^4.0.1",
-        "utf-8-validate": ">=5.0.2"
-      },
-      "peerDependenciesMeta": {
-        "bufferutil": {
-          "optional": true
-        },
-        "utf-8-validate": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/xtend": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
-      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.4"
-      }
-    },
-    "node_modules/yaml": {
-      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.7.0.tgz",
-      "integrity": "sha512-+hSoy/QHluxmC9kCIJyL/uyFmLmc+e5CFR5Wa+bpIhIj85LVb9ZH2nVnqrHoSvKogwODv0ClqZkmiSSaIH5LTA==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "yaml": "bin.mjs"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/yocto-queue": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
-      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/zimmerframe": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/zimmerframe/-/zimmerframe-1.1.2.tgz",
-      "integrity": "sha512-rAbqEGa8ovJy4pyBxZM70hg4pE6gDgaQ0Sl9M3enG3I0d6H4XSAM3GeNGLKnsBpuijUow064sf7ww1nutC5/3w==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true
-    },
-    "node_modules/zod": {
-      "version": "3.24.2",
-      "resolved": "https://registry.npmjs.org/zod/-/zod-3.24.2.tgz",
-      "integrity": "sha512-lY7CDW43ECgW9u1TcT3IoXHflywfVqDYze4waEz812jR/bZ8FHDsl7pFQoSZTz5N+2NqRXs8GBwnAwo3ZNxqhQ==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/colinhacks"
-      }
-    },
-    "node_modules/zod-to-json-schema": {
-      "version": "3.24.3",
-      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.24.3.tgz",
-      "integrity": "sha512-HIAfWdYIt1sssHfYZFCXp4rU1w2r8hVVXYIlmoa0r0gABLs5di3RCqPU5DDROogVz1pAdYBaz7HK5n9pSUNs3A==",
-      "license": "ISC",
-      "peerDependencies": {
-        "zod": "^3.24.1"
-      }
-    }
-  }
-}
diff --git a/package.json b/package.json
index ad675a846..1a5b9f3ba 100644
--- a/package.json
+++ b/package.json
@@ -1,106 +1,62 @@
 {
-  "name": "@browserbasehq/stagehand",
-  "version": "2.1.0",
-  "description": "An AI web browsing framework focused on simplicity and extensibility.",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "name": "stagehand-workspace",
+  "version": "0.0.0",
+  "private": true,
+  "description": "Stagehand monorepo workspace",
+  "type": "module",
   "scripts": {
-    "2048": "npm run build && tsx examples/2048.ts",
-    "popup": "npm run build && tsx examples/popup.ts",
-    "cua": "npm run build && tsx examples/cua-example.ts",
-    "operator": "npm run build && tsx examples/operator-example.ts",
-    "example": "npm run build && tsx examples/example.ts",
-    "langchain": "npm run build && tsx examples/langchain.ts",
-    "debug-url": "npm run build && tsx examples/debugUrl.ts",
-    "external-client": "npm run build && tsx examples/external_client.ts",
-    "instructions": "npm run build && tsx examples/instructions.ts",
-    "ai-sdk-client": "npm run build && tsx examples/ai_sdk_example.ts",
-    "actionable_observe_example": "npm run build && tsx examples/actionable_observe_example.ts",
-    "form-filling-sensible-cerebras": "npm run build && tsx examples/form_filling_sensible_cerebras.ts",
-    "form-filling-sensible": "npm run build && tsx examples/form_filling_sensible.ts",
-    "google-enter": "npm run build && tsx examples/google_enter.ts",
-    "try-wordle": "npm run build && tsx examples/try_wordle.ts",
+    "build": "turbo run build",
+    "build:full": "turbo run build",
+    "build:cjs": "turbo run build:cjs",
+    "build:cli": "turbo run build:cli",
+    "build:esm": "turbo run build:esm",
+    "build:sea": "turbo run build:sea:esm",
+    "build:sea:esm": "turbo run build:sea:esm",
+    "build:sea:cjs": "turbo run build:sea:cjs",
+    "lint": "turbo run lint",
     "format": "prettier --write .",
-    "prettier": "prettier --check .",
-    "prettier:fix": "prettier --write .",
+    "prettier": "prettier --write .",
     "eslint": "eslint .",
-    "cache:clear": "rm -rf .cache",
-    "evals": "npm run build && tsx evals/index.eval.ts",
-    "e2e": "npm run build && cd evals/deterministic && npx playwright test --config=e2e.playwright.config.ts",
-    "e2e:bb": "npm run build && cd evals/deterministic && npx playwright test --config=bb.playwright.config.ts",
-    "e2e:local": "npm run build && cd evals/deterministic && npx playwright test --config=local.playwright.config.ts",
-    "build-dom-scripts": "tsx lib/dom/genDomScripts.ts",
-    "build-types": "tsc --emitDeclarationOnly --outDir dist",
-    "build-js": "tsup lib/index.ts --dts",
-    "build": "npm run lint && npm run build-dom-scripts && npm run build-js && npm run build-types",
-    "lint": "npm run prettier && npm run eslint",
-    "release": "npm run build && changeset publish",
-    "release-canary": "npm run build && changeset version --snapshot && changeset publish --tag alpha"
+    "test": "turbo run test:core test:e2e test:server test:evals",
+    "test:core": "turbo run test:core --",
+    "test:core:local": "STAGEHAND_BROWSER_TARGET=local pnpm run test:core --",
+    "test:core:bb": "STAGEHAND_BROWSER_TARGET=browserbase pnpm run test:core --",
+    "test:e2e": "turbo run test:e2e --",
+    "test:e2e:local": "STAGEHAND_BROWSER_TARGET=local pnpm run test:e2e --",
+    "test:e2e:bb": "STAGEHAND_BROWSER_TARGET=browserbase pnpm run test:e2e --",
+    "test:server": "turbo run test:server --",
+    "test:server:sea": "STAGEHAND_SERVER_TARGET=sea pnpm run test:server --",
+    "test:server:local": "STAGEHAND_SERVER_TARGET=local pnpm run test:server --",
+    "test:server:remote": "STAGEHAND_SERVER_TARGET=remote pnpm run test:server --",
+    "test:evals": "turbo run test:evals --",
+    "test:evals:local": "STAGEHAND_BROWSER_TARGET=local pnpm run test:evals --",
+    "test:evals:bb": "STAGEHAND_BROWSER_TARGET=browserbase pnpm run test:evals --",
+    "coverage:merge": "pnpm -w exec tsx packages/core/scripts/coverage.ts merge",
+    "docs": "turbo run docs",
+    "dev": "turbo run dev",
+    "example": "pnpm --filter @browserbasehq/stagehand run example --",
+    "cache:clear": "turbo run build --force",
+    "prepare": "node packages/core/scripts/prepare.js",
+    "release": "turbo run build && changeset publish",
+    "release-canary": "turbo run build && changeset version --snapshot && changeset publish --tag alpha"
   },
-  "files": [
-    "dist/**",
-    "lib/**"
-  ],
-  "keywords": [],
-  "author": "Browserbase",
-  "license": "MIT",
   "devDependencies": {
-    "@ai-sdk/anthropic": "^1.2.6",
-    "@ai-sdk/cerebras": "^0.2.6",
-    "@ai-sdk/google": "^1.2.6",
-    "@ai-sdk/groq": "^1.2.4",
-    "@ai-sdk/openai": "^1.0.14",
-    "@ai-sdk/togetherai": "^0.2.6",
     "@changesets/changelog-github": "^0.5.0",
     "@changesets/cli": "^2.27.9",
-    "@eslint/js": "^9.16.0",
-    "@langchain/core": "^0.3.40",
-    "@langchain/openai": "^0.4.4",
-    "@types/adm-zip": "^0.5.7",
-    "@types/cheerio": "^0.22.35",
-    "@types/express": "^4.17.21",
-    "@types/node": "^20.11.30",
-    "@types/ws": "^8.5.13",
-    "adm-zip": "^0.5.16",
-    "ai": "^4.3.0",
-    "autoevals": "^0.0.64",
-    "braintrust": "^0.0.171",
-    "chalk": "^5.4.1",
-    "cheerio": "^1.0.0",
-    "chromium-bidi": "^0.10.0",
-    "esbuild": "^0.21.4",
-    "eslint": "^9.16.0",
-    "express": "^4.21.0",
+    "@eslint/js": "^10.0.1",
+    "c8": "^10.1.3",
+    "dotenv": "^17.3.1",
+    "esbuild": "0.27.2",
+    "eslint": "^10.0.2",
+    "eslint-plugin-security": "^3.0.1",
     "globals": "^15.13.0",
-    "multer": "^1.4.5-lts.1",
+    "junit-to-ctrf": "^0.0.14",
     "prettier": "^3.2.5",
-    "string-comparison": "^1.3.0",
-    "tsup": "^8.2.1",
-    "tsx": "^4.10.5",
-    "typescript": "^5.2.2",
-    "typescript-eslint": "^8.17.0"
-  },
-  "peerDependencies": {
-    "@playwright/test": "^1.42.1",
-    "deepmerge": "^4.3.1",
-    "dotenv": "^16.4.5",
-    "zod": "^3.23.8"
-  },
-  "dependencies": {
-    "@anthropic-ai/sdk": "0.39.0",
-    "@browserbasehq/sdk": "^2.4.0",
-    "@google/genai": "^0.8.0",
-    "openai": "^4.87.1",
-    "pino": "^9.6.0",
-    "pino-pretty": "^13.0.0",
-    "ws": "^8.18.0",
-    "zod-to-json-schema": "^3.23.5"
-  },
-  "directories": {
-    "doc": "docs",
-    "example": "examples",
-    "lib": "lib"
+    "source-map": "^0.7.4",
+    "tsx": "^4.19.4",
+    "turbo": "^2.8.10",
+    "typescript": "5.8.3",
+    "typescript-eslint": "^8.56.1"
   },
   "repository": {
     "type": "git",
@@ -111,6 +67,13 @@
   },
   "homepage": "https://stagehand.dev",
   "overrides": {
-    "whatwg-url": "^14.0.0"
-  }
+    "whatwg-url": "^14.0.0",
+    "jwa": "^2.0.1",
+    "zod": "4.2.1",
+    "tsx": "4.19.4"
+  },
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "packageManager": "pnpm@9.15.0+sha512.76e2379760a4328ec4415815bcd6628dee727af3779aaa4c914e3944156c4299921a89f976381ee107d41f12cfa4b66681ca9c718f0668fa0831ed4c6d8ba56c"
 }
diff --git a/packages/README.md b/packages/README.md
new file mode 100644
index 000000000..e019ef1d2
--- /dev/null
+++ b/packages/README.md
@@ -0,0 +1,8 @@
+# Stagehand Packages
+
+This directory contains the Stagehand monorepo packages:
+
+- **core** - The main Stagehand package
+- **evals** - Evals CLI
+- **docs** - [Docs](https://docs.stagehand.dev)
+- **server** - Fastify server wrapping the core package for different language clients
\ No newline at end of file
diff --git a/packages/cli/.prettierignore b/packages/cli/.prettierignore
new file mode 100644
index 000000000..832b52938
--- /dev/null
+++ b/packages/cli/.prettierignore
@@ -0,0 +1,3 @@
+dist/
+node_modules/
+*.json
diff --git a/packages/cli/.prettierrc b/packages/cli/.prettierrc
new file mode 100644
index 000000000..9e26dfeeb
--- /dev/null
+++ b/packages/cli/.prettierrc
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/packages/cli/README.md b/packages/cli/README.md
new file mode 100644
index 000000000..c1619d6b1
--- /dev/null
+++ b/packages/cli/README.md
@@ -0,0 +1,341 @@
+# Browse CLI
+
+Browser automation CLI for AI agents. Built on [Stagehand](https://github.com/browserbase/stagehand), providing raw browser control without requiring LLM integration.
+
+## Installation
+
+```bash
+npm install -g @browserbasehq/browse-cli
+```
+
+Requires Chrome/Chromium installed on the system.
+
+## Quick Start
+
+```bash
+# Navigate to a URL (auto-starts browser daemon)
+browse open https://example.com
+
+# Take a snapshot to get element refs
+browse snapshot -c
+
+# Click an element by ref
+browse click @0-5
+
+# Type text
+browse type "Hello, world!"
+
+# Take a screenshot
+browse screenshot ./page.png
+
+# Stop the browser
+browse stop
+```
+
+## How It Works
+
+Browse uses a daemon architecture for fast, stateful interactions:
+
+1. **First command** auto-starts a Chrome browser daemon
+2. **Subsequent commands** reuse the same browser session
+3. **State persists** between commands (cookies, refs, etc.)
+4. **Multiple sessions** supported via `--session` or `BROWSE_SESSION` env var
+
+### Self-Healing Sessions
+
+The CLI automatically recovers from stale sessions. If the daemon or Chrome crashes:
+1. Detects the failure
+2. Cleans up stale processes and files
+3. Restarts the daemon
+4. Retries the command
+
+Agents don't need to handle recovery - commands "just work".
+
+## Commands
+
+### Navigation
+
+```bash
+browse open <url> [--wait load|domcontentloaded|networkidle] [-t|--timeout ms]
+browse reload
+browse back
+browse forward
+```
+
+The `--timeout` flag (default: 30000ms) controls how long to wait for the page load state. Use longer timeouts for slow-loading pages:
+
+```bash
+browse open https://slow-site.com --timeout 60000
+```
+
+### Click Actions
+
+```bash
+browse click <ref> [-b left|right|middle] [-c count]  # Click by ref (e.g., @0-5)
+browse click_xy <x> <y> [--button] [--xpath]          # Click at coordinates
+```
+
+### Coordinate Actions
+
+```bash
+browse hover <x> <y> [--xpath]
+browse scroll <x> <y> <deltaX> <deltaY> [--xpath]
+browse drag <fromX> <fromY> <toX> <toY> [--steps n] [--xpath]
+```
+
+### Keyboard
+
+```bash
+browse type <text> [-d delay] [--mistakes]
+browse press <key>  # e.g., Enter, Tab, Cmd+A
+```
+
+### Forms
+
+```bash
+browse fill <selector> <value> [--no-press-enter]
+browse select <selector> <values...>
+browse highlight <selector> [-d duration]
+```
+
+### Page Info
+
+```bash
+browse get url
+browse get title
+browse get text <selector>
+browse get html <selector>
+browse get value <selector>
+browse get box <selector>  # Returns center coordinates
+
+browse snapshot [-c|--compact]  # Accessibility tree with refs
+browse screenshot [path] [-f|--full-page] [-t png|jpeg]
+```
+
+### Waiting
+
+```bash
+browse wait load [state]
+browse wait selector <selector> [-t timeout] [-s visible|hidden|attached|detached]
+browse wait timeout <ms>
+```
+
+### Multi-Tab
+
+```bash
+browse pages          # List all tabs
+browse newpage [url]  # Open new tab
+browse tab_switch <n> # Switch to tab by index
+browse tab_close [n]  # Close tab (default: last)
+```
+
+### Network Capture
+
+Capture HTTP requests to the filesystem for inspection:
+
+```bash
+browse network on     # Start capturing requests
+browse network off    # Stop capturing
+browse network path   # Get capture directory path
+browse network clear  # Clear captured requests
+```
+
+Captured requests are saved as directories:
+
+```
+/tmp/browse-default-network/
+  001-GET-api.github.com-repos/
+    request.json      # method, url, headers, body
+    response.json     # status, headers, body, duration
+```
+
+### Daemon Control
+
+```bash
+browse start          # Explicitly start daemon
+browse stop [--force] # Stop daemon
+browse status         # Check daemon status
+browse env [target]   # Show or switch environment: local | remote
+```
+
+### Environment Switching (Local vs Remote)
+
+Use environment switching when an agent should keep the same command flow, but the
+browser runtime needs to change:
+
+- `local` runs Chrome on your machine (best for local debugging/dev loops)
+- `remote` runs a Browserbase session (best for anti-bot hardening and cloud runs)
+
+```bash
+# Show active environment (if running) and desired environment for next start
+browse env
+
+# Switch current session to Browserbase (restarts daemon if needed)
+browse env remote
+
+# Switch back to local Chrome
+browse env local
+```
+
+Behavior details:
+
+- Environment is scoped per `--session`
+- `browse env <target>` persists an override and restarts the daemon
+- `browse stop` clears the override so next start falls back to env-var-based auto detection
+- Auto detection defaults to:
+  - `remote` when `BROWSERBASE_API_KEY` is set
+  - `local` otherwise
+
+## Global Options
+
+| Option | Description |
+|--------|-------------|
+| `--session <name>` | Session name for multiple browsers (default: "default") |
+| `--headless` | Run Chrome in headless mode |
+| `--headed` | Run Chrome with visible window (default) |
+| `--ws <url>` | Connect to existing Chrome via CDP WebSocket |
+| `--json` | Output as JSON |
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `BROWSE_SESSION` | Default session name (alternative to `--session`) |
+| `BROWSERBASE_API_KEY` | Browserbase API key (required for `browse env remote`) |
+| `BROWSERBASE_PROJECT_ID` | Browserbase project ID (optional, passed through if set) |
+
+## Element References
+
+After running `browse snapshot`, you can reference elements by their ref ID:
+
+```bash
+# Get snapshot with refs
+browse snapshot -c
+
+# Output includes refs like [0-5], [1-2], etc.
+# RootWebArea "Example" url="https://example.com"
+#   [0-0] link "Home"
+#   [0-1] link "About"
+#   [0-2] button "Sign In"
+
+# Click using ref (multiple formats supported)
+browse click @0-2       # @ prefix
+browse click 0-2        # Plain ref
+browse click ref=0-2    # Explicit prefix
+```
+
+The full snapshot output includes mappings:
+- **xpathMap**: Cross-frame XPath selectors
+- **cssMap**: Fast CSS selectors when available
+- **urlMap**: Extracted URLs from links
+
+## Multiple Sessions
+
+Run multiple browser instances simultaneously:
+
+```bash
+# Terminal 1
+BROWSE_SESSION=session1 browse open https://google.com
+
+# Terminal 2
+BROWSE_SESSION=session2 browse open https://github.com
+
+# Or use --session flag
+browse --session work open https://slack.com
+browse --session personal open https://twitter.com
+```
+
+## Direct CDP Connection
+
+Connect to an existing Chrome instance:
+
+```bash
+# Start Chrome with remote debugging
+google-chrome --remote-debugging-port=9222
+
+# Connect via WebSocket
+browse --ws ws://localhost:9222/devtools/browser/... open https://example.com
+```
+
+## Optimal AI Workflow
+
+1. **Navigate** to target page (browser auto-starts)
+2. **Snapshot** to get the accessibility tree with refs
+3. **Click/Fill** using refs directly (e.g., `@0-5`)
+4. **Re-snapshot** after actions to verify state changes
+5. **Stop** when done
+
+```bash
+browse open https://example.com
+browse snapshot -c
+# [0-5] textbox: Search
+# [0-8] button: Submit
+browse fill @0-5 "my query"
+browse click @0-8
+browse snapshot -c  # Verify result
+browse stop
+```
+
+## Troubleshooting
+
+### Chrome not found
+
+The CLI uses your system Chrome/Chromium. If not found:
+
+```bash
+# macOS - Install Chrome or set path
+export CHROME_PATH=/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome
+
+# Linux - Install chromium
+sudo apt install chromium-browser
+```
+
+### Stale daemon
+
+If the daemon becomes unresponsive:
+
+```bash
+browse stop --force
+```
+
+### Permission denied on socket
+
+```bash
+# Clean up stale socket files
+rm /tmp/browse-*.sock /tmp/browse-*.pid
+```
+
+## Platform Support
+
+- macOS (Intel and Apple Silicon)
+- Linux (x64 and arm64)
+
+Windows support requires WSL or TCP socket implementation.
+
+## Development
+
+```bash
+# Clone and setup (in monorepo)
+cd packages/cli
+pnpm install         # Install dependencies first!
+pnpm run build       # Build the CLI
+
+# Run without building (for development)
+pnpm run dev -- <command>
+
+# Or with tsx directly
+npx tsx src/index.ts <command>
+
+# Run linting and formatting
+pnpm run lint
+pnpm run format
+```
+
+## License
+
+MIT - see [LICENSE](./LICENSE)
+
+## Related
+
+- [Stagehand](https://github.com/browserbase/stagehand) - AI web browser automation framework
+- [Browserbase](https://browserbase.com) - Cloud browser infrastructure
diff --git a/packages/cli/eslint.config.mjs b/packages/cli/eslint.config.mjs
new file mode 100644
index 000000000..518872a15
--- /dev/null
+++ b/packages/cli/eslint.config.mjs
@@ -0,0 +1,32 @@
+import globals from "globals";
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+/** @type {import('eslint').Linter.Config[]} */
+export default [
+  { files: ["**/*.{js,mjs,cjs,ts}"] },
+  { languageOptions: { globals: { ...globals.browser, ...globals.node } } },
+  {
+    ignores: [
+      "dist/**",
+      "node_modules/**",
+      "**/*.config.js",
+      "**/*.config.mjs",
+    ],
+  },
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    rules: {
+      // Allow unused vars prefixed with _
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        { argsIgnorePattern: "^_", varsIgnorePattern: "^_" },
+      ],
+      // Allow explicit any for CLI flexibility
+      "@typescript-eslint/no-explicit-any": "off",
+      // Allow empty catch blocks (used for cleanup/ignoring expected errors)
+      "no-empty": ["error", { "allowEmptyCatch": true }],
+    },
+  },
+];
diff --git a/packages/cli/package.json b/packages/cli/package.json
new file mode 100644
index 000000000..38d729aae
--- /dev/null
+++ b/packages/cli/package.json
@@ -0,0 +1,85 @@
+{
+  "name": "@browserbasehq/browse-cli",
+  "version": "0.1.4",
+  "description": "Browser automation CLI for AI agents, built on Stagehand",
+  "type": "commonjs",
+  "license": "MIT",
+  "author": "Browserbase <support@browserbase.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/browserbase/stagehand.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/browserbase/stagehand/issues"
+  },
+  "homepage": "https://github.com/browserbase/stagehand/tree/main/packages/cli#readme",
+  "keywords": [
+    "browser",
+    "automation",
+    "cli",
+    "ai",
+    "agent",
+    "chrome",
+    "cdp",
+    "web-scraping",
+    "testing",
+    "stagehand"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "bin": {
+    "browse": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "browse": "tsx src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@browserbasehq/stagehand": "workspace:*",
+    "commander": "^12.0.0",
+    "dotenv": "^16.4.5",
+    "pino": "^9.6.0",
+    "pino-pretty": "^13.0.0",
+    "ws": "^8.18.0"
+  },
+  "peerDependencies": {
+    "playwright": "^1.50.0"
+  },
+  "peerDependenciesMeta": {
+    "playwright": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.16.0",
+    "@types/node": "^20.11.30",
+    "eslint": "^9.16.0",
+    "globals": "^15.13.0",
+    "prettier": "^3.2.5",
+    "tsup": "^8.2.1",
+    "tsx": "^4.10.5",
+    "typescript": "^5.2.2",
+    "typescript-eslint": "^8.17.0",
+    "vitest": "^1.6.0"
+  }
+}
diff --git a/packages/cli/src/index.ts b/packages/cli/src/index.ts
new file mode 100644
index 000000000..141edc329
--- /dev/null
+++ b/packages/cli/src/index.ts
@@ -0,0 +1,2189 @@
+/**
+ * Browse CLI - Browser automation for AI agents
+ *
+ * Usage:
+ *   browse [options] <command> [args...]
+ *
+ * The CLI runs a daemon process that maintains browser state between commands.
+ * Multiple sessions can run simultaneously using --session <name> or BROWSE_SESSION env var.
+ */
+
+import { Command } from "commander";
+import { Stagehand } from "@browserbasehq/stagehand";
+import { promises as fs } from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as net from "net";
+import { spawn } from "child_process";
+import * as readline from "readline";
+import { createRequire } from "module";
+
+// Load version from package.json
+const require = createRequire(import.meta.url);
+const { version: VERSION } = require("../package.json");
+
+const program = new Command();
+
+// Type aliases - using any for flexibility with Stagehand internals
+type BrowseContext = Stagehand["context"];
+type BrowsePage = ReturnType<BrowseContext["pages"]>[number];
+
+// ==================== DAEMON INFRASTRUCTURE ====================
+
+const SOCKET_DIR = os.tmpdir();
+
+function getSocketPath(session: string): string {
+  return path.join(SOCKET_DIR, `browse-${session}.sock`);
+}
+
+function getLockPath(session: string): string {
+  return path.join(SOCKET_DIR, `browse-${session}.lock`);
+}
+
+/**
+ * Acquire an exclusive lock for daemon operations.
+ * Uses O_EXCL for atomic file creation to prevent race conditions.
+ */
+async function acquireLock(session: string, timeoutMs: number = 10000): Promise<boolean> {
+  const lockPath = getLockPath(session);
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < timeoutMs) {
+    try {
+      // O_EXCL ensures atomic creation - fails if file exists
+      const handle = await fs.open(lockPath, "wx");
+      await handle.write(String(process.pid));
+      await handle.close();
+      return true;
+    } catch (err: unknown) {
+      if ((err as NodeJS.ErrnoException).code === "EEXIST") {
+        // Lock exists - check if holder is still alive
+        try {
+          const holderPid = parseInt(await fs.readFile(lockPath, "utf-8"));
+          process.kill(holderPid, 0); // Throws if process doesn't exist
+          // Process exists, wait and retry
+          await new Promise(r => setTimeout(r, 100));
+        } catch {
+          // Lock holder is dead, remove stale lock
+          try { await fs.unlink(lockPath); } catch {}
+        }
+        continue;
+      }
+      throw err;
+    }
+  }
+  return false;
+}
+
+async function releaseLock(session: string): Promise<void> {
+  try { await fs.unlink(getLockPath(session)); } catch {}
+}
+
+/**
+ * Check if a socket is actually connectable (not just exists on disk).
+ */
+async function isSocketConnectable(socketPath: string, timeoutMs: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const client = net.createConnection(socketPath);
+    const timeout = setTimeout(() => {
+      client.destroy();
+      resolve(false);
+    }, timeoutMs);
+
+    client.on("connect", () => {
+      clearTimeout(timeout);
+      client.destroy();
+      resolve(true);
+    });
+
+    client.on("error", () => {
+      clearTimeout(timeout);
+      resolve(false);
+    });
+  });
+}
+
+/**
+ * Wait for socket to become connectable with exponential backoff.
+ */
+async function waitForSocketReady(socketPath: string, timeoutMs: number): Promise<void> {
+  const startTime = Date.now();
+  let delay = 50;
+
+  while (Date.now() - startTime < timeoutMs) {
+    if (await isSocketConnectable(socketPath, 500)) return;
+    await new Promise(r => setTimeout(r, delay));
+    delay = Math.min(delay * 1.5, 500);
+  }
+  throw new Error(`Socket not ready after ${timeoutMs}ms`);
+}
+
+function getPidPath(session: string): string {
+  return path.join(SOCKET_DIR, `browse-${session}.pid`);
+}
+
+function getWsPath(session: string): string {
+  return path.join(SOCKET_DIR, `browse-${session}.ws`);
+}
+
+function getChromePidPath(session: string): string {
+  return path.join(SOCKET_DIR, `browse-${session}.chrome.pid`);
+}
+
+function getNetworkDir(session: string): string {
+  return path.join(SOCKET_DIR, `browse-${session}-network`);
+}
+
+function getModePath(session: string): string {
+  return path.join(SOCKET_DIR, `browse-${session}.mode`);
+}
+
+function getModeOverridePath(session: string): string {
+  return path.join(SOCKET_DIR, `browse-${session}.mode-override`);
+}
+
+type BrowseMode = "browserbase" | "local";
+
+function hasBrowserbaseCredentials(): boolean {
+  return Boolean(process.env.BROWSERBASE_API_KEY);
+}
+
+function assertModeSupported(mode: BrowseMode): void {
+  if (mode === "browserbase" && !hasBrowserbaseCredentials()) {
+    throw new Error(
+      "Remote mode requires BROWSERBASE_API_KEY. Set the env var or run `browse env local`.",
+    );
+  }
+}
+
+function toModeTarget(mode: BrowseMode): "local" | "remote" {
+  return mode === "browserbase" ? "remote" : "local";
+}
+
+async function readCurrentMode(session: string): Promise<BrowseMode | null> {
+  try {
+    const mode = (await fs.readFile(getModePath(session), "utf-8")).trim();
+    if (mode === "browserbase" || mode === "local") {
+      return mode;
+    }
+  } catch {
+    // File may not exist yet.
+  }
+  return null;
+}
+
+/** Determine desired mode: explicit override > env var detection */
+async function getDesiredMode(session: string): Promise<BrowseMode> {
+  try {
+    const override = (await fs.readFile(getModeOverridePath(session), "utf-8")).trim();
+    if (override === "browserbase" || override === "local") return override;
+  } catch {}
+  return hasBrowserbaseCredentials() ? "browserbase" : "local";
+}
+
+async function isDaemonRunning(session: string): Promise<boolean> {
+  try {
+    const pidFile = getPidPath(session);
+    const pid = parseInt(await fs.readFile(pidFile, "utf-8"));
+    process.kill(pid, 0); // Check if process exists
+
+    // Also verify socket exists and is actually connectable
+    const socketPath = getSocketPath(session);
+    await fs.access(socketPath);
+
+    // Verify socket is actually connectable (not just exists on disk)
+    return await isSocketConnectable(socketPath, 500);
+  } catch {
+    return false;
+  }
+}
+
+async function cleanupStaleFiles(session: string): Promise<void> {
+  const files = [
+    getSocketPath(session),
+    getPidPath(session),
+    getWsPath(session),
+    getChromePidPath(session),
+    getLockPath(session),
+    getModePath(session),
+  ];
+
+  for (const file of files) {
+    try { await fs.unlink(file); } catch {}
+  }
+}
+
+/** Find and kill Chrome processes for this session */
+async function killChromeProcesses(session: string): Promise<boolean> {
+  try {
+    const { exec } = await import("child_process");
+    const { promisify } = await import("util");
+    const execAsync = promisify(exec);
+
+    if (process.platform === "darwin" || process.platform === "linux") {
+      // Find Chrome processes with our user data dir pattern
+      const { stdout } = await execAsync(
+        `pgrep -f "browse-${session}" || true`,
+      );
+      const pids = stdout.trim().split("\n").filter(Boolean);
+      for (const pid of pids) {
+        try {
+          process.kill(parseInt(pid), "SIGTERM");
+        } catch {}
+      }
+      return pids.length > 0;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+interface DaemonRequest {
+  command: string;
+  args: unknown[];
+}
+
+interface DaemonResponse {
+  success: boolean;
+  result?: unknown;
+  error?: string;
+}
+
+// ==================== DAEMON SERVER ====================
+
+// Default viewport matching Stagehand core
+const DEFAULT_VIEWPORT = { width: 1288, height: 711 };
+
+async function runDaemon(session: string, headless: boolean): Promise<void> {
+  await cleanupStaleFiles(session);
+
+  // Write daemon PID file and initial mode so status is immediately available
+  await fs.writeFile(getPidPath(session), String(process.pid));
+  await fs.writeFile(getModePath(session), await getDesiredMode(session));
+
+  // Browser state (initialized lazily on first command)
+  let stagehand: Stagehand | null = null;
+  let context: BrowseContext | null = null;
+  let isInitializing = false;
+
+  /**
+   * Lazy browser initialization - called on first command (like agent-browser)
+   * This allows daemon to signal "started" immediately without waiting for browser
+   */
+  async function ensureBrowserInitialized(): Promise<{ stagehand: Stagehand; context: BrowseContext }> {
+    if (stagehand && context) {
+      return { stagehand, context };
+    }
+
+    // Prevent concurrent initialization
+    if (isInitializing) {
+      // Wait for initialization to complete
+      while (isInitializing) {
+        await new Promise(resolve => setTimeout(resolve, 100));
+      }
+      if (stagehand && context) {
+        return { stagehand, context };
+      }
+      throw new Error("Browser initialization failed");
+    }
+
+    isInitializing = true;
+
+    try {
+      const desiredMode = await getDesiredMode(session);
+      assertModeSupported(desiredMode);
+      const useBrowserbase = desiredMode === "browserbase";
+
+      stagehand = new Stagehand({
+        env: useBrowserbase ? "BROWSERBASE" : "LOCAL",
+        verbose: 0,
+        disablePino: true,
+        ...(useBrowserbase
+          ? {
+              disableAPI: true,
+            }
+          : { localBrowserLaunchOptions: { headless, viewport: DEFAULT_VIEWPORT } }
+        ),
+      });
+
+      // Persist mode so status command can report it
+      await fs.writeFile(getModePath(session), desiredMode);
+
+      await stagehand.init();
+
+      context = stagehand.context;
+
+      // Try to save Chrome info for reference (best effort)
+      try {
+        const wsUrl = (context as any).conn?.wsUrl || "unknown";
+        await fs.writeFile(getWsPath(session), wsUrl);
+      } catch {}
+
+      // Store session name for network capture
+      networkSession = session;
+
+      // Setup network capture helpers (called when network is enabled)
+      const setupNetworkCapture = async (targetPage: BrowsePage) => {
+    const cdpSession = targetPage.mainFrame().session;
+
+    // Track request start times for duration calculation
+    const requestStartTimes = new Map<string, number>();
+    const requestDirs = new Map<string, string>();
+
+    cdpSession.on("Network.requestWillBeSent", async (params: any) => {
+      if (!networkEnabled || !networkDir) return;
+
+      const request: PendingRequest = {
+        id: params.requestId,
+        timestamp: new Date().toISOString(),
+        method: params.request.method,
+        url: params.request.url,
+        headers: params.request.headers || {},
+        body: params.request.postData || null,
+        resourceType: params.type || "Other",
+      };
+
+      pendingRequests.set(params.requestId, request);
+      requestStartTimes.set(params.requestId, Date.now());
+
+      // Write request immediately
+      const requestDir = await writeRequestToFs(request);
+      if (requestDir) {
+        requestDirs.set(params.requestId, requestDir);
+      }
+    });
+
+    cdpSession.on("Network.responseReceived", async (params: any) => {
+      if (!networkEnabled) return;
+
+      const requestDir = requestDirs.get(params.requestId);
+      if (!requestDir) return;
+
+      // Store response info for when we get the body
+      const startTime = requestStartTimes.get(params.requestId) || Date.now();
+      const duration = Date.now() - startTime;
+
+      // Response info without body (body comes later)
+      const responseInfo = {
+        id: params.requestId,
+        status: params.response.status,
+        statusText: params.response.statusText || "",
+        headers: params.response.headers || {},
+        mimeType: params.response.mimeType || "",
+        body: null as string | null,
+        duration,
+      };
+
+      // Store for body retrieval
+      (params as any)._responseInfo = responseInfo;
+      (params as any)._requestDir = requestDir;
+    });
+
+    cdpSession.on("Network.loadingFinished", async (params: any) => {
+      if (!networkEnabled) return;
+
+      const requestDir = requestDirs.get(params.requestId);
+      const pending = pendingRequests.get(params.requestId);
+      if (!requestDir || !pending) return;
+
+      const startTime = requestStartTimes.get(params.requestId) || Date.now();
+      const duration = Date.now() - startTime;
+
+      let body: string | null = null;
+      try {
+        const result = await cdpSession.send("Network.getResponseBody", {
+          requestId: params.requestId,
+        });
+        body = (result as any).body || null;
+        if ((result as any).base64Encoded && body) {
+          body = `[base64] ${body.slice(0, 100)}...`;
+        }
+      } catch {
+        // Body not available (e.g., for redirects)
+      }
+
+      const responseData = {
+        id: params.requestId,
+        status: 0,
+        statusText: "",
+        headers: {} as Record<string, string>,
+        mimeType: "",
+        body,
+        duration,
+      };
+
+      await writeResponseToFs(requestDir, responseData);
+
+      // Cleanup
+      pendingRequests.delete(params.requestId);
+      requestStartTimes.delete(params.requestId);
+      requestDirs.delete(params.requestId);
+    });
+
+    cdpSession.on("Network.loadingFailed", async (params: any) => {
+      if (!networkEnabled) return;
+
+      const requestDir = requestDirs.get(params.requestId);
+      if (!requestDir) return;
+
+      const startTime = requestStartTimes.get(params.requestId) || Date.now();
+      const duration = Date.now() - startTime;
+
+      const responseData = {
+        id: params.requestId,
+        status: 0,
+        statusText: "Failed",
+        headers: {},
+        mimeType: "",
+        body: null,
+        duration,
+        error: params.errorText || "Unknown error",
+      };
+
+      await writeResponseToFs(requestDir, responseData);
+
+      // Cleanup
+      pendingRequests.delete(params.requestId);
+      requestStartTimes.delete(params.requestId);
+      requestDirs.delete(params.requestId);
+    });
+      }; // Close setupNetworkCapture function
+
+      // Store the setup function for use when network is enabled
+      (context as any)._setupNetworkCapture = setupNetworkCapture;
+
+      return { stagehand, context };
+    } finally {
+      isInitializing = false;
+    }
+  }
+
+  // Create Unix socket server
+  const socketPath = getSocketPath(session);
+  const server = net.createServer((conn) => {
+    const rl = readline.createInterface({ input: conn });
+
+    rl.on("line", async (line) => {
+      let response: DaemonResponse;
+      try {
+        const request: DaemonRequest = JSON.parse(line);
+
+        // Lazy browser initialization on first command (like agent-browser)
+        const { stagehand: sh, context: ctx } = await ensureBrowserInitialized();
+
+        const result = await executeCommand(
+          ctx,
+          request.command,
+          request.args,
+          sh,
+        );
+        response = { success: true, result };
+      } catch (e) {
+        response = {
+          success: false,
+          error: e instanceof Error ? e.message : String(e),
+        };
+      }
+      conn.write(JSON.stringify(response) + "\n");
+    });
+
+    rl.on("close", () => {
+      conn.destroy();
+    });
+  });
+
+  server.listen(socketPath);
+
+  // Signal daemon started immediately (before browser initialization)
+  console.log(JSON.stringify({ daemon: "started", session, pid: process.pid }));
+
+  // Graceful shutdown handler
+  let shuttingDown = false;
+  const shutdown = async (_signal?: string) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+
+    server.close();
+
+    try {
+      if (stagehand) {
+        await stagehand.close();
+      }
+    } catch {}
+
+    await cleanupStaleFiles(session);
+    process.exit(0);
+  };
+
+  // Handle all termination signals
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGHUP", () => shutdown("SIGHUP"));
+  process.on("uncaughtException", (err) => {
+    console.error("Uncaught exception:", err);
+    shutdown("uncaughtException");
+  });
+  process.on("unhandledRejection", (reason) => {
+    console.error("Unhandled rejection:", reason);
+    shutdown("unhandledRejection");
+  });
+
+  // Keep daemon running (signal already sent above)
+}
+
+// ==================== REF MAP (cached from last snapshot) ====================
+
+/** Cached ref maps from the last snapshot - allows @ref syntax in commands */
+let refMap: {
+  xpathMap: Record<string, string>;
+  cssMap: Record<string, string>;
+  urlMap: Record<string, string>;
+} = {
+  xpathMap: {},
+  cssMap: {},
+  urlMap: {},
+};
+
+// ==================== NETWORK CAPTURE STATE ====================
+
+interface PendingRequest {
+  id: string;
+  timestamp: string;
+  method: string;
+  url: string;
+  headers: Record<string, string>;
+  body: string | null;
+  resourceType: string;
+}
+
+let networkEnabled = false;
+let networkDir: string | null = null;
+let networkCounter = 0;
+let networkSession: string | null = null;
+const pendingRequests = new Map<string, PendingRequest>();
+
+/** Sanitize a string for use in a filename */
+function sanitizeForFilename(str: string, maxLen: number = 30): string {
+  return str
+    .replace(/[^a-zA-Z0-9.-]/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, maxLen);
+}
+
+/** Generate a directory name for a request */
+function getRequestDirName(
+  counter: number,
+  method: string,
+  url: string,
+): string {
+  try {
+    const parsed = new URL(url);
+    const domain = sanitizeForFilename(parsed.hostname, 30);
+    const pathPart = parsed.pathname.split("/").filter(Boolean)[0] || "root";
+    const pathSlug = sanitizeForFilename(pathPart, 20);
+    return `${String(counter).padStart(3, "0")}-${method}-${domain}-${pathSlug}`;
+  } catch {
+    return `${String(counter).padStart(3, "0")}-${method}-unknown`;
+  }
+}
+
+/** Write request data to filesystem */
+async function writeRequestToFs(
+  request: PendingRequest,
+): Promise<string | null> {
+  if (!networkDir) return null;
+
+  const dirName = getRequestDirName(
+    networkCounter++,
+    request.method,
+    request.url,
+  );
+  const requestDir = path.join(networkDir, dirName);
+
+  try {
+    await fs.mkdir(requestDir, { recursive: true });
+
+    const requestData = {
+      id: request.id,
+      timestamp: request.timestamp,
+      method: request.method,
+      url: request.url,
+      headers: request.headers,
+      body: request.body,
+      resourceType: request.resourceType,
+    };
+    await fs.writeFile(
+      path.join(requestDir, "request.json"),
+      JSON.stringify(requestData, null, 2),
+    );
+
+    return requestDir;
+  } catch (err) {
+    console.error("Failed to write request:", err);
+    return null;
+  }
+}
+
+/** Write response data to filesystem */
+async function writeResponseToFs(
+  requestDir: string,
+  response: {
+    id: string;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    mimeType: string;
+    body: string | null;
+    duration: number;
+    error?: string;
+  },
+): Promise<void> {
+  try {
+    await fs.writeFile(
+      path.join(requestDir, "response.json"),
+      JSON.stringify(response, null, 2),
+    );
+  } catch (err) {
+    console.error("Failed to write response:", err);
+  }
+}
+
+
+/**
+ * Parse a ref from a selector argument.
+ * Supports: @0-3, @[0-3], [0-3], 0-3, ref=0-3
+ */
+function parseRef(selector: string): string | null {
+  if (selector.startsWith("@")) {
+    const rest = selector.slice(1);
+    if (rest.startsWith("[") && rest.endsWith("]")) {
+      return rest.slice(1, -1);
+    }
+    return rest;
+  }
+  if (
+    selector.startsWith("[") &&
+    selector.endsWith("]") &&
+    /^\[\d+-\d+\]$/.test(selector)
+  ) {
+    return selector.slice(1, -1);
+  }
+  if (selector.startsWith("ref=")) {
+    return selector.slice(4);
+  }
+  if (/^\d+-\d+$/.test(selector)) {
+    return selector;
+  }
+  return null;
+}
+
+/**
+ * Resolve a selector - if it's a ref, look up from refMap.
+ * Always uses XPath since CSS selectors cannot cross shadow DOM boundaries
+ * and can cause issues with dynamically generated class names.
+ */
+function resolveSelector(selector: string): string {
+  const ref = parseRef(selector);
+  if (ref) {
+    const xpath = refMap.xpathMap[ref];
+    if (!xpath) {
+      throw new Error(
+        `Unknown ref "${ref}" - run snapshot first to populate refs (have ${Object.keys(refMap.xpathMap).length} refs)`,
+      );
+    }
+    return xpath;
+  }
+  return selector;
+}
+
+// ==================== COMMAND EXECUTION ====================
+
+async function executeCommand(
+  context: BrowseContext,
+  command: string,
+  args: unknown[],
+  stagehand?: Stagehand,
+): Promise<unknown> {
+  // Use awaitActivePage() like stagehand.act() does - handles popups and waits for page to be ready
+  const page = command !== "pages" && command !== "newpage"
+    ? await context.awaitActivePage()
+    : context.activePage();
+  if (!page && command !== "pages" && command !== "newpage") {
+    throw new Error("No active page");
+  }
+
+  switch (command) {
+    // Navigation
+    case "open": {
+      const [url, waitUntil, timeout] = args as [string, string?, number?];
+      await page!.goto(url, {
+        waitUntil: waitUntil as "load" | "domcontentloaded" | "networkidle",
+        timeout: timeout ?? 30000,
+      });
+      return { url: page!.url() };
+    }
+    case "reload": {
+      await page!.reload();
+      return { url: page!.url() };
+    }
+    case "back": {
+      await page!.goBack();
+      return { url: page!.url() };
+    }
+    case "forward": {
+      await page!.goForward();
+      return { url: page!.url() };
+    }
+
+    // Click by ref - uses stagehand.act with Action type (skips LLM, uses deterministic path)
+    case "click": {
+      const [selector] = args as [string];
+      if (!stagehand) {
+        throw new Error("Stagehand instance not available");
+      }
+      const resolved = resolveSelector(selector);
+
+      // Construct an Action object (like observe() returns) to use the deterministic path
+      const action = {
+        selector: resolved,
+        description: "click element",
+        method: "click",
+        arguments: [],
+      };
+
+      await stagehand.act(action);
+      return { clicked: true };
+    }
+
+    // Click by coordinates
+    case "click_xy": {
+      const [x, y, opts] = args as [
+        number,
+        number,
+        { button?: string; clickCount?: number; returnXPath?: boolean },
+      ];
+      const result = await page!.click(x, y, {
+        button: (opts?.button as "left" | "right" | "middle") ?? "left",
+        clickCount: opts?.clickCount ?? 1,
+      });
+      if (opts?.returnXPath) {
+        return { clicked: true, xpath: result?.xpath };
+      }
+      return { clicked: true };
+    }
+    case "hover": {
+      const [x, y, opts] = args as [number, number, { returnXPath?: boolean }];
+      const result = await page!.hover(x, y);
+      if (opts?.returnXPath) {
+        return { hovered: true, xpath: result?.xpath };
+      }
+      return { hovered: true };
+    }
+    case "scroll": {
+      const [x, y, deltaX, deltaY, opts] = args as [
+        number,
+        number,
+        number,
+        number,
+        { returnXPath?: boolean },
+      ];
+      const result = await page!.scroll(x, y, deltaX, deltaY);
+      if (opts?.returnXPath) {
+        return { scrolled: true, xpath: result?.xpath };
+      }
+      return { scrolled: true };
+    }
+    case "drag": {
+      const [fromX, fromY, toX, toY, opts] = args as [
+        number,
+        number,
+        number,
+        number,
+        {
+          steps?: number;
+          delay?: number;
+          button?: string;
+          returnXPath?: boolean;
+        },
+      ];
+
+      const [fromXpath, toXpath] = await page!.dragAndDrop(
+        fromX,
+        fromY,
+        toX,
+        toY,
+        {
+          button: (opts?.button as "left" | "right" | "middle") ?? "left",
+          steps: opts?.steps ?? 10,
+          delay: opts?.delay ?? 0,
+          returnXpath: opts?.returnXPath,
+        },
+      );
+
+      if (opts?.returnXPath) {
+        return {
+          dragged: true,
+          xpath: fromXpath,
+          fromXpath,
+          toXpath,
+        };
+      }
+      return { dragged: true };
+    }
+    // Keyboard
+    case "type": {
+      const [text, opts] = args as [
+        string,
+        { delay?: number; mistakes?: boolean },
+      ];
+      await page!.type(text, { delay: opts?.delay, humanize: opts?.mistakes });
+      return { typed: true };
+    }
+    case "press": {
+      const [key] = args as [string];
+      await page!.keyPress(key);
+      return { pressed: key };
+    }
+
+    // Element actions - use stagehand.act with Action type for reliable interaction
+    case "fill": {
+      const [selector, value, opts] = args as [
+        string,
+        string,
+        { pressEnter?: boolean }?,
+      ];
+      if (!stagehand) {
+        throw new Error("Stagehand instance not available");
+      }
+      const resolved = resolveSelector(selector);
+      const action = {
+        selector: resolved,
+        description: "fill element",
+        method: "fill",
+        arguments: [value],
+      };
+      await stagehand.act(action);
+      if (opts?.pressEnter) {
+        await page!.keyPress("Enter");
+      }
+      return { filled: true, pressedEnter: opts?.pressEnter ?? false };
+    }
+    case "select": {
+      const [selector, values] = args as [string, string[]];
+      if (!stagehand) {
+        throw new Error("Stagehand instance not available");
+      }
+      const resolved = resolveSelector(selector);
+      // selectOption takes the first value as argument
+      const action = {
+        selector: resolved,
+        description: "select option",
+        method: "selectOption",
+        arguments: [values[0] || ""],
+      };
+      await stagehand.act(action);
+      return { selected: values };
+    }
+    case "highlight": {
+      const [selector, duration] = args as [string, number?];
+      await page!
+        .deepLocator(resolveSelector(selector))
+        .highlight({ durationMs: duration ?? 2000 });
+      return { highlighted: true };
+    }
+    // Page info
+    case "get": {
+      const [what, selector] = args as [string, string?];
+      switch (what) {
+        case "url":
+          return { url: page!.url() };
+        case "title":
+          return { title: await page!.title() };
+        case "text":
+          return {
+            text: await page!
+              .deepLocator(resolveSelector(selector!))
+              .textContent(),
+          };
+        case "html":
+          return {
+            html: await page!
+              .deepLocator(resolveSelector(selector!))
+              .innerHtml(),
+          };
+        case "value":
+          return {
+            value: await page!
+              .deepLocator(resolveSelector(selector!))
+              .inputValue(),
+          };
+        case "box": {
+          const { x, y } = await page!
+            .deepLocator(resolveSelector(selector!))
+            .centroid();
+          return { x: Math.round(x), y: Math.round(y) };
+        }
+        case "visible":
+          return {
+            visible: await page!
+              .deepLocator(resolveSelector(selector!))
+              .isVisible(),
+          };
+        case "checked":
+          return {
+            checked: await page!
+              .deepLocator(resolveSelector(selector!))
+              .isChecked(),
+          };
+        default:
+          throw new Error(`Unknown get type: ${what}`);
+      }
+    }
+
+    // Screenshot
+    case "screenshot": {
+      const [opts] = args as [
+        {
+          path?: string;
+          fullPage?: boolean;
+          type?: string;
+          quality?: number;
+          clip?: object;
+          animations?: string;
+          caret?: string;
+        },
+      ];
+      const buffer = await page!.screenshot({
+        fullPage: opts?.fullPage,
+        type: opts?.type as "png" | "jpeg" | undefined,
+        quality: opts?.quality,
+        clip: opts?.clip as
+          | { x: number; y: number; width: number; height: number }
+          | undefined,
+        animations: opts?.animations as "disabled" | "allow" | undefined,
+        caret: opts?.caret as "hide" | "initial" | undefined,
+        timeout: 10000,
+      });
+      if (opts?.path) {
+        await fs.writeFile(opts.path, buffer);
+        return { saved: opts.path };
+      }
+      return { base64: buffer.toString("base64") };
+    }
+
+    // Snapshot
+    case "snapshot": {
+      const [compact] = args as [boolean?];
+      const snapshot = await page!.snapshot();
+
+      refMap = {
+        xpathMap: snapshot.xpathMap ?? {},
+        cssMap: snapshot.cssMap ?? {},
+        urlMap: snapshot.urlMap ?? {},
+      };
+
+      if (compact) {
+        return { tree: snapshot.formattedTree };
+      }
+      return {
+        tree: snapshot.formattedTree,
+        xpathMap: snapshot.xpathMap,
+        urlMap: snapshot.urlMap,
+        cssMap: snapshot.cssMap,
+      };
+    }
+
+    // Viewport
+    case "viewport": {
+      const [width, height, scale] = args as [number, number, number?];
+      await page!.setViewportSize(width, height, {
+        deviceScaleFactor: scale ?? 1,
+      });
+      return { viewport: { width, height } };
+    }
+
+    // Eval
+    case "eval": {
+      const [expr] = args as [string];
+      const result = await page!.evaluate(expr);
+      return { result };
+    }
+    // Element state
+    case "is": {
+      const [check, selector] = args as [string, string];
+      const locator = page!.deepLocator(resolveSelector(selector));
+      switch (check) {
+        case "visible":
+          return { visible: await locator.isVisible() };
+        case "checked":
+          return { checked: await locator.isChecked() };
+        default:
+          throw new Error(`Unknown check: ${check}`);
+      }
+    }
+    // Wait
+    case "wait": {
+      const [type, arg, opts] = args as [
+        string,
+        string?,
+        { timeout?: number; state?: string }?,
+      ];
+      switch (type) {
+        case "load":
+          await page!.waitForLoadState(
+            (arg as "load" | "domcontentloaded" | "networkidle") ?? "load",
+            opts?.timeout ?? 30000,
+          );
+          break;
+        case "selector":
+          await page!.waitForSelector(resolveSelector(arg!), {
+            state:
+              (opts?.state as "attached" | "detached" | "visible" | "hidden") ??
+              "visible",
+            timeout: opts?.timeout ?? 30000,
+          });
+          break;
+        case "timeout":
+          await page!.waitForTimeout(parseInt(arg!));
+          break;
+        default:
+          throw new Error(`Unknown wait type: ${type}`);
+      }
+      return { waited: true };
+    }
+
+    // Cursor
+    case "cursor": {
+      await page!.enableCursorOverlay();
+      return { cursor: "enabled" };
+    }
+
+    // Multi-page
+    case "pages": {
+      const pages = context.pages();
+      return {
+        pages: pages.map((p: BrowsePage, i: number) => ({
+          index: i,
+          url: p.url(),
+          targetId: p.targetId(),
+        })),
+      };
+    }
+    case "newpage": {
+      const [url] = args as [string?];
+      const newPage = await context.newPage(url);
+      return {
+        created: true,
+        url: newPage.url(),
+        targetId: newPage.targetId(),
+      };
+    }
+    case "tab_switch": {
+      const [index] = args as [number];
+      const pages = context.pages();
+      if (index < 0 || index >= pages.length) {
+        throw new Error(
+          `Tab index ${index} out of range (0-${pages.length - 1})`,
+        );
+      }
+      context.setActivePage(pages[index]);
+      return { switched: true, index, url: pages[index].url() };
+    }
+    case "tab_close": {
+      const [index] = args as [number?];
+      const pages = context.pages();
+      const targetIndex = index ?? pages.length - 1;
+      if (targetIndex < 0 || targetIndex >= pages.length) {
+        throw new Error(
+          `Tab index ${targetIndex} out of range (0-${pages.length - 1})`,
+        );
+      }
+      if (pages.length === 1) {
+        throw new Error("Cannot close the last tab");
+      }
+      await pages[targetIndex].close();
+      return { closed: true, index: targetIndex };
+    }
+
+    // Debug: show current ref map
+    case "refs": {
+      return {
+        count: Object.keys(refMap.xpathMap).length,
+        xpathMap: refMap.xpathMap,
+        cssMap: refMap.cssMap,
+        urlMap: refMap.urlMap,
+      };
+    }
+
+    // Network capture commands
+    case "network_enable": {
+      if (networkEnabled && networkDir) {
+        return { enabled: true, path: networkDir, alreadyEnabled: true };
+      }
+
+      const session = networkSession || "default";
+      networkDir = getNetworkDir(session);
+      await fs.mkdir(networkDir, { recursive: true });
+      networkCounter = 0;
+      pendingRequests.clear();
+
+      const cdpSession = page!.mainFrame().session;
+      await cdpSession.send("Network.enable", {
+        maxTotalBufferSize: 10000000,
+        maxResourceBufferSize: 5000000,
+      });
+
+      const setupFn = (context as any)._setupNetworkCapture;
+      if (setupFn) {
+        await setupFn(page!);
+      }
+
+      networkEnabled = true;
+      return { enabled: true, path: networkDir };
+    }
+
+    case "network_disable": {
+      if (!networkEnabled) {
+        return { enabled: false, alreadyDisabled: true };
+      }
+
+      try {
+        const cdpSession = page!.mainFrame().session;
+        await cdpSession.send("Network.disable");
+      } catch {}
+
+      networkEnabled = false;
+      return { enabled: false, path: networkDir };
+    }
+
+    case "network_path": {
+      if (!networkDir) {
+        const session = networkSession || "default";
+        return { path: getNetworkDir(session), enabled: false };
+      }
+      return { path: networkDir, enabled: networkEnabled };
+    }
+
+    case "network_clear": {
+      if (!networkDir) {
+        return { cleared: false, error: "Network capture not enabled" };
+      }
+
+      try {
+        const entries = await fs.readdir(networkDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            await fs.rm(path.join(networkDir, entry.name), { recursive: true });
+          }
+        }
+        networkCounter = 0;
+        pendingRequests.clear();
+        return { cleared: true, path: networkDir };
+      } catch (err) {
+        return {
+          cleared: false,
+          error: err instanceof Error ? err.message : String(err),
+        };
+      }
+    }
+
+    // Daemon control
+    case "stop": {
+      process.nextTick(() => {
+        process.emit("SIGTERM");
+      });
+      return { stopping: true };
+    }
+
+    default:
+      throw new Error(`Unknown command: ${command}`);
+  }
+}
+
+// ==================== CLIENT ====================
+
+async function sendCommandOnce(
+  session: string,
+  command: string,
+  args: unknown[],
+): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    const socketPath = getSocketPath(session);
+    const client = net.createConnection(socketPath);
+    let done = false;
+
+    const timeout = setTimeout(() => {
+      cleanup();
+      reject(new Error("Command timeout"));
+    }, 60000);
+
+    const cleanup = () => {
+      if (!done) {
+        done = true;
+        clearTimeout(timeout);
+        rl.close();
+        client.destroy();
+      }
+    };
+
+    const rl = readline.createInterface({ input: client });
+
+    rl.on("line", (line) => {
+      const response: DaemonResponse = JSON.parse(line);
+      cleanup();
+      if (response.success) {
+        resolve(response.result);
+      } else {
+        reject(new Error(response.error));
+      }
+    });
+
+    rl.on("error", () => {});
+
+    client.on("connect", () => {
+      const request: DaemonRequest = { command, args };
+      client.write(JSON.stringify(request) + "\n");
+    });
+
+    client.on("error", (err) => {
+      cleanup();
+      reject(new Error(`Connection failed: ${err.message}`));
+    });
+  });
+}
+
+/** Send command with automatic retry and daemon restart on connection failure */
+async function sendCommand(
+  session: string,
+  command: string,
+  args: unknown[],
+  headless: boolean = false,
+): Promise<unknown> {
+  const maxRetries = 3;
+
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      return await sendCommandOnce(session, command, args);
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+
+      if (command === "stop") {
+        throw err;
+      }
+
+      const isConnectionError =
+        errMsg.includes("ENOENT") ||
+        errMsg.includes("ECONNREFUSED") ||
+        errMsg.includes("Connection failed");
+
+      if (!isConnectionError) {
+        throw err;
+      }
+
+      // Attempt 0: Brief wait and retry (socket might be temporarily unavailable)
+      if (attempt === 0) {
+        await new Promise(r => setTimeout(r, 200));
+        continue;
+      }
+
+      // Attempt 1: Try to restart daemon without cleanup
+      if (attempt === 1) {
+        await ensureDaemon(session, headless);
+        continue;
+      }
+
+      // Final attempt: Full cleanup and restart
+      await killChromeProcesses(session);
+      await cleanupStaleFiles(session);
+      await ensureDaemon(session, headless);
+    }
+  }
+
+  throw new Error(`Max retries exceeded for command ${command} on session ${session}`);
+}
+
+async function stopDaemonAndCleanup(session: string): Promise<void> {
+  try {
+    await sendCommandOnce(session, "stop", []);
+  } catch {
+    // Daemon may already be down.
+  }
+  await new Promise((r) => setTimeout(r, 500));
+  await cleanupStaleFiles(session);
+}
+
+async function ensureDaemon(session: string, headless: boolean): Promise<void> {
+  const wantMode = await getDesiredMode(session);
+  assertModeSupported(wantMode);
+
+  if (await isDaemonRunning(session)) {
+    // Missing mode file means daemon predates mode support, which was local-only.
+    const currentMode = (await readCurrentMode(session)) ?? "local";
+    if (currentMode === wantMode) {
+      return;
+    }
+    await stopDaemonAndCleanup(session);
+  }
+
+  // Acquire lock before spawning to prevent race conditions
+  const locked = await acquireLock(session);
+  if (!locked) {
+    throw new Error(`Timeout acquiring lock for session ${session}`);
+  }
+
+  try {
+    // Re-check after acquiring lock (another process may have started daemon)
+    if (await isDaemonRunning(session)) {
+      const currentMode = (await readCurrentMode(session)) ?? "local";
+      if (currentMode === wantMode) {
+        return;
+      }
+      await stopDaemonAndCleanup(session);
+    }
+
+    const args = ["--session", session, "daemon"];
+    if (headless) args.push("--headless");
+
+    const child = spawn(process.argv[0], [process.argv[1], ...args], {
+      detached: true,
+      // Avoid piping stdout for detached daemon startup. Deep-locator internals
+      // can log via console fallback, and writing to a broken pipe crashes daemon.
+      stdio: ["ignore", "ignore", "ignore"],
+    });
+    child.unref();
+
+    await new Promise<void>((resolve, reject) => {
+      let settled = false;
+
+      const finish = (err?: Error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        child.off("error", onError);
+        child.off("exit", onExit);
+        if (err) reject(err);
+        else resolve();
+      };
+
+      const onError = (err: Error) => {
+        finish(err);
+      };
+
+      const onExit = (code: number | null, signal: string | null) => {
+        finish(
+          new Error(
+            `Daemon exited before ready (code=${code ?? "null"}, signal=${signal ?? "null"})`,
+          ),
+        );
+      };
+
+      const timeout = setTimeout(() => {
+        finish(new Error("Timeout waiting for daemon to start"));
+      }, 30000);
+
+      child.once("error", onError);
+      child.once("exit", onExit);
+
+      // Readiness is determined by socket connectivity, not daemon stdout.
+      waitForSocketReady(getSocketPath(session), 28000)
+        .then(() => finish())
+        .catch((err) =>
+          finish(err instanceof Error ? err : new Error(String(err))),
+        );
+    });
+  } finally {
+    await releaseLock(session);
+  }
+}
+
+// ==================== CLI INTERFACE ====================
+
+interface GlobalOpts {
+  ws?: string;
+  headless?: boolean;
+  headed?: boolean;
+  json?: boolean;
+  session?: string;
+}
+
+function getSession(opts: GlobalOpts): string {
+  return opts.session ?? process.env.BROWSE_SESSION ?? "default";
+}
+
+function isHeadless(opts: GlobalOpts): boolean {
+  return opts.headless === true && opts.headed !== true;
+}
+
+function output(data: unknown, json: boolean): void {
+  if (json) {
+    console.log(JSON.stringify(data, null, 2));
+  } else if (typeof data === "string") {
+    console.log(data);
+  } else {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}
+
+async function runCommand(command: string, args: unknown[]): Promise<unknown> {
+  const opts = program.opts<GlobalOpts>();
+  const session = getSession(opts);
+  const headless = isHeadless(opts);
+  // If --ws provided, bypass daemon and connect directly
+  if (opts.ws) {
+    const stagehand = new Stagehand({
+      env: "LOCAL",
+      verbose: 0,
+      disablePino: true,
+      localBrowserLaunchOptions: {
+        cdpUrl: opts.ws,
+      },
+    });
+    await stagehand.init();
+    try {
+      return await executeCommand(stagehand.context, command, args);
+    } finally {
+      await stagehand.close();
+    }
+  }
+
+  await ensureDaemon(session, headless);
+  return sendCommand(session, command, args, headless);
+}
+
+program
+  .name("browse")
+  .description("Browser automation CLI for AI agents")
+  .version(VERSION)
+  .option(
+    "--ws <url>",
+    "CDP WebSocket URL (bypasses daemon, direct connection)",
+  )
+  .option("--headless", "Run Chrome in headless mode")
+  .option("--headed", "Run Chrome with visible window (default)")
+  .option("--json", "Output as JSON", false)
+  .option(
+    "--session <name>",
+    "Session name for multiple browsers (or use BROWSE_SESSION env var)",
+  );
+
+// ==================== DAEMON COMMANDS ====================
+
+program
+  .command("start")
+  .description("Start browser daemon (auto-started by other commands)")
+  .action(async () => {
+    const opts = program.opts<GlobalOpts>();
+    const session = getSession(opts);
+    if (await isDaemonRunning(session)) {
+      console.log(JSON.stringify({ status: "already running", session }));
+      return;
+    }
+    await ensureDaemon(session, isHeadless(opts));
+    console.log(JSON.stringify({ status: "started", session }));
+  });
+
+program
+  .command("stop")
+  .description("Stop browser daemon")
+  .option("--force", "Force kill Chrome processes if daemon is unresponsive")
+  .action(async (cmdOpts) => {
+    const opts = program.opts<GlobalOpts>();
+    const session = getSession(opts);
+    // Clear any explicit env override so next start uses env var detection
+    try { await fs.unlink(getModeOverridePath(session)); } catch {}
+    try {
+      await sendCommand(session, "stop", []);
+      console.log(JSON.stringify({ status: "stopped", session }));
+    } catch {
+      if (cmdOpts.force) {
+        await killChromeProcesses(session);
+        await cleanupStaleFiles(session);
+        console.log(JSON.stringify({ status: "force stopped", session }));
+      } else {
+        console.log(JSON.stringify({ status: "not running", session }));
+      }
+    }
+  });
+
+program
+  .command("status")
+  .description("Check daemon status")
+  .action(async () => {
+    const opts = program.opts<GlobalOpts>();
+    const session = getSession(opts);
+    const running = await isDaemonRunning(session);
+    let wsUrl = null;
+    let mode: BrowseMode | null = null;
+    if (running) {
+      try {
+        wsUrl = await fs.readFile(getWsPath(session), "utf-8");
+      } catch {}
+      mode = await readCurrentMode(session);
+    }
+    console.log(JSON.stringify({ running, session, wsUrl, mode }));
+  });
+
+program
+  .command("env [target]")
+  .description("Show or switch browser environment (local | remote)")
+  .action(async (target?: string) => {
+    const opts = program.opts<GlobalOpts>();
+    const session = getSession(opts);
+
+    if (!target) {
+      let mode: string | null = null;
+      const desiredMode = await getDesiredMode(session);
+      if (await isDaemonRunning(session)) {
+        mode = toModeTarget((await readCurrentMode(session)) ?? desiredMode);
+      }
+      console.log(JSON.stringify({
+        mode: mode ?? "not running",
+        desired: toModeTarget(desiredMode),
+        session,
+      }));
+      return;
+    }
+
+    const modeMap: Record<string, BrowseMode> = {
+      local: "local",
+      remote: "browserbase",
+    };
+    const mapped = modeMap[target];
+    if (!mapped) {
+      console.error('Usage: browse env [local|remote]');
+      process.exit(1);
+    }
+
+    try {
+      assertModeSupported(mapped);
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+
+    await fs.writeFile(getModeOverridePath(session), mapped);
+
+    if (await isDaemonRunning(session)) {
+      const currentMode = (await readCurrentMode(session)) ?? "local";
+      if (currentMode === mapped) {
+        console.log(JSON.stringify({
+          mode: toModeTarget(mapped),
+          session,
+          restarted: false,
+        }));
+        return;
+      }
+      await stopDaemonAndCleanup(session);
+    }
+
+    await ensureDaemon(session, isHeadless(opts));
+
+    console.log(JSON.stringify({
+      mode: toModeTarget(mapped),
+      session,
+      restarted: true,
+    }));
+  });
+
+program
+  .command("refs")
+  .description("Show cached ref map from last snapshot")
+  .action(async () => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("refs", []);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("daemon")
+  .description("Run as daemon (internal use)")
+  .action(async () => {
+    const opts = program.opts<GlobalOpts>();
+    await runDaemon(getSession(opts), isHeadless(opts));
+  });
+
+// ==================== NAVIGATION ====================
+
+program
+  .command("open <url>")
+  .alias("goto")
+  .description("Navigate to URL")
+  .option(
+    "--wait <state>",
+    "Wait state: load, domcontentloaded, networkidle",
+    "load",
+  )
+  .option("-t, --timeout <ms>", "Navigation timeout in milliseconds", "30000")
+  .action(async (url: string, cmdOpts) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("open", [
+        url,
+        cmdOpts.wait,
+        parseInt(cmdOpts.timeout),
+      ]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("reload")
+  .description("Reload current page")
+  .action(async () => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("reload", []);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("back")
+  .description("Go back in history")
+  .action(async () => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("back", []);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("forward")
+  .description("Go forward in history")
+  .action(async () => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("forward", []);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+// ==================== CLICK ACTIONS ====================
+
+program
+  .command("click <ref>")
+  .description("Click element by ref (e.g., @0-5, 0-5, or CSS/XPath selector)")
+  .option("-b, --button <btn>", "Mouse button: left, right, middle", "left")
+  .option("-c, --count <n>", "Click count", "1")
+  .option("-f, --force", "Force click even if element has no layout (uses synthetic event)")
+  .action(async (ref: string, cmdOpts) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("click", [
+        ref,
+        { button: cmdOpts.button, clickCount: parseInt(cmdOpts.count), force: cmdOpts.force },
+      ]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("click_xy <x> <y>")
+  .description("Click at exact coordinates")
+  .option("-b, --button <btn>", "Mouse button: left, right, middle", "left")
+  .option("-c, --count <n>", "Click count", "1")
+  .option("--xpath", "Return XPath of clicked element")
+  .action(async (x: string, y: string, cmdOpts) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("click_xy", [
+        parseFloat(x),
+        parseFloat(y),
+        {
+          button: cmdOpts.button,
+          clickCount: parseInt(cmdOpts.count),
+          returnXPath: cmdOpts.xpath,
+        },
+      ]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+// ==================== COORDINATE ACTIONS ====================
+
+program
+  .command("hover <x> <y>")
+  .description("Hover at coordinates")
+  .option("--xpath", "Return XPath of hovered element")
+  .action(async (x: string, y: string, cmdOpts) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("hover", [
+        parseFloat(x),
+        parseFloat(y),
+        { returnXPath: cmdOpts.xpath },
+      ]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("scroll <x> <y> <deltaX> <deltaY>")
+  .description("Scroll at coordinates")
+  .option("--xpath", "Return XPath of scrolled element")
+  .action(async (x: string, y: string, dx: string, dy: string, cmdOpts) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("scroll", [
+        parseFloat(x),
+        parseFloat(y),
+        parseFloat(dx),
+        parseFloat(dy),
+        { returnXPath: cmdOpts.xpath },
+      ]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("drag <fromX> <fromY> <toX> <toY>")
+  .description("Drag from one point to another")
+  .option("-b, --button <btn>", "Mouse button: left, right, middle", "left")
+  .option("--steps <n>", "Number of intermediate drag steps", "10")
+  .option("--delay <ms>", "Delay between drag steps in milliseconds", "0")
+  .option("--xpath", "Return XPath of source and target elements")
+  .action(async (fx: string, fy: string, tx: string, ty: string, cmdOpts) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("drag", [
+        parseFloat(fx),
+        parseFloat(fy),
+        parseFloat(tx),
+        parseFloat(ty),
+        {
+          button: cmdOpts.button,
+          steps: parseInt(cmdOpts.steps, 10),
+          delay: parseInt(cmdOpts.delay, 10),
+          returnXPath: cmdOpts.xpath,
+        },
+      ]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+// ==================== KEYBOARD ====================
+
+program
+  .command("type <text>")
+  .description("Type text")
+  .option("-d, --delay <ms>", "Delay between keystrokes")
+  .option("--mistakes", "Enable human-like typing with mistakes")
+  .action(async (text: string, cmdOpts) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("type", [
+        text,
+        {
+          delay: cmdOpts.delay ? parseInt(cmdOpts.delay) : undefined,
+          mistakes: cmdOpts.mistakes,
+        },
+      ]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("press <key>")
+  .alias("key")
+  .description("Press key (e.g., Enter, Tab, Escape, Cmd+A)")
+  .action(async (key: string) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("press", [key]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+// ==================== ELEMENT ACTIONS ====================
+
+program
+  .command("fill <selector> <value>")
+  .description("Fill input element (presses Enter by default)")
+  .option("--no-press-enter", "Don't press Enter after filling")
+  .action(async (selector: string, value: string, cmdOpts) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const pressEnter = cmdOpts.pressEnter !== false;
+      const result = await runCommand("fill", [
+        selector,
+        value,
+        { pressEnter },
+      ]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("select <selector> <values...>")
+  .description("Select option(s)")
+  .action(async (selector: string, values: string[]) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("select", [selector, values]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("highlight <selector>")
+  .description("Highlight element")
+  .option("-d, --duration <ms>", "Duration", "2000")
+  .action(async (selector: string, cmdOpts) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("highlight", [
+        selector,
+        parseInt(cmdOpts.duration),
+      ]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+// ==================== PAGE INFO ====================
+
+program
+  .command("get <what> [selector]")
+  .description("Get page info: url, title, text, html, value, box, visible, checked")
+  .action(async (what: string, selector?: string) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("get", [what, selector]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+// ==================== SCREENSHOT ====================
+
+program
+  .command("screenshot [path]")
+  .description("Take screenshot")
+  .option("-f, --full-page", "Full page screenshot")
+  .option("-t, --type <type>", "Image type: png, jpeg", "png")
+  .option("-q, --quality <n>", "JPEG quality (0-100)")
+  .option("--clip <json>", "Clip region as JSON")
+  .option("--no-animations", "Disable animations")
+  .option("--hide-caret", "Hide text caret")
+  .action(async (filePath: string | undefined, cmdOpts) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("screenshot", [
+        {
+          path: filePath,
+          fullPage: cmdOpts.fullPage,
+          type: cmdOpts.type,
+          quality: cmdOpts.quality ? parseInt(cmdOpts.quality) : undefined,
+          clip: cmdOpts.clip ? JSON.parse(cmdOpts.clip) : undefined,
+          animations: cmdOpts.animations === false ? "disabled" : "allow",
+          caret: cmdOpts.hideCaret ? "hide" : "initial",
+        },
+      ]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+// ==================== SNAPSHOT ====================
+
+program
+  .command("snapshot")
+  .description("Get accessibility tree snapshot")
+  .option("-c, --compact", "Output tree only (no xpath map)")
+  .action(async (cmdOpts) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = (await runCommand("snapshot", [cmdOpts.compact])) as {
+        tree: string;
+        xpathMap?: Record<string, string>;
+        urlMap?: Record<string, string>;
+        cssMap?: Record<string, string>;
+      };
+      if (cmdOpts.compact && !opts.json) {
+        console.log(result.tree);
+      } else {
+        output(result, opts.json ?? false);
+      }
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+// ==================== VIEWPORT ====================
+
+program
+  .command("viewport <width> <height>")
+  .description("Set viewport size")
+  .option("-s, --scale <n>", "Device scale factor", "1")
+  .action(async (w: string, h: string, cmdOpts) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("viewport", [
+        parseInt(w),
+        parseInt(h),
+        parseFloat(cmdOpts.scale),
+      ]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+// ==================== EVAL ====================
+
+program
+  .command("eval <expression>")
+  .description("Evaluate JavaScript in page")
+  .action(async (expr: string) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("eval", [expr]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+// ==================== WAIT ====================
+
+program
+  .command("wait <type> [arg]")
+  .description("Wait for: load, selector, timeout")
+  .option("-t, --timeout <ms>", "Timeout", "30000")
+  .option(
+    "-s, --state <state>",
+    "Element state: visible, hidden, attached, detached",
+    "visible",
+  )
+  .action(async (type: string, arg: string | undefined, cmdOpts) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("wait", [
+        type,
+        arg,
+        { timeout: parseInt(cmdOpts.timeout), state: cmdOpts.state },
+      ]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+// ==================== ELEMENT STATE CHECKS ====================
+
+program
+  .command("is <check> <selector>")
+  .description("Check element state: visible, checked")
+  .action(async (check: string, selector: string) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("is", [check, selector]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+// ==================== CURSOR ====================
+
+program
+  .command("cursor")
+  .description("Enable visual cursor overlay")
+  .action(async () => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("cursor", []);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+// ==================== MULTI-PAGE ====================
+
+program
+  .command("pages")
+  .description("List all open pages")
+  .action(async () => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("pages", []);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("newpage [url]")
+  .description("Create a new page/tab")
+  .action(async (url?: string) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("newpage", [url]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("tab_switch <index>")
+  .alias("switch")
+  .description("Switch to tab by index")
+  .action(async (index: string) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("tab_switch", [parseInt(index)]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("tab_close [index]")
+  .alias("close")
+  .description("Close tab by index (defaults to last tab)")
+  .action(async (index?: string) => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("tab_close", [
+        index ? parseInt(index) : undefined,
+      ]);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+// ==================== NETWORK CAPTURE ====================
+
+const networkCmd = program
+  .command("network")
+  .description(
+    "Network capture commands (writes to filesystem for agent inspection)",
+  );
+
+networkCmd
+  .command("on")
+  .description("Enable network capture (creates temp directory for requests)")
+  .action(async () => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("network_enable", []);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+networkCmd
+  .command("off")
+  .description("Disable network capture")
+  .action(async () => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("network_disable", []);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+networkCmd
+  .command("path")
+  .description("Get network capture directory path")
+  .action(async () => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("network_path", []);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+networkCmd
+  .command("clear")
+  .description("Clear all captured requests")
+  .action(async () => {
+    const opts = program.opts<GlobalOpts>();
+    try {
+      const result = await runCommand("network_clear", []);
+      output(result, opts.json ?? false);
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+// ==================== RUN ====================
+
+program.parse();
diff --git a/packages/cli/tests/cli.test.ts b/packages/cli/tests/cli.test.ts
new file mode 100644
index 000000000..6cf21a776
--- /dev/null
+++ b/packages/cli/tests/cli.test.ts
@@ -0,0 +1,573 @@
+/**
+ * Browse CLI Tests
+ *
+ * Comprehensive test suite covering:
+ * - Daemon lifecycle
+ * - Navigation commands
+ * - Actions (click, type, fill)
+ * - Information retrieval (snapshot, screenshot, get)
+ * - Multi-tab operations
+ * - Network capture
+ * - Error handling
+ */
+
+import {
+  describe,
+  it,
+  expect,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from "vitest";
+import { exec } from "child_process";
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+
+// CLI executable path - use tsx for development testing
+const CLI_PATH = path.join(__dirname, "../src/index.ts");
+
+// Test session name to avoid conflicts
+const TEST_SESSION = `test-${Date.now()}`;
+
+// Helper to run CLI commands
+async function browse(
+  args: string,
+  options: { timeout?: number; session?: string } = {},
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  const session = options.session ?? TEST_SESSION;
+  const timeout = options.timeout ?? 30000;
+
+  return new Promise((resolve) => {
+    const fullArgs = `tsx ${CLI_PATH} --session ${session} ${args}`;
+    exec(fullArgs, { timeout }, (error, stdout, stderr) => {
+      resolve({
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: error?.code ?? 0,
+      });
+    });
+  });
+}
+
+// Helper to parse JSON output
+function parseJson(output: string): any {
+  try {
+    return JSON.parse(output);
+  } catch {
+    throw new Error(`Failed to parse JSON: ${output}`);
+  }
+}
+
+// Cleanup helper
+async function cleanupSession(session: string): Promise<void> {
+  const tmpDir = os.tmpdir();
+  const patterns = [
+    `browse-${session}.sock`,
+    `browse-${session}.pid`,
+    `browse-${session}.ws`,
+    `browse-${session}.chrome.pid`,
+    `browse-${session}.mode`,
+    `browse-${session}.mode-override`,
+  ];
+
+  for (const pattern of patterns) {
+    try {
+      await fs.unlink(path.join(tmpDir, pattern));
+    } catch {}
+  }
+
+  // Clean network dir
+  try {
+    await fs.rm(path.join(tmpDir, `browse-${session}-network`), {
+      recursive: true,
+    });
+  } catch {}
+}
+
+describe("Browse CLI", () => {
+  // Cleanup before and after all tests
+  beforeAll(async () => {
+    await cleanupSession(TEST_SESSION);
+  });
+
+  afterAll(async () => {
+    // Stop daemon if running
+    await browse("stop --force");
+    await cleanupSession(TEST_SESSION);
+  });
+
+  describe("Daemon Lifecycle", () => {
+    afterEach(async () => {
+      await browse("stop --force");
+    });
+
+    it("should start daemon on first command", async () => {
+      const result = await browse("status");
+      const data = parseJson(result.stdout);
+      // Initially not running
+      expect(data.running).toBe(false);
+
+      // Start via command
+      const startResult = await browse("start");
+      expect(startResult.stdout).toContain("started");
+
+      // Now should be running
+      const statusResult = await browse("status");
+      const statusData = parseJson(statusResult.stdout);
+      expect(statusData.running).toBe(true);
+    });
+
+    it("should stop daemon gracefully", async () => {
+      await browse("start");
+
+      const stopResult = await browse("stop");
+      const data = parseJson(stopResult.stdout);
+      expect(data.status).toBe("stopped");
+
+      // Verify stopped
+      const statusResult = await browse("status");
+      const statusData = parseJson(statusResult.stdout);
+      expect(statusData.running).toBe(false);
+    });
+
+    it("should force stop unresponsive daemon", async () => {
+      await browse("start");
+
+      const result = await browse("stop --force");
+      const data = parseJson(result.stdout);
+      expect(["stopped", "force stopped", "not running"]).toContain(
+        data.status,
+      );
+    });
+
+    it("should support multiple sessions", async () => {
+      const session1 = `${TEST_SESSION}-1`;
+      const session2 = `${TEST_SESSION}-2`;
+
+      try {
+        // Start both sessions
+        await browse("start", { session: session1 });
+        await browse("start", { session: session2 });
+
+        // Both should be running
+        const status1 = parseJson(
+          (await browse("status", { session: session1 })).stdout,
+        );
+        const status2 = parseJson(
+          (await browse("status", { session: session2 })).stdout,
+        );
+
+        expect(status1.running).toBe(true);
+        expect(status2.running).toBe(true);
+      } finally {
+        await browse("stop --force", { session: session1 });
+        await browse("stop --force", { session: session2 });
+        await cleanupSession(session1);
+        await cleanupSession(session2);
+      }
+    });
+  });
+
+  describe("Navigation", () => {
+    beforeAll(async () => {
+      await browse("start");
+    });
+
+    afterAll(async () => {
+      await browse("stop --force");
+    });
+
+    it("should navigate to URL", async () => {
+      const result = await browse("open https://example.com");
+      const data = parseJson(result.stdout);
+      expect(data.url).toContain("example.com");
+    });
+
+    it("should get current URL", async () => {
+      await browse("open https://example.com");
+      const result = await browse("get url");
+      const data = parseJson(result.stdout);
+      expect(data.url).toContain("example.com");
+    });
+
+    it("should get page title", async () => {
+      await browse("open https://example.com");
+      const result = await browse("get title");
+      const data = parseJson(result.stdout);
+      expect(data.title).toBeTruthy();
+    });
+
+    it("should reload page", async () => {
+      await browse("open https://example.com");
+      const result = await browse("reload");
+      const data = parseJson(result.stdout);
+      expect(data.url).toContain("example.com");
+    });
+  });
+
+  describe("Snapshot", () => {
+    beforeAll(async () => {
+      await browse("start");
+      await browse("open https://example.com");
+    });
+
+    afterAll(async () => {
+      await browse("stop --force");
+    });
+
+    it("should take snapshot with refs", async () => {
+      const result = await browse("snapshot");
+      const data = parseJson(result.stdout);
+
+      expect(data.tree).toBeTruthy();
+      expect(data.xpathMap).toBeTruthy();
+      expect(typeof data.xpathMap).toBe("object");
+    });
+
+    it("should take compact snapshot", async () => {
+      const result = await browse("snapshot -c");
+      // Compact mode outputs tree directly (not JSON when not --json)
+      expect(result.stdout).toContain("RootWebArea");
+    });
+
+    it("should populate refs for subsequent commands", async () => {
+      await browse("snapshot");
+      const refsResult = await browse("refs");
+      const data = parseJson(refsResult.stdout);
+
+      expect(data.count).toBeGreaterThan(0);
+      expect(data.xpathMap).toBeTruthy();
+    });
+  });
+
+  describe("Screenshot", () => {
+    const screenshotPath = path.join(
+      os.tmpdir(),
+      `browse-test-${Date.now()}.png`,
+    );
+
+    beforeAll(async () => {
+      await browse("start");
+      await browse("open https://example.com");
+    });
+
+    afterAll(async () => {
+      await browse("stop --force");
+      try {
+        await fs.unlink(screenshotPath);
+      } catch {}
+    });
+
+    it("should take screenshot and return base64", async () => {
+      const result = await browse("screenshot");
+      const data = parseJson(result.stdout);
+      expect(data.base64).toBeTruthy();
+      expect(data.base64.length).toBeGreaterThan(100);
+    });
+
+    it("should save screenshot to file", async () => {
+      const result = await browse(`screenshot ${screenshotPath}`);
+      const data = parseJson(result.stdout);
+      expect(data.saved).toBe(screenshotPath);
+
+      // Verify file exists
+      const stat = await fs.stat(screenshotPath);
+      expect(stat.size).toBeGreaterThan(0);
+    });
+  });
+
+  describe("Actions", () => {
+    beforeAll(async () => {
+      await browse("start");
+    });
+
+    afterAll(async () => {
+      await browse("stop --force");
+    });
+
+    it("should click by coordinates", async () => {
+      await browse("open https://example.com");
+      const result = await browse("click_xy 100 100");
+      const data = parseJson(result.stdout);
+      expect(data.clicked).toBe(true);
+    });
+
+    it("should click by ref after snapshot", async () => {
+      await browse("open https://example.com");
+      await browse("snapshot");
+
+      // Find a clickable ref
+      const refsResult = await browse("refs");
+      const refs = parseJson(refsResult.stdout);
+
+      if (refs.count > 0) {
+        const firstRef = Object.keys(refs.xpathMap)[0];
+        const result = await browse(`click @${firstRef}`);
+        const data = parseJson(result.stdout);
+        expect(data.clicked).toBe(true);
+      }
+    });
+
+    it("should type text", async () => {
+      await browse("open https://example.com");
+      const result = await browse('type "Hello World"');
+      const data = parseJson(result.stdout);
+      expect(data.typed).toBe(true);
+    });
+
+    it("should press keys", async () => {
+      await browse("open https://example.com");
+      const result = await browse("press Tab");
+      const data = parseJson(result.stdout);
+      expect(data.pressed).toBe("Tab");
+    });
+
+    it("should hover at coordinates", async () => {
+      await browse("open https://example.com");
+      const result = await browse("hover 200 200");
+      const data = parseJson(result.stdout);
+      expect(data.hovered).toBe(true);
+    });
+
+    it("should scroll", async () => {
+      await browse("open https://example.com");
+      const result = await browse("scroll 400 400 0 100");
+      const data = parseJson(result.stdout);
+      expect(data.scrolled).toBe(true);
+    });
+
+    it("should drag and drop between coordinates", async () => {
+      const html = `<!doctype html><html><body style="margin:0"><div id="source" draggable="true" style="position:absolute;left:40px;top:40px;width:80px;height:80px;background:#e66;cursor:move"></div><div id="target" style="position:absolute;left:250px;top:40px;width:120px;height:120px;background:#ddd"></div><div id="status" style="position:absolute;left:40px;top:180px">Not dropped</div><script>const source=document.getElementById('source');const target=document.getElementById('target');const status=document.getElementById('status');source.addEventListener('dragstart',e=>{e.dataTransfer.setData('text/plain','dragged')});target.addEventListener('dragover',e=>{e.preventDefault()});target.addEventListener('drop',e=>{e.preventDefault();status.textContent='Dropped'})</script></body></html>`;
+      const dataUrl = `data:text/html,${encodeURIComponent(html)}`;
+
+      await browse(`open "${dataUrl}"`);
+      const dragResult = await browse("drag 80 80 310 100 --steps 8 --xpath");
+      const dragData = parseJson(dragResult.stdout);
+      expect(dragData.dragged).toBe(true);
+      expect(typeof dragData.fromXpath).toBe("string");
+      expect(typeof dragData.toXpath).toBe("string");
+
+      const statusResult = await browse(
+        'eval "document.getElementById(\\"status\\").textContent"',
+      );
+      const statusData = parseJson(statusResult.stdout);
+      expect(statusData.result).toBe("Dropped");
+    });
+  });
+
+  describe("Multi-Tab", () => {
+    beforeAll(async () => {
+      await browse("start");
+    });
+
+    afterAll(async () => {
+      await browse("stop --force");
+    });
+
+    it("should list pages", async () => {
+      await browse("open https://example.com");
+      const result = await browse("pages");
+      const data = parseJson(result.stdout);
+
+      expect(data.pages).toBeInstanceOf(Array);
+      expect(data.pages.length).toBeGreaterThan(0);
+      expect(data.pages[0]).toHaveProperty("index");
+      expect(data.pages[0]).toHaveProperty("url");
+    });
+
+    it("should create new page", async () => {
+      const beforeResult = await browse("pages");
+      const beforeData = parseJson(beforeResult.stdout);
+      const beforeCount = beforeData.pages.length;
+
+      const newResult = await browse("newpage https://github.com");
+      const newData = parseJson(newResult.stdout);
+      expect(newData.created).toBe(true);
+
+      const afterResult = await browse("pages");
+      const afterData = parseJson(afterResult.stdout);
+      expect(afterData.pages.length).toBe(beforeCount + 1);
+    });
+
+    it("should switch tabs", async () => {
+      await browse("open https://example.com");
+      await browse("newpage https://github.com");
+
+      const result = await browse("tab_switch 0");
+      const data = parseJson(result.stdout);
+      expect(data.switched).toBe(true);
+      expect(data.index).toBe(0);
+    });
+
+    it("should close tab", async () => {
+      await browse("open https://example.com");
+      await browse("newpage https://github.com");
+
+      const beforeResult = await browse("pages");
+      const beforeCount = parseJson(beforeResult.stdout).pages.length;
+
+      const closeResult = await browse("tab_close");
+      const closeData = parseJson(closeResult.stdout);
+      expect(closeData.closed).toBe(true);
+
+      const afterResult = await browse("pages");
+      const afterCount = parseJson(afterResult.stdout).pages.length;
+      expect(afterCount).toBe(beforeCount - 1);
+    });
+  });
+
+  describe("Waiting", () => {
+    beforeAll(async () => {
+      await browse("start");
+    });
+
+    afterAll(async () => {
+      await browse("stop --force");
+    });
+
+    it("should wait for timeout", async () => {
+      await browse("open https://example.com");
+      const start = Date.now();
+      const result = await browse("wait timeout 500");
+      const elapsed = Date.now() - start;
+
+      const data = parseJson(result.stdout);
+      expect(data.waited).toBe(true);
+      expect(elapsed).toBeGreaterThanOrEqual(450);
+    });
+
+    it("should wait for load state", async () => {
+      await browse("open https://example.com");
+      const result = await browse("wait load");
+      const data = parseJson(result.stdout);
+      expect(data.waited).toBe(true);
+    });
+  });
+
+  describe("Network Capture", () => {
+    beforeAll(async () => {
+      await browse("start");
+    });
+
+    afterAll(async () => {
+      await browse("stop --force");
+    });
+
+    it("should enable network capture", async () => {
+      const result = await browse("network on");
+      const data = parseJson(result.stdout);
+      expect(data.enabled).toBe(true);
+      expect(data.path).toBeTruthy();
+    });
+
+    it("should return network path", async () => {
+      await browse("network on");
+      const result = await browse("network path");
+      const data = parseJson(result.stdout);
+      expect(data.path).toBeTruthy();
+      expect(data.enabled).toBe(true);
+    });
+
+    it("should capture requests to filesystem", async () => {
+      await browse("network on");
+      const pathResult = await browse("network path");
+      const networkDir = parseJson(pathResult.stdout).path;
+
+      // Navigate to trigger requests
+      await browse("open https://example.com");
+
+      // Wait for requests to be written
+      await browse("wait timeout 1000");
+
+      // Check if directory has content
+      try {
+        const entries = await fs.readdir(networkDir);
+        // May or may not have captured requests depending on timing
+        expect(Array.isArray(entries)).toBe(true);
+      } catch {
+        // Directory may not exist if no requests captured
+      }
+    });
+
+    it("should disable network capture", async () => {
+      await browse("network on");
+      const result = await browse("network off");
+      const data = parseJson(result.stdout);
+      expect(data.enabled).toBe(false);
+    });
+
+    it("should clear network captures", async () => {
+      await browse("network on");
+      await browse("open https://example.com");
+      await browse("wait timeout 500");
+
+      const result = await browse("network clear");
+      const data = parseJson(result.stdout);
+      expect(data.cleared).toBe(true);
+    });
+  });
+
+  describe("Viewport", () => {
+    beforeAll(async () => {
+      await browse("start");
+      await browse("open https://example.com");
+    });
+
+    afterAll(async () => {
+      await browse("stop --force");
+    });
+
+    it("should set viewport size", async () => {
+      const result = await browse("viewport 1920 1080");
+      const data = parseJson(result.stdout);
+      expect(data.viewport.width).toBe(1920);
+      expect(data.viewport.height).toBe(1080);
+    });
+  });
+
+  describe("Eval", () => {
+    beforeAll(async () => {
+      await browse("start");
+      await browse("open https://example.com");
+    });
+
+    afterAll(async () => {
+      await browse("stop --force");
+    });
+
+    it("should evaluate JavaScript", async () => {
+      const result = await browse('eval "document.title"');
+      const data = parseJson(result.stdout);
+      expect(data.result).toBeTruthy();
+    });
+
+    it("should return computed values", async () => {
+      const result = await browse('eval "1 + 1"');
+      const data = parseJson(result.stdout);
+      expect(data.result).toBe(2);
+    });
+  });
+
+  describe("Error Handling", () => {
+    beforeAll(async () => {
+      await browse("start");
+    });
+
+    afterAll(async () => {
+      await browse("stop --force");
+    });
+
+    it("should error on invalid ref", async () => {
+      await browse("open https://example.com");
+      // Don't run snapshot, so refs are empty
+      const result = await browse("click @99-99");
+      expect(result.stderr).toContain("Error");
+    });
+
+    it("should error on unknown command", async () => {
+      const result = await browse("nonexistent");
+      expect(result.exitCode).not.toBe(0);
+    });
+  });
+});
diff --git a/packages/cli/tests/mode.test.ts b/packages/cli/tests/mode.test.ts
new file mode 100644
index 000000000..1ce31fe86
--- /dev/null
+++ b/packages/cli/tests/mode.test.ts
@@ -0,0 +1,98 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { exec } from "child_process";
+import { promises as fs } from "fs";
+import * as path from "path";
+import * as os from "os";
+
+const CLI_PATH = path.join(__dirname, "../src/index.ts");
+const TEST_SESSION = `env-test-${Date.now()}`;
+
+async function browse(
+  args: string,
+  options: { timeout?: number; env?: NodeJS.ProcessEnv } = {},
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  const timeout = options.timeout ?? 30000;
+  const env = { ...process.env, ...options.env };
+
+  return new Promise((resolve) => {
+    const fullArgs = `tsx ${CLI_PATH} --session ${TEST_SESSION} ${args}`;
+    exec(fullArgs, { timeout, env }, (error, stdout, stderr) => {
+      resolve({
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: error?.code ?? 0,
+      });
+    });
+  });
+}
+
+function parseJson(output: string): any {
+  try {
+    return JSON.parse(output);
+  } catch {
+    throw new Error(`Failed to parse JSON: ${output}`);
+  }
+}
+
+async function cleanupSession(session: string): Promise<void> {
+  const tmpDir = os.tmpdir();
+  const patterns = [
+    `browse-${session}.sock`,
+    `browse-${session}.pid`,
+    `browse-${session}.ws`,
+    `browse-${session}.chrome.pid`,
+    `browse-${session}.mode`,
+    `browse-${session}.mode-override`,
+  ];
+
+  for (const pattern of patterns) {
+    try {
+      await fs.unlink(path.join(tmpDir, pattern));
+    } catch {
+      // Ignore missing files.
+    }
+  }
+
+  try {
+    await fs.rm(path.join(tmpDir, `browse-${session}-network`), {
+      recursive: true,
+    });
+  } catch {
+    // Ignore missing directory.
+  }
+}
+
+describe("Browse CLI env command", () => {
+  afterEach(async () => {
+    await browse("stop --force");
+    await cleanupSession(TEST_SESSION);
+  });
+
+  it("shows desired env even when daemon is not running", async () => {
+    const result = await browse("env");
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result.stdout);
+    expect(data.mode).toBe("not running");
+    expect(["local", "remote"]).toContain(data.desired);
+  });
+
+  it("rejects unsupported env target", async () => {
+    const result = await browse("env invalid-target");
+    expect(result.exitCode).not.toBe(0);
+    expect(result.stderr).toContain("Usage: browse env [local|remote]");
+  });
+
+  it("rejects remote env without Browserbase credentials", async () => {
+    const result = await browse("env remote", {
+      env: {
+        ...process.env,
+        BROWSERBASE_API_KEY: "",
+      },
+    });
+    expect(result.exitCode).not.toBe(0);
+    expect(result.stderr).toContain(
+      "Remote mode requires BROWSERBASE_API_KEY",
+    );
+  });
+});
diff --git a/packages/cli/tsconfig.json b/packages/cli/tsconfig.json
new file mode 100644
index 000000000..459996f1e
--- /dev/null
+++ b/packages/cli/tsconfig.json
@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": ".",
+    "types": ["node", "vitest/globals"]
+  },
+  "include": ["src/**/*", "tests/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
diff --git a/packages/cli/tsup.config.ts b/packages/cli/tsup.config.ts
new file mode 100644
index 000000000..e76acd6fa
--- /dev/null
+++ b/packages/cli/tsup.config.ts
@@ -0,0 +1,24 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["cjs"],
+  target: "node20",
+  clean: true,
+  shims: true,
+  banner: {
+    js: "#!/usr/bin/env node",
+  },
+  // Bundle everything possible, only externalize what truly can't be bundled
+  noExternal: [/@browserbasehq\/stagehand/],
+  external: [
+    // Browser automation - user must install playwright to use the CLI
+    "playwright",
+    "playwright-core",
+    // CJS packages with dynamic requires that break in ESM bundles
+    "pino",
+    "pino-pretty",
+    "ws",
+    "dotenv",
+  ],
+});
diff --git a/packages/cli/vitest.config.ts b/packages/cli/vitest.config.ts
new file mode 100644
index 000000000..b0b02c5ce
--- /dev/null
+++ b/packages/cli/vitest.config.ts
@@ -0,0 +1,17 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    testTimeout: 60000,
+    hookTimeout: 60000,
+    include: ["tests/**/*.test.ts"],
+    // Run tests sequentially since they share browser state
+    pool: "forks",
+    poolOptions: {
+      forks: {
+        singleFork: true,
+      },
+    },
+  },
+});
diff --git a/packages/core/CHANGELOG.md b/packages/core/CHANGELOG.md
new file mode 100644
index 000000000..06effeb7c
--- /dev/null
+++ b/packages/core/CHANGELOG.md
@@ -0,0 +1,310 @@
+# @browserbasehq/stagehand
+
+## 3.1.0
+
+### Minor Changes
+
+- [#1681](https://github.com/browserbase/stagehand/pull/1681) [`e3db9aa`](https://github.com/browserbase/stagehand/commit/e3db9aa863f44270792215801fe6e3a02a1321aa) Thanks [@tkattkat](https://github.com/tkattkat)! - Add cookie management APIs: `context.addCookies()`, `context.clearCookies()`, & `context.cookies()`
+
+- [#1672](https://github.com/browserbase/stagehand/pull/1672) [`b65756e`](https://github.com/browserbase/stagehand/commit/b65756e9e85643055446aa4a51956f7d6627c89f) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - add boolean keepAlive parameter to allow for configuring whether the browser should be closed when stagehand.close() is called.
+
+- [#1708](https://github.com/browserbase/stagehand/pull/1708) [`176d420`](https://github.com/browserbase/stagehand/commit/176d42002cc0a2c7d13b4c0ffbbd56b70fdc49e8) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - add context.setExtraHTTPHeaders()
+
+- [#1611](https://github.com/browserbase/stagehand/pull/1611) [`8a3c066`](https://github.com/browserbase/stagehand/commit/8a3c06600a9ba98485db7e9ed5c3cc43ea180334) Thanks [@monadoid](https://github.com/monadoid)! - Using `mode` enum instead of old `cua` boolean in openapi spec
+
+### Patch Changes
+
+- [#1683](https://github.com/browserbase/stagehand/pull/1683) [`7584f3e`](https://github.com/browserbase/stagehand/commit/7584f3e92e60a557d2b3e0e0d2a2af04c3527523) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: include shadow DOM in .count() & .nth() & support xpath predicates
+
+- [#1644](https://github.com/browserbase/stagehand/pull/1644) [`1e1c9c1`](https://github.com/browserbase/stagehand/commit/1e1c9c15773e49d5c3cd36021dbc1d23495c1bce) Thanks [@monadoid](https://github.com/monadoid)! - Fix unhandled CDP detaches by returning the original sendCDP promise
+
+- [#1729](https://github.com/browserbase/stagehand/pull/1729) [`6bef890`](https://github.com/browserbase/stagehand/commit/6bef89090ebd231e77d8092b2c32a0f06303d5a9) Thanks [@shrey150](https://github.com/shrey150)! - fix: support Claude 4.6 (Opus and Sonnet) in CUA mode by using the correct `computer_20251124` tool version and `computer-use-2025-11-24` beta header
+
+- [#1647](https://github.com/browserbase/stagehand/pull/1647) [`ffd4b33`](https://github.com/browserbase/stagehand/commit/ffd4b335a873d0f4dcd76ea22d44f47919bf8e49) Thanks [@tkattkat](https://github.com/tkattkat)! - Fix [Agent] - Address bug causing issues with continuing a conversation from past messages in dom mode
+
+- [#1614](https://github.com/browserbase/stagehand/pull/1614) [`677bff5`](https://github.com/browserbase/stagehand/commit/677bff5834c879a2d95f7dbff918b8e1510516b3) Thanks [@miguelg719](https://github.com/miguelg719)! - Enforce <number>-<number> regex validation on act/observe for elementId
+
+- [#1580](https://github.com/browserbase/stagehand/pull/1580) [`65ff464`](https://github.com/browserbase/stagehand/commit/65ff464bc13388eb109eba0a2cf533c1cc202854) Thanks [@tkattkat](https://github.com/tkattkat)! - Add unified variables support across act and agent with a single VariableValue type
+
+- [#1666](https://github.com/browserbase/stagehand/pull/1666) [`101bcf2`](https://github.com/browserbase/stagehand/commit/101bcf2da8b527fd6ace6aa291ada5d0f2d90344) Thanks [@Kylejeong2](https://github.com/Kylejeong2)! - add support for codex models
+
+- [#1728](https://github.com/browserbase/stagehand/pull/1728) [`0a94301`](https://github.com/browserbase/stagehand/commit/0a94301caa991d1aa4cdade6e28a065b1aefb3e2) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - handle potential race condition on `.close()` when using the Stagehand API
+
+- [#1664](https://github.com/browserbase/stagehand/pull/1664) [`b27c04d`](https://github.com/browserbase/stagehand/commit/b27c04d278c290364347acd0c354a878ea9b7c2d) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fixes issue with context.addInitScript() where scripts were not being applied to out of process iframes (OOPIFs), and popup pages with same process iframes (SPIFs)
+
+- [#1632](https://github.com/browserbase/stagehand/pull/1632) [`afbd08b`](https://github.com/browserbase/stagehand/commit/afbd08bb6367a9c9f65f67e453667987e4659918) Thanks [@pirate](https://github.com/pirate)! - Remove automatic `.env` loading via `dotenv`.
+
+  If your app relies on `.env` files, install `dotenv` and load it explicitly in your code:
+
+  ```ts
+  import dotenv from "dotenv";
+  dotenv.config({ path: ".env" });
+  ```
+
+- [#1624](https://github.com/browserbase/stagehand/pull/1624) [`0e8d569`](https://github.com/browserbase/stagehand/commit/0e8d5695f662040f7384e64f46301152802e3c62) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix issue where screenshot masks were not being applied to dialog elements
+
+- [#1596](https://github.com/browserbase/stagehand/pull/1596) [`ff0f979`](https://github.com/browserbase/stagehand/commit/ff0f9795f3b2c1cf4f2610a80ebcb3341a24f987) Thanks [@tkattkat](https://github.com/tkattkat)! - Update usage/metrics handling in agent
+
+- [#1631](https://github.com/browserbase/stagehand/pull/1631) [`2d89d2b`](https://github.com/browserbase/stagehand/commit/2d89d2b35ce812431956b28e0c8b52d32ddc7a27) Thanks [@miguelg719](https://github.com/miguelg719)! - Add right and middle click support to act and observe
+
+- [#1697](https://github.com/browserbase/stagehand/pull/1697) [`aac9a19`](https://github.com/browserbase/stagehand/commit/aac9a19bdfbe62e4508631337ab0bfbcf8ae62b2) Thanks [@shrey150](https://github.com/shrey150)! - fix: support `<frame>` elements in XPath frame boundary detection so `act()` works on legacy `<frameset>` pages
+
+- [#1692](https://github.com/browserbase/stagehand/pull/1692) [`06de50f`](https://github.com/browserbase/stagehand/commit/06de50ff377fd31f1b0fcf79adb996d04562d2c0) Thanks [@shrey150](https://github.com/shrey150)! - fix: skip piercer injection for chrome-extension:// and other non-HTML targets
+
+- [#1613](https://github.com/browserbase/stagehand/pull/1613) [`aa4d981`](https://github.com/browserbase/stagehand/commit/aa4d981e440bdd0e3d3f42ccc310d5958aa25cc6) Thanks [@miguelg719](https://github.com/miguelg719)! - SupportedUnderstudyAction Enum validation for 'method' on act/observe inference
+
+- [#1652](https://github.com/browserbase/stagehand/pull/1652) [`18b1e3b`](https://github.com/browserbase/stagehand/commit/18b1e3bd2b16b721845d52fcf1a45c6158e2403f) Thanks [@miguelg719](https://github.com/miguelg719)! - Add support for gemini 3 flash and pro in hybrid/cua agent
+
+- [#1706](https://github.com/browserbase/stagehand/pull/1706) [`957d82b`](https://github.com/browserbase/stagehand/commit/957d82b9845b4413b123539e81a2e4a490e74a8a) Thanks [@chrisreadsf](https://github.com/chrisreadsf)! - Add GLM to prompt-based JSON fallback for models without native structured output support
+
+- [#1633](https://github.com/browserbase/stagehand/pull/1633) [`22e371a`](https://github.com/browserbase/stagehand/commit/22e371ae4c25deb6350328fe02832bf2b2197b94) Thanks [@tkattkat](https://github.com/tkattkat)! - Add warning when incorrect models are used with agents hybrid mode
+
+- [#1673](https://github.com/browserbase/stagehand/pull/1673) [`d29b91f`](https://github.com/browserbase/stagehand/commit/d29b91fa506636ca36f724fcf106320de54ec3f3) Thanks [@miguelg719](https://github.com/miguelg719)! - Add multi-region support for Stagehand API with region-specific endpoints
+
+- [#1695](https://github.com/browserbase/stagehand/pull/1695) [`7b4f817`](https://github.com/browserbase/stagehand/commit/7b4f817cafb9829ac81c4b5890c318c7f9521fe4) Thanks [@tkattkat](https://github.com/tkattkat)! - Fix: zod bug when pinning zod to v3 and using structured output in agent
+
+- [#1609](https://github.com/browserbase/stagehand/pull/1609) [`3f9ca4d`](https://github.com/browserbase/stagehand/commit/3f9ca4d9acc109101357378d29cf969168991608) Thanks [@miguelg719](https://github.com/miguelg719)! - Add SupportedUnderstudyActions to observe system prompt
+
+- [#1581](https://github.com/browserbase/stagehand/pull/1581) [`49ead1e`](https://github.com/browserbase/stagehand/commit/49ead1e1e8678a8da0f87ad2042491dacc6b01d7) Thanks [@sameelarif](https://github.com/sameelarif)! - **Server-side caching is now available.**
+
+  When running `env: "BROWSERBASE"`, Stagehand automatically caches `act()`, `extract()`, and `observe()` results server-side — repeated calls with the same inputs return instantly without consuming LLM tokens.
+
+  Caching is enabled by default and can be disabled via `serverCache: false` on the Stagehand instance or per individual call. Check out the [browserbase blog](https://www.browserbase.com/blog/stagehand-caching) for more details.
+
+- [#1642](https://github.com/browserbase/stagehand/pull/1642) [`3673369`](https://github.com/browserbase/stagehand/commit/36733691f90c15386cf2a7b47d04ef429b7195ae) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix issue where scripts added via context.addInitScripts() were not being injected into new pages that were opened via popups (eg, clicking a link that opens a new page) and/or calling context.newPage(url)
+
+- [#1735](https://github.com/browserbase/stagehand/pull/1735) [`c465e87`](https://github.com/browserbase/stagehand/commit/c465e87ab41942435132c76338518fb3fa8e7896) Thanks [@monadoid](https://github.com/monadoid)! - Supports request header authentication with connectToMCPServer
+
+- [#1705](https://github.com/browserbase/stagehand/pull/1705) [`ae533e4`](https://github.com/browserbase/stagehand/commit/ae533e40195181b53833f8055b1259fb360a927b) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - include error cause in UnderstudyCommandException
+
+- [#1636](https://github.com/browserbase/stagehand/pull/1636) [`ea33052`](https://github.com/browserbase/stagehand/commit/ea330520a325583b71b87d85beb740df4bdb9b2d) Thanks [@miguelg719](https://github.com/miguelg719)! - Include executionModel on the AgentConfigSchema
+
+- [#1679](https://github.com/browserbase/stagehand/pull/1679) [`5764ede`](https://github.com/browserbase/stagehand/commit/5764edee7aab00ef1aafafb68fc56eb26c0a70b2) Thanks [@shrey150](https://github.com/shrey150)! - fix issue where locator.count() was not working with xpaths that have attribute predicates
+
+- [#1646](https://github.com/browserbase/stagehand/pull/1646) [`f09b184`](https://github.com/browserbase/stagehand/commit/f09b184cc5e774736280ae8c94ba3f4f13adda80) Thanks [@miguelg719](https://github.com/miguelg719)! - Add user-agent to CDP connections
+
+- [#1637](https://github.com/browserbase/stagehand/pull/1637) [`a7d29de`](https://github.com/browserbase/stagehand/commit/a7d29decee0f7d12e2437267b9eef1795d3b4e3a) Thanks [@miguelg719](https://github.com/miguelg719)! - Improve error and warning message for legacy model format
+
+- [#1685](https://github.com/browserbase/stagehand/pull/1685) [`d334399`](https://github.com/browserbase/stagehand/commit/d3343990041bf9cd5613569840afb0c17131e33c) Thanks [@tkattkat](https://github.com/tkattkat)! - Bump ai sdk & google provider version
+
+- [#1662](https://github.com/browserbase/stagehand/pull/1662) [`44416da`](https://github.com/browserbase/stagehand/commit/44416da7ff33301bb32d3811e6c3be8782a7d168) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix issue where locator.fill() was not working on elements that require direct value setting
+
+- [#1612](https://github.com/browserbase/stagehand/pull/1612) [`bdd8b4e`](https://github.com/browserbase/stagehand/commit/bdd8b4ee3c697a02728375510ab7fae764990576) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix issue where screenshot mask was only being applied to the first element that the locator resolved to. masks now apply to all matching elements.
+
+## 3.0.8
+
+### Patch Changes
+
+- [#1514](https://github.com/browserbase/stagehand/pull/1514) [`40ce5cc`](https://github.com/browserbase/stagehand/commit/40ce5cc83ec758f4e8c37132a7f4ac8eeea7ca34) Thanks [@tkattkat](https://github.com/tkattkat)! - Rename the close tool in agent to "done"
+
+- [#1574](https://github.com/browserbase/stagehand/pull/1574) [`5506f41`](https://github.com/browserbase/stagehand/commit/5506f416d2609d112b553263984e21d7a30e32b1) Thanks [@tkattkat](https://github.com/tkattkat)! - fix(server): pass cdpUrl to localBrowserLaunchOptions when launchOptions absent
+
+- [#1521](https://github.com/browserbase/stagehand/pull/1521) [`84c05ca`](https://github.com/browserbase/stagehand/commit/84c05ca8de4587181faf128e5c7464fd960caacc) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: get agent cache working in API mode
+
+- [#1486](https://github.com/browserbase/stagehand/pull/1486) [`692ffa0`](https://github.com/browserbase/stagehand/commit/692ffa0346ad3d121686aba503c0a22844293efa) Thanks [@tkattkat](https://github.com/tkattkat)! - improve logging in agent
+
+- [#1551](https://github.com/browserbase/stagehand/pull/1551) [`1ef8901`](https://github.com/browserbase/stagehand/commit/1ef8901e1314e90f43b36be20192e652d3b5598f) Thanks [@miguelg719](https://github.com/miguelg719)! - move extract handler response log to after URL injection
+
+- [#1495](https://github.com/browserbase/stagehand/pull/1495) [`72ac775`](https://github.com/browserbase/stagehand/commit/72ac775a831d6f0f376ceda4426525f93cc21452) Thanks [@tkattkat](https://github.com/tkattkat)! - export tool function & type to simplify defining custom tools
+
+- [#1481](https://github.com/browserbase/stagehand/pull/1481) [`3d5af07`](https://github.com/browserbase/stagehand/commit/3d5af07f66d6d26d1f5ac4bd9be7183c3381dd92) Thanks [@tkattkat](https://github.com/tkattkat)! - add waitForTimeout to page
+
+- [#1423](https://github.com/browserbase/stagehand/pull/1423) [`40e1d80`](https://github.com/browserbase/stagehand/commit/40e1d80776b9216422a25a81070ccb3105e56ec2) Thanks [@miguelg719](https://github.com/miguelg719)! - Improve benchmark handling and add metadata
+
+- [#1588](https://github.com/browserbase/stagehand/pull/1588) [`56c0d24`](https://github.com/browserbase/stagehand/commit/56c0d244f9b2431218bfa832ddfc0587930ae038) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - add SnapshotOptions to page.snapshot()
+
+- [#1483](https://github.com/browserbase/stagehand/pull/1483) [`16d72fb`](https://github.com/browserbase/stagehand/commit/16d72fb4c4081dd33bf45605d75c27644ea4c00e) Thanks [@tkattkat](https://github.com/tkattkat)! - Optimize screenshot handling in agent hybrid mode
+
+- [#1498](https://github.com/browserbase/stagehand/pull/1498) [`088c4cc`](https://github.com/browserbase/stagehand/commit/088c4cc31dc924bb232a9d5a09ab42cd961c2d36) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: replaying cached actions (for agent & act) now uses the originally defined model, (instead of default model) when action fails and rerunning inference is needed
+
+- [#1575](https://github.com/browserbase/stagehand/pull/1575) [`4276f4a`](https://github.com/browserbase/stagehand/commit/4276f4abc8bbde215faac6c0321bf243484c376b) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - expose port param in localBrowserLaunchOptions
+
+- [#1544](https://github.com/browserbase/stagehand/pull/1544) [`6005786`](https://github.com/browserbase/stagehand/commit/600578637e65f6fd18b0cdb322b9e0b857708b2f) Thanks [@tkattkat](https://github.com/tkattkat)! - Recommend hybrid mode over DOM mode in agent, which is now considered legacy
+
+- [#1505](https://github.com/browserbase/stagehand/pull/1505) [`6fbf5fc`](https://github.com/browserbase/stagehand/commit/6fbf5fc811e5e5d9d22f10c5309fbd336892263a) Thanks [@tkattkat](https://github.com/tkattkat)! - Add structured output to agent result + ensure close tool is always called
+
+- [#1511](https://github.com/browserbase/stagehand/pull/1511) [`704cf18`](https://github.com/browserbase/stagehand/commit/704cf18cb2bdd187ba06c35f05ccb47317a7668c) Thanks [@shrey150](https://github.com/shrey150)! - Fix ControlOrMeta keypress event
+
+- [#1480](https://github.com/browserbase/stagehand/pull/1480) [`091296e`](https://github.com/browserbase/stagehand/commit/091296e438bb2374c8bb10ef6c08283978145ebf) Thanks [@tkattkat](https://github.com/tkattkat)! - Update agent to only calculate xpath when caching is enabled
+
+- [#1509](https://github.com/browserbase/stagehand/pull/1509) [`e56c6eb`](https://github.com/browserbase/stagehand/commit/e56c6eb139bf3aad37e98b16626fff13a6c671d0) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - add support for page.waitForSelector()
+
+- [#1478](https://github.com/browserbase/stagehand/pull/1478) [`2cb78d0`](https://github.com/browserbase/stagehand/commit/2cb78d0f5ddef9f7337a9a2fe3137f1421df700a) Thanks [@tkattkat](https://github.com/tkattkat)! - update agent message handling
+
+- [#1518](https://github.com/browserbase/stagehand/pull/1518) [`5dad639`](https://github.com/browserbase/stagehand/commit/5dad63938f08d968d434bb1ee2804f1e54fb836a) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - add page.snapshot() for capturing a stringified DOM snapshot of the page, including an xpath map & url map
+
+- [#1576](https://github.com/browserbase/stagehand/pull/1576) [`b7c2571`](https://github.com/browserbase/stagehand/commit/b7c2571ad4ac563f3ca0518e1f29a40da93e33bc) Thanks [@tkattkat](https://github.com/tkattkat)! - utilize waitForSelector when running agent cache
+
+- [#1560](https://github.com/browserbase/stagehand/pull/1560) [`4c69117`](https://github.com/browserbase/stagehand/commit/4c6911748953199dc9aad3eabe98bcf325f871e4) Thanks [@tkattkat](https://github.com/tkattkat)! - Update coordinate handling in cua and hybrid
+
+## 3.0.7
+
+### Patch Changes
+
+- [#1461](https://github.com/browserbase/stagehand/pull/1461) [`0f3991e`](https://github.com/browserbase/stagehand/commit/0f3991eedc0aaff72ef718dda3ddb0839cf4a464) Thanks [@tkattkat](https://github.com/tkattkat)! - Move hybrid mode out of experimental
+
+- [#1433](https://github.com/browserbase/stagehand/pull/1433) [`e0e22e0`](https://github.com/browserbase/stagehand/commit/e0e22e06bc752a8ffde30f3dbfa58d91e24e6c09) Thanks [@tkattkat](https://github.com/tkattkat)! - Put hybrid mode behind experimental
+
+- [#1456](https://github.com/browserbase/stagehand/pull/1456) [`f261051`](https://github.com/browserbase/stagehand/commit/f2610517d74774374de9ee93191e663439ef55e5) Thanks [@shrey150](https://github.com/shrey150)! - Invoke page.hover for agent move action
+
+- [#1473](https://github.com/browserbase/stagehand/pull/1473) [`e021674`](https://github.com/browserbase/stagehand/commit/e021674f9641c1c5f9d0c1817c3fdf599eea124d) Thanks [@shrey150](https://github.com/shrey150)! - Add safety confirmation support for OpenAI + Google CUA
+
+- [#1399](https://github.com/browserbase/stagehand/pull/1399) [`6a5496f`](https://github.com/browserbase/stagehand/commit/6a5496f17dbb716be1ee1aaa4e5ba9d8c723b30b) Thanks [@tkattkat](https://github.com/tkattkat)! - Ensure cua agent is killed when stagehand.close is called
+
+- [#1436](https://github.com/browserbase/stagehand/pull/1436) [`fea1700`](https://github.com/browserbase/stagehand/commit/fea1700552af3319052f463685752501c8e71de3) Thanks [@miguelg719](https://github.com/miguelg719)! - Fix auto-load key for act/extract/observe parametrized models on api
+
+- [#1439](https://github.com/browserbase/stagehand/pull/1439) [`5b288d9`](https://github.com/browserbase/stagehand/commit/5b288d9ac37406ff22460ac8050bea26b87a378e) Thanks [@tkattkat](https://github.com/tkattkat)! - Remove base64 from agent actions array ( still present in messages object )
+
+- [#1408](https://github.com/browserbase/stagehand/pull/1408) [`e822f5a`](https://github.com/browserbase/stagehand/commit/e822f5a8898df9eb48ca32c321025f0c74b638f0) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - allow for act() cache hit when variable values change
+
+- [#1472](https://github.com/browserbase/stagehand/pull/1472) [`638efc7`](https://github.com/browserbase/stagehand/commit/638efc7fea401bc43dd05dceedf4c13a3495a728) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: agent cache not refreshed on action failure
+
+- [#1424](https://github.com/browserbase/stagehand/pull/1424) [`a890f16`](https://github.com/browserbase/stagehand/commit/a890f16fa3a752f308f858e5ab9c9a0faf6b3b34) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: "Error: -32000 Failed to convert response to JSON: CBOR: stack limit exceeded"
+
+- [#1418](https://github.com/browserbase/stagehand/pull/1418) [`934f492`](https://github.com/browserbase/stagehand/commit/934f492ec587bef81f0ce75b45a35b44ab545712) Thanks [@miguelg719](https://github.com/miguelg719)! - Cleanup handlers and bus listeners on close
+
+- [#1430](https://github.com/browserbase/stagehand/pull/1430) [`bd2db92`](https://github.com/browserbase/stagehand/commit/bd2db925f66a826d61d58be1611d55646cbdb560) Thanks [@shrey150](https://github.com/shrey150)! - Fix CUA model coordinate translation
+
+- [#1465](https://github.com/browserbase/stagehand/pull/1465) [`51e0170`](https://github.com/browserbase/stagehand/commit/51e01709ce1c947c1947b4e2cb0b1f4f97b77182) Thanks [@miguelg719](https://github.com/miguelg719)! - Add media resolution high provider option to gemini 3 hybrid agent
+
+- [#1431](https://github.com/browserbase/stagehand/pull/1431) [`05f5580`](https://github.com/browserbase/stagehand/commit/05f5580937c3c157550e3c25ae6671f44f562211) Thanks [@tkattkat](https://github.com/tkattkat)! - Update the cache handling for agent
+
+- [#1432](https://github.com/browserbase/stagehand/pull/1432) [`f56a9c2`](https://github.com/browserbase/stagehand/commit/f56a9c296d4ddce25a405358c66837f8ce4d679f) Thanks [@tkattkat](https://github.com/tkattkat)! - Deprecate cua: true in favor of mode: "cua"
+
+- [#1406](https://github.com/browserbase/stagehand/pull/1406) [`b40ae11`](https://github.com/browserbase/stagehand/commit/b40ae11391af49c3581fce27faa1b7483fc4a169) Thanks [@tkattkat](https://github.com/tkattkat)! - Add support for hovering with coordinates ( page.hover )
+
+- [#1407](https://github.com/browserbase/stagehand/pull/1407) [`0d2b398`](https://github.com/browserbase/stagehand/commit/0d2b398cd40b32a9ecaf28ede70853036b7c91bd) Thanks [@tkattkat](https://github.com/tkattkat)! - Clean up page methods
+
+- [#1412](https://github.com/browserbase/stagehand/pull/1412) [`cd01f29`](https://github.com/browserbase/stagehand/commit/cd01f290578eac703521f801ba3712f5332918f3) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: load GOOGLE_API_KEY from .env
+
+- [#1462](https://github.com/browserbase/stagehand/pull/1462) [`a734fca`](https://github.com/browserbase/stagehand/commit/a734fca0b4573753767d3ebc48ec414baf4f23e1) Thanks [@shrey150](https://github.com/shrey150)! - fix: correctly pass userDataDir to chrome launcher
+
+- [#1466](https://github.com/browserbase/stagehand/pull/1466) [`b342acf`](https://github.com/browserbase/stagehand/commit/b342acfaae058127fb57664644c5fd965db02bf2) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - move playwright to optional dependencies
+
+- [#1440](https://github.com/browserbase/stagehand/pull/1440) [`2987cd1`](https://github.com/browserbase/stagehand/commit/2987cd1e5ffabefa9411936609635d4a638faed5) Thanks [@tkattkat](https://github.com/tkattkat)! - [Feature] support excluding tools from agent
+
+- [#1455](https://github.com/browserbase/stagehand/pull/1455) [`dfab1d5`](https://github.com/browserbase/stagehand/commit/dfab1d566299c8c5a63f20565a6da07dc8f61ccd) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - update aisdk client to better enforce structured output with deepseek models
+
+- [#1428](https://github.com/browserbase/stagehand/pull/1428) [`4d71162`](https://github.com/browserbase/stagehand/commit/4d71162beb119635b69b17637564a2bbd0e373e7) Thanks [@tkattkat](https://github.com/tkattkat)! - Add "hybrid" mode to stagehand agent
+
+## 3.0.6
+
+### Patch Changes
+
+- [#1388](https://github.com/browserbase/stagehand/pull/1388) [`605ed6b`](https://github.com/browserbase/stagehand/commit/605ed6b81a3ff8f25d4022f1e5fce6b42aecfc19) Thanks [@miguelg719](https://github.com/miguelg719)! - Fix multiple click event dispatches on CDP and Anthropic CUA handling (double clicks)
+
+- [#1400](https://github.com/browserbase/stagehand/pull/1400) [`34e7e5b`](https://github.com/browserbase/stagehand/commit/34e7e5b292f5e6af6efc0da60118663310c5f718) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - don't write base64 encoded screenshots to disk when caching agent actions
+
+- [#1345](https://github.com/browserbase/stagehand/pull/1345) [`943d2d7`](https://github.com/browserbase/stagehand/commit/943d2d79d0f289ac41c9164578f2f1dd876058f2) Thanks [@tkattkat](https://github.com/tkattkat)! - Add support for aborting / stopping an agent run & continuing an agent run using messages from prior runs
+
+- [#1334](https://github.com/browserbase/stagehand/pull/1334) [`0e95cd2`](https://github.com/browserbase/stagehand/commit/0e95cd2f67672f64f0017024fd47d8b3aef59a95) Thanks [@tkattkat](https://github.com/tkattkat)! - Add support for google vertex provider
+
+- [#1410](https://github.com/browserbase/stagehand/pull/1410) [`d4237e4`](https://github.com/browserbase/stagehand/commit/d4237e40951ecd10abfdbe766672d498f8806484) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: include extract in stagehand.history()
+
+- [#1315](https://github.com/browserbase/stagehand/pull/1315) [`86975e7`](https://github.com/browserbase/stagehand/commit/86975e795db7505804949a267b20509bd16b5256) Thanks [@tkattkat](https://github.com/tkattkat)! - Add streaming support to agent through stream:true in the agent config
+
+- [#1304](https://github.com/browserbase/stagehand/pull/1304) [`d5e119b`](https://github.com/browserbase/stagehand/commit/d5e119be5eec84915a79f8d611b6ba0546f48c99) Thanks [@miguelg719](https://github.com/miguelg719)! - Add support for Microsoft's Fara-7B
+
+- [#1346](https://github.com/browserbase/stagehand/pull/1346) [`4e051b2`](https://github.com/browserbase/stagehand/commit/4e051b23add7ae276b0dbead38b4587838cfc1c1) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: don't attach to targets twice
+
+- [#1327](https://github.com/browserbase/stagehand/pull/1327) [`6b5a3c9`](https://github.com/browserbase/stagehand/commit/6b5a3c9035654caaed2da375085b465edda97de4) Thanks [@miguelg719](https://github.com/miguelg719)! - Informed error parsing from api
+
+- [#1335](https://github.com/browserbase/stagehand/pull/1335) [`bb85ad9`](https://github.com/browserbase/stagehand/commit/bb85ad912738623a7a866f0cb6e8d5807c6c2738) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - add support for page.addInitScript()
+
+- [#1331](https://github.com/browserbase/stagehand/pull/1331) [`88d28cc`](https://github.com/browserbase/stagehand/commit/88d28cc6f31058d1cf6ec6dc948a4ae77a926b3c) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: page.evaluate() now works with scripts injected via context.addInitScript()
+
+- [#1316](https://github.com/browserbase/stagehand/pull/1316) [`45bcef0`](https://github.com/browserbase/stagehand/commit/45bcef0e5788b083f9e38dfd7c3bc63afcd4b6dd) Thanks [@tkattkat](https://github.com/tkattkat)! - Add support for callbacks in stagehand agent
+
+- [#1374](https://github.com/browserbase/stagehand/pull/1374) [`6aa9d45`](https://github.com/browserbase/stagehand/commit/6aa9d455aa5836ec2ee8ab2e8b9df3fb218e5381) Thanks [@miguelg719](https://github.com/miguelg719)! - Fix key action mapping in Anthropic CUA
+
+- [#1330](https://github.com/browserbase/stagehand/pull/1330) [`d382084`](https://github.com/browserbase/stagehand/commit/d382084745fff98c3e71413371466394a2625429) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: make act, extract, and observe respect user defined timeout param
+
+- [#1336](https://github.com/browserbase/stagehand/pull/1336) [`1df08cc`](https://github.com/browserbase/stagehand/commit/1df08ccb0a2cf73b5c37a91c129721114ff6371c) Thanks [@tkattkat](https://github.com/tkattkat)! - Patch agent on api
+
+- [#1358](https://github.com/browserbase/stagehand/pull/1358) [`2b56600`](https://github.com/browserbase/stagehand/commit/2b566009606fcbba987260f21b075b318690ce99) Thanks [@tkattkat](https://github.com/tkattkat)! - Add support for 4.5 opus in cua agent
+
+## 3.0.4
+
+### Patch Changes
+
+- [#1281](https://github.com/browserbase/stagehand/pull/1281) [`fa18cfd`](https://github.com/browserbase/stagehand/commit/fa18cfdc45f28e35e6566587b54612396e6ece45) Thanks [@monadoid](https://github.com/monadoid)! - Add Browserbase session URL and debug URL accessors
+
+- [#1264](https://github.com/browserbase/stagehand/pull/1264) [`767d168`](https://github.com/browserbase/stagehand/commit/767d1686285cf9c57675595f553f8a891f13c63b) Thanks [@Kylejeong2](https://github.com/Kylejeong2)! - feat: adding gpt 5.1 to stagehand
+
+- [#1282](https://github.com/browserbase/stagehand/pull/1282) [`f27a99c`](https://github.com/browserbase/stagehand/commit/f27a99c11b020b33736fe67af8f7f0e663c6f45f) Thanks [@tkattkat](https://github.com/tkattkat)! - Add support for zod 4, while maintaining backwards compatibility for zod 3
+
+- [#1295](https://github.com/browserbase/stagehand/pull/1295) [`91a1ca0`](https://github.com/browserbase/stagehand/commit/91a1ca07d9178c46269bfb951abb20a215eb7c29) Thanks [@tkattkat](https://github.com/tkattkat)! - Patch zod handling of non objects in extract
+
+- [#1298](https://github.com/browserbase/stagehand/pull/1298) [`1dd7d43`](https://github.com/browserbase/stagehand/commit/1dd7d4330de9022dc6cd45a8b5c86cb9e1b575ec) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - log Browserbase session status when websocket is closed due to session timeout
+
+- [#1284](https://github.com/browserbase/stagehand/pull/1284) [`c0f3b98`](https://github.com/browserbase/stagehand/commit/c0f3b98277c15c77b2b4c3f55503e61ef3d27cf3) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: waitForDomNetworkQuiet() causing `act()` to hang indefinitely
+
+- [#1246](https://github.com/browserbase/stagehand/pull/1246) [`44bb4f5`](https://github.com/browserbase/stagehand/commit/44bb4f51dcccbdca8df07e4d7f8d28a7e6e793ec) Thanks [@filip-michalsky](https://github.com/filip-michalsky)! - make ci faster
+
+- [#1300](https://github.com/browserbase/stagehand/pull/1300) [`2b70347`](https://github.com/browserbase/stagehand/commit/2b7034771bc6d6b1fabb13deaa56c299881b3728) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - add support for context.addInitScript()
+
+## 3.0.3
+
+### Patch Changes
+
+- [#1273](https://github.com/browserbase/stagehand/pull/1273) [`ab51232`](https://github.com/browserbase/stagehand/commit/ab51232db428be048957c0f5d67f2176eb7a5194) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: trigger shadow root rerender in OOPIFs by cloning & replacing instead of reloading
+
+- [#1268](https://github.com/browserbase/stagehand/pull/1268) [`c76ade0`](https://github.com/browserbase/stagehand/commit/c76ade009ef81208accae6475ec4707d3906e566) Thanks [@tkattkat](https://github.com/tkattkat)! - Expose reasoning, and cached input tokens in stagehand metrics
+
+- [#1267](https://github.com/browserbase/stagehand/pull/1267) [`ffb5e5d`](https://github.com/browserbase/stagehand/commit/ffb5e5d2ab49adcb2efdfc9e5c76e8c96268b5b3) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: file uploads failing on Browserbase
+
+- [#1269](https://github.com/browserbase/stagehand/pull/1269) [`772e735`](https://github.com/browserbase/stagehand/commit/772e73543e45106d7fa0fafd95ade46ae11023bc) Thanks [@tkattkat](https://github.com/tkattkat)! - Add example using playwright screen recording
+
+## 3.0.2
+
+### Patch Changes
+
+- [#1245](https://github.com/browserbase/stagehand/pull/1245) [`a224b33`](https://github.com/browserbase/stagehand/commit/a224b3371b6c1470baf342742fb745c7192b52c6) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - allow act() to call hover()
+
+- [#1234](https://github.com/browserbase/stagehand/pull/1234) [`6fc9de2`](https://github.com/browserbase/stagehand/commit/6fc9de2a1079e4f2fb0b1633d8df0bb7a9f7f89f) Thanks [@miguelg719](https://github.com/miguelg719)! - Add a page.sendCDP method
+
+- [#1233](https://github.com/browserbase/stagehand/pull/1233) [`4935be7`](https://github.com/browserbase/stagehand/commit/4935be788b3431527f3d110864c0fd7060cfaf7c) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - extend page.screenshot() options to mirror playwright
+
+- [#1232](https://github.com/browserbase/stagehand/pull/1232) [`bdd76fc`](https://github.com/browserbase/stagehand/commit/bdd76fcd1e48079fc5ab8cf040ebb5997dfc6c99) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - export Page type
+
+- [#1229](https://github.com/browserbase/stagehand/pull/1229) [`7ea18a4`](https://github.com/browserbase/stagehand/commit/7ea18a420fc033d1b72556db83a1f41735e5a022) Thanks [@tkattkat](https://github.com/tkattkat)! - Adjust extract tool + expose extract response in agent result
+
+- [#1239](https://github.com/browserbase/stagehand/pull/1239) [`d4de014`](https://github.com/browserbase/stagehand/commit/d4de014235a18f9e1089240bc72e28cbfe77ca1c) Thanks [@miguelg719](https://github.com/miguelg719)! - Fix stagehand.metrics on api mode
+
+- [#1241](https://github.com/browserbase/stagehand/pull/1241) [`2d1b573`](https://github.com/browserbase/stagehand/commit/2d1b5732dc441a3331f5743cdfed3e1037d8b3b5) Thanks [@miguelg719](https://github.com/miguelg719)! - Return response on page.goto api mode
+
+- [#1253](https://github.com/browserbase/stagehand/pull/1253) [`5556041`](https://github.com/browserbase/stagehand/commit/5556041e2deaed5012363303fd7a8ac00e3242cd) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix missing page issue when connecting to existing browser
+
+- [#1235](https://github.com/browserbase/stagehand/pull/1235) [`7e4b43e`](https://github.com/browserbase/stagehand/commit/7e4b43ed46fbdd2074827e87d9a245e2dc96456b) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - make page.goto() return a Response object
+
+- [#1254](https://github.com/browserbase/stagehand/pull/1254) [`7e72adf`](https://github.com/browserbase/stagehand/commit/7e72adfd7e4af5ec49ac2f552e7f1f57c1acc554) Thanks [@sameelarif](https://github.com/sameelarif)! - Added custom error types to allow for a smoother debugging experience.
+
+- [#1227](https://github.com/browserbase/stagehand/pull/1227) [`9bf09d0`](https://github.com/browserbase/stagehand/commit/9bf09d041111870d71cb9ffcb3ac5fa2c4b1399d) Thanks [@miguelg719](https://github.com/miguelg719)! - Fix readme's media links and add instructions for installing from a branch
+
+- [#1257](https://github.com/browserbase/stagehand/pull/1257) [`92d32ea`](https://github.com/browserbase/stagehand/commit/92d32eafe91a4241615cc65501b8461c6074a02b) Thanks [@tkattkat](https://github.com/tkattkat)! - Add support for a custom baseUrl with google cua client
+
+- [#1230](https://github.com/browserbase/stagehand/pull/1230) [`ebcf3a1`](https://github.com/browserbase/stagehand/commit/ebcf3a1ffa859374d71de4931c6a9b982a565e46) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - add stagehand.browserbaseSessionID getter
+
+- [#1262](https://github.com/browserbase/stagehand/pull/1262) [`c29a4f2`](https://github.com/browserbase/stagehand/commit/c29a4f2eca91ae2902ed9d48b2385b4436f7b664) Thanks [@miguelg719](https://github.com/miguelg719)! - Remove error throwing when api and experimental are both set
+
+- [#1223](https://github.com/browserbase/stagehand/pull/1223) [`6d21efa`](https://github.com/browserbase/stagehand/commit/6d21efa8b30317aa3ce3e37ac6c2222af3b967b5) Thanks [@miguelg719](https://github.com/miguelg719)! - Disable api mode when using custom LLM clients
+
+- [#1228](https://github.com/browserbase/stagehand/pull/1228) [`525ef0c`](https://github.com/browserbase/stagehand/commit/525ef0c1243aaf3452ee7e4ea81b4208f4c2efd1) Thanks [@Kylejeong2](https://github.com/Kylejeong2)! - update slack link in docs
+
+- [#1226](https://github.com/browserbase/stagehand/pull/1226) [`9ddb872`](https://github.com/browserbase/stagehand/commit/9ddb872e350358214e12a91cf6a614fd2ec1f74c) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - add support for page.on('console') events
+
+## 3.0.1
+
+### Patch Changes
+
+- [#1207](https://github.com/browserbase/stagehand/pull/1207) [`55da8c6`](https://github.com/browserbase/stagehand/commit/55da8c6e9575cbad3246c55b17650cf6b293ddbe) Thanks [@miguelg719](https://github.com/miguelg719)! - Fix broken links to quickstart docs
+
+- [#1200](https://github.com/browserbase/stagehand/pull/1200) [`0a5ee63`](https://github.com/browserbase/stagehand/commit/0a5ee638bde051d109eb2266e665934a12f3dc31) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - log info when scope narrowing selector fails
+
+- [#1205](https://github.com/browserbase/stagehand/pull/1205) [`ee76881`](https://github.com/browserbase/stagehand/commit/ee7688156cb67a9f0f90dfe0dbab77423693a332) Thanks [@miguelg719](https://github.com/miguelg719)! - Update README.md, add Changelog for v3
+
+- [#1209](https://github.com/browserbase/stagehand/pull/1209) [`9e95add`](https://github.com/browserbase/stagehand/commit/9e95add37eb30db4f85e73df7760c7e63fb4131e) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix circular import in exported aisdk example client
+
+- [#1211](https://github.com/browserbase/stagehand/pull/1211) [`98e212b`](https://github.com/browserbase/stagehand/commit/98e212b27887241879608c6c1b6c2524477a40d7) Thanks [@miguelg719](https://github.com/miguelg719)! - Add an example for passing custom tools to agent
+
+- [#1206](https://github.com/browserbase/stagehand/pull/1206) [`d5ecbfc`](https://github.com/browserbase/stagehand/commit/d5ecbfc8e419a59b91c2115fd7f984378381d3d0) Thanks [@miguelg719](https://github.com/miguelg719)! - Export example AISdkClient properly from the stagehand package
diff --git a/packages/core/README.md b/packages/core/README.md
new file mode 100644
index 000000000..7df1261d6
--- /dev/null
+++ b/packages/core/README.md
@@ -0,0 +1,164 @@
+<div id="toc" align="center" style="margin-bottom: 0;">
+  <ul style="list-style: none; margin: 0; padding: 0;">
+    <a href="https://stagehand.dev">
+      <picture>
+        <source media="(prefers-color-scheme: dark)" srcset="../../media/dark_logo.png" />
+        <img alt="Stagehand" src="../../media/light_logo.png" width="200" style="margin-right: 30px;" />
+      </picture>
+    </a>
+  </ul>
+</div>
+<p align="center">
+  <strong>The AI Browser Automation Framework</strong><br>
+  <a href="https://docs.stagehand.dev">Read the Docs</a>
+</p>
+
+<p align="center">
+  <a href="https://github.com/browserbase/stagehand/tree/main?tab=MIT-1-ov-file#MIT-1-ov-file">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="../../media/dark_license.svg" />
+      <img alt="MIT License" src="../../media/light_license.svg" />
+    </picture>
+  </a>
+  <a href="https://stagehand.dev/discord">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="../../media/dark_discord.svg" />
+      <img alt="Discord Community" src="../../media/light_discord.svg" />
+    </picture>
+  </a>
+</p>
+
+<p align="center">
+	<a href="https://trendshift.io/repositories/12122" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12122" alt="browserbase%2Fstagehand | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+</p>
+
+<p align="center">
+  <a href="https://deepwiki.com/browserbase/stagehand">
+    <img alt="Ask DeepWiki" src="https://deepwiki.com/badge.svg" />
+  </a>
+</p>
+
+<p align="center">
+If you're looking for the Python implementation, you can find it 
+<a href="https://github.com/browserbase/stagehand-python"> here</a>
+</p>
+
+<div align="center" style="display: flex; align-items: center; justify-content: center; gap: 4px; margin-bottom: 0;">
+  <b>Vibe code</b>
+  <span style="font-size: 1.05em;"> Stagehand with </span>
+  <a href="https://director.ai" style="display: flex; align-items: center;">
+    <span>Director</span>
+  </a>
+  <span> </span>
+  <picture>
+    <img alt="Director" src="../../media/director_icon.svg" width="25" />
+  </picture>
+</div>
+
+## What is Stagehand?
+
+Stagehand is a browser automation framework used to control web browsers with natural language and code. By combining the power of AI with the precision of code, Stagehand makes web automation flexible, maintainable, and actually reliable.
+
+## Why Stagehand?
+
+Most existing browser automation tools either require you to write low-level code in a framework like Selenium, Playwright, or Puppeteer, or use high-level agents that can be unpredictable in production. By letting developers choose what to write in code vs. natural language (and bridging the gap between the two) Stagehand is the natural choice for browser automations in production.
+
+1. **Choose when to write code vs. natural language**: use AI when you want to navigate unfamiliar pages, and use code when you know exactly what you want to do.
+
+2. **Go from AI-driven to repeatable workflows**: Stagehand lets you preview AI actions before running them, and also helps you easily cache repeatable actions to save time and tokens.
+
+3. **Write once, run forever**: Stagehand's auto-caching combined with self-healing remembers previous actions, runs without LLM inference, and knows when to involve AI whenever the website changes and your automation breaks.
+
+## Getting Started
+
+Start with Stagehand with one line of code, or check out our [Quickstart Guide](https://docs.stagehand.dev/v3/first-steps/quickstart) for more information:
+
+```bash
+npx create-browser-app
+```
+
+## Example
+
+Here's how to build a sample browser automation with Stagehand:
+
+```typescript
+// Stagehand's CDP engine provides an optimized, low level interface to the browser built for automation
+const page = stagehand.context.pages()[0];
+await page.goto("https://github.com/browserbase");
+
+// Use act() to execute individual actions
+await stagehand.act("click on the stagehand repo");
+
+// Use agent() for multi-step tasks
+const agent = stagehand.agent();
+await agent.execute("Get to the latest PR");
+
+// Use extract() to get structured data from the page
+const { author, title } = await stagehand.extract(
+  "extract the author and title of the PR",
+  z.object({
+    author: z.string().describe("The username of the PR author"),
+    title: z.string().describe("The title of the PR"),
+  }),
+);
+```
+
+## Documentation
+
+Visit [docs.stagehand.dev](https://docs.stagehand.dev) to view the full documentation.
+
+### Build and Run from Source
+
+```bash
+git clone https://github.com/browserbase/stagehand.git
+cd stagehand
+pnpm install
+pnpm run build
+pnpm run example # run the blank script at ./examples/example.ts
+```
+
+Stagehand is best when you have an API key for an LLM provider and Browserbase credentials. To add these to your project, run:
+
+```bash
+cp .env.example .env
+nano .env # Edit the .env file to add API keys
+```
+
+### Installing from a branch
+
+You can install and build Stagehand directly from a github branch using [gitpkg](https://github.com/EqualMa/gitpkg)
+
+In your project's `package.json` set:
+
+```json
+"@browserbasehq/stagehand": "https://gitpkg.now.sh/browserbase/stagehand/packages/core?<branchName>",
+```
+
+## Contributing
+
+> [!NOTE]
+> We highly value contributions to Stagehand! For questions or support, please join our [Discord community](https://stagehand.dev/discord).
+
+At a high level, we're focused on improving reliability, extensibility, speed, and cost in that order of priority. If you're interested in contributing, **bug fixes and small improvements are the best way to get started**. For more involved features, we strongly recommend reaching out to [Miguel Gonzalez](https://x.com/miguel_gonzf) or [Paul Klein](https://x.com/pk_iv) in our [Discord community](https://stagehand.dev/discord) before starting to ensure that your contribution aligns with our goals.
+
+<!-- For more information, please see our [Contributing Guide](https://docs.stagehand.dev/examples/contributing). -->
+
+## Acknowledgements
+
+We'd like to thank the following people for their major contributions to Stagehand:
+
+- [Paul Klein](https://github.com/pkiv)
+- [Sean McGuire](https://github.com/seanmcguire12)
+- [Miguel Gonzalez](https://github.com/miguelg719)
+- [Sameel Arif](https://github.com/sameelarif)
+- [Thomas Katwan](https://github.com/tkattkat)
+- [Filip Michalsky](https://github.com/filip-michalsky)
+- [Anirudh Kamath](https://github.com/kamath)
+- [Jeremy Press](https://x.com/jeremypress)
+- [Navid Pour](https://github.com/navidpour)
+
+## License
+
+Licensed under the MIT License.
+
+Copyright 2025 Browserbase, Inc.
diff --git a/examples/2048.ts b/packages/core/examples/2048.ts
similarity index 79%
rename from examples/2048.ts
rename to packages/core/examples/2048.ts
index 9c651198a..17b295dd1 100644
--- a/examples/2048.ts
+++ b/packages/core/examples/2048.ts
@@ -1,4 +1,4 @@
-import { Stagehand } from "@/dist";
+import { Stagehand } from "../lib/v3/index.js";
 import { z } from "zod";
 
 async function example() {
@@ -6,32 +6,31 @@ async function example() {
   const stagehand = new Stagehand({
     env: "LOCAL",
     verbose: 1,
-    domSettleTimeoutMs: 100,
   });
+
+  console.log("🌟 Initializing Stagehand...");
+  await stagehand.init();
+  const page = stagehand.context.pages()[0];
   try {
-    console.log("🌟 Initializing Stagehand...");
-    await stagehand.init();
     console.log("🌐 Navigating to 2048...");
-    await stagehand.page.goto("https://ovolve.github.io/2048-AI/");
-    console.log("⌛ Waiting for game to initialize...");
-    await stagehand.page.waitForSelector(".grid-container", { timeout: 10000 });
+    await page.goto("https://ovolve.github.io/2048-AI/");
     // Main game loop
     while (true) {
       console.log("🔄 Game loop iteration...");
       // Add a small delay for UI updates
       await new Promise((resolve) => setTimeout(resolve, 300));
       // Get current game state
-      const gameState = await stagehand.page.extract({
-        instruction: `Extract the current game state:
+      const gameState = await stagehand.extract(
+        `Extract the current game state:
           1. Score from the score counter
           2. All tile values in the 4x4 grid (empty spaces as 0)
           3. Highest tile value present`,
-        schema: z.object({
+        z.object({
           score: z.number(),
           highestTile: z.number(),
           grid: z.array(z.array(z.number())),
         }),
-      });
+      );
       const transposedGrid = gameState.grid[0].map((_, colIndex) =>
         gameState.grid.map((row) => row[colIndex]),
       );
@@ -44,8 +43,8 @@ async function example() {
         grid: grid,
       });
       // Analyze board and decide next move
-      const analysis = await stagehand.page.extract({
-        instruction: `Based on the current game state:
+      const analysis = await stagehand.extract(
+        `Based on the current game state:
           - Score: ${gameState.score}
           - Highest tile: ${gameState.highestTile}
           - Grid: This is a 4x4 matrix ordered by row (top to bottom) and column (left to right). The rows are stacked vertically, and tiles can move vertically between rows or horizontally between columns:\n${grid
@@ -62,12 +61,12 @@ async function example() {
           5. Making a move will move all tiles in that direction until they hit a tile of a different value or the edge of the board
           6. Tiles cannot move past the edge of the board
           7. Each move must move at least one tile`,
-        schema: z.object({
+        z.object({
           move: z.enum(["up", "down", "left", "right"]),
           confidence: z.number(),
           reasoning: z.string(),
         }),
-      });
+      );
       console.log("Move Analysis:", analysis);
       const moveKey = {
         up: "ArrowUp",
@@ -75,12 +74,12 @@ async function example() {
         left: "ArrowLeft",
         right: "ArrowRight",
       }[analysis.move];
-      await stagehand.page.keyboard.press(moveKey);
+      await page.keyPress(moveKey);
       console.log("🎯 Executed move:", analysis.move);
     }
   } catch (error) {
     console.error("❌ Error in game loop:", error);
-    const isGameOver = await stagehand.page.evaluate(() => {
+    const isGameOver = await page.evaluate(() => {
       return document.querySelector(".game-over") !== null;
     });
     if (isGameOver) {
diff --git a/packages/core/examples/CHANGELOG.md b/packages/core/examples/CHANGELOG.md
new file mode 100644
index 000000000..4db2cda02
--- /dev/null
+++ b/packages/core/examples/CHANGELOG.md
@@ -0,0 +1,64 @@
+# @browserbasehq/stagehand-examples
+
+## 1.0.9
+
+### Patch Changes
+
+- Updated dependencies [[`09b5e1e`](https://github.com/browserbase/stagehand/commit/09b5e1e9c23c845903686db6665cc968ac34efbb), [`e3734b9`](https://github.com/browserbase/stagehand/commit/e3734b9c98352d5f0a4eca49791b0bbf2130ab41), [`8244ab2`](https://github.com/browserbase/stagehand/commit/8244ab247cd679962685ae2f7c54e874ce1fa614), [`be85b19`](https://github.com/browserbase/stagehand/commit/be85b19679a826f19702e00f0aae72fce1118ec8), [`88d1565`](https://github.com/browserbase/stagehand/commit/88d1565c65bb65a104fea2d5f5e862bbbda69677), [`ab5d6ed`](https://github.com/browserbase/stagehand/commit/ab5d6ede19aabc059badc4247f1cb2c6c9e71bae)]:
+  - @browserbasehq/stagehand@2.5.0
+
+## 1.0.8
+
+### Patch Changes
+
+- Updated dependencies [[`9e8c173`](https://github.com/browserbase/stagehand/commit/9e8c17374fdc8fbe7f26e6cf802c36bd14f11039)]:
+  - @browserbasehq/stagehand@2.4.4
+
+## 1.0.7
+
+### Patch Changes
+
+- Updated dependencies [[`f45afdc`](https://github.com/browserbase/stagehand/commit/f45afdccc8680650755fee66ffbeac32b41e075d), [`261bba4`](https://github.com/browserbase/stagehand/commit/261bba43fa79ac3af95328e673ef3e9fced3279b), [`8de7bd8`](https://github.com/browserbase/stagehand/commit/8de7bd8635c2051cd8025e365c6c8aa83d81c7e7), [`3d80421`](https://github.com/browserbase/stagehand/commit/3d804210a106a6828c7fa50f8b765b10afd4cc6a), [`0ead63d`](https://github.com/browserbase/stagehand/commit/0ead63d6526f6c286362b74b6407c8bebc900e69), [`8422828`](https://github.com/browserbase/stagehand/commit/8422828c4cd5fd5ebcf348cfbdb40c768bb76dd9), [`b769206`](https://github.com/browserbase/stagehand/commit/b7692060f98a2f49aeeefb90d8789ed034b08ec2), [`72d2683`](https://github.com/browserbase/stagehand/commit/72d2683202af7e578d98367893964b33e0828de5)]:
+  - @browserbasehq/stagehand@2.4.3
+
+## 1.0.6
+
+### Patch Changes
+
+- Updated dependencies [[`6b4e6e3`](https://github.com/browserbase/stagehand/commit/6b4e6e3f31d5496cf15728e9018eddeb04839542), [`e77d018`](https://github.com/browserbase/stagehand/commit/e77d0188683ebf596dfb78dfafbbca1dc32993f0), [`c20adb9`](https://github.com/browserbase/stagehand/commit/c20adb95539fed8c56a4aa413262a9c65a8e6474), [`b86df93`](https://github.com/browserbase/stagehand/commit/b86df93b9136aae96292121a29c25f3d74d84bf7), [`023c2c2`](https://github.com/browserbase/stagehand/commit/023c2c273b46d3792d7e5d3c902089487b16b531), [`8c28647`](https://github.com/browserbase/stagehand/commit/8c2864755ecd05c8f7de235d4198deec0dd5f78e), [`87e09c6`](https://github.com/browserbase/stagehand/commit/87e09c618940f364ec8af00455a19a17ec63cbd3), [`a611115`](https://github.com/browserbase/stagehand/commit/a61111525d70b450bdfc43f112380f44899c9e97), [`69913fe`](https://github.com/browserbase/stagehand/commit/69913fe1dfb8201ae2aeffa5f049fb46ab02cbc2), [`b1b83a1`](https://github.com/browserbase/stagehand/commit/b1b83a1d334fe76e5f5f9dd32dc92c16b7d40ce6), [`be8497c`](https://github.com/browserbase/stagehand/commit/be8497cb6b142cc893cea9692b8c47bd19514c60), [`98704c9`](https://github.com/browserbase/stagehand/commit/98704c9ed225ca25bbde4bb3dc286936e9c54471), [`04978bd`](https://github.com/browserbase/stagehand/commit/04978bdd30d2edcbc69eb9fd91358a16975ea2eb)]:
+  - @browserbasehq/stagehand@2.4.2
+
+## 1.0.5
+
+### Patch Changes
+
+- Updated dependencies [[`8a43c5a`](https://github.com/browserbase/stagehand/commit/8a43c5a86d4da40cfaedd9cf2e42186928bdf946), [`890ffcc`](https://github.com/browserbase/stagehand/commit/890ffccac5e0a60ade64a46eb550c981ffb3e84a), [`64c1072`](https://github.com/browserbase/stagehand/commit/64c10727bda50470483a3eb175c02842db0923a1), [`b077d3f`](https://github.com/browserbase/stagehand/commit/b077d3f48a97f47a71ccc79ae39b41e7f07f9c04), [`8bcb5d7`](https://github.com/browserbase/stagehand/commit/8bcb5d77debf6bf7601fd5c090efd7fde75c5d5e), [`7bf10c5`](https://github.com/browserbase/stagehand/commit/7bf10c55b267078fe847c1d7f7a60d604f9c7c94)]:
+  - @browserbasehq/stagehand@2.4.1
+
+## 1.0.4
+
+### Patch Changes
+
+- Updated dependencies [[`124e0d3`](https://github.com/browserbase/stagehand/commit/124e0d3bb54ddb6738ede6d7aa99a945ef1cacd1), [`6a18c1e`](https://github.com/browserbase/stagehand/commit/6a18c1ee1e46d55c6e90c4d5572e17ed8daa140c), [`1660751`](https://github.com/browserbase/stagehand/commit/1660751cd14cb5b27d44f8167216afb8d1c3c45c), [`cadac9d`](https://github.com/browserbase/stagehand/commit/cadac9da09123d12e5d496a0e8b12660964c1b33), [`759da55`](https://github.com/browserbase/stagehand/commit/759da55775eb2df81d56ae18c0f386fd9b02a9f0), [`a175a51`](https://github.com/browserbase/stagehand/commit/a175a519b8c14300db6f1ed30709e113d18e99db), [`8527a80`](https://github.com/browserbase/stagehand/commit/8527a80522c3eedb9516a6caa1a0e4e4be981a3d), [`55fca2f`](https://github.com/browserbase/stagehand/commit/55fca2f7da63cc0ef6e27b45a33f63c666cdce7e)]:
+  - @browserbasehq/stagehand@2.4.0
+
+## 1.0.3
+
+### Patch Changes
+
+- Updated dependencies [[`12a99b3`](https://github.com/browserbase/stagehand/commit/12a99b398d8a4c3eea3ca69a3cf793faaaf4aea3), [`2451797`](https://github.com/browserbase/stagehand/commit/2451797f64c0efa4a72fd70265110003c8d0a6cd), [`1d631a5`](https://github.com/browserbase/stagehand/commit/1d631a57a197390f672b718ae5199991ab27cfb1), [`9c398bb`](https://github.com/browserbase/stagehand/commit/9c398bb9ec2d10bdb53ad5aa7e3b58cce24fdb2b), [`c19ad7f`](https://github.com/browserbase/stagehand/commit/c19ad7f1e082e91fdeaa9c2ef63767a5a2b3a195)]:
+  - @browserbasehq/stagehand@2.3.1
+
+## 1.0.2
+
+### Patch Changes
+
+- Updated dependencies [[`5680d25`](https://github.com/browserbase/stagehand/commit/5680d2509352c383ad502c9f4fabde01fa638833), [`4de92a8`](https://github.com/browserbase/stagehand/commit/4de92a8af461fc95063faf39feee1d49259f58ba), [`6ef6073`](https://github.com/browserbase/stagehand/commit/6ef60730cab0ad9025f44b6eeb2c83751d1dcd35)]:
+  - @browserbasehq/stagehand@2.3.0
+
+## 1.0.1
+
+### Patch Changes
+
+- Updated dependencies [[`be8652e`](https://github.com/browserbase/stagehand/commit/be8652e770b57fdb3299fa0b2efa4eb0e816434e), [`6b413b7`](https://github.com/browserbase/stagehand/commit/6b413b7ad00b13ca0bd53ee2e7393023821408b6), [`7eafbd9`](https://github.com/browserbase/stagehand/commit/7eafbd9b1a73b37effa444929767df7c592caf02), [`1b50aa6`](https://github.com/browserbase/stagehand/commit/1b50aa61cf0a429dd6cb2760a08f7f698a50454b), [`f2b7f1f`](https://github.com/browserbase/stagehand/commit/f2b7f1f284eef1f96753319b66c7d0b273a6f8cd), [`c8d672f`](https://github.com/browserbase/stagehand/commit/c8d672f7c410c256defbc2e87ead99239837aa28), [`bebf204`](https://github.com/browserbase/stagehand/commit/bebf2044502333c694743078c5b0c9deae11fb79), [`37d6810`](https://github.com/browserbase/stagehand/commit/37d6810a704773d0383a86f98f5f17c7d5b21975)]:
+  - @browserbasehq/stagehand@2.2.1
diff --git a/packages/core/examples/actionable_observe_example.ts b/packages/core/examples/actionable_observe_example.ts
new file mode 100644
index 000000000..c05aceb3e
--- /dev/null
+++ b/packages/core/examples/actionable_observe_example.ts
@@ -0,0 +1,80 @@
+/**
+ * This example shows how to use actionable observe()
+ *
+ * You can use observe to get a cache-able Playwright action as JSON, then pass that JSON to act() to perform the action.
+ *
+ * This is useful for:
+ * - Previewing actions before running them
+ * - Saving actions to a file and replaying them later
+ * - Hiding sensitive information from LLMs
+ *
+ * For more on caching, see: https://docs.stagehand.dev/examples/caching
+ * Also check out the form_filling_sensible.ts example for a more complex example of using observe() to fill out a form.
+ */
+
+import { Action, Stagehand } from "../lib/v3/index.js";
+
+async function example() {
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    verbose: 1,
+  });
+  await stagehand.init();
+  const page = stagehand.context.pages()[0];
+
+  await page.goto("https://www.apartments.com/san-francisco-ca/");
+
+  let observation: Action;
+
+  await new Promise((resolve) => setTimeout(resolve, 3000));
+  [observation] = await stagehand.observe("find the 'all filters' button");
+  await stagehand.act(observation);
+
+  await new Promise((resolve) => setTimeout(resolve, 3000));
+  [observation] = await stagehand.observe(
+    "find the '1+' button in the 'beds' section",
+  );
+  await stagehand.act(observation);
+
+  await new Promise((resolve) => setTimeout(resolve, 3000));
+  [observation] = await stagehand.observe(
+    "find the 'apartments' button in the 'home type' section",
+  );
+  await stagehand.act(observation);
+
+  await new Promise((resolve) => setTimeout(resolve, 3000));
+  [observation] = await stagehand.observe(
+    "find the pet policy dropdown to click on.",
+  );
+  await stagehand.act(observation);
+
+  await new Promise((resolve) => setTimeout(resolve, 3000));
+  [observation] = await stagehand.observe(
+    "find the 'Dog Friendly' option to click on",
+  );
+  await stagehand.act(observation);
+
+  await new Promise((resolve) => setTimeout(resolve, 3000));
+  [observation] = await stagehand.observe("find the 'see results' section");
+  await stagehand.act(observation);
+
+  const currentUrl = page.url();
+  await stagehand.close();
+  if (
+    currentUrl.includes(
+      "https://www.apartments.com/apartments/san-francisco-ca/min-1-bedrooms-pet-friendly-dog/",
+    )
+  ) {
+    console.log("✅ Success! we made it to the correct page");
+  } else {
+    console.log(
+      "❌ Whoops, looks like we didn't make it to the correct page. " +
+        "\nThanks for testing out this new Stagehand feature!" +
+        "\nReach us on Discord if you have any feedback/questions/suggestions!",
+    );
+  }
+}
+
+(async () => {
+  await example();
+})();
diff --git a/packages/core/examples/agent-custom-tools.ts b/packages/core/examples/agent-custom-tools.ts
new file mode 100644
index 000000000..1195757ce
--- /dev/null
+++ b/packages/core/examples/agent-custom-tools.ts
@@ -0,0 +1,107 @@
+/**
+ * This example shows how to pass custom tools to stagehand agent (both CUA and non-CUA)
+ */
+import { z } from "zod";
+import { tool } from "ai";
+import { Stagehand } from "../lib/v3/index.js";
+import chalk from "chalk";
+
+// Mock weather API, replace with your own API/tool logic
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const fetchWeatherAPI = async (location: string) => {
+  return {
+    temp: 70,
+    conditions: "sunny",
+  };
+};
+
+// Define the tool in an AI SDK format
+const getWeather = tool({
+  description: "Get the current weather in a location",
+  inputSchema: z.object({
+    location: z.string().describe("The location to get weather for"),
+  }),
+  execute: async ({ location }) => {
+    // Your custom logic here
+    const weather = await fetchWeatherAPI(location);
+    return {
+      location,
+      temperature: weather.temp,
+      conditions: weather.conditions,
+    };
+  },
+});
+
+async function main() {
+  console.log(
+    `\n${chalk.bold("Stagehand 🤘 Computer Use Agent (CUA) Demo")}\n`,
+  );
+
+  // Initialize Stagehand
+  const stagehand = new Stagehand({
+    env: "LOCAL",
+    verbose: 2,
+    experimental: true, // You must enable experimental mode to use custom tools / MCP integrations
+    model: "anthropic/claude-sonnet-4-5",
+  });
+  await stagehand.init();
+
+  try {
+    const page = stagehand.context.pages()[0];
+
+    // Create a computer use agent
+    const agent = stagehand.agent({
+      mode: "cua",
+      model: {
+        modelName: "anthropic/claude-sonnet-4-5-20250929",
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      systemPrompt: `You are a helpful assistant that can use a web browser.
+      You are currently on the following page: ${page.url()}.
+      Do not ask follow up questions, the user will trust your judgement. Today's date is ${new Date().toLocaleDateString()}.`,
+      tools: {
+        getWeather, // Pass the tools to the agent
+      },
+    });
+
+    // const agent = stagehand.agent({
+    //   systemPrompt: `You are a helpful assistant that can use a web browser.
+    //   You are currently on the following page: ${page.url()}.
+    //   Do not ask follow up questions, the user will trust your judgement. Today's date is ${new Date().toLocaleDateString()}.`,
+    //   // Pass the tools to the agent
+    //   tools: {
+    //     getWeather: getWeather,
+    //   },
+    // });
+
+    // Navigate to the Browserbase careers page
+    await page.goto("https://www.google.com");
+
+    // Define the instruction for the CUA
+    const instruction = "What's the weather in San Francisco?";
+    console.log(`Instruction: ${chalk.white(instruction)}`);
+
+    // Execute the instruction
+    const result = await agent.execute({
+      instruction,
+      maxSteps: 20,
+    });
+
+    console.log(`${chalk.green("✓")} Execution complete`);
+    console.log(`${chalk.yellow("⤷")} Result:`);
+    console.log(chalk.white(JSON.stringify(result, null, 2)));
+  } catch (error) {
+    console.log(`${chalk.red("✗")} Error: ${error}`);
+    if (error instanceof Error && error.stack) {
+      console.log(chalk.dim(error.stack.split("\n").slice(1).join("\n")));
+    }
+  } finally {
+    // Close the browser
+    await stagehand.close();
+  }
+}
+
+main().catch((error) => {
+  console.log(`${chalk.red("✗")} Unhandled error in main function`);
+  console.log(chalk.red(error));
+});
diff --git a/packages/core/examples/agent_stream_example.ts b/packages/core/examples/agent_stream_example.ts
new file mode 100644
index 000000000..29c8dc18e
--- /dev/null
+++ b/packages/core/examples/agent_stream_example.ts
@@ -0,0 +1,47 @@
+import { Stagehand } from "../lib/v3/index.js";
+import chalk from "chalk";
+
+// Load environment variables
+async function main() {
+  console.log(`\n${chalk.bold("Stagehand 🤘 Agent Streaming Example")}\n`);
+  // Initialize Stagehand
+  const stagehand = new Stagehand({
+    env: "LOCAL",
+    verbose: 0,
+    cacheDir: "stagehand-agent-cache",
+    logInferenceToFile: false,
+    experimental: true,
+  });
+
+  await stagehand.init();
+
+  try {
+    const page = stagehand.context.pages()[0];
+    await page.goto("https://amazon.com");
+
+    // Create a streaming agent with stream: true in the config
+    const agent = stagehand.agent({
+      model: "anthropic/claude-sonnet-4-5-20250929",
+      stream: true, // This makes execute() return AgentStreamResult
+    });
+
+    const agentRun = await agent.execute({
+      instruction: "go to amazon, and search for shampoo, stop after searching",
+      maxSteps: 20,
+    });
+    // stream the text
+    for await (const delta of agentRun.textStream) {
+      process.stdout.write(delta);
+    }
+    // stream everything ( toolcalls, messages, etc.)
+    // for await (const delta of result.fullStream) {
+    //   console.log(delta);
+    // }
+
+    const finalResult = await agentRun.result;
+    console.log("Final Result:", finalResult);
+  } catch (error) {
+    console.log(`${chalk.red("✗")} Error: ${error}`);
+  }
+}
+main();
diff --git a/packages/core/examples/cua-example.ts b/packages/core/examples/cua-example.ts
new file mode 100644
index 000000000..9b828a18d
--- /dev/null
+++ b/packages/core/examples/cua-example.ts
@@ -0,0 +1,71 @@
+/**
+ * This example shows how to use a computer use agent (CUA) to navigate a web page and extract data.
+ *
+ * To learn more about the CUA, see: https://docs.stagehand.dev/examples/computer_use
+ *
+ * NOTE: YOU MUST CONFIGURE BROWSER DIMENSIONS TO USE COMPUTER USE!
+ * Check out stagehand.config.ts for more information.
+ */
+import { Stagehand } from "../lib/v3/index.js";
+import chalk from "chalk";
+
+async function main() {
+  console.log(
+    `\n${chalk.bold("Stagehand 🤘 Computer Use Agent (CUA) Demo")}\n`,
+  );
+
+  // Initialize Stagehand
+  const stagehand = new Stagehand({
+    env: "LOCAL",
+    verbose: 2,
+  });
+  await stagehand.init();
+
+  try {
+    const page = stagehand.context.pages()[0];
+
+    // Create a computer use agent
+    const agent = stagehand.agent({
+      mode: "cua",
+      model: {
+        modelName: "google/gemini-3-flash-preview",
+        apiKey: process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY,
+      },
+      systemPrompt: `You are a helpful assistant that can use a web browser.
+      You are currently on the following page: ${page.url()}.
+      Do not ask follow up questions, the user will trust your judgement. Today's date is ${new Date().toLocaleDateString()}.`,
+    });
+
+    // Navigate to the Browserbase careers page
+    await page.goto("https://www.browserbase.com/careers");
+
+    // Define the instruction for the CUA
+    const instruction =
+      "Apply for the first engineer position with mock data. Don't submit the form. You're on the right page";
+    console.log(`Instruction: ${chalk.white(instruction)}`);
+
+    // Execute the instruction
+    const result = await agent.execute({
+      instruction,
+      maxSteps: 20,
+    });
+    await new Promise((resolve) => setTimeout(resolve, 30000));
+
+    console.log(`${chalk.green("✓")} Execution complete`);
+    console.log(`${chalk.yellow("⤷")} Result:`);
+    console.log(chalk.white(JSON.stringify(result, null, 2)));
+  } catch (error) {
+    console.log(`${chalk.red("✗")} Error: ${error}`);
+    if (error instanceof Error && error.stack) {
+      console.log(chalk.dim(error.stack.split("\n").slice(1).join("\n")));
+    }
+  } finally {
+    // Close the browser
+    await stagehand.close();
+  }
+}
+
+main().catch((error) => {
+  console.log(`${chalk.red("✗")} Unhandled error in main function`);
+  console.log(chalk.red(error));
+});
diff --git a/packages/core/examples/custom_client_aisdk.ts b/packages/core/examples/custom_client_aisdk.ts
new file mode 100644
index 000000000..034aeb0dd
--- /dev/null
+++ b/packages/core/examples/custom_client_aisdk.ts
@@ -0,0 +1,42 @@
+/**
+ * This example shows how to use the Vercel AI SDK to power the Stagehand LLM Client.
+ *
+ * You will need to reference the AI SDK Client in /external_clients/aisdk.ts
+ *
+ * To learn more about the Vercel AI SDK, see: https://sdk.vercel.ai/docs
+ */
+import { Stagehand } from "../lib/v3/index.js";
+import { AISdkClient } from "./external_clients/aisdk.js";
+import { z } from "zod";
+import { openai } from "@ai-sdk/openai";
+
+async function example() {
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    verbose: 1,
+    llmClient: new AISdkClient({
+      model: openai("gpt-4o"),
+    }),
+  });
+
+  await stagehand.init();
+  const page = stagehand.context.pages()[0];
+
+  await page.goto("https://news.ycombinator.com");
+
+  const { story } = await stagehand.extract(
+    "extract the title of the top story on the page",
+    z.object({
+      story: z.string().describe("the top story on the page"),
+    }),
+  );
+
+  console.log("The top story is:", story);
+  await stagehand.act("click the first story");
+
+  await stagehand.close();
+}
+
+(async () => {
+  await example();
+})();
diff --git a/packages/core/examples/custom_client_langchain.ts b/packages/core/examples/custom_client_langchain.ts
new file mode 100644
index 000000000..a51ad3a57
--- /dev/null
+++ b/packages/core/examples/custom_client_langchain.ts
@@ -0,0 +1,36 @@
+/**
+ * This example shows how to use the Langchain client with Stagehand.
+ *
+ * You will need to reference the Langchain Client in /external_clients/langchain.ts
+ */
+import { z } from "zod";
+import { Stagehand } from "../lib/v3/index.js";
+import { LangchainClient } from "./external_clients/langchain.js";
+import { ChatOpenAI } from "@langchain/openai";
+
+async function example() {
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    verbose: 1,
+    llmClient: new LangchainClient(
+      new ChatOpenAI({
+        model: "gpt-4o",
+      }),
+    ),
+  });
+  await stagehand.init();
+  const page = stagehand.context.pages()[0];
+  await page.goto("https://news.ycombinator.com");
+  const { story } = await stagehand.extract(
+    "extract the title of the top story on the page",
+    z.object({
+      story: z.string().describe("the top story on the page"),
+    }),
+  );
+  console.log("The top story is:", story);
+  await stagehand.act("click the first story");
+  await stagehand.close();
+}
+(async () => {
+  await example();
+})();
diff --git a/packages/core/examples/custom_client_openai.ts b/packages/core/examples/custom_client_openai.ts
new file mode 100644
index 000000000..ea1236efb
--- /dev/null
+++ b/packages/core/examples/custom_client_openai.ts
@@ -0,0 +1,50 @@
+/**
+ * This example shows how to use a custom OpenAI client with Stagehand.
+ *
+ * The OpenAI API provides a simple, type-safe, and composable way to build AI applications.
+ *
+ * You will need to reference the Custom OpenAI Client in /external_clients/customOpenAI.ts
+ */
+import { Stagehand } from "../lib/v3/index.js";
+import { z } from "zod";
+import { CustomOpenAIClient } from "./external_clients/customOpenAI.js";
+import OpenAI from "openai";
+
+async function example() {
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    verbose: 1,
+    llmClient: new CustomOpenAIClient({
+      modelName: "gpt-4o-mini",
+      client: new OpenAI({
+        apiKey: process.env.OPENAI_API_KEY,
+      }),
+    }),
+  });
+  await stagehand.init();
+
+  const page = stagehand.context.pages()[0];
+  await page.goto("https://news.ycombinator.com");
+  await stagehand.act("click on the 'new' link");
+
+  const headlines = await stagehand.extract(
+    "Extract the top 3 stories from the Hacker News homepage.",
+    z.object({
+      stories: z.array(
+        z.object({
+          title: z.string(),
+          url: z.string(),
+          points: z.number(),
+        }),
+      ),
+    }),
+  );
+
+  console.log(headlines);
+
+  await stagehand.close();
+}
+
+(async () => {
+  await example();
+})();
diff --git a/packages/core/examples/example.ts b/packages/core/examples/example.ts
new file mode 100644
index 000000000..fa4d3cbfc
--- /dev/null
+++ b/packages/core/examples/example.ts
@@ -0,0 +1,54 @@
+import { Stagehand } from "../lib/v3/index.js";
+
+async function example(stagehand: Stagehand) {
+  /**
+   * Add your code here!
+   */
+  const page = stagehand.context.pages()[0];
+  await page.goto(
+    "https://browserbase.github.io/stagehand-eval-sites/sites/iframe-hn/",
+  );
+
+  const { extraction } = await stagehand.extract(
+    "grab the the first title from inside the iframe",
+  );
+  console.log(extraction);
+
+  const page2 = await stagehand.context.newPage();
+  await page2.goto(
+    "https://browserbase.github.io/stagehand-eval-sites/sites/iframe-same-proc/",
+  );
+  await stagehand.extract(
+    "extract the placeholder text on the your name field",
+    { page: page2 },
+  );
+  await stagehand.act("fill the your name field with the text 'John Doe'", {
+    page: page2,
+  });
+  const action2 = await stagehand.observe(
+    "select blue as the favorite color on the dropdown",
+    { page: page2 },
+  );
+  for (const action of action2) {
+    await stagehand.act(action, { page: page2, timeout: 30_000 });
+  }
+}
+
+(async () => {
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    apiKey: process.env.BROWSERBASE_API_KEY,
+    projectId: process.env.BROWSERBASE_PROJECT_ID,
+    model: {
+      modelName: "openai/gpt-5",
+      apiKey: process.env.MODEL_API_KEY,
+    },
+    verbose: 2,
+  });
+  try {
+    await stagehand.init();
+    await example(stagehand);
+  } finally {
+    await stagehand.close();
+  }
+})();
diff --git a/packages/core/examples/external_clients/aisdk.ts b/packages/core/examples/external_clients/aisdk.ts
new file mode 100644
index 000000000..6b0584d84
--- /dev/null
+++ b/packages/core/examples/external_clients/aisdk.ts
@@ -0,0 +1 @@
+export { AISdkClient } from "../../lib/v3/external_clients/aisdk.js";
diff --git a/packages/core/examples/external_clients/customOpenAI.ts b/packages/core/examples/external_clients/customOpenAI.ts
new file mode 100644
index 000000000..15dcdcbf0
--- /dev/null
+++ b/packages/core/examples/external_clients/customOpenAI.ts
@@ -0,0 +1 @@
+export { CustomOpenAIClient } from "../../lib/v3/external_clients/customOpenAI.js";
diff --git a/examples/external_clients/langchain.ts b/packages/core/examples/external_clients/langchain.ts
similarity index 88%
rename from examples/external_clients/langchain.ts
rename to packages/core/examples/external_clients/langchain.ts
index 1d071a63b..d2865b5d9 100644
--- a/examples/external_clients/langchain.ts
+++ b/packages/core/examples/external_clients/langchain.ts
@@ -1,6 +1,9 @@
 import { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import { CreateChatCompletionOptions, LLMClient, AvailableModel } from "@/dist";
-import { zodToJsonSchema } from "zod-to-json-schema";
+import {
+  CreateChatCompletionOptions,
+  LLMClient,
+  AvailableModel,
+} from "../../lib/v3/index.js";
 import {
   AIMessage,
   BaseMessageLike,
@@ -8,6 +11,7 @@ import {
   SystemMessage,
 } from "@langchain/core/messages";
 import { ChatCompletion } from "openai/resources";
+import { toJsonSchema } from "../../lib/v3/zodCompat.js";
 
 export class LangchainClient extends LLMClient {
   public type = "langchainClient" as const;
@@ -56,9 +60,8 @@ export class LangchainClient extends LLMClient {
     );
 
     if (options.response_model) {
-      const responseSchema = zodToJsonSchema(options.response_model.schema, {
-        $refStrategy: "none",
-      });
+      //ref string no longer needed, this is now default behavior
+      const responseSchema = toJsonSchema(options.response_model.schema);
       const structuredModel = this.model.withStructuredOutput(responseSchema);
       const response = await structuredModel.invoke(formattedMessages);
 
diff --git a/examples/form_filling_sensible.ts b/packages/core/examples/form_filling_sensible.ts
similarity index 73%
rename from examples/form_filling_sensible.ts
rename to packages/core/examples/form_filling_sensible.ts
index e2de10dd7..d053f9b7d 100644
--- a/examples/form_filling_sensible.ts
+++ b/packages/core/examples/form_filling_sensible.ts
@@ -1,32 +1,29 @@
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/stagehand.config";
+/**
+ * This example shows you how to use observe() to get a cacheable Playwright action as JSON, then pass that JSON to act() to perform the action.
+ *
+ * In this specific example, we use observe() to get multiple actions, then iterate through each action to fill the form with sensitive data at lightning speed.
+ */
+import { Stagehand } from "../lib/v3/index.js";
 import chalk from "chalk";
 
 async function formFillingSensible() {
   const stagehand = new Stagehand({
-    ...StagehandConfig,
-    // Uncomment the following lines to run locally or use a different model
-    env: "LOCAL",
-    modelName: "gpt-4o-mini",
+    env: "BROWSERBASE",
+    verbose: 1,
   });
   await stagehand.init();
-
-  // Block manifest worker to prevent PWA installation popup.
-  // This is necessary because the website prompts the user to install the PWA and prevents form filling.
-  await stagehand.page.route("**/manifest.json", (route) => route.abort());
+  const page = stagehand.context.pages()[0];
 
   // Go to the website and wait for it to load
-  await stagehand.page.goto("https://file.1040.com/estimate/", {
+  await page.goto("https://file.1040.com/estimate/", {
     waitUntil: "networkidle",
-    timeout: 30000,
+    timeoutMs: 30000,
   });
 
   // Observe the form fields with suggested actions
-  const observed = await stagehand.page.observe({
-    instruction:
-      "fill all the form fields in the page with mock data. In the description inlcude the field name",
-    returnAction: true,
-  });
+  const observed = await stagehand.observe(
+    "fill all the form fields in the page with mock data. In the description include the field name",
+  );
 
   // Uncomment the following snippet to see the stagehand candidate suggestions (initial)
   console.log(
@@ -82,7 +79,7 @@ async function formFillingSensible() {
 
   // Fill all the form fields with the sensible candidates
   for (const candidate of updatedFields) {
-    await stagehand.page.act(candidate);
+    await stagehand.act(candidate);
   }
 }
 
diff --git a/packages/core/examples/google_enter.ts b/packages/core/examples/google_enter.ts
new file mode 100644
index 000000000..ae2781c7f
--- /dev/null
+++ b/packages/core/examples/google_enter.ts
@@ -0,0 +1,24 @@
+/**
+ * This example shows how to use the Stagehand agent to navigate to Google and search for "Browserbase".
+ *
+ * It's mainly meant to sanity check using page.act() to press enter, since some LLMs have issues with it.
+ */
+
+import { Stagehand } from "../lib/v3/index.js";
+
+async function example() {
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    verbose: 1,
+  });
+  await stagehand.init();
+  const page = stagehand.context.pages()[0];
+  await page.goto("https://google.com");
+  await stagehand.act("type in 'Browserbase'");
+  await stagehand.act("press enter");
+  await stagehand.close();
+}
+
+(async () => {
+  await example();
+})();
diff --git a/examples/instructions.ts b/packages/core/examples/instructions.ts
similarity index 55%
rename from examples/instructions.ts
rename to packages/core/examples/instructions.ts
index 250199ba1..4cd1d88e9 100644
--- a/examples/instructions.ts
+++ b/packages/core/examples/instructions.ts
@@ -1,28 +1,23 @@
 /**
- * This example shows how to use custom instructions with Stagehand.
+ * This example shows how to use custom system prompts with Stagehand.
  */
-import { Stagehand } from "@/dist";
-import StagehandConfig from "@/stagehand.config";
+import { Stagehand } from "../lib/v3/index.js";
 
 async function example() {
   const stagehand = new Stagehand({
-    ...StagehandConfig,
+    env: "BROWSERBASE",
+    verbose: 1,
     systemPrompt:
       "if the users says `secret12345`, click on the 'getting started' tab. additionally, if the user says to type something, translate their input into french and type it.",
   });
   await stagehand.init();
 
-  const page = stagehand.page;
-
+  const page = stagehand.context.pages()[0];
   await page.goto("https://docs.browserbase.com/");
 
-  await page.act({
-    action: "secret12345",
-  });
+  await stagehand.act("secret12345");
 
-  await page.act({
-    action: "search for 'how to use browserbase'",
-  });
+  await stagehand.act("search for 'how to use browserbase'");
 
   await stagehand.close();
 }
diff --git a/packages/core/examples/integrations/exa.ts b/packages/core/examples/integrations/exa.ts
new file mode 100644
index 000000000..82d4863c6
--- /dev/null
+++ b/packages/core/examples/integrations/exa.ts
@@ -0,0 +1,42 @@
+import { Stagehand } from "../../lib/v3/index.js";
+
+async function example(stagehand: Stagehand) {
+  const page = stagehand.context.pages()[0];
+  await page.goto("https://www.google.com");
+
+  const agent = stagehand.agent({
+    integrations: [
+      `https://mcp.exa.ai/mcp?exaApiKey=${process.env.EXA_API_KEY}`,
+    ],
+    // Optional: Add custom instructions
+    systemPrompt: `You are a helpful assistant that can use a browser as well as external tools such as web search.
+    You have access to the Exa search tool to find information on the web.
+    When looking for products to buy, make sure to search for current and reliable information.
+    Be thorough in your research before making purchase decisions.`,
+  });
+
+  const result = await agent.execute(
+    "Use one of the tools from Exa to search for the top headphones of 2025. After doing so, use the browser and go through the checkout flow for the best one.",
+  );
+
+  console.log(result);
+}
+
+(async () => {
+  const stagehand = new Stagehand({
+    env: "LOCAL",
+    model: "openai/gpt-4.1",
+    verbose: 1,
+    logInferenceToFile: true,
+    experimental: true,
+  });
+
+  try {
+    await stagehand.init();
+    await example(stagehand);
+  } catch (error) {
+    console.error("Error running example:", error);
+  } finally {
+    await stagehand.close();
+  }
+})();
diff --git a/packages/core/examples/integrations/supabase.ts b/packages/core/examples/integrations/supabase.ts
new file mode 100644
index 000000000..fdc22d002
--- /dev/null
+++ b/packages/core/examples/integrations/supabase.ts
@@ -0,0 +1,37 @@
+import { connectToMCPServer, Stagehand } from "../../lib/v3/index.js";
+
+async function example(stagehand: Stagehand) {
+  const page = stagehand.context.pages()[0];
+  await page.goto("https://www.opentable.com/");
+
+  const supabaseClient = await connectToMCPServer(
+    `https://server.smithery.ai/@supabase-community/supabase-mcp/mcp?api_key=${process.env.SMITHERY_API_KEY}`,
+  );
+
+  const agent = stagehand.agent({
+    model: "openai/computer-use-preview",
+    integrations: [supabaseClient],
+  });
+
+  const result = await agent.execute(
+    "Search for restaurants in New Brunswick, NJ. Then, use the Supabase tools to insert the name of the first result of the search into a table called 'restaurants'.",
+  );
+
+  console.log(result);
+}
+
+(async () => {
+  const stagehand = new Stagehand({
+    env: "LOCAL",
+    verbose: 1,
+  });
+
+  try {
+    await stagehand.init();
+    await example(stagehand);
+  } catch (error) {
+    console.error("Error running example:", error);
+  } finally {
+    await stagehand.close();
+  }
+})();
diff --git a/packages/core/examples/mcp.ts b/packages/core/examples/mcp.ts
new file mode 100644
index 000000000..b698bbdb4
--- /dev/null
+++ b/packages/core/examples/mcp.ts
@@ -0,0 +1,75 @@
+// import { Stagehand } from "../lib/v3";
+// import StagehandConfig from "@/stagehand.config";
+// import chalk from "chalk";
+// import { connectToMCPServer } from "../lib/mcp/connection";
+
+// async function main() {
+//   console.log(`\n${chalk.bold("Stagehand 🤘 MCP Demo")}\n`);
+//   console.log(process.env.NOTION_TOKEN);
+
+//   // Initialize Stagehand
+//   const stagehand = new Stagehand({
+//     ...StagehandConfig,
+//     env: "LOCAL",
+//     experimental: true,
+//   });
+//   await stagehand.init();
+
+//   const notionClient = await connectToMCPServer({
+//     command: "npx",
+//     args: ["-y", "@notionhq/notion-mcp-server"],
+//     env: {
+//       NOTION_TOKEN: process.env.NOTION_TOKEN,
+//     },
+//   });
+
+//   try {
+//     const page = stagehand.page;
+
+//     // Create a computer use agent
+//     const agent = stagehand.agent({
+//       provider: "anthropic",
+//       // For Anthropic, use claude-sonnet-4-6 or claude-sonnet-4-5-20250929
+//       model: "claude-sonnet-4-6",
+//       instructions: `You are a helpful assistant that can use a web browser.
+//       You are currently on the following page: ${page.url()}.
+//       Do not ask follow up questions, the user will trust your judgement.
+//       You have access to the Notion MCP.`,
+//       options: {
+//         apiKey: process.env.ANTHROPIC_API_KEY,
+//       },
+//       integrations: [notionClient],
+//     });
+
+//     // Navigate to the Browserbase careers page
+//     await page.goto("https://www.google.com");
+
+//     // Define the instruction for the CUA
+//     const instruction =
+//       "Check the Agent Tasks page in notion, read your tasks, perform them and update the notion page with the results.";
+//     console.log(`Instruction: ${chalk.white(instruction)}`);
+
+//     // Execute the instruction
+//     const result = await agent.execute({
+//       instruction,
+//       maxSteps: 50,
+//     });
+
+//     console.log(`${chalk.green("✓")} Execution complete`);
+//     console.log(`${chalk.yellow("⤷")} Result:`);
+//     console.log(chalk.white(JSON.stringify(result, null, 2)));
+//   } catch (error) {
+//     console.log(`${chalk.red("✗")} Error: ${error}`);
+//     if (error instanceof Error && error.stack) {
+//       console.log(chalk.dim(error.stack.split("\n").slice(1).join("\n")));
+//     }
+//   } finally {
+//     // Close the browser
+//     await stagehand.close();
+//   }
+// }
+
+// main().catch((error) => {
+//   console.log(`${chalk.red("✗")} Unhandled error in main function`);
+//   console.log(chalk.red(error));
+// });
diff --git a/examples/operator-example.ts b/packages/core/examples/operator-example.ts
similarity index 50%
rename from examples/operator-example.ts
rename to packages/core/examples/operator-example.ts
index 5978e8d72..97fdd601e 100644
--- a/examples/operator-example.ts
+++ b/packages/core/examples/operator-example.ts
@@ -1,35 +1,36 @@
-import { LogLine, Stagehand } from "@/dist";
-import dotenv from "dotenv";
-import StagehandConfig from "@/stagehand.config";
+/**
+ * This example shows how to use the Stagehand operator to do simple autonomous tasks.
+ *
+ * This is built off of our open source project, Open Operator: https://operator.browserbase.com
+ *
+ * To learn more about Stagehand Agents, see: https://docs.stagehand.dev/concepts/agent
+ */
+import { Stagehand } from "../lib/v3/index.js";
 import chalk from "chalk";
 
 // Load environment variables
-dotenv.config();
-
-const INSTRUCTION =
-  "Go to Google Japan and interact with it in Japanese. Tell me (in English) an authentic recipe that I can make with ingredients found in American grocery stores.";
 
 async function main() {
   console.log(`\n${chalk.bold("Stagehand 🤘 Operator Example")}\n`);
-
   // Initialize Stagehand
   const stagehand = new Stagehand({
-    ...StagehandConfig,
-    logger: ({ level, message, timestamp }: LogLine) => {
-      console.log({ level, message, timestamp });
-    },
+    env: "LOCAL",
+    verbose: 2,
+    cacheDir: "stagehand-agent-cache",
+    logInferenceToFile: false,
   });
 
   await stagehand.init();
 
   try {
+    const page = stagehand.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/shadow-dom/",
+    );
     const agent = stagehand.agent();
 
-    // Execute the agent
-    console.log(`${chalk.cyan("↳")} Instruction: ${INSTRUCTION}`);
-
     const result = await agent.execute({
-      instruction: INSTRUCTION,
+      instruction: "click the button",
       maxSteps: 20,
     });
 
@@ -40,8 +41,7 @@ async function main() {
   } catch (error) {
     console.log(`${chalk.red("✗")} Error: ${error}`);
   } finally {
-    await stagehand.close();
+    // await stagehand.close();
   }
 }
-
 main();
diff --git a/packages/core/examples/oss-cua-example.ts b/packages/core/examples/oss-cua-example.ts
new file mode 100644
index 000000000..4b643d574
--- /dev/null
+++ b/packages/core/examples/oss-cua-example.ts
@@ -0,0 +1,83 @@
+/**
+ * This example shows how to use a computer use agent (CUA) to navigate a web page and extract data.
+ *
+ * To learn more about the CUA, see: https://docs.stagehand.dev/examples/computer_use
+ *
+ * NOTE: YOU MUST CONFIGURE BROWSER DIMENSIONS TO USE COMPUTER USE!
+ * Check out stagehand.config.ts for more information.
+ */
+import { Stagehand } from "../lib/v3/index.js";
+import chalk from "chalk";
+
+async function main() {
+  console.log(
+    `\n${chalk.bold("Stagehand 🤘 Computer Use Agent (CUA) Demo")}\n`,
+  );
+
+  // Initialize Stagehand
+  const stagehand = new Stagehand({
+    env: "LOCAL",
+    verbose: 2,
+    localBrowserLaunchOptions: {
+      viewport: {
+        width: 1288,
+        height: 711,
+      },
+      deviceScaleFactor: 1,
+    },
+  });
+  await stagehand.init();
+
+  try {
+    const page = stagehand.context.pages()[0];
+
+    // Create a computer use agent
+    const agent = stagehand.agent({
+      mode: "cua",
+      model: {
+        modelName: "microsoft/fara-7b",
+        apiKey: process.env.AZURE_API_KEY,
+        baseURL: process.env.AZURE_ENDPOINT,
+        /** Alternative model configuration for Fireworks Deployments */
+        // modelName: "accounts/...",
+        // apiKey: process.env.FIREWORKS_API_KEY,
+        // baseURL: "https://api.fireworks.ai/inference/v1",
+        // provider: "microsoft", // Important: this routes to the MicrosoftCUAClient
+      },
+      systemPrompt: `You are a helpful assistant that can use a web browser.
+      You are currently on the following page: ${page.url()}.
+      Do not ask follow up questions, the user will trust your judgement. Today's date is ${new Date().toLocaleDateString()}. Remember apply buttons are there for a reason.`,
+    });
+
+    // Navigate to the Browserbase careers page
+    await page.goto("https://www.browserbase.com/careers");
+
+    // Define the instruction for the CUA
+    const instruction = `Apply for the first engineer position with mock data on the ${page.url()} page. Don't submit the form.`;
+    console.log(`Instruction: ${chalk.white(instruction)}`);
+
+    // Execute the instruction
+    const result = await agent.execute({
+      instruction,
+      maxSteps: 20,
+    });
+    await new Promise((resolve) => setTimeout(resolve, 30000));
+
+    console.log(`${chalk.green("✓")} Execution complete`);
+    console.log(`${chalk.yellow("⤷")} Result:`);
+    console.log(chalk.white(JSON.stringify(result, null, 2)));
+  } catch (error) {
+    console.log(`${chalk.red("✗")} Error: ${error}`);
+    if (error instanceof Error && error.stack) {
+      console.log(chalk.dim(error.stack.split("\n").slice(1).join("\n")));
+    }
+  } finally {
+    // Close the browser
+    await stagehand.close();
+  }
+}
+
+main().catch((error) => {
+  console.log(`${chalk.red("✗")} Unhandled error in main function`);
+  console.log(chalk.red(error));
+});
diff --git a/examples/parameterizeApiKey.ts b/packages/core/examples/parameterizeApiKey.ts
similarity index 64%
rename from examples/parameterizeApiKey.ts
rename to packages/core/examples/parameterizeApiKey.ts
index 7af1c3eb1..58c6d27d3 100644
--- a/examples/parameterizeApiKey.ts
+++ b/packages/core/examples/parameterizeApiKey.ts
@@ -1,4 +1,4 @@
-import { Stagehand } from "@/dist";
+import { Stagehand } from "../lib/v3/index.js";
 import { z } from "zod";
 
 /**
@@ -15,23 +15,23 @@ async function example() {
   const stagehand = new Stagehand({
     env: "LOCAL",
     verbose: 1,
-    enableCaching: false,
-    modelName: "gpt-4o",
-    modelClientOptions: {
+    model: {
+      modelName: "gpt-4o",
       apiKey: process.env.USE_OPENAI_API_KEY,
     },
   });
 
   await stagehand.init();
-  await stagehand.page.goto("https://github.com/browserbase/stagehand");
-  await stagehand.page.act({ action: "click on the contributors" });
-  const contributor = await stagehand.page.extract({
-    instruction: "extract the top contributor",
-    schema: z.object({
+  const page = stagehand.context.pages()[0];
+  await page.goto("https://github.com/browserbase/stagehand");
+  await stagehand.act("click on the contributors");
+  const contributor = await stagehand.extract(
+    "extract the top contributor",
+    z.object({
       username: z.string(),
       url: z.string(),
     }),
-  });
+  );
   console.log(`Our favorite contributor is ${contributor.username}`);
 }
 
diff --git a/packages/core/examples/persist_logs_example.ts b/packages/core/examples/persist_logs_example.ts
new file mode 100644
index 000000000..bf9017302
--- /dev/null
+++ b/packages/core/examples/persist_logs_example.ts
@@ -0,0 +1,37 @@
+/**
+ * Example: Run a Stagehand agent and persist structured logging events to a user-specified dir.
+ */
+import path from "node:path";
+import { Stagehand } from "../lib/v3/index.js";
+
+async function main() {
+  const logsRoot = path.resolve(process.cwd(), "examples", "logs");
+  process.env.BROWSERBASE_CONFIG_DIR = logsRoot;
+
+  const stagehand = new Stagehand({
+    env: "LOCAL",
+    verbose: 1,
+  });
+
+  await stagehand.init();
+
+  try {
+    const page = stagehand.context.pages()[0];
+    await page.goto("https://www.google.com");
+
+    const agent = stagehand.agent();
+    await agent.execute({
+      instruction:
+        "Search for Browserbase and stop after the results are visible.",
+      maxSteps: 10,
+    });
+  } finally {
+    // All logs can be found at logs/sessions/$SESSION_ID/session.json, or agent_events.log etc
+    await stagehand.close();
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});
diff --git a/packages/core/examples/tsconfig.json b/packages/core/examples/tsconfig.json
new file mode 100644
index 000000000..cdde24e8f
--- /dev/null
+++ b/packages/core/examples/tsconfig.json
@@ -0,0 +1,5 @@
+{
+  "extends": "../tsconfig.json",
+  "include": ["*.ts"],
+  "exclude": ["node_modules"]
+}
diff --git a/packages/core/examples/v3/cuaReplay.ts b/packages/core/examples/v3/cuaReplay.ts
new file mode 100644
index 000000000..680b23045
--- /dev/null
+++ b/packages/core/examples/v3/cuaReplay.ts
@@ -0,0 +1,98 @@
+import { Stagehand } from "../../lib/v3/index.js";
+import { v3Logger } from "../../lib/v3/logger.js";
+
+async function runDemo(runNumber: number) {
+  const startTime = Date.now();
+
+  v3Logger({
+    level: 1,
+    category: "demo",
+    message: `RUN ${runNumber}: ${runNumber === 1 ? "BUILDING CACHE" : "USING CACHE"}`,
+  });
+
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    disableAPI: false,
+    verbose: 1,
+    cacheDir: "cua-agent-cache",
+  });
+
+  await stagehand.init();
+
+  const page = stagehand.context.pages()[0];
+
+  await page.goto("https://v0-modern-login-flow.vercel.app/", {
+    waitUntil: "networkidle",
+  });
+
+  const agent = stagehand.agent({
+    mode: "cua",
+    model: {
+      modelName: "anthropic/claude-sonnet-4-20250514",
+      apiKey: process.env.ANTHROPIC_API_KEY!,
+    },
+  });
+
+  const result = await agent.execute({
+    instruction: `Sign in with the email address 'test@browserbaser.com' and the password 'stagehand=goated'`,
+    maxSteps: 20,
+  });
+
+  const endTime = Date.now();
+  const duration = (endTime - startTime) / 1000;
+
+  await stagehand.close();
+
+  return {
+    duration,
+    success: result.success,
+    result,
+  };
+}
+
+async function main() {
+  const metrics1 = await runDemo(1);
+
+  v3Logger({
+    level: 1,
+    category: "demo",
+    message: "⏳ Waiting 2 seconds before cached run...",
+  });
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  v3Logger({
+    level: 1,
+    category: "demo",
+    message: "Starting second run with cache...",
+  });
+  const metrics2 = await runDemo(2);
+
+  const duration1 = `${metrics1.duration.toFixed(2)}s`;
+  const duration2 = `${metrics2.duration.toFixed(2)}s`;
+
+  v3Logger({
+    level: 1,
+    category: "demo",
+    message: `
+╔════════════════════════════════════════════════════════════╗
+║                  📊 PERFORMANCE COMPARISON                 ║
+╚════════════════════════════════════════════════════════════╝
+
+┌─────────────────────┬──────────────────┬──────────────────┐
+│     Metric          │   Run 1 (Cold)   │  Run 2 (Cached)  │
+├─────────────────────┼──────────────────┼──────────────────┤
+│ Duration            │ ${duration1.padEnd(16)} │ ${duration2.padEnd(16)} │
+└─────────────────────┴──────────────────┴──────────────────┘
+
+ Performance Comparison:
+   • Speed: ${((1 - metrics2.duration / metrics1.duration) * 100).toFixed(1)}% faster with cache
+   • Time saved: ${(metrics1.duration - metrics2.duration).toFixed(2)} seconds
+
+ Insights:
+   • First run establishes the CUA action cache
+   • Second run reuses cached actions for instant execution
+   • Zero LLM tokens used on cached run`,
+  });
+}
+
+main().catch(console.error);
diff --git a/packages/core/examples/v3/deepLocator.ts b/packages/core/examples/v3/deepLocator.ts
new file mode 100644
index 000000000..b07a357b5
--- /dev/null
+++ b/packages/core/examples/v3/deepLocator.ts
@@ -0,0 +1,30 @@
+import { Stagehand } from "../../lib/v3/index.js";
+
+async function example(stagehand: Stagehand) {
+  const page = stagehand.context.pages()[0];
+  await page.goto(
+    "https://browserbase.github.io/stagehand-eval-sites/sites/oopif-in-closed-shadow-dom/",
+  );
+
+  // crossing OOPIF & shadow root boundaries with deep locator
+  await page
+    .deepLocator(
+      "/html/body/shadow-host//section/iframe/html/body/main/section[1]/form/div/div[1]/input",
+    )
+    .fill("nunya");
+  await page
+    .deepLocator(
+      "/html/body/shadow-host//section/iframe/html/body/main/section[1]/form/div/div[2]/input",
+    )
+    .fill("business");
+}
+
+(async () => {
+  const stagehand = new Stagehand({
+    env: "LOCAL",
+    verbose: 0,
+    model: "openai/gpt-4.1",
+  });
+  await stagehand.init();
+  await example(stagehand);
+})();
diff --git a/packages/core/examples/v3/dropdown.ts b/packages/core/examples/v3/dropdown.ts
new file mode 100644
index 000000000..ee8df297a
--- /dev/null
+++ b/packages/core/examples/v3/dropdown.ts
@@ -0,0 +1,32 @@
+import { Stagehand } from "../../lib/v3/index.js";
+
+async function example(stagehand: Stagehand) {
+  const page = stagehand.context.pages()[0];
+  await page.goto(
+    "https://browserbase.github.io/stagehand-eval-sites/sites/scroll-dropdown/",
+  );
+
+  const actResult = await stagehand.act(
+    "choose 'Peach' from the favorite colour dropdown",
+  );
+
+  const numSteps = actResult.actions.length;
+
+  console.log(
+    `\n\nThis act() call took ${numSteps} steps. Here are the actions:`,
+  );
+
+  for (const action of actResult.actions) {
+    console.log(`\naction: `, action);
+  }
+}
+
+(async () => {
+  const stagehand = new Stagehand({
+    env: "LOCAL",
+    verbose: 0,
+    model: "google/gemini-2.5-flash",
+  });
+  await stagehand.init();
+  await example(stagehand);
+})();
diff --git a/packages/core/examples/v3/highlight.ts b/packages/core/examples/v3/highlight.ts
new file mode 100644
index 000000000..44449a8dc
--- /dev/null
+++ b/packages/core/examples/v3/highlight.ts
@@ -0,0 +1,27 @@
+import { Stagehand } from "../../lib/v3/index.js";
+
+async function example(stagehand: Stagehand) {
+  const page = stagehand.context.pages()[0];
+  await page.goto(
+    "https://browserbase.github.io/stagehand-eval-sites/sites/closed-shadow-root-in-oopif/",
+  );
+
+  await page
+    .deepLocator(
+      "xpath=/html/body/main/section/iframe/html/body/shadow-demo//div/button",
+    )
+    .highlight({
+      durationMs: 20000,
+      contentColor: { r: 255, g: 0, b: 0 },
+    });
+}
+
+(async () => {
+  const stagehand = new Stagehand({
+    env: "LOCAL",
+    verbose: 0,
+    model: "google/gemini-2.5-flash",
+  });
+  await stagehand.init();
+  await example(stagehand);
+})();
diff --git a/packages/core/examples/v3/patchright.ts b/packages/core/examples/v3/patchright.ts
new file mode 100644
index 000000000..81f6a0975
--- /dev/null
+++ b/packages/core/examples/v3/patchright.ts
@@ -0,0 +1,32 @@
+import { Stagehand } from "../../lib/v3/index.js";
+import { chromium } from "patchright-core";
+import { z } from "zod";
+
+async function example(stagehand: Stagehand) {
+  const browser = await chromium.connectOverCDP({
+    wsEndpoint: stagehand.connectURL(),
+  });
+
+  const prContext = browser.contexts()[0];
+  const prPage = prContext.pages()[0];
+  await prPage.goto("https://github.com/microsoft/playwright/issues/30261");
+
+  await stagehand.act("scroll to the bottom of the page", { page: prPage });
+
+  const reason = await stagehand.extract(
+    "extract the reason why playwright doesn't expose frame IDs",
+    z.string(),
+    // page arg not required
+  );
+  console.log(reason);
+}
+
+(async () => {
+  const stagehand = new Stagehand({
+    env: "LOCAL",
+    verbose: 0,
+    model: "openai/gpt-4.1",
+  });
+  await stagehand.init();
+  await example(stagehand);
+})();
diff --git a/packages/core/examples/v3/playwright.ts b/packages/core/examples/v3/playwright.ts
new file mode 100644
index 000000000..df3c16efe
--- /dev/null
+++ b/packages/core/examples/v3/playwright.ts
@@ -0,0 +1,41 @@
+import { Stagehand } from "../../lib/v3/index.js";
+import { chromium } from "playwright-core";
+import { z } from "zod";
+
+async function example(stagehand: Stagehand) {
+  const browser = await chromium.connectOverCDP({
+    wsEndpoint: stagehand.connectURL(),
+  });
+  const pwContext = browser.contexts()[0];
+  const pwPage1 = pwContext.pages()[0];
+  await pwPage1.goto("https://docs.stagehand.dev/first-steps/introduction");
+
+  const pwPage2 = await pwContext.newPage();
+  await pwPage2.goto("https://docs.stagehand.dev/configuration/observability");
+
+  const [page1Extraction, page2Extraction] = await Promise.all([
+    stagehand.extract(
+      "extract the names of the four stagehand primitives",
+      z.array(z.string()),
+      { page: pwPage1 },
+    ),
+    stagehand.extract(
+      "extract the list of session dashboard features",
+      z.array(z.string()),
+      { page: pwPage2 },
+    ),
+  ]);
+
+  console.log(page1Extraction);
+  console.log(page2Extraction);
+}
+
+(async () => {
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    verbose: 1,
+    model: "openai/gpt-4.1",
+  });
+  await stagehand.init();
+  await example(stagehand);
+})();
diff --git a/packages/core/examples/v3/puppeteer.ts b/packages/core/examples/v3/puppeteer.ts
new file mode 100644
index 000000000..48bf99ec2
--- /dev/null
+++ b/packages/core/examples/v3/puppeteer.ts
@@ -0,0 +1,29 @@
+import { Stagehand } from "../../lib/v3/index.js";
+import puppeteer from "puppeteer-core";
+
+async function example(stagehand: Stagehand) {
+  const browser = await puppeteer.connect({
+    browserWSEndpoint: stagehand.connectURL(),
+    defaultViewport: null,
+  });
+  const ppPages = await browser.pages();
+  const ppPage = ppPages[0];
+
+  await ppPage.goto("https://www.browserbase.com/blog");
+
+  const actions = await stagehand.observe("find the next page button", {
+    page: ppPage,
+  });
+
+  await stagehand.act(actions[0]);
+}
+
+(async () => {
+  const stagehand = new Stagehand({
+    env: "LOCAL",
+    verbose: 0,
+    model: "openai/gpt-4.1",
+  });
+  await stagehand.init();
+  await example(stagehand);
+})();
diff --git a/packages/core/examples/v3/recordVideo.ts b/packages/core/examples/v3/recordVideo.ts
new file mode 100644
index 000000000..b75287e3b
--- /dev/null
+++ b/packages/core/examples/v3/recordVideo.ts
@@ -0,0 +1,65 @@
+import path from "node:path";
+import { mkdir } from "node:fs/promises";
+import { Stagehand } from "../../lib/v3/index.js";
+import { chromium } from "playwright-core";
+import { z } from "zod";
+
+async function recordPlaywrightVideo(stagehand: Stagehand): Promise<void> {
+  const browser = await chromium.connectOverCDP({
+    wsEndpoint: stagehand.connectURL(),
+  });
+
+  const videoDir = path.resolve(process.cwd(), "artifacts", "stagehand-videos");
+  await mkdir(videoDir, { recursive: true });
+
+  const context = await browser.newContext({
+    recordVideo: {
+      dir: videoDir,
+      size: { width: 1280, height: 720 },
+    },
+  });
+
+  const page = await context.newPage();
+  await page.goto("https://docs.stagehand.dev/first-steps/quickstart", {
+    waitUntil: "domcontentloaded",
+  });
+
+  await stagehand.act("click the introduction div in the first steps section");
+
+  const { primitives } = await stagehand.extract(
+    "list the four Stagehand primitives that are described on the page",
+    z.object({
+      primitives: z.array(z.string()),
+    }),
+    { page },
+  );
+
+  console.log("Stagehand primitives:", primitives.join(", "));
+
+  // Capture the handle before closing the context so we can read the video path afterwards.
+  const video = page.video();
+
+  await context.close();
+
+  if (video) {
+    const videoPath = await video.path();
+    console.log(`Playwright saved the video to ${videoPath}`);
+  } else {
+    console.log("Video recording was not enabled for this context.");
+  }
+}
+
+(async () => {
+  const stagehand = new Stagehand({
+    env: "LOCAL",
+    verbose: 1,
+    model: "google/gemini-2.5-flash",
+  });
+
+  try {
+    await stagehand.init();
+    await recordPlaywrightVideo(stagehand);
+  } finally {
+    await stagehand.close().catch(() => {});
+  }
+})();
diff --git a/packages/core/examples/v3/returnXpath.ts b/packages/core/examples/v3/returnXpath.ts
new file mode 100644
index 000000000..773197d23
--- /dev/null
+++ b/packages/core/examples/v3/returnXpath.ts
@@ -0,0 +1,23 @@
+import { Stagehand } from "../../lib/v3/index.js";
+
+async function example(stagehand: Stagehand) {
+  const page = stagehand.context.pages()[0];
+  await page.goto(
+    "https://browserbase.github.io/stagehand-eval-sites/sites/oopif-in-closed-shadow-dom/",
+  );
+
+  const xpath = await page.click(286, 628, { returnXpath: true });
+
+  // use the xpath that was returned from out coord click
+  await page.deepLocator(xpath).fill("hellooooooooo");
+}
+
+(async () => {
+  const stagehand = new Stagehand({
+    env: "LOCAL",
+    verbose: 0,
+    model: "openai/gpt-4.1",
+  });
+  await stagehand.init();
+  await example(stagehand);
+})();
diff --git a/packages/core/examples/v3/shadowRoot.ts b/packages/core/examples/v3/shadowRoot.ts
new file mode 100644
index 000000000..e892f5f6d
--- /dev/null
+++ b/packages/core/examples/v3/shadowRoot.ts
@@ -0,0 +1,29 @@
+import { Stagehand } from "../../lib/v3/index.js";
+
+async function example(stagehand: Stagehand) {
+  const page = stagehand.context.pages()[0];
+  await page.goto(
+    "https://browserbase.github.io/stagehand-eval-sites/sites/shadow-dom-closed/",
+  );
+
+  // clicking in closed mode shadow root with an xpath
+  await page.locator("/html/body/shadow-demo//div/button").click();
+
+  await new Promise((resolve) => setTimeout(resolve, 3000));
+
+  await page.reload();
+  await new Promise((resolve) => setTimeout(resolve, 3000));
+
+  // clicking in closed mode shadow root with css selector
+  await page.locator("div > button").click();
+}
+
+(async () => {
+  const stagehand = new Stagehand({
+    env: "LOCAL",
+    verbose: 0,
+    model: "openai/gpt-4.1",
+  });
+  await stagehand.init();
+  await example(stagehand);
+})();
diff --git a/packages/core/examples/v3/targetedExtract.ts b/packages/core/examples/v3/targetedExtract.ts
new file mode 100644
index 000000000..33ec09eb8
--- /dev/null
+++ b/packages/core/examples/v3/targetedExtract.ts
@@ -0,0 +1,35 @@
+import { Stagehand } from "../../lib/v3/index.js";
+import { z } from "zod";
+
+async function example(stagehand: Stagehand) {
+  const page = stagehand.context.pages()[0];
+  await page.goto(
+    "https://ambarc.github.io/web-element-test/stagehand-breaking-test.html",
+  );
+
+  await page
+    .deepLocator("/html/body/div[2]/div[3]/iframe/html/body/p")
+    .highlight({
+      durationMs: 5000,
+      contentColor: { r: 255, g: 0, b: 0 },
+    });
+
+  const reason = await stagehand.extract(
+    "extract the reason why script injection fails",
+    z.string(),
+    // selector: "// body > div.test-container > div:nth-child(3) > iframe >> body > p:nth-child(3)",
+    { selector: "/html/body/div[2]/div[3]/iframe/html/body/p[2]" },
+  );
+  console.log(reason);
+}
+
+(async () => {
+  const stagehand = new Stagehand({
+    env: "LOCAL",
+    verbose: 0,
+    model: "openai/gpt-4.1",
+    logInferenceToFile: true,
+  });
+  await stagehand.init();
+  await example(stagehand);
+})();
diff --git a/packages/core/examples/v3/v3_agent.ts b/packages/core/examples/v3/v3_agent.ts
new file mode 100644
index 000000000..4e8dbea9d
--- /dev/null
+++ b/packages/core/examples/v3/v3_agent.ts
@@ -0,0 +1,50 @@
+import chalk from "chalk";
+import { V3 } from "../../lib/v3/index.js";
+
+const INSTRUCTION = "scroll down and click on the last hn story";
+
+async function main() {
+  console.log(`\n${chalk.bold("Stagehand V3 🤘 Operator Example")}\n`);
+
+  // Initialize Stagehand
+  const v3 = new V3({
+    env: "LOCAL",
+    verbose: 2,
+  });
+
+  await v3.init();
+
+  try {
+    const startPage = v3.context.pages()[0];
+    await startPage.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/iframe-hn/",
+    );
+    const agent = v3.agent({
+      cua: false,
+      model: "google/gemini-2.0-flash",
+      executionModel: "google/gemini-2.0-flash",
+    });
+    // {
+    //   model: "computer-use-preview-2025-03-11",
+    //   provider: "openai",
+    // }
+
+    // Execute the agent
+    console.log(`${chalk.cyan("↳")} Instruction: ${INSTRUCTION}`);
+    const result = await agent.execute({
+      instruction: INSTRUCTION,
+      maxSteps: 20,
+    });
+
+    console.log(`${chalk.green("✓")} Execution complete`);
+    console.log(`${chalk.yellow("⤷")} Result:`);
+    console.log(JSON.stringify(result, null, 2));
+    console.log(chalk.white(result.message));
+  } catch (error) {
+    console.log(`${chalk.red("✗")} Error: ${error}`);
+  } finally {
+    // await v3.close();
+  }
+}
+
+main();
diff --git a/packages/core/examples/v3_example.ts b/packages/core/examples/v3_example.ts
new file mode 100644
index 000000000..37692025b
--- /dev/null
+++ b/packages/core/examples/v3_example.ts
@@ -0,0 +1,36 @@
+import { V3 } from "../lib/v3/index.js";
+import { z } from "zod";
+
+async function example(v3: V3) {
+  const page = v3.context.pages()[0];
+  await page.goto("https://www.apartments.com/san-francisco-ca/2-bedrooms/", {
+    waitUntil: "load",
+  });
+  const apartment_listings = await v3.extract(
+    "Extract all the apartment listings with their prices and their addresses.",
+    z.object({
+      listings: z.array(
+        z.object({
+          price: z.string().describe("The price of the listing"),
+          address: z.string().describe("The address of the listing"),
+        }),
+      ),
+    }),
+  );
+
+  const listings = apartment_listings.listings;
+  console.log(listings);
+  console.log(`found ${listings.length} listings`);
+}
+
+(async () => {
+  const v3 = new V3({
+    env: "LOCAL",
+    verbose: 2,
+    logInferenceToFile: false,
+    model: "google/gemini-2.0-flash",
+    cacheDir: "stagehand-extract-cache",
+  });
+  await v3.init();
+  await example(v3);
+})();
diff --git a/packages/core/examples/wordle.ts b/packages/core/examples/wordle.ts
new file mode 100644
index 000000000..49b9b8fe4
--- /dev/null
+++ b/packages/core/examples/wordle.ts
@@ -0,0 +1,24 @@
+import { Stagehand } from "../lib/v3/index.js";
+
+async function example() {
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    verbose: 1,
+  });
+  await stagehand.init();
+  const page = stagehand.context.pages()[0];
+  await page.goto("https://www.nytimes.com/games/wordle/index.html");
+  await stagehand.act("click 'Continue'");
+  await stagehand.act("click 'Play'");
+  await stagehand.act("click cross sign on top right of 'How To Play' card");
+  const word = "WORDS";
+  for (const letter of word) {
+    await stagehand.act(`press ${letter}`);
+  }
+  await stagehand.act("press enter");
+  await stagehand.close();
+}
+
+(async () => {
+  await example();
+})();
diff --git a/packages/core/lib/CHANGELOG.md b/packages/core/lib/CHANGELOG.md
new file mode 100644
index 000000000..6b0ab62a9
--- /dev/null
+++ b/packages/core/lib/CHANGELOG.md
@@ -0,0 +1,63 @@
+# @browserbasehq/stagehand-lib
+
+## 2.4.1
+
+### Patch Changes
+
+- [#1027](https://github.com/browserbase/stagehand/pull/1027) [`455b61f`](https://github.com/browserbase/stagehand/commit/455b61fb6f7a34ae50d7e7c76c1d639241e213d6) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - Fixed small issue with module-level state guard for the Playwright selectors.register call
+
+## 2.4.0
+
+### Minor Changes
+
+- [#778](https://github.com/browserbase/stagehand/pull/778) [`df570b6`](https://github.com/browserbase/stagehand/commit/df570b67e46febcaf7282ffb65dd5707e2808152) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - iframe support
+
+### Patch Changes
+
+- [#809](https://github.com/browserbase/stagehand/pull/809) [`03ebebc`](https://github.com/browserbase/stagehand/commit/03ebebc0317f92d8de77285cc2e66dc0131fe9fe) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - log NoObjectGenerated error details
+
+- [#801](https://github.com/browserbase/stagehand/pull/801) [`1d4f0ab`](https://github.com/browserbase/stagehand/commit/1d4f0abca47bf47ae8b7aeb53f3cd1155a7e5448) Thanks [@miguelg719](https://github.com/miguelg719)! - Default use API to true
+
+- [#798](https://github.com/browserbase/stagehand/pull/798) [`d86200b`](https://github.com/browserbase/stagehand/commit/d86200bd5bde4c5ba113ca89e28ab86c14a8304e) Thanks [@miguelg719](https://github.com/miguelg719)! - Fix pino logging memory leak by reusing worker
+
+## 2.3.0
+
+### Minor Changes
+
+- [#731](https://github.com/browserbase/stagehand/pull/731) [`393c8e0`](https://github.com/browserbase/stagehand/commit/393c8e05d016086e481c0043ee6b084c61886cad) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - make extract() with no arguments return the hybrid tree instead of text-rendered webpage
+
+- [#737](https://github.com/browserbase/stagehand/pull/737) [`6ef6073`](https://github.com/browserbase/stagehand/commit/6ef60730cab0ad9025f44b6eeb2c83751d1dcd35) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - deprecate useTextExtract and remove functionality
+
+### Patch Changes
+
+- [#741](https://github.com/browserbase/stagehand/pull/741) [`5680d25`](https://github.com/browserbase/stagehand/commit/5680d2509352c383ad502c9f4fabde01fa638833) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - use safeparse for zod validation
+
+- [#740](https://github.com/browserbase/stagehand/pull/740) [`28840a7`](https://github.com/browserbase/stagehand/commit/28840a7d3fec89a490984582fb37fa3d007c0349) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - dont log deprecation warning when onlyVisible is undefined
+
+- [#755](https://github.com/browserbase/stagehand/pull/755) [`ba687ab`](https://github.com/browserbase/stagehand/commit/ba687abdfb598f839ddfec0442d3d7b6b696b0a3) Thanks [@miguelg719](https://github.com/miguelg719)! - Fix context init error on undefined context
+
+- [#789](https://github.com/browserbase/stagehand/pull/789) [`c5ff8ce`](https://github.com/browserbase/stagehand/commit/c5ff8ce2d7467b70a450ca52bc3e03b15280ce1b) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix noisy useTextExtract deprecation log
+
+- [#757](https://github.com/browserbase/stagehand/pull/757) [`628e534`](https://github.com/browserbase/stagehand/commit/628e534ea6d7ca081bad6c32167c7d53d4772eed) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - optimize CDP calls when building hybrid tree
+
+- [#772](https://github.com/browserbase/stagehand/pull/772) [`64d331d`](https://github.com/browserbase/stagehand/commit/64d331dc2eba86675a8b148d361897f55f170703) Thanks [@miguelg719](https://github.com/miguelg719)! - Fixes an issue with the new tab intercepts for invalid urls
+
+- [#770](https://github.com/browserbase/stagehand/pull/770) [`d312a43`](https://github.com/browserbase/stagehand/commit/d312a43672fe2865abcf184a712a759a12f5b9d1) Thanks [@miguelg719](https://github.com/miguelg719)! - Removed default chromium flags that delay browser launching
+
+- [#753](https://github.com/browserbase/stagehand/pull/753) [`fbca400`](https://github.com/browserbase/stagehand/commit/fbca4003a547dc5eee0c0be5edc5e98c1f4d8c22) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix `stagehand.history`
+
+- [#745](https://github.com/browserbase/stagehand/pull/745) [`c54afab`](https://github.com/browserbase/stagehand/commit/c54afab0e43a2144eecbc56df7f33c5e444ceed5) Thanks [@miguelg719](https://github.com/miguelg719)! - Add an identifier for client language/runtime
+
+- [#768](https://github.com/browserbase/stagehand/pull/768) [`58b06eb`](https://github.com/browserbase/stagehand/commit/58b06eb2fdfb1a9cd84c03f46655ab0ea00ee07f) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix: page.evaluate: Execution context was destroyed, most likely because of a navigation
+
+- [#758](https://github.com/browserbase/stagehand/pull/758) [`98e1356`](https://github.com/browserbase/stagehand/commit/98e13566846a547003e4c9aebbe4f95eff653bba) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - rm unused functions
+
+- [#781](https://github.com/browserbase/stagehand/pull/781) [`8d239ce`](https://github.com/browserbase/stagehand/commit/8d239cec7a835d35243b2b00c3c00c1b66c05b5e) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix variable parsing issue with gpt-4.1
+
+- [#761](https://github.com/browserbase/stagehand/pull/761) [`e1f7074`](https://github.com/browserbase/stagehand/commit/e1f7074be23c82ae897386d5e5e132ff8cb4120a) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - build xpaths on node side instead of using injected JS
+
+## 2.2.1
+
+### Patch Changes
+
+- [#729](https://github.com/browserbase/stagehand/pull/729) [`fc24f84`](https://github.com/browserbase/stagehand/commit/fc24f848ee0f300182e88993dfe8d68025d69fcb) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - fix "failed to inject helper scripts" log on stagehand.close()
diff --git a/packages/core/lib/inference.ts b/packages/core/lib/inference.ts
new file mode 100644
index 000000000..0bda03aea
--- /dev/null
+++ b/packages/core/lib/inference.ts
@@ -0,0 +1,524 @@
+import { z } from "zod";
+import { LogLine } from "./v3/types/public/logs.js";
+import { ChatMessage, LLMClient } from "./v3/llm/LLMClient.js";
+import { getEnvTimeoutMs, withTimeout } from "./v3/timeoutConfig.js";
+import {
+  buildActSystemPrompt,
+  buildExtractSystemPrompt,
+  buildExtractUserPrompt,
+  buildMetadataPrompt,
+  buildMetadataSystemPrompt,
+  buildObserveSystemPrompt,
+  buildObserveUserMessage,
+} from "./prompt.js";
+import { appendSummary, writeTimestampedTxtFile } from "./inferenceLogUtils.js";
+import type {
+  InferStagehandSchema,
+  StagehandZodObject,
+} from "./v3/zodCompat.js";
+import { SupportedUnderstudyAction } from "./v3/types/private/handlers.js";
+
+// Re-export for backward compatibility
+export type { LLMParsedResponse, LLMUsage } from "./v3/llm/LLMClient.js";
+
+function withLlmTimeout<T>(promise: Promise<T>, operation: string): Promise<T> {
+  return withTimeout(
+    promise,
+    getEnvTimeoutMs("LLM_MAX_MS"),
+    `LLM ${operation}`,
+  );
+}
+
+export async function extract<T extends StagehandZodObject>({
+  instruction,
+  domElements,
+  schema,
+  llmClient,
+  logger,
+  userProvidedInstructions,
+  logInferenceToFile = false,
+}: {
+  instruction: string;
+  domElements: string;
+  schema: T;
+  llmClient: LLMClient;
+  userProvidedInstructions?: string;
+  logger: (message: LogLine) => void;
+  logInferenceToFile?: boolean;
+}) {
+  const metadataSchema = z.object({
+    progress: z
+      .string()
+      .describe(
+        "progress of what has been extracted so far, as concise as possible",
+      ),
+    completed: z
+      .boolean()
+      .describe(
+        "true if the goal is now accomplished. Use this conservatively, only when sure that the goal has been completed.",
+      ),
+  });
+
+  type ExtractionResponse = InferStagehandSchema<T>;
+  type MetadataResponse = z.infer<typeof metadataSchema>;
+
+  const isUsingAnthropic = llmClient.type === "anthropic";
+  const isGPT5 = llmClient.modelName.includes("gpt-5"); // TODO: remove this as we update support for gpt-5 configuration options
+
+  const extractCallMessages: ChatMessage[] = [
+    buildExtractSystemPrompt(isUsingAnthropic, userProvidedInstructions),
+    buildExtractUserPrompt(instruction, domElements, isUsingAnthropic),
+  ];
+
+  let extractCallFile = "";
+  let extractCallTimestamp = "";
+  if (logInferenceToFile) {
+    const { fileName, timestamp } = writeTimestampedTxtFile(
+      "extract_summary",
+      "extract_call",
+      {
+        modelCall: "extract",
+        messages: extractCallMessages,
+      },
+    );
+    extractCallFile = fileName;
+    extractCallTimestamp = timestamp;
+  }
+
+  const extractStartTime = Date.now();
+  const extractionResponse = await withLlmTimeout(
+    llmClient.createChatCompletion<ExtractionResponse>({
+      options: {
+        messages: extractCallMessages,
+        response_model: {
+          schema,
+          name: "Extraction",
+        },
+        temperature: isGPT5 ? 1 : 0.1,
+        top_p: 1,
+        frequency_penalty: 0,
+        presence_penalty: 0,
+      },
+      logger,
+    }),
+    "extract",
+  );
+  const extractEndTime = Date.now();
+
+  const { data: extractedData, usage: extractUsage } = extractionResponse;
+
+  let extractResponseFile: string;
+  if (logInferenceToFile) {
+    const { fileName } = writeTimestampedTxtFile(
+      "extract_summary",
+      "extract_response",
+      {
+        modelResponse: "extract",
+        rawResponse: extractedData,
+      },
+    );
+    extractResponseFile = fileName;
+
+    appendSummary("extract", {
+      extract_inference_type: "extract",
+      timestamp: extractCallTimestamp,
+      LLM_input_file: extractCallFile,
+      LLM_output_file: extractResponseFile,
+      prompt_tokens: extractUsage?.prompt_tokens ?? 0,
+      completion_tokens: extractUsage?.completion_tokens ?? 0,
+      reasoning_tokens: extractUsage?.reasoning_tokens ?? 0,
+      cached_input_tokens: extractUsage?.cached_input_tokens ?? 0,
+      inference_time_ms: extractEndTime - extractStartTime,
+    });
+  }
+
+  const metadataCallMessages: ChatMessage[] = [
+    buildMetadataSystemPrompt(),
+    buildMetadataPrompt(instruction, extractedData),
+  ];
+
+  let metadataCallFile = "";
+  let metadataCallTimestamp = "";
+  if (logInferenceToFile) {
+    const { fileName, timestamp } = writeTimestampedTxtFile(
+      "extract_summary",
+      "metadata_call",
+      {
+        modelCall: "metadata",
+        messages: metadataCallMessages,
+      },
+    );
+    metadataCallFile = fileName;
+    metadataCallTimestamp = timestamp;
+  }
+
+  const metadataStartTime = Date.now();
+  const metadataResponse = await withLlmTimeout(
+    llmClient.createChatCompletion<MetadataResponse>({
+      options: {
+        messages: metadataCallMessages,
+        response_model: {
+          name: "Metadata",
+          schema: metadataSchema,
+        },
+        temperature: isGPT5 ? 1 : 0.1,
+        top_p: 1,
+        frequency_penalty: 0,
+        presence_penalty: 0,
+      },
+      logger,
+    }),
+    "extract metadata",
+  );
+  const metadataEndTime = Date.now();
+
+  const {
+    data: {
+      completed: metadataResponseCompleted,
+      progress: metadataResponseProgress,
+    },
+    usage: metadataResponseUsage,
+  } = metadataResponse;
+
+  let metadataResponseFile: string;
+  if (logInferenceToFile) {
+    const { fileName } = writeTimestampedTxtFile(
+      "extract_summary",
+      "metadata_response",
+      {
+        modelResponse: "metadata",
+        completed: metadataResponseCompleted,
+        progress: metadataResponseProgress,
+      },
+    );
+    metadataResponseFile = fileName;
+
+    appendSummary("extract", {
+      extract_inference_type: "metadata",
+      timestamp: metadataCallTimestamp,
+      LLM_input_file: metadataCallFile,
+      LLM_output_file: metadataResponseFile,
+      prompt_tokens: metadataResponseUsage?.prompt_tokens ?? 0,
+      completion_tokens: metadataResponseUsage?.completion_tokens ?? 0,
+      reasoning_tokens: metadataResponseUsage?.reasoning_tokens ?? 0,
+      cached_input_tokens: metadataResponseUsage?.cached_input_tokens ?? 0,
+      inference_time_ms: metadataEndTime - metadataStartTime,
+    });
+  }
+
+  const totalPromptTokens =
+    (extractUsage?.prompt_tokens ?? 0) +
+    (metadataResponseUsage?.prompt_tokens ?? 0);
+
+  const totalCompletionTokens =
+    (extractUsage?.completion_tokens ?? 0) +
+    (metadataResponseUsage?.completion_tokens ?? 0);
+
+  const totalInferenceTimeMs =
+    extractEndTime - extractStartTime + (metadataEndTime - metadataStartTime);
+  const totalReasoningTokens =
+    (extractUsage?.reasoning_tokens ?? 0) +
+    (metadataResponseUsage?.reasoning_tokens ?? 0);
+  const totalCachedInputTokens =
+    (extractUsage?.cached_input_tokens ?? 0) +
+    (metadataResponseUsage?.cached_input_tokens ?? 0);
+
+  return {
+    ...extractedData,
+    metadata: {
+      completed: metadataResponseCompleted,
+      progress: metadataResponseProgress,
+    },
+    prompt_tokens: totalPromptTokens,
+    completion_tokens: totalCompletionTokens,
+    reasoning_tokens: totalReasoningTokens,
+    cached_input_tokens: totalCachedInputTokens,
+    inference_time_ms: totalInferenceTimeMs,
+  };
+}
+
+export async function observe({
+  instruction,
+  domElements,
+  llmClient,
+  userProvidedInstructions,
+  logger,
+  logInferenceToFile = false,
+  supportedActions,
+}: {
+  instruction: string;
+  domElements: string;
+  llmClient: LLMClient;
+  userProvidedInstructions?: string;
+  logger: (message: LogLine) => void;
+  logInferenceToFile?: boolean;
+  supportedActions?: string[];
+}) {
+  const isGPT5 = llmClient.modelName.includes("gpt-5"); // TODO: remove this as we update support for gpt-5 configuration options
+
+  const observeSchema = z.object({
+    elements: z
+      .array(
+        z.object({
+          elementId: z
+            .string()
+            .regex(/^\d+-\d+$/)
+            .describe(
+              "the ID string associated with the element. Never include surrounding square brackets. This field must follow the format of 'number-number'.",
+            ),
+          description: z
+            .string()
+            .describe(
+              "a description of the accessible element and its purpose",
+            ),
+          method: z
+            .enum(
+              // Use Object.values() for Zod v3 compatibility - z.enum() in v3 doesn't accept TypeScript enums directly
+              Object.values(SupportedUnderstudyAction) as unknown as readonly [
+                string,
+                ...string[],
+              ],
+            )
+            .describe(
+              `the candidate method/action to interact with the element. Select one of the available Understudy interaction methods.`,
+            ),
+          arguments: z.array(
+            z
+              .string()
+              .describe(
+                "the arguments to pass to the method. For example, for a click, the arguments are empty, but for a fill, the arguments are the value to fill in.",
+              ),
+          ),
+        }),
+      )
+      .describe("an array of accessible elements that match the instruction"),
+  });
+
+  type ObserveResponse = z.infer<typeof observeSchema>;
+
+  const messages: ChatMessage[] = [
+    buildObserveSystemPrompt(userProvidedInstructions, supportedActions),
+    buildObserveUserMessage(instruction, domElements),
+  ];
+
+  let callTimestamp = "";
+  let callFile = "";
+  if (logInferenceToFile) {
+    const { fileName, timestamp } = writeTimestampedTxtFile(
+      `observe_summary`,
+      `observe_call`,
+      {
+        modelCall: "observe",
+        messages,
+      },
+    );
+    callFile = fileName;
+    callTimestamp = timestamp;
+  }
+
+  const start = Date.now();
+  const rawResponse = await llmClient.createChatCompletion<ObserveResponse>({
+    options: {
+      messages,
+      response_model: {
+        schema: observeSchema,
+        name: "Observation",
+      },
+      temperature: isGPT5 ? 1 : 0.1,
+      top_p: 1,
+      frequency_penalty: 0,
+      presence_penalty: 0,
+    },
+    logger,
+  });
+  const end = Date.now();
+  const usageTimeMs = end - start;
+
+  const { data: observeData, usage: observeUsage } = rawResponse;
+  const promptTokens = observeUsage?.prompt_tokens ?? 0;
+  const completionTokens = observeUsage?.completion_tokens ?? 0;
+  const reasoningTokens = observeUsage?.reasoning_tokens ?? 0;
+  const cachedInputTokens = observeUsage?.cached_input_tokens ?? 0;
+
+  let responseFile: string;
+  if (logInferenceToFile) {
+    const { fileName: responseFileName } = writeTimestampedTxtFile(
+      `observe_summary`,
+      `observe_response`,
+      {
+        modelResponse: "observe",
+        rawResponse: observeData,
+      },
+    );
+    responseFile = responseFileName;
+
+    appendSummary("observe", {
+      [`observe_inference_type`]: "observe",
+      timestamp: callTimestamp,
+      LLM_input_file: callFile,
+      LLM_output_file: responseFile,
+      prompt_tokens: promptTokens,
+      completion_tokens: completionTokens,
+      reasoning_tokens: reasoningTokens,
+      cached_input_tokens: cachedInputTokens,
+      inference_time_ms: usageTimeMs,
+    });
+  }
+
+  const parsedElements =
+    observeData.elements?.map((el) => {
+      const base = {
+        elementId: el.elementId,
+        description: String(el.description),
+        method: String(el.method),
+        arguments: el.arguments,
+      };
+      return base;
+    }) ?? [];
+
+  return {
+    elements: parsedElements,
+    prompt_tokens: promptTokens,
+    completion_tokens: completionTokens,
+    reasoning_tokens: reasoningTokens,
+    cached_input_tokens: cachedInputTokens,
+    inference_time_ms: usageTimeMs,
+  };
+}
+
+export async function act({
+  instruction,
+  domElements,
+  llmClient,
+  userProvidedInstructions,
+  logger,
+  logInferenceToFile = false,
+}: {
+  instruction: string;
+  domElements: string;
+  llmClient: LLMClient;
+  userProvidedInstructions?: string;
+  logger: (message: LogLine) => void;
+  logInferenceToFile?: boolean;
+}) {
+  const isGPT5 = llmClient.modelName.includes("gpt-5"); // TODO: remove this as we update support for gpt-5 configuration options
+
+  const actSchema = z.object({
+    elementId: z
+      .string()
+      .regex(/^\d+-\d+$/)
+      .describe(
+        "the ID string associated with the element. Never include surrounding square brackets. This field must follow the format of 'number-number'.",
+      ),
+    description: z
+      .string()
+      .describe("a description of the accessible element and its purpose"),
+    method: z
+      .enum(
+        // Use Object.values() for Zod v3 compatibility - z.enum() in v3 doesn't accept TypeScript enums directly
+        Object.values(SupportedUnderstudyAction) as unknown as readonly [
+          string,
+          ...string[],
+        ],
+      )
+      .describe(
+        "the candidate method/action to interact with the element. Select one of the available Understudy interaction methods.",
+      ),
+    arguments: z.array(
+      z
+        .string()
+        .describe(
+          "the arguments to pass to the method. For example, for a click, the arguments are empty, but for a fill, the arguments are the value to fill in.",
+        ),
+    ),
+    twoStep: z.boolean(),
+  });
+
+  type ActResponse = z.infer<typeof actSchema>;
+
+  const messages: ChatMessage[] = [
+    buildActSystemPrompt(userProvidedInstructions),
+    buildObserveUserMessage(instruction, domElements),
+  ];
+
+  let callTimestamp = "";
+  let callFile = "";
+  if (logInferenceToFile) {
+    const { fileName, timestamp } = writeTimestampedTxtFile(
+      `act_summary`,
+      `act_call`,
+      {
+        modelCall: "act",
+        messages,
+      },
+    );
+    callFile = fileName;
+    callTimestamp = timestamp;
+  }
+
+  const start = Date.now();
+  const rawResponse = await llmClient.createChatCompletion<ActResponse>({
+    options: {
+      messages,
+      response_model: {
+        schema: actSchema,
+        name: "act",
+      },
+      temperature: isGPT5 ? 1 : 0.1,
+      top_p: 1,
+      frequency_penalty: 0,
+      presence_penalty: 0,
+    },
+    logger,
+  });
+  const end = Date.now();
+  const usageTimeMs = end - start;
+
+  const { data: actData, usage: actUsage } = rawResponse;
+  const promptTokens = actUsage?.prompt_tokens ?? 0;
+  const completionTokens = actUsage?.completion_tokens ?? 0;
+  const reasoningTokens = actUsage?.reasoning_tokens ?? 0;
+  const cachedInputTokens = actUsage?.cached_input_tokens ?? 0;
+
+  let responseFile: string;
+  if (logInferenceToFile) {
+    const { fileName: responseFileName } = writeTimestampedTxtFile(
+      `act_summary`,
+      `act_response`,
+      {
+        modelResponse: "act",
+        rawResponse: actData,
+      },
+    );
+    responseFile = responseFileName;
+
+    appendSummary("act", {
+      [`act_inference_type`]: "act",
+      timestamp: callTimestamp,
+      LLM_input_file: callFile,
+      LLM_output_file: responseFile,
+      prompt_tokens: promptTokens,
+      completion_tokens: completionTokens,
+      reasoning_tokens: reasoningTokens,
+      cached_input_tokens: cachedInputTokens,
+      inference_time_ms: usageTimeMs,
+    });
+  }
+
+  const parsedElement = {
+    elementId: actData.elementId,
+    description: String(actData.description),
+    method: String(actData.method),
+    arguments: actData.arguments,
+  };
+
+  return {
+    element: parsedElement,
+    prompt_tokens: promptTokens,
+    completion_tokens: completionTokens,
+    reasoning_tokens: reasoningTokens,
+    cached_input_tokens: cachedInputTokens,
+    inference_time_ms: usageTimeMs,
+    twoStep: actData.twoStep,
+  };
+}
diff --git a/lib/inferenceLogUtils.ts b/packages/core/lib/inferenceLogUtils.ts
similarity index 100%
rename from lib/inferenceLogUtils.ts
rename to packages/core/lib/inferenceLogUtils.ts
index 4a5f8693b..a6a60ca61 100644
--- a/lib/inferenceLogUtils.ts
+++ b/packages/core/lib/inferenceLogUtils.ts
@@ -1,5 +1,5 @@
-import path from "path";
 import fs from "fs";
+import path from "path";
 
 /**
  * Create (or ensure) a parent directory named "inference_summary".
diff --git a/lib/logger.ts b/packages/core/lib/logger.ts
similarity index 58%
rename from lib/logger.ts
rename to packages/core/lib/logger.ts
index 54814e434..135ba8d15 100644
--- a/lib/logger.ts
+++ b/packages/core/lib/logger.ts
@@ -1,5 +1,5 @@
 import pino from "pino";
-import { LogLine } from "../types/log";
+import { LogLine } from "./v3/types/public/logs.js";
 
 // Map our existing levels to Pino's standard levels
 const levelMapping: Record<number, pino.Level> = {
@@ -71,9 +71,33 @@ function isTestEnvironment(): boolean {
 
 /**
  * StagehandLogger class that wraps Pino for our specific needs
+ *
+ * LOGGING PRECEDENCE:
+ *
+ * Test environments:
+ *   - External logger provided -> external logger only.
+ *   - No external logger -> console fallback only (Pino disabled).
+ *
+ * Non-test environments:
+ *   - usePino === true -> emit via Pino and also call the external logger when present.
+ *   - usePino === false -> disable Pino; use the external logger when present, otherwise console fallback.
+ *   - usePino === undefined -> prefer the external logger when present; otherwise use Pino.
+ *
+ * SHARED PINO OPTIMIZATION:
+ * We maintain a single shared Pino instance when `usePino` is enabled.
+ * This prevents spawning a new worker thread for every Stagehand instance
+ * (which happens when `pino-pretty` transport is used), eliminating the
+ * memory/RSS growth observed when many Stagehand objects are created and
+ * disposed within the same process (e.g. a request-per-instance API).
  */
 export class StagehandLogger {
-  private logger: pino.Logger;
+  /**
+   * Shared Pino logger instance across all StagehandLogger instances.
+   * First instance to enable Pino creates it, subsequent instances reuse it.
+   */
+  private static sharedPinoLogger: pino.Logger | null = null;
+
+  private logger?: pino.Logger;
   private verbose: 0 | 1 | 2;
   private externalLogger?: (logLine: LogLine) => void;
   private usePino: boolean;
@@ -84,13 +108,30 @@ export class StagehandLogger {
     externalLogger?: (logLine: LogLine) => void,
   ) {
     this.isTest = isTestEnvironment();
+    this.externalLogger = externalLogger;
 
-    // In test environments, default to not using Pino to avoid worker thread issues
-    this.usePino = this.isTest ? false : options.usePino !== false; // Default to using Pino if not specified and not in test
+    const externalProvided = typeof externalLogger === "function";
+    const explicitUsePino = options.usePino;
+
+    if (this.isTest) {
+      this.usePino = false;
+    } else if (explicitUsePino === true) {
+      this.usePino = true;
+    } else if (explicitUsePino === false) {
+      this.usePino = false;
+    } else {
+      this.usePino = !externalProvided;
+    }
+
+    if (this.usePino) {
+      // Re-use (or create) a single shared Pino logger instance
+      if (!StagehandLogger.sharedPinoLogger) {
+        StagehandLogger.sharedPinoLogger = createLogger(options);
+      }
+      this.logger = StagehandLogger.sharedPinoLogger;
+    }
 
-    this.logger = this.usePino ? createLogger(options) : null;
     this.verbose = 1; // Default verbosity level
-    this.externalLogger = externalLogger;
   }
 
   /**
@@ -124,23 +165,52 @@ export class StagehandLogger {
       return;
     }
 
-    // If we're in a test environment but no external logger is provided,
-    // use console for basic logging
-    if (this.isTest && !this.externalLogger) {
+    // For test environments WITHOUT an external logger OR for cases where Pino
+    // is disabled and no external logger is provided, fall back to console.* so
+    // users still see logs (non-colourised).
+    const shouldFallbackToConsole =
+      (!this.usePino && !this.externalLogger) ||
+      (this.isTest && !this.externalLogger);
+
+    if (shouldFallbackToConsole) {
       const level = logLine.level ?? 1;
-      const prefix = `[${logLine.category || "log"}] `;
+      const ts = logLine.timestamp ?? new Date().toISOString();
+      const levelStr = level === 0 ? "ERROR" : level === 2 ? "DEBUG" : "INFO";
+
+      // Format like Pino: [timestamp] LEVEL: message
+      let output = `[${ts}] ${levelStr}: ${logLine.message}`;
+
+      // Add auxiliary data on separate indented lines (like Pino pretty format)
+      if (logLine.auxiliary) {
+        const formattedData = this.formatAuxiliaryData(logLine.auxiliary);
+        for (const [key, value] of Object.entries(formattedData)) {
+          let formattedValue: string;
+          if (typeof value === "object" && value !== null) {
+            // Pretty print objects with indentation
+            formattedValue = JSON.stringify(value, null, 2)
+              .split("\n")
+              .map((line, i) => (i === 0 ? line : `    ${line}`))
+              .join("\n");
+          } else {
+            formattedValue = String(value);
+          }
+          output += `\n    ${key}: ${formattedValue}`;
+        }
+      }
 
       switch (level) {
         case 0:
-          console.error(prefix + logLine.message);
+          console.error(output);
           break;
         case 1:
-          console.log(prefix + logLine.message);
+          console.log(output);
           break;
         case 2:
-          console.debug(prefix + logLine.message);
+          console.debug(output);
           break;
       }
+
+      return; // already handled via console output, avoid duplicate logging
     }
 
     if (this.usePino && this.logger) {
@@ -170,8 +240,11 @@ export class StagehandLogger {
       }
     }
 
-    // Use external logger if provided and either Pino is disabled or we're in a test
-    if (this.externalLogger && (!this.usePino || this.isTest)) {
+    // IMPORTANT: External logger receives logs ALWAYS when provided (takes precedence)
+    // This ensures user-provided loggers (e.g., EvalLogger, custom loggers) capture all logs
+    // regardless of Pino configuration. Pino is used for console output, external logger
+    // is used for programmatic log capture.
+    if (this.externalLogger) {
       this.externalLogger(logLine);
     }
   }
@@ -185,27 +258,40 @@ export class StagehandLogger {
     const formattedData: Record<string, unknown> = {};
 
     for (const [key, { value, type }] of Object.entries(auxiliary)) {
+      let formattedValue: unknown;
+
       // Convert values based on their type
       switch (type) {
         case "integer":
-          formattedData[key] = parseInt(value, 10);
+          formattedValue = parseInt(value, 10);
           break;
         case "float":
-          formattedData[key] = parseFloat(value);
+          formattedValue = parseFloat(value);
           break;
         case "boolean":
-          formattedData[key] = value === "true";
+          formattedValue = value === "true";
           break;
         case "object":
           try {
-            formattedData[key] = JSON.parse(value);
+            formattedValue = JSON.parse(value);
           } catch {
-            formattedData[key] = value;
+            formattedValue = value;
           }
           break;
         default:
-          formattedData[key] = value;
+          formattedValue = value;
       }
+
+      // Skip undefined values and empty objects/arrays
+      if (formattedValue === undefined) continue;
+      if (typeof formattedValue === "object" && formattedValue !== null) {
+        const isEmpty = Array.isArray(formattedValue)
+          ? formattedValue.length === 0
+          : Object.keys(formattedValue).length === 0;
+        if (isEmpty) continue;
+      }
+
+      formattedData[key] = formattedValue;
     }
 
     return formattedData;
@@ -225,7 +311,7 @@ export class StagehandLogger {
   warn(message: string, data?: Record<string, unknown>): void {
     this.log({
       message,
-      level: 0, // Using error level for warnings as we don't have a separate warning level
+      level: 1,
       category: "warning",
       auxiliary: this.convertToAuxiliary(data),
     });
diff --git a/packages/core/lib/modelUtils.ts b/packages/core/lib/modelUtils.ts
new file mode 100644
index 000000000..db6b968f8
--- /dev/null
+++ b/packages/core/lib/modelUtils.ts
@@ -0,0 +1,69 @@
+import { ClientOptions, ModelConfiguration } from "./v3/types/public/model.js";
+import {
+  AVAILABLE_CUA_MODELS,
+  AvailableCuaModel,
+} from "./v3/types/public/agent.js";
+
+//useful when resolving a model from string or object formats we accept
+export function extractModelName(
+  model?: string | { modelName: string; [key: string]: unknown },
+): string | undefined {
+  if (!model) return undefined;
+  return typeof model === "string" ? model : model.modelName;
+}
+
+export function splitModelName(model: string): {
+  provider: string;
+  modelName: string;
+} {
+  const firstSlashIndex = model.indexOf("/");
+  const provider = model.substring(0, firstSlashIndex);
+  const modelName = model.substring(firstSlashIndex + 1);
+  return { provider, modelName };
+}
+
+export function resolveModel(model: string | ModelConfiguration): {
+  provider: string;
+  modelName: string;
+  clientOptions: ClientOptions;
+  isCua: boolean;
+} {
+  const modelString = extractModelName(model)!;
+  const clientOptions =
+    typeof model === "string"
+      ? {}
+      : (() => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
+          const { modelName: _, ...rest } = model;
+          return rest;
+        })();
+
+  // Check if provider is explicitly set in clientOptions
+  const hasExplicitProvider = clientOptions.provider !== undefined;
+
+  // If provider is explicitly set, don't split the model name - pass it through as-is
+  let provider: string;
+  let parsedModelName: string;
+
+  if (hasExplicitProvider) {
+    provider = clientOptions.provider as string;
+    parsedModelName = modelString; // Keep the full model name
+  } else {
+    // Parse the model string normally
+    const split = splitModelName(modelString);
+    provider = split.provider;
+    parsedModelName = split.modelName;
+  }
+
+  // Check if it's a CUA model
+  const isCua =
+    hasExplicitProvider ||
+    AVAILABLE_CUA_MODELS.includes(modelString as AvailableCuaModel);
+
+  return {
+    provider,
+    modelName: parsedModelName,
+    clientOptions,
+    isCua,
+  };
+}
diff --git a/packages/core/lib/prompt.ts b/packages/core/lib/prompt.ts
new file mode 100644
index 000000000..10437b66d
--- /dev/null
+++ b/packages/core/lib/prompt.ts
@@ -0,0 +1,297 @@
+import { ChatMessage } from "./v3/llm/LLMClient.js";
+import type { Variables } from "./v3/types/public/agent.js";
+
+export function buildUserInstructionsString(
+  userProvidedInstructions?: string,
+): string {
+  if (!userProvidedInstructions) {
+    return "";
+  }
+
+  return `\n\n# Custom Instructions Provided by the User
+    
+Please keep the user's instructions in mind when performing actions. If the user's instructions are not relevant to the current task, ignore them.
+
+User Instructions:
+${userProvidedInstructions}`;
+}
+
+// extract
+export function buildExtractSystemPrompt(
+  isUsingPrintExtractedDataTool: boolean = false,
+  userProvidedInstructions?: string,
+): ChatMessage {
+  const baseContent = `You are extracting content on behalf of a user.
+  If a user asks you to extract a 'list' of information, or 'all' information, 
+  YOU MUST EXTRACT ALL OF THE INFORMATION THAT THE USER REQUESTS.
+   
+  You will be given:
+1. An instruction
+2. `;
+
+  const contentDetail = `A list of DOM elements to extract from.`;
+
+  const instructions = `
+Print the exact text from the DOM elements with all symbols, characters, and endlines as is.
+Print null or an empty string if no new information is found.
+  `.trim();
+
+  const toolInstructions = isUsingPrintExtractedDataTool
+    ? `
+ONLY print the content using the print_extracted_data tool provided.
+ONLY print the content using the print_extracted_data tool provided.
+  `.trim()
+    : "";
+
+  const additionalInstructions =
+    "If a user is attempting to extract links or URLs, you MUST respond with ONLY the IDs of the link elements. \n" +
+    "Do not attempt to extract links directly from the text unless absolutely necessary. ";
+
+  const userInstructions = buildUserInstructionsString(
+    userProvidedInstructions,
+  );
+
+  const content =
+    `${baseContent}${contentDetail}\n\n${instructions}\n${toolInstructions}${
+      additionalInstructions ? `\n\n${additionalInstructions}` : ""
+    }${userInstructions ? `\n\n${userInstructions}` : ""}`.replace(/\s+/g, " ");
+
+  return {
+    role: "system",
+    content,
+  };
+}
+
+export function buildExtractUserPrompt(
+  instruction: string,
+  domElements: string,
+  isUsingPrintExtractedDataTool: boolean = false,
+): ChatMessage {
+  let content = `Instruction: ${instruction}
+DOM: ${domElements}`;
+
+  if (isUsingPrintExtractedDataTool) {
+    content += `
+ONLY print the content using the print_extracted_data tool provided.
+ONLY print the content using the print_extracted_data tool provided.`;
+  }
+
+  return {
+    role: "user",
+    content,
+  };
+}
+
+const metadataSystemPrompt = `You are an AI assistant tasked with evaluating the progress and completion status of an extraction task.
+Analyze the extraction response and determine if the task is completed or if more information is needed.
+Strictly abide by the following criteria:
+1. Once the instruction has been satisfied by the current extraction response, ALWAYS set completion status to true and stop processing, regardless of remaining chunks.
+2. Only set completion status to false if BOTH of these conditions are true:
+   - The instruction has not been satisfied yet
+   - There are still chunks left to process (chunksTotal > chunksSeen)`;
+
+export function buildMetadataSystemPrompt(): ChatMessage {
+  return {
+    role: "system",
+    content: metadataSystemPrompt,
+  };
+}
+
+export function buildMetadataPrompt(
+  instruction: string,
+  extractionResponse: object,
+): ChatMessage {
+  return {
+    role: "user",
+    content: `Instruction: ${instruction}
+Extracted content: ${JSON.stringify(extractionResponse, null, 2)}`,
+  };
+}
+
+// observe
+export function buildObserveSystemPrompt(
+  userProvidedInstructions?: string,
+  supportedActions?: string[],
+): ChatMessage {
+  const actionsString = supportedActions?.length
+    ? `\n\nSupported actions: ${supportedActions.join(", ")}`
+    : "";
+
+  const observeSystemPrompt = `
+You are helping the user automate the browser by finding elements based on what the user wants to observe in the page.
+
+You will be given:
+1. a instruction of elements to observe
+2. a hierarchical accessibility tree showing the semantic structure of the page. The tree is a hybrid of the DOM and the accessibility tree.
+
+Return an array of elements that match the instruction if they exist, otherwise return an empty array.
+When returning elements, include the appropriate method from the supported actions list.${actionsString}. When choosing non-left click actions, provide right or middle as the argument.`;
+  const content = observeSystemPrompt.replace(/\s+/g, " ");
+
+  return {
+    role: "system",
+    content: [content, buildUserInstructionsString(userProvidedInstructions)]
+      .filter(Boolean)
+      .join("\n\n"),
+  };
+}
+
+export function buildObserveUserMessage(
+  instruction: string,
+  domElements: string,
+): ChatMessage {
+  return {
+    role: "user",
+    content: `instruction: ${instruction}
+Accessibility Tree: \n${domElements}\n`,
+  };
+}
+
+export function buildActSystemPrompt(
+  userProvidedInstructions?: string,
+): ChatMessage {
+  const actSystemPrompt = `
+You are helping the user automate the browser by finding elements based on what action the user wants to take on the page
+
+You will be given:
+1. a user defined instruction about what action to take
+2. a hierarchical accessibility tree showing the semantic structure of the page. The tree is a hybrid of the DOM and the accessibility tree.
+
+Return the element that matches the instruction if it exists. Otherwise, return an empty object.`;
+  const content = actSystemPrompt.replace(/\s+/g, " ");
+
+  return {
+    role: "system",
+    content: [content, buildUserInstructionsString(userProvidedInstructions)]
+      .filter(Boolean)
+      .join("\n\n"),
+  };
+}
+
+export function buildActPrompt(
+  action: string,
+  supportedActions: string[],
+  variables?: Variables,
+): string {
+  // Base instruction
+  let instruction = `Find the most relevant element to perform an action on given the following action: ${action}.  
+  IF AND ONLY IF the action EXPLICITLY includes the word 'dropdown' and implies choosing/selecting an option from a dropdown, ignore the 'General Instructions' section, and follow the 'Dropdown Specific Instructions' section carefully.
+  
+  General Instructions: 
+    Provide an action for this element such as ${supportedActions.join(", ")}. Remember that to users, buttons and links look the same in most cases.
+    When choosing non-left click actions, provide right or middle as the argument
+    If the action is completely unrelated to a potential action to be taken on the page, return an empty object. 
+    ONLY return one action. If multiple actions are relevant, return the most relevant one. 
+    If the user is asking to scroll to a position on the page, e.g., 'halfway' or 0.75, etc, you must return the argument formatted as the correct percentage, e.g., '50%' or '75%', etc.
+    If the user is asking to scroll to the next chunk/previous chunk, choose the nextChunk/prevChunk method. No arguments are required here.
+    If the action implies a key press, e.g., 'press enter', 'press a', 'press space', etc., always choose the press method with the appropriate key as argument — e.g. 'a', 'Enter', 'Space'. Do not choose a click action on an on-screen keyboard. Capitalize the first character like 'Enter', 'Tab', 'Escape' only for special keys. 
+  
+  Dropdown Specific Instructions:
+    For interacting with dropdowns, there are two specific cases that you need to handle. 
+    
+    CASE 1: the element is a 'select' element. 
+      - choose the selectOptionFromDropdown method,
+      - set the argument to the exact text of the option that should be selected,
+      - set twoStep to false.
+    CASE 2: the element is NOT a 'select' element:
+      - do not attempt to directly choose the element from the dropdown. You will need to click to expand the dropdown first. You will achieve this by following these instructions:
+        - choose the node that most closely corresponds to the given instruction EVEN if it is a 'StaticText' element, or otherwise does not appear to be interactable.  
+        - choose the 'click' method
+        - set twoStep to true.
+  `;
+
+  // Add variable names (not values) to the instruction if any
+  if (variables && Object.keys(variables).length > 0) {
+    const variableNames = Object.keys(variables)
+      .map((key) => `%${key}%`)
+      .join(", ");
+    const variablesPrompt = `The following variables are available to use in the action: ${variableNames}. Fill the argument variables with the variable name.`;
+    instruction += ` ${variablesPrompt}`;
+  }
+
+  return instruction;
+}
+
+export function buildStepTwoPrompt(
+  originalUserAction: string,
+  previousAction: string,
+  supportedActions: string[],
+  variables?: Variables,
+): string {
+  // Base instruction
+  let instruction = `
+  The original user action was: ${originalUserAction}.
+  You have just taken the following action which completed step 1 of 2: ${previousAction}.
+  
+  Now, you must find the most relevant element to perform an action on in order to complete step 2 of 2. 
+  
+  General Instructions: 
+  Provide an action for this element such as ${supportedActions.join(", ")}. Remember that to users, buttons and links look the same in most cases.
+  If the action is completely unrelated to a potential action to be taken on the page, return an empty object. 
+  ONLY return one action. If multiple actions are relevant, return the most relevant one. 
+  If the user is asking to scroll to a position on the page, e.g., 'halfway' or 0.75, etc, you must return the argument formatted as the correct percentage, e.g., '50%' or '75%', etc.
+  If the user is asking to scroll to the next chunk/previous chunk, choose the nextChunk/prevChunk method. No arguments are required here.
+  If the action implies a key press, e.g., 'press enter', 'press a', 'press space', etc., always choose the press method with the appropriate key as argument — e.g. 'a', 'Enter', 'Space'. Do not choose a click action on an on-screen keyboard. Capitalize the first character like 'Enter', 'Tab', 'Escape' only for special keys. 
+  `;
+
+  // Add variable names (not values) to the instruction if any
+  if (variables && Object.keys(variables).length > 0) {
+    const variableNames = Object.keys(variables)
+      .map((key) => `%${key}%`)
+      .join(", ");
+    const variablesPrompt = `The following variables are available to use in the action: ${variableNames}. Fill the argument variables with the variable name.`;
+    instruction += ` ${variablesPrompt}`;
+  }
+
+  return instruction;
+}
+
+export function buildOperatorSystemPrompt(goal: string): ChatMessage {
+  return {
+    role: "system",
+    content: `You are a general-purpose agent whose job is to accomplish the user's goal across multiple model calls by running actions on the page.
+
+You will be given a goal and a list of steps that have been taken so far. Your job is to determine if either the user's goal has been completed or if there are still steps that need to be taken.
+
+# Your current goal
+${goal}
+
+# CRITICAL: You MUST use the provided tools to take actions. Do not just describe what you want to do - actually call the appropriate tools.
+
+# Available tools and when to use them:
+- \`act\`: Use this to interact with the page (click, type, navigate, etc.)
+- \`extract\`: Use this to get information from the page
+- \`goto\`: Use this to navigate to a specific URL
+- \`wait\`: Use this to wait for a period of time
+- \`navback\`: Use this to go back to the previous page
+- \`refresh\`: Use this to refresh the current page
+- \`close\`: Use this ONLY when the task is complete or cannot be achieved
+- External tools: Use any additional tools (like search tools) as needed for your goal
+
+# Important guidelines
+1. ALWAYS use tools - never just provide text responses about what you plan to do
+2. Break down complex actions into individual atomic steps
+3. For \`act\` commands, use only one action at a time, such as:
+   - Single click on a specific element
+   - Type into a single input field
+   - Select a single option
+4. Avoid combining multiple actions in one instruction
+5. If multiple actions are needed, they should be separate steps
+6. Only use \`close\` when the task is genuinely complete or impossible to achieve`,
+  };
+}
+
+export function buildCuaDefaultSystemPrompt(): string {
+  return `You are a helpful assistant that can use a web browser.\nDo not ask follow up questions, the user will trust your judgement. Today's date is ${new Date().toISOString().split("T")[0]}.`;
+}
+
+export function buildGoogleCUASystemPrompt(): ChatMessage {
+  return {
+    role: "system",
+    content: `You are a general-purpose browser agent whose job is to accomplish the user's goal.
+Today's date is ${new Date().toISOString().split("T")[0]}.
+You have access to a search tool; however, in most cases you should operate within the page/url the user has provided. ONLY use the search tool if you're stuck or the task is impossible to complete within the current page.
+You will be given a goal and a list of steps that have been taken so far. Avoid requesting the user for input as much as possible. Good luck!
+`,
+  };
+}
diff --git a/packages/core/lib/utils.ts b/packages/core/lib/utils.ts
new file mode 100644
index 000000000..44dca52b3
--- /dev/null
+++ b/packages/core/lib/utils.ts
@@ -0,0 +1,843 @@
+import { ZodSchemaValidationError } from "./v3/types/public/sdkErrors.js";
+import { Schema, Type } from "@google/genai";
+import { z, ZodTypeAny } from "zod";
+import z3 from "zod/v3";
+import { LogLine } from "./v3/types/public/logs.js";
+import { ModelProvider } from "./v3/types/public/model.js";
+import { ZodPathSegments } from "./v3/types/private/internal.js";
+import type { StagehandZodSchema } from "./v3/zodCompat.js";
+import { isZod4Schema } from "./v3/zodCompat.js";
+
+const ID_PATTERN = /^\d+-\d+$/;
+
+const zFactories = {
+  v4: z,
+  v3: z3 as unknown as typeof z,
+};
+
+export function getZFactory(schema: StagehandZodSchema): typeof z {
+  return isZod4Schema(schema) ? zFactories.v4 : zFactories.v3;
+}
+
+const TYPE_NAME_MAP: Record<string, string> = {
+  ZodString: "string",
+  string: "string",
+  ZodNumber: "number",
+  number: "number",
+  ZodBoolean: "boolean",
+  boolean: "boolean",
+  ZodObject: "object",
+  object: "object",
+  ZodArray: "array",
+  array: "array",
+  ZodUnion: "union",
+  union: "union",
+  ZodIntersection: "intersection",
+  intersection: "intersection",
+  ZodOptional: "optional",
+  optional: "optional",
+  ZodNullable: "nullable",
+  nullable: "nullable",
+  ZodLiteral: "literal",
+  literal: "literal",
+  ZodEnum: "enum",
+  enum: "enum",
+  ZodDefault: "default",
+  default: "default",
+  ZodEffects: "effects",
+  effects: "effects",
+  pipe: "pipe",
+};
+
+function getZ4Def(schema: StagehandZodSchema) {
+  return (schema as SchemaInternals)._zod?.def as
+    | Record<string, unknown>
+    | undefined;
+}
+
+function getZ4Bag(schema: StagehandZodSchema) {
+  return (schema as SchemaInternals)._zod?.bag as
+    | Record<string, unknown>
+    | undefined;
+}
+
+function getZ3Def(schema: StagehandZodSchema) {
+  return (schema as SchemaInternals)._def as
+    | Record<string, unknown>
+    | undefined;
+}
+
+function getObjectShape(
+  schema: StagehandZodSchema,
+): Record<string, StagehandZodSchema> | undefined {
+  const z4Shape = getZ4Def(schema)?.shape as
+    | Record<string, StagehandZodSchema>
+    | undefined;
+  if (z4Shape) {
+    return z4Shape;
+  }
+
+  const z3Shape = getZ3Def(schema)?.shape;
+  if (!z3Shape) {
+    return undefined;
+  }
+
+  if (typeof z3Shape === "function") {
+    return (z3Shape as () => Record<string, StagehandZodSchema>)();
+  }
+
+  return z3Shape as Record<string, StagehandZodSchema>;
+}
+
+function getArrayElement(
+  schema: StagehandZodSchema,
+): StagehandZodSchema | undefined {
+  return (getZ4Def(schema)?.element ?? getZ3Def(schema)?.type) as
+    | StagehandZodSchema
+    | undefined;
+}
+
+function getInnerType(
+  schema: StagehandZodSchema,
+): StagehandZodSchema | undefined {
+  return (getZ4Def(schema)?.innerType ?? getZ3Def(schema)?.innerType) as
+    | StagehandZodSchema
+    | undefined;
+}
+
+function getUnionOptions(
+  schema: StagehandZodSchema,
+): StagehandZodSchema[] | undefined {
+  const z4Options = getZ4Def(schema)?.options;
+  if (Array.isArray(z4Options)) {
+    return z4Options as StagehandZodSchema[];
+  }
+  const z3Options = getZ3Def(schema)?.options;
+  return Array.isArray(z3Options)
+    ? (z3Options as StagehandZodSchema[])
+    : undefined;
+}
+
+function getIntersectionSides(schema: StagehandZodSchema): {
+  left?: StagehandZodSchema;
+  right?: StagehandZodSchema;
+} {
+  const z4Def = getZ4Def(schema);
+  if (z4Def?.left || z4Def?.right) {
+    return {
+      left: z4Def?.left as StagehandZodSchema | undefined,
+      right: z4Def?.right as StagehandZodSchema | undefined,
+    };
+  }
+  const z3Def = getZ3Def(schema);
+  return {
+    left: z3Def?.left as StagehandZodSchema | undefined,
+    right: z3Def?.right as StagehandZodSchema | undefined,
+  };
+}
+
+function getEnumValues(schema: StagehandZodSchema): string[] | undefined {
+  const z4Entries = getZ4Def(schema)?.entries;
+  if (z4Entries && typeof z4Entries === "object") {
+    return Object.values(z4Entries as Record<string, string>);
+  }
+  const z3Values = getZ3Def(schema)?.values;
+  return Array.isArray(z3Values) ? (z3Values as string[]) : undefined;
+}
+
+function getLiteralValues(schema: StagehandZodSchema): unknown[] {
+  const z4Values = getZ4Def(schema)?.values;
+  if (Array.isArray(z4Values)) {
+    return z4Values as unknown[];
+  }
+  const value = getZ3Def(schema)?.value;
+  return typeof value !== "undefined" ? [value] : [];
+}
+
+function getStringChecks(schema: StagehandZodSchema): unknown[] {
+  const z4Checks = getZ4Def(schema)?.checks;
+  if (Array.isArray(z4Checks)) {
+    return z4Checks;
+  }
+  const z3Checks = getZ3Def(schema)?.checks;
+  return Array.isArray(z3Checks) ? z3Checks : [];
+}
+
+function getStringFormat(schema: StagehandZodSchema): string | undefined {
+  const bagFormat = getZ4Bag(schema)?.format;
+  if (typeof bagFormat === "string") {
+    return bagFormat;
+  }
+  const z4Format = getZ4Def(schema)?.format;
+  if (typeof z4Format === "string") {
+    return z4Format;
+  }
+  const z3Format = getZ3Def(schema)?.format;
+  return typeof z3Format === "string" ? z3Format : undefined;
+}
+
+function getPipeEndpoints(schema: StagehandZodSchema): {
+  in?: StagehandZodSchema;
+  out?: StagehandZodSchema;
+} {
+  const z4Def = getZ4Def(schema);
+  if (z4Def?.in || z4Def?.out) {
+    return {
+      in: z4Def?.in as StagehandZodSchema | undefined,
+      out: z4Def?.out as StagehandZodSchema | undefined,
+    };
+  }
+  return {};
+}
+
+function getEffectsBaseSchema(
+  schema: StagehandZodSchema,
+): StagehandZodSchema | undefined {
+  return getZ3Def(schema)?.schema as StagehandZodSchema | undefined;
+}
+
+type SchemaInternals = {
+  _zod?: { def?: Record<string, unknown>; bag?: Record<string, unknown> };
+  _def?: Record<string, unknown>;
+};
+
+export function validateZodSchema(schema: StagehandZodSchema, data: unknown) {
+  const result = schema.safeParse(data);
+
+  if (result.success) {
+    return true;
+  }
+  throw new ZodSchemaValidationError(data, result.error.format());
+}
+
+/**
+ * Detects if the code is running in the Bun runtime environment.
+ * @returns {boolean} True if running in Bun, false otherwise.
+ */
+export function isRunningInBun(): boolean {
+  return (
+    typeof process !== "undefined" &&
+    typeof process.versions !== "undefined" &&
+    "bun" in process.versions
+  );
+}
+
+/*
+ * Helper functions for converting between Gemini and Zod schemas
+ */
+function decorateGeminiSchema(
+  geminiSchema: Schema,
+  zodSchema: z.ZodTypeAny,
+): Schema {
+  if (geminiSchema.nullable === undefined) {
+    geminiSchema.nullable = zodSchema.isOptional();
+  }
+
+  if (zodSchema.description) {
+    geminiSchema.description = zodSchema.description;
+  }
+
+  return geminiSchema;
+}
+
+export function toGeminiSchema(zodSchema: StagehandZodSchema): Schema {
+  const normalizedSchema = zodSchema as z.ZodTypeAny;
+  const zodType = getZodType(zodSchema);
+  switch (zodType) {
+    case "array": {
+      const element = getArrayElement(zodSchema) ?? z.any();
+      return decorateGeminiSchema(
+        {
+          type: Type.ARRAY,
+          items: toGeminiSchema(element),
+        },
+        normalizedSchema,
+      );
+    }
+    case "object": {
+      const properties: Record<string, Schema> = {};
+      const required: string[] = [];
+
+      const shape = getObjectShape(zodSchema);
+      if (shape) {
+        Object.entries(shape).forEach(
+          ([key, value]: [string, StagehandZodSchema]) => {
+            properties[key] = toGeminiSchema(value);
+            if (getZodType(value) !== "optional") {
+              required.push(key);
+            }
+          },
+        );
+      }
+
+      return decorateGeminiSchema(
+        {
+          type: Type.OBJECT,
+          properties,
+          required: required.length > 0 ? required : undefined,
+        },
+        normalizedSchema,
+      );
+    }
+    case "string":
+      return decorateGeminiSchema(
+        {
+          type: Type.STRING,
+        },
+        normalizedSchema,
+      );
+    case "number":
+      return decorateGeminiSchema(
+        {
+          type: Type.NUMBER,
+        },
+        normalizedSchema,
+      );
+    case "boolean":
+      return decorateGeminiSchema(
+        {
+          type: Type.BOOLEAN,
+        },
+        normalizedSchema,
+      );
+    case "enum": {
+      const values = getEnumValues(zodSchema);
+      return decorateGeminiSchema(
+        {
+          type: Type.STRING,
+          enum: values,
+        },
+        normalizedSchema,
+      );
+    }
+    case "default":
+    case "nullable":
+    case "optional": {
+      const innerType = getInnerType(zodSchema) ?? z.any();
+      const innerSchema = toGeminiSchema(innerType);
+      return decorateGeminiSchema(
+        {
+          ...innerSchema,
+          nullable: true,
+        },
+        normalizedSchema,
+      );
+    }
+    case "literal": {
+      const values = getLiteralValues(zodSchema);
+      return decorateGeminiSchema(
+        {
+          type: Type.STRING,
+          enum: values as string[],
+        },
+        normalizedSchema,
+      );
+    }
+    case "pipe": {
+      const endpoints = getPipeEndpoints(zodSchema);
+      if (endpoints.in) {
+        return toGeminiSchema(endpoints.in);
+      }
+      return decorateGeminiSchema(
+        {
+          type: Type.STRING,
+        },
+        normalizedSchema,
+      );
+    }
+    // Standalone transforms and any unknown types fall through to default
+    default:
+      return decorateGeminiSchema(
+        {
+          type: Type.STRING,
+        },
+        normalizedSchema,
+      );
+  }
+}
+
+// Helper function to check the type of Zod schema
+export function getZodType(schema: StagehandZodSchema): string {
+  const schemaWithDef = schema as SchemaInternals & {
+    _zod?: { def?: { type?: string } };
+  };
+  const rawType =
+    (schemaWithDef._zod?.def?.type as string | undefined) ??
+    (schemaWithDef._def?.typeName as string | undefined) ??
+    (schemaWithDef._def?.type as string | undefined);
+
+  if (!rawType) {
+    return "unknown";
+  }
+
+  return TYPE_NAME_MAP[rawType] ?? rawType;
+}
+
+/**
+ * Recursively traverses a given Zod schema, scanning for any fields of type `z.string().url()`.
+ * For each such field, it replaces the `z.string().url()` with `z.number()`.
+ *
+ * This function is used internally by higher-level utilities (e.g., transforming entire object schemas)
+ * and handles nested objects, arrays, unions, intersections, optionals.
+ *
+ * @param schema - The Zod schema to transform.
+ * @param currentPath - An array of string/number keys representing the current schema path (used internally for recursion).
+ * @returns A two-element tuple:
+ *   1. The updated Zod schema, with any `.url()` fields replaced by `z.number()`.
+ *   2. An array of {@link ZodPathSegments} objects representing each replaced field, including the path segments.
+ */
+export function transformSchema(
+  schema: StagehandZodSchema,
+  currentPath: Array<string | number>,
+): [StagehandZodSchema, ZodPathSegments[]] {
+  if (isKind(schema, "string")) {
+    const checks = getStringChecks(schema);
+    const format = getStringFormat(schema);
+    const hasUrlCheck =
+      checks.some((check) => {
+        const candidate = check as {
+          kind?: string;
+          format?: string;
+          _zod?: { def?: { check?: string; format?: string } };
+        };
+        return (
+          candidate.kind === "url" ||
+          candidate.format === "url" ||
+          candidate._zod?.def?.check === "url" ||
+          candidate._zod?.def?.format === "url"
+        );
+      }) || format === "url";
+
+    if (hasUrlCheck) {
+      return [makeIdStringSchema(schema), [{ segments: [] }]];
+    }
+    return [schema, []];
+  }
+
+  if (isKind(schema, "object")) {
+    const shape = getObjectShape(schema);
+    if (!shape) {
+      return [schema, []];
+    }
+    const newShape: Record<string, StagehandZodSchema> = {};
+    const urlPaths: ZodPathSegments[] = [];
+    let changed = false;
+
+    for (const key of Object.keys(shape)) {
+      const child = shape[key];
+      const [transformedChild, childPaths] = transformSchema(child, [
+        ...currentPath,
+        key,
+      ]);
+      if (transformedChild !== child) {
+        changed = true;
+      }
+      newShape[key] = transformedChild;
+      childPaths.forEach((cp) => {
+        urlPaths.push({ segments: [key, ...cp.segments] });
+      });
+    }
+
+    if (changed) {
+      const factory = getZFactory(schema);
+      return [
+        factory.object(newShape as Record<string, z.ZodTypeAny>),
+        urlPaths,
+      ];
+    }
+    return [schema, urlPaths];
+  }
+
+  if (isKind(schema, "array")) {
+    const itemType = getArrayElement(schema);
+    if (!itemType) {
+      return [schema, []];
+    }
+    const [transformedItem, childPaths] = transformSchema(itemType, [
+      ...currentPath,
+      "*",
+    ]);
+    const arrayPaths: ZodPathSegments[] = childPaths.map((cp) => ({
+      segments: ["*", ...cp.segments],
+    }));
+    if (transformedItem !== itemType) {
+      const factory = getZFactory(schema);
+      return [
+        factory.array(transformedItem as unknown as z.ZodTypeAny),
+        arrayPaths,
+      ];
+    }
+    return [schema, arrayPaths];
+  }
+
+  if (isKind(schema, "union")) {
+    const unionOptions = getUnionOptions(schema);
+    if (!unionOptions || unionOptions.length === 0) {
+      return [schema, []];
+    }
+    const newOptions: StagehandZodSchema[] = [];
+    let changed = false;
+    let allPaths: ZodPathSegments[] = [];
+
+    unionOptions.forEach((option, idx) => {
+      const [newOption, childPaths] = transformSchema(option, [
+        ...currentPath,
+        `union_${idx}`,
+      ]);
+      if (newOption !== option) {
+        changed = true;
+      }
+      newOptions.push(newOption);
+      allPaths = [...allPaths, ...childPaths];
+    });
+
+    if (changed) {
+      const factory = getZFactory(schema);
+      return [
+        factory.union(
+          newOptions as unknown as [
+            z.ZodTypeAny,
+            z.ZodTypeAny,
+            ...z.ZodTypeAny[],
+          ],
+        ),
+        allPaths,
+      ];
+    }
+    return [schema, allPaths];
+  }
+
+  if (isKind(schema, "intersection")) {
+    const { left, right } = getIntersectionSides(schema);
+    if (!left || !right) {
+      return [schema, []];
+    }
+    const [newLeft, leftPaths] = transformSchema(left, [
+      ...currentPath,
+      "intersection_left",
+    ]);
+    const [newRight, rightPaths] = transformSchema(right, [
+      ...currentPath,
+      "intersection_right",
+    ]);
+    const changed = newLeft !== left || newRight !== right;
+    const allPaths = [...leftPaths, ...rightPaths];
+    if (changed) {
+      const factory = getZFactory(schema);
+      return [
+        factory.intersection(
+          newLeft as unknown as z.ZodTypeAny,
+          newRight as unknown as z.ZodTypeAny,
+        ),
+        allPaths,
+      ];
+    }
+    return [schema, allPaths];
+  }
+
+  if (isKind(schema, "optional")) {
+    const innerType = getInnerType(schema);
+    if (!innerType) {
+      return [schema, []];
+    }
+    const [inner, innerPaths] = transformSchema(innerType, currentPath);
+    if (inner !== innerType) {
+      return [
+        (inner as z.ZodTypeAny).optional() as unknown as StagehandZodSchema,
+        innerPaths,
+      ];
+    }
+    return [schema, innerPaths];
+  }
+
+  if (isKind(schema, "nullable")) {
+    const innerType = getInnerType(schema);
+    if (!innerType) {
+      return [schema, []];
+    }
+    const [inner, innerPaths] = transformSchema(innerType, currentPath);
+    if (inner !== innerType) {
+      return [
+        (inner as z.ZodTypeAny).nullable() as unknown as StagehandZodSchema,
+        innerPaths,
+      ];
+    }
+    return [schema, innerPaths];
+  }
+
+  if (isKind(schema, "pipe") && isZod4Schema(schema)) {
+    const { in: inSchema, out: outSchema } = getPipeEndpoints(schema);
+    if (!inSchema || !outSchema) {
+      return [schema, []];
+    }
+
+    const [newIn, inPaths] = transformSchema(inSchema, currentPath);
+    const [newOut, outPaths] = transformSchema(outSchema, currentPath);
+    const allPaths = [...inPaths, ...outPaths];
+
+    if (newIn !== inSchema || newOut !== outSchema) {
+      const result = z.pipe(
+        newIn as unknown as z.ZodTypeAny,
+        newOut as unknown as z.ZodTypeAny,
+      ) as StagehandZodSchema;
+      return [result, allPaths];
+    }
+    return [schema, allPaths];
+  }
+
+  if (isKind(schema, "effects")) {
+    const baseSchema = getEffectsBaseSchema(schema);
+    if (!baseSchema) {
+      return [schema, []];
+    }
+    return transformSchema(baseSchema, currentPath);
+  }
+
+  return [schema, []];
+}
+
+/**
+ * Once we get the final extracted object that has numeric IDs in place of URLs,
+ * use `injectUrls` to walk the object and replace numeric IDs
+ * with the real URL strings from idToUrlMapping. The `path` may include `*`
+ * for array indices (indicating "all items in the array").
+ */
+export function injectUrls(
+  obj: unknown,
+  path: Array<string | number>,
+  idToUrlMapping: Record<string, string>,
+): void {
+  if (path.length === 0) return;
+  const toId = (value: unknown): string | undefined => {
+    if (typeof value === "number") {
+      return String(value);
+    }
+    if (typeof value === "string" && ID_PATTERN.test(value)) {
+      return value;
+    }
+    return undefined;
+  };
+  const [key, ...rest] = path;
+
+  if (key === "*") {
+    if (Array.isArray(obj)) {
+      if (rest.length === 0) {
+        for (let i = 0; i < obj.length; i += 1) {
+          const id = toId(obj[i]);
+          if (id !== undefined) {
+            obj[i] = idToUrlMapping[id] ?? "";
+          }
+        }
+      } else {
+        for (const item of obj) injectUrls(item, rest, idToUrlMapping);
+      }
+    }
+    return;
+  }
+
+  if (obj && typeof obj === "object") {
+    const record = obj as Record<string | number, unknown>;
+    if (path.length === 1) {
+      const fieldValue = record[key];
+      const id = toId(fieldValue);
+      if (id !== undefined) {
+        record[key] = idToUrlMapping[id] ?? "";
+      }
+    } else {
+      injectUrls(record[key], rest, idToUrlMapping);
+    }
+  }
+}
+
+// Helper to check if a schema is of a specific type
+function isKind(s: StagehandZodSchema, kind: string): boolean {
+  try {
+    return getZodType(s) === kind;
+  } catch {
+    return false;
+  }
+}
+
+function makeIdStringSchema(orig: StagehandZodSchema): StagehandZodSchema {
+  const userDesc =
+    (orig as unknown as { description?: string }).description ?? "";
+
+  const base =
+    "This field must be the element-ID in the form 'frameId-backendId' " +
+    '(e.g. "0-432").';
+  const composed =
+    userDesc.trim().length > 0
+      ? `${base} that follows this user-defined description: ${userDesc}`
+      : base;
+
+  const factory = getZFactory(orig);
+  return factory.string().regex(ID_PATTERN).describe(composed);
+}
+
+/**
+ * Mapping from LLM provider names to their corresponding environment variable names for API keys.
+ */
+export const providerEnvVarMap: Partial<
+  Record<ModelProvider | string, string | Array<string>>
+> = {
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  google: ["GEMINI_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY", "GOOGLE_API_KEY"],
+  vertex: "GOOGLE_VERTEX_AI_API_KEY",
+  groq: "GROQ_API_KEY",
+  cerebras: "CEREBRAS_API_KEY",
+  togetherai: "TOGETHER_AI_API_KEY",
+  mistral: "MISTRAL_API_KEY",
+  deepseek: "DEEPSEEK_API_KEY",
+  perplexity: "PERPLEXITY_API_KEY",
+  azure: "AZURE_API_KEY",
+  xai: "XAI_API_KEY",
+  google_legacy: "GOOGLE_API_KEY",
+};
+
+const providersWithoutApiKey = new Set(["bedrock", "ollama"]);
+
+/**
+ * Loads an API key for a provider, checking environment variables.
+ * @param provider The name of the provider (e.g., 'openai', 'anthropic')
+ * @param logger Optional logger for info/error messages
+ * @returns The API key if found, undefined otherwise
+ */
+export function loadApiKeyFromEnv(
+  provider: string | undefined,
+  logger: (logLine: LogLine) => void,
+): string | undefined {
+  if (!provider) {
+    return undefined;
+  }
+
+  const envVarName = providerEnvVarMap[provider];
+  if (!envVarName) {
+    if (!providersWithoutApiKey.has(provider)) {
+      logger({
+        category: "init",
+        message: `No known environment variable for provider '${provider}'`,
+        level: 0,
+      });
+    }
+    return undefined;
+  }
+
+  const apiKeyFromEnv = Array.isArray(envVarName)
+    ? envVarName
+        .map((name) => process.env[name])
+        .find((key) => key && key.length > 0)
+    : process.env[envVarName as string];
+  if (typeof apiKeyFromEnv === "string" && apiKeyFromEnv.length > 0) {
+    return apiKeyFromEnv;
+  }
+
+  // Don't log - this is expected when llmClient is provided or API key will be set later
+  return undefined;
+}
+
+export function trimTrailingTextNode(
+  path: string | undefined,
+): string | undefined {
+  return path?.replace(/\/text\(\)(\[\d+\])?$/iu, "");
+}
+
+// TODO: move to separate types file
+export interface JsonSchemaProperty {
+  type: string;
+  enum?: unknown[];
+  items?: JsonSchemaProperty;
+  properties?: Record<string, JsonSchemaProperty>;
+  required?: string[];
+  minimum?: number;
+  maximum?: number;
+  description?: string;
+  format?: string; // JSON Schema format field (e.g., "uri", "url", "email", etc.)
+}
+export interface JsonSchema extends JsonSchemaProperty {
+  type: string;
+}
+
+/**
+ * Converts a JSON Schema object to a Zod schema
+ * @param schema The JSON Schema object to convert
+ * @returns A Zod schema equivalent to the input JSON Schema
+ */
+export function jsonSchemaToZod(schema: JsonSchema): ZodTypeAny {
+  switch (schema.type) {
+    case "object":
+      if (schema.properties) {
+        const shape: Record<string, ZodTypeAny> = {};
+        for (const key in schema.properties) {
+          shape[key] = jsonSchemaToZod(schema.properties[key]);
+        }
+        let zodObject = z.object(shape);
+        if (schema.required && Array.isArray(schema.required)) {
+          const requiredFields = schema.required.reduce<Record<string, true>>(
+            (acc, field) => ({ ...acc, [field]: true }),
+            {},
+          );
+          zodObject = zodObject.partial().required(requiredFields);
+        }
+        if (schema.description) {
+          zodObject = zodObject.describe(schema.description);
+        }
+        return zodObject;
+      } else {
+        return z.object({});
+      }
+    case "array":
+      if (schema.items) {
+        let zodArray = z.array(jsonSchemaToZod(schema.items));
+        if (schema.description) {
+          zodArray = zodArray.describe(schema.description);
+        }
+        return zodArray;
+      } else {
+        return z.array(z.any());
+      }
+    case "string": {
+      if (schema.enum) {
+        return z.string().refine((val) => schema.enum!.includes(val));
+      }
+      let zodString = z.string();
+
+      // Handle JSON Schema format field
+      if (schema.format === "uri" || schema.format === "url") {
+        zodString = zodString.url();
+      } else if (schema.format === "email") {
+        zodString = zodString.email();
+      } else if (schema.format === "uuid") {
+        zodString = zodString.uuid();
+      }
+      // Add more format handlers as needed
+
+      if (schema.description) {
+        zodString = zodString.describe(schema.description);
+      }
+      return zodString;
+    }
+    case "number": {
+      let zodNumber = z.number();
+      if (schema.minimum !== undefined) {
+        zodNumber = zodNumber.min(schema.minimum);
+      }
+      if (schema.maximum !== undefined) {
+        zodNumber = zodNumber.max(schema.maximum);
+      }
+      if (schema.description) {
+        zodNumber = zodNumber.describe(schema.description);
+      }
+      return zodNumber;
+    }
+    case "boolean": {
+      let zodBoolean = z.boolean();
+      if (schema.description) {
+        zodBoolean = zodBoolean.describe(schema.description);
+      }
+      return zodBoolean;
+    }
+    default:
+      return z.any();
+  }
+}
diff --git a/lib/agent/AgentClient.ts b/packages/core/lib/v3/agent/AgentClient.ts
similarity index 88%
rename from lib/agent/AgentClient.ts
rename to packages/core/lib/v3/agent/AgentClient.ts
index ac0aa83af..e09a60595 100644
--- a/lib/agent/AgentClient.ts
+++ b/packages/core/lib/v3/agent/AgentClient.ts
@@ -3,7 +3,8 @@ import {
   AgentResult,
   AgentType,
   AgentExecutionOptions,
-} from "@/types/agent";
+} from "../types/public/agent.js";
+import { ClientOptions } from "../types/public/model.js";
 
 /**
  * Abstract base class for agent clients
@@ -12,7 +13,7 @@ import {
 export abstract class AgentClient {
   public type: AgentType;
   public modelName: string;
-  public clientOptions: Record<string, unknown>;
+  public clientOptions: ClientOptions;
   public userProvidedInstructions?: string;
 
   constructor(
diff --git a/packages/core/lib/v3/agent/AgentProvider.ts b/packages/core/lib/v3/agent/AgentProvider.ts
new file mode 100644
index 000000000..248e61805
--- /dev/null
+++ b/packages/core/lib/v3/agent/AgentProvider.ts
@@ -0,0 +1,129 @@
+import { ToolSet } from "ai/dist";
+import { AgentProviderType } from "../types/public/agent.js";
+import { LogLine } from "../types/public/logs.js";
+import { ClientOptions } from "../types/public/model.js";
+import {
+  UnsupportedModelError,
+  UnsupportedModelProviderError,
+} from "../types/public/sdkErrors.js";
+import { AgentClient } from "./AgentClient.js";
+import { AnthropicCUAClient } from "./AnthropicCUAClient.js";
+import { OpenAICUAClient } from "./OpenAICUAClient.js";
+import { GoogleCUAClient } from "./GoogleCUAClient.js";
+import { MicrosoftCUAClient } from "./MicrosoftCUAClient.js";
+
+// Map model names to their provider types
+export const modelToAgentProviderMap: Record<string, AgentProviderType> = {
+  "computer-use-preview": "openai",
+  "computer-use-preview-2025-03-11": "openai",
+  "claude-sonnet-4-20250514": "anthropic",
+  "claude-sonnet-4-5-20250929": "anthropic",
+  "claude-opus-4-5-20251101": "anthropic",
+  "claude-opus-4-6": "anthropic",
+  "claude-sonnet-4-6": "anthropic",
+  "claude-haiku-4-5-20251001": "anthropic",
+  "gemini-2.5-computer-use-preview-10-2025": "google",
+  "gemini-3-flash-preview": "google",
+  "gemini-3-pro-preview": "google",
+  "fara-7b": "microsoft",
+};
+
+/**
+ * Provider for agent clients
+ * This class is responsible for creating the appropriate agent client
+ * based on the provider type
+ */
+export class AgentProvider {
+  private logger: (message: LogLine) => void;
+
+  /**
+   * Create a new agent provider
+   */
+  constructor(logger: (message: LogLine) => void) {
+    this.logger = logger;
+  }
+
+  getClient(
+    modelName: string,
+    clientOptions?: ClientOptions,
+    userProvidedInstructions?: string,
+    tools?: ToolSet,
+  ): AgentClient {
+    // Check if provider is explicitly set in clientOptions
+    const explicitProvider = clientOptions?.provider as
+      | AgentProviderType
+      | undefined;
+    const type = explicitProvider || AgentProvider.getAgentProvider(modelName);
+
+    this.logger({
+      category: "agent",
+      message: `Getting agent client for type: ${type}, model: ${modelName}${explicitProvider ? " (explicit provider)" : ""}`,
+      level: 2,
+    });
+
+    try {
+      switch (type) {
+        case "openai":
+          return new OpenAICUAClient(
+            type,
+            modelName,
+            userProvidedInstructions,
+            clientOptions,
+            tools,
+          );
+        case "anthropic":
+          return new AnthropicCUAClient(
+            type,
+            modelName,
+            userProvidedInstructions,
+            clientOptions,
+            tools,
+          );
+        case "google":
+          return new GoogleCUAClient(
+            type,
+            modelName,
+            userProvidedInstructions,
+            clientOptions,
+            tools,
+          );
+        case "microsoft":
+          return new MicrosoftCUAClient(
+            type,
+            modelName,
+            userProvidedInstructions,
+            clientOptions,
+          );
+        default:
+          throw new UnsupportedModelProviderError(
+            ["openai", "anthropic", "google", "microsoft"],
+            "Computer Use Agent",
+          );
+      }
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      this.logger({
+        category: "agent",
+        message: `Error creating agent client: ${errorMessage}`,
+        level: 0,
+      });
+      throw error;
+    }
+  }
+
+  static getAgentProvider(modelName: string): AgentProviderType {
+    const normalized = modelName.includes("/")
+      ? modelName.split("/")[1]
+      : modelName;
+
+    if (normalized in modelToAgentProviderMap) {
+      return modelToAgentProviderMap[normalized];
+    }
+
+    throw new UnsupportedModelError(
+      Object.keys(modelToAgentProviderMap),
+      "Computer Use Agent",
+    );
+  }
+}
diff --git a/lib/agent/AnthropicCUAClient.ts b/packages/core/lib/v3/agent/AnthropicCUAClient.ts
similarity index 74%
rename from lib/agent/AnthropicCUAClient.ts
rename to packages/core/lib/v3/agent/AnthropicCUAClient.ts
index fbbc97d82..1df4fa8cf 100644
--- a/lib/agent/AnthropicCUAClient.ts
+++ b/packages/core/lib/v3/agent/AnthropicCUAClient.ts
@@ -1,18 +1,32 @@
-import Anthropic from "@anthropic-ai/sdk";
-import { LogLine } from "@/types/log";
 import {
   AgentAction,
   AgentResult,
   AgentType,
-  AgentExecutionOptions,
-  ToolUseItem,
-  AnthropicMessage,
   AnthropicContentBlock,
+  AnthropicMessage,
   AnthropicTextBlock,
   AnthropicToolResult,
-} from "@/types/agent";
-import { AgentClient } from "./AgentClient";
-import { AgentScreenshotProviderError } from "@/types/stagehandErrors";
+  AgentExecutionOptions,
+  ToolUseItem,
+} from "../types/public/agent.js";
+import { LogLine } from "../types/public/logs.js";
+import { ClientOptions } from "../types/public/model.js";
+import {
+  AgentScreenshotProviderError,
+  StagehandClosedError,
+} from "../types/public/sdkErrors.js";
+import Anthropic from "@anthropic-ai/sdk";
+import { ToolSet } from "ai";
+import { AgentClient } from "./AgentClient.js";
+import { compressConversationImages } from "./utils/imageCompression.js";
+import { toJsonSchema } from "../zodCompat.js";
+import type { StagehandZodSchema } from "../zodCompat.js";
+import {
+  SessionFileLogger,
+  formatCuaPromptPreview,
+  formatCuaResponsePreview,
+} from "../flowLogger.js";
+import { v7 as uuidv7 } from "uuid";
 
 export type ResponseInputItem = AnthropicMessage | AnthropicToolResult;
 
@@ -25,17 +39,19 @@ export class AnthropicCUAClient extends AgentClient {
   private baseURL?: string;
   private client: Anthropic;
   public lastMessageId?: string;
-  private currentViewport = { width: 1024, height: 768 };
+  private currentViewport = { width: 1288, height: 711 };
   private currentUrl?: string;
   private screenshotProvider?: () => Promise<string>;
   private actionHandler?: (action: AgentAction) => Promise<void>;
   private thinkingBudget: number | null = null;
+  private tools?: ToolSet;
 
   constructor(
     type: AgentType,
     modelName: string,
     userProvidedInstructions?: string,
-    clientOptions?: Record<string, unknown>,
+    clientOptions?: ClientOptions,
+    tools?: ToolSet,
   ) {
     super(type, modelName, userProvidedInstructions);
 
@@ -58,11 +74,13 @@ export class AnthropicCUAClient extends AgentClient {
     };
 
     if (this.baseURL) {
-      this.clientOptions.baseUrl = this.baseURL;
+      this.clientOptions.baseURL = this.baseURL;
     }
 
     // Initialize the Anthropic client
     this.client = new Anthropic(this.clientOptions);
+
+    this.tools = tools;
   }
 
   setViewport(width: number, height: number): void {
@@ -81,6 +99,10 @@ export class AnthropicCUAClient extends AgentClient {
     this.actionHandler = handler;
   }
 
+  setTools(tools: ToolSet): void {
+    this.tools = tools;
+  }
+
   /**
    * Execute a task with the Anthropic CUA
    * This is the main entry point for the agent
@@ -107,16 +129,23 @@ export class AnthropicCUAClient extends AgentClient {
       level: 1,
     });
 
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalInferenceTime = 0;
+
     try {
       // Execute steps until completion or max steps reached
       while (!completed && currentStep < maxSteps) {
         logger({
           category: "agent",
           message: `Executing step ${currentStep + 1}/${maxSteps}`,
-          level: 2,
+          level: 1,
         });
 
         const result = await this.executeStep(inputItems, logger);
+        totalInputTokens += result.usage.input_tokens;
+        totalOutputTokens += result.usage.output_tokens;
+        totalInferenceTime += result.usage.inference_time_ms;
 
         // Add actions to the list
         if (result.actions.length > 0) {
@@ -158,6 +187,11 @@ export class AnthropicCUAClient extends AgentClient {
         actions,
         message: finalMessage,
         completed,
+        usage: {
+          input_tokens: totalInputTokens,
+          output_tokens: totalOutputTokens,
+          inference_time_ms: totalInferenceTime,
+        },
       };
     } catch (error) {
       const errorMessage =
@@ -173,6 +207,11 @@ export class AnthropicCUAClient extends AgentClient {
         actions,
         message: `Failed to execute task: ${errorMessage}`,
         completed: false,
+        usage: {
+          input_tokens: totalInputTokens,
+          output_tokens: totalOutputTokens,
+          inference_time_ms: totalInferenceTime,
+        },
       };
     }
   }
@@ -185,11 +224,21 @@ export class AnthropicCUAClient extends AgentClient {
     message: string;
     completed: boolean;
     nextInputItems: ResponseInputItem[];
+    usage: {
+      input_tokens: number;
+      output_tokens: number;
+      inference_time_ms: number;
+    };
   }> {
     try {
       // Get response from the model
       const result = await this.getAction(inputItems);
       const content = result.content;
+      const usage = {
+        input_tokens: result.usage.input_tokens,
+        output_tokens: result.usage.output_tokens,
+        inference_time_ms: result.usage.inference_time_ms,
+      };
 
       logger({
         category: "agent",
@@ -204,10 +253,6 @@ export class AnthropicCUAClient extends AgentClient {
 
       // Process content blocks to find tool use items and text content
       for (const block of content) {
-        // Log the block for debugging
-        console.log("Processing block:", JSON.stringify(block, null, 2));
-
-        // Enhanced logging for debugging
         logger({
           category: "agent",
           message: `Processing block type: ${block.type}, id: ${block.id || "unknown"}`,
@@ -241,6 +286,12 @@ export class AnthropicCUAClient extends AgentClient {
               level: 2,
             });
             stepActions.push(action);
+          } else if (this.tools && toolUseItem.name in this.tools) {
+            stepActions.push({
+              type: "custom_tool",
+              tool: toolUseItem.name,
+              input: toolUseItem.input,
+            } as AgentAction);
           }
         } else if (block.type === "text") {
           // Safe to cast here since we've verified it's a text block
@@ -249,7 +300,7 @@ export class AnthropicCUAClient extends AgentClient {
 
           logger({
             category: "agent",
-            message: `Found text block: ${textBlock.text.substring(0, 50)}...`,
+            message: `Found text block: ${textBlock.text}`,
             level: 2,
           });
         } else {
@@ -272,6 +323,9 @@ export class AnthropicCUAClient extends AgentClient {
             });
             await this.actionHandler(action);
           } catch (error) {
+            if (error instanceof StagehandClosedError) {
+              throw error;
+            }
             const errorMessage =
               error instanceof Error ? error.message : String(error);
             logger({
@@ -294,6 +348,8 @@ export class AnthropicCUAClient extends AgentClient {
       const nextInputItems: ResponseInputItem[] = [...inputItems];
 
       // Add the assistant message with tool_use blocks to the history
+      compressConversationImages(nextInputItems);
+
       nextInputItems.push(assistantMessage);
 
       // Generate tool results and add them as a user message
@@ -301,7 +357,7 @@ export class AnthropicCUAClient extends AgentClient {
         const toolResults = await this.takeAction(toolUseItems, logger);
 
         if (toolResults.length > 0) {
-          // We wrap the tool results in a user message
+          // Tool results are AnthropicToolResult[] which are compatible with AnthropicContentBlock[]
           const userToolResultsMessage: AnthropicMessage = {
             role: "user",
             content: toolResults as unknown as AnthropicContentBlock[],
@@ -324,6 +380,7 @@ export class AnthropicCUAClient extends AgentClient {
         message: message.trim(),
         completed,
         nextInputItems,
+        usage: usage,
       };
     } catch (error) {
       const errorMessage =
@@ -355,6 +412,7 @@ export class AnthropicCUAClient extends AgentClient {
   async getAction(inputItems: ResponseInputItem[]): Promise<{
     content: AnthropicContentBlock[];
     id: string;
+    usage: Record<string, number>;
   }> {
     try {
       // For the API request, we use the inputItems directly
@@ -377,6 +435,23 @@ export class AnthropicCUAClient extends AgentClient {
         ? { type: "enabled" as const, budget_tokens: this.thinkingBudget }
         : undefined;
 
+      // Claude 4.6+ models require the newer computer_20251124 tool version
+      const modelBase = this.modelName.includes("/")
+        ? this.modelName.split("/")[1]
+        : this.modelName;
+      const shouldUseNewToolVersion = [
+        "claude-opus-4-6",
+        "claude-sonnet-4-6",
+        "claude-opus-4-5-20251101",
+      ].includes(modelBase);
+
+      const computerToolType = shouldUseNewToolVersion
+        ? "computer_20251124"
+        : "computer_20250124";
+      const betaFlag = shouldUseNewToolVersion
+        ? "computer-use-2025-11-24"
+        : "computer-use-2025-01-24";
+
       // Create the request parameters
       const requestParams: Record<string, unknown> = {
         model: this.modelName,
@@ -384,16 +459,46 @@ export class AnthropicCUAClient extends AgentClient {
         messages: messages,
         tools: [
           {
-            type: "computer_20250124", // Use the latest version for Claude 3.7 Sonnet
+            type: computerToolType,
             name: "computer",
             display_width_px: this.currentViewport.width,
             display_height_px: this.currentViewport.height,
             display_number: 1,
           },
         ],
-        betas: ["computer-use-2025-01-24"],
+        betas: [betaFlag],
       };
 
+      // Add custom tools if available
+      if (this.tools && Object.keys(this.tools).length > 0) {
+        const customTools = Object.entries(this.tools).map(([name, tool]) => {
+          const schema = tool.inputSchema as StagehandZodSchema;
+
+          // Convert Zod schema to proper JSON schema format for Anthropic
+          const jsonSchema = toJsonSchema(schema) as {
+            properties?: Record<string, unknown>;
+            required?: string[];
+          };
+
+          const inputSchema = {
+            type: "object",
+            properties: jsonSchema.properties || {},
+            required: jsonSchema.required || [],
+          };
+
+          return {
+            name,
+            description: tool.description,
+            input_schema: inputSchema,
+          };
+        });
+
+        requestParams.tools = [
+          ...(requestParams.tools as Record<string, unknown>[]),
+          ...customTools,
+        ];
+      }
+
       // Add system parameter if provided
       if (this.userProvidedInstructions) {
         requestParams.system = this.userProvidedInstructions;
@@ -404,22 +509,36 @@ export class AnthropicCUAClient extends AgentClient {
         requestParams.thinking = thinking;
       }
 
-      // Log the request
-      if (messages.length > 0) {
-        const firstMessage = messages[0];
-        const contentPreview =
-          typeof firstMessage.content === "string"
-            ? firstMessage.content.substring(0, 50)
-            : "complex content";
-
-        console.log(
-          `Sending request to Anthropic with ${messages.length} messages and ${messages.length > 0 ? `first message role: ${messages[0].role}, content: ${contentPreview}...` : "no messages"}`,
-        );
-      }
+      // Log LLM request
+      const llmRequestId = uuidv7();
+      SessionFileLogger.logLlmRequest({
+        requestId: llmRequestId,
+        model: this.modelName,
+        operation: "CUA.getAction",
+        prompt: formatCuaPromptPreview(messages),
+      });
 
+      const startTime = Date.now();
       // Create the message using the Anthropic Messages API
       // @ts-expect-error - The Anthropic SDK types are stricter than what we need
       const response = await this.client.beta.messages.create(requestParams);
+      const endTime = Date.now();
+      const elapsedMs = endTime - startTime;
+      const usage = {
+        input_tokens: response.usage.input_tokens,
+        output_tokens: response.usage.output_tokens,
+        inference_time_ms: elapsedMs,
+      };
+
+      // Log LLM response
+      SessionFileLogger.logLlmResponse({
+        requestId: llmRequestId,
+        model: this.modelName,
+        operation: "CUA.getAction",
+        output: formatCuaResponsePreview(response.content),
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+      });
 
       // Store the message ID for future use
       this.lastMessageId = response.id;
@@ -429,6 +548,7 @@ export class AnthropicCUAClient extends AgentClient {
         // Cast the response content to our internal type
         content: response.content as unknown as AnthropicContentBlock[],
         id: response.id,
+        usage,
       };
     } catch (error) {
       console.error("Error getting action from Anthropic:", error);
@@ -439,8 +559,8 @@ export class AnthropicCUAClient extends AgentClient {
   async takeAction(
     toolUseItems: ToolUseItem[],
     logger: (message: LogLine) => void,
-  ): Promise<ResponseInputItem[]> {
-    const nextInputItems: ResponseInputItem[] = [];
+  ): Promise<AnthropicToolResult[]> {
+    const toolResults: AnthropicToolResult[] = [];
 
     logger({
       category: "agent",
@@ -491,7 +611,7 @@ export class AnthropicCUAClient extends AgentClient {
 
           // Add current URL if available
           if (this.currentUrl) {
-            nextInputItems.push({
+            toolResults.push({
               type: "tool_result",
               tool_use_id: item.id,
               content: [
@@ -503,7 +623,7 @@ export class AnthropicCUAClient extends AgentClient {
               ],
             });
           } else {
-            nextInputItems.push({
+            toolResults.push({
               type: "tool_result",
               tool_use_id: item.id,
               content: imageContent,
@@ -516,16 +636,58 @@ export class AnthropicCUAClient extends AgentClient {
             level: 2,
           });
         } else {
-          // For any other tools, return a simple result as a string
-          nextInputItems.push({
+          // Handle custom tools
+          let toolResult = "Tool executed successfully";
+          if (this.tools && item.name in this.tools) {
+            try {
+              const tool = this.tools[item.name];
+
+              logger({
+                category: "agent",
+                message: `Executing tool call: ${item.name} with args: ${JSON.stringify(item.input)}`,
+                level: 1,
+              });
+
+              const result = await tool.execute(item.input, {
+                toolCallId: item.id,
+                messages: [],
+              });
+              toolResult = JSON.stringify(result);
+
+              logger({
+                category: "agent",
+                message: `Tool ${item.name} completed successfully. Result: ${toolResult}`,
+                level: 1,
+              });
+            } catch (toolError) {
+              const errorMessage =
+                toolError instanceof Error
+                  ? toolError.message
+                  : String(toolError);
+              toolResult = `Error executing tool: ${errorMessage}`;
+
+              logger({
+                category: "agent",
+                message: `Error executing tool ${item.name}: ${errorMessage}`,
+                level: 0,
+              });
+            }
+          }
+
+          toolResults.push({
             type: "tool_result",
             tool_use_id: item.id,
-            content: "Tool executed successfully",
+            content: [
+              {
+                type: "text",
+                text: toolResult,
+              },
+            ],
           });
 
           logger({
             category: "agent",
-            message: `Added generic tool result for tool ${item.name}, tool_use_id: ${item.id}`,
+            message: `Added custom tool result for tool ${item.name}, tool_use_id: ${item.id}`,
             level: 2,
           });
         }
@@ -544,7 +706,7 @@ export class AnthropicCUAClient extends AgentClient {
           if (item.name === "computer") {
             const screenshot = await this.captureScreenshot();
 
-            nextInputItems.push({
+            toolResults.push({
               type: "tool_result",
               tool_use_id: item.id,
               content: [
@@ -569,11 +731,16 @@ export class AnthropicCUAClient extends AgentClient {
               level: 1,
             });
           } else {
-            // For other tools, return an error message as a string
-            nextInputItems.push({
+            // For other tools, return an error message as a text content block
+            toolResults.push({
               type: "tool_result",
               tool_use_id: item.id,
-              content: `Error: ${errorMessage}`,
+              content: [
+                {
+                  type: "text",
+                  text: `Error: ${errorMessage}`,
+                },
+              ],
             });
 
             logger({
@@ -590,10 +757,15 @@ export class AnthropicCUAClient extends AgentClient {
             level: 0,
           });
 
-          nextInputItems.push({
+          toolResults.push({
             type: "tool_result",
             tool_use_id: item.id,
-            content: `Error: ${errorMessage}`,
+            content: [
+              {
+                type: "text",
+                text: `Error: ${errorMessage}`,
+              },
+            ],
           });
 
           logger({
@@ -607,11 +779,11 @@ export class AnthropicCUAClient extends AgentClient {
 
     logger({
       category: "agent",
-      message: `Prepared ${nextInputItems.length} input items for next request`,
+      message: `Prepared ${toolResults.length} tool results for next request`,
       level: 2,
     });
 
-    return nextInputItems;
+    return toolResults;
   }
 
   private convertToolUseToAction(item: ToolUseItem): AgentAction | null {
@@ -647,17 +819,21 @@ export class AnthropicCUAClient extends AgentClient {
             text: input.text as string,
             ...input,
           };
-        } else if (action === "keypress") {
+        } else if (action === "keypress" || action === "key") {
           return {
             type: "keypress",
-            keys: input.keys as string[],
+            keys: [input.text as string],
             ...input,
           };
         } else if (action === "double_click" || action === "doubleClick") {
           return {
-            type: action,
-            x: input.x as number,
-            y: input.y as number,
+            type: "doubleClick",
+            x:
+              (input.x as number) ||
+              (input.coordinate ? (input.coordinate as number[])[0] : 0),
+            y:
+              (input.y as number) ||
+              (input.coordinate ? (input.coordinate as number[])[1] : 0),
             ...input,
           };
         } else if (action === "scroll") {
@@ -713,7 +889,7 @@ export class AnthropicCUAClient extends AgentClient {
             y: y,
             ...input,
           };
-        } else if (action === "drag") {
+        } else if (action === "drag" || action === "left_click_drag") {
           // Make sure path is properly formatted
           const path =
             (input.path as { x: number; y: number }[]) ||
@@ -740,63 +916,6 @@ export class AnthropicCUAClient extends AgentClient {
             type: "wait",
             ...input,
           };
-        } else if (action === "key") {
-          const text = input.text as string;
-          // Convert common key names to a format our handler can understand
-          let mappedKey = text;
-
-          if (
-            text === "Return" ||
-            text === "return" ||
-            text === "Enter" ||
-            text === "enter"
-          ) {
-            mappedKey = "Enter";
-          } else if (text === "Tab" || text === "tab") {
-            mappedKey = "Tab";
-          } else if (
-            text === "Escape" ||
-            text === "escape" ||
-            text === "Esc" ||
-            text === "esc"
-          ) {
-            mappedKey = "Escape";
-          } else if (text === "Backspace" || text === "backspace") {
-            mappedKey = "Backspace";
-          } else if (
-            text === "Delete" ||
-            text === "delete" ||
-            text === "Del" ||
-            text === "del"
-          ) {
-            mappedKey = "Delete";
-          } else if (text === "ArrowUp" || text === "Up" || text === "up") {
-            mappedKey = "ArrowUp";
-          } else if (
-            text === "ArrowDown" ||
-            text === "Down" ||
-            text === "down"
-          ) {
-            mappedKey = "ArrowDown";
-          } else if (
-            text === "ArrowLeft" ||
-            text === "Left" ||
-            text === "left"
-          ) {
-            mappedKey = "ArrowLeft";
-          } else if (
-            text === "ArrowRight" ||
-            text === "Right" ||
-            text === "right"
-          ) {
-            mappedKey = "ArrowRight";
-          }
-
-          return {
-            type: "key",
-            text: mappedKey,
-            ...input,
-          };
         } else if (action === "left_click") {
           // Convert left_click to regular click
           const coordinates = input.coordinate as number[] | undefined;
@@ -812,7 +931,6 @@ export class AnthropicCUAClient extends AgentClient {
           };
         } else {
           // For other computer actions, use the action type directly
-          console.log(`Using default action mapping for ${action}`);
           return {
             type: action,
             ...input,
@@ -824,6 +942,8 @@ export class AnthropicCUAClient extends AgentClient {
           type: name,
           params: input,
         };
+      } else if (this.tools && name in this.tools) {
+        return null;
       }
 
       console.warn(`Unknown tool name: ${name}`);
diff --git a/packages/core/lib/v3/agent/GoogleCUAClient.ts b/packages/core/lib/v3/agent/GoogleCUAClient.ts
new file mode 100644
index 000000000..1845ce9a0
--- /dev/null
+++ b/packages/core/lib/v3/agent/GoogleCUAClient.ts
@@ -0,0 +1,1012 @@
+import {
+  GoogleGenAI,
+  Content,
+  Part,
+  GenerateContentResponse,
+  FunctionCall,
+  GenerateContentConfig,
+  Tool,
+  GoogleGenAIOptions,
+} from "@google/genai";
+import { LogLine } from "../types/public/logs.js";
+import {
+  AgentAction,
+  AgentResult,
+  AgentType,
+  AgentExecutionOptions,
+  SafetyCheck,
+  SafetyConfirmationHandler,
+} from "../types/public/agent.js";
+import { ClientOptions } from "../types/public/model.js";
+import { AgentClient } from "./AgentClient.js";
+import {
+  AgentScreenshotProviderError,
+  LLMResponseError,
+  StagehandClosedError,
+} from "../types/public/sdkErrors.js";
+import { buildGoogleCUASystemPrompt } from "../../prompt.js";
+import { compressGoogleConversationImages } from "./utils/imageCompression.js";
+import { mapKeyToPlaywright } from "./utils/cuaKeyMapping.js";
+import {
+  executeGoogleCustomTool,
+  isCustomTool,
+  convertToolSetToFunctionDeclarations,
+} from "./utils/googleCustomToolHandler.js";
+import { ToolSet } from "ai";
+import {
+  SessionFileLogger,
+  formatCuaPromptPreview,
+  formatCuaResponsePreview,
+} from "../flowLogger.js";
+import { v7 as uuidv7 } from "uuid";
+
+/**
+ * Client for Google's Computer Use Assistant API
+ * This implementation uses the Google Generative AI SDK for Computer Use
+ */
+export class GoogleCUAClient extends AgentClient {
+  private apiKey: string;
+  private client: GoogleGenAI;
+  private currentViewport = { width: 1288, height: 711 };
+  private currentUrl?: string;
+  private screenshotProvider?: () => Promise<string>;
+  private actionHandler?: (action: AgentAction) => Promise<void>;
+  private history: Content[] = [];
+  private environment: "ENVIRONMENT_BROWSER" | "ENVIRONMENT_DESKTOP" =
+    "ENVIRONMENT_BROWSER";
+  private generateContentConfig: GenerateContentConfig;
+  private tools?: ToolSet;
+  private baseURL?: string;
+  private safetyConfirmationHandler?: SafetyConfirmationHandler;
+  constructor(
+    type: AgentType,
+    modelName: string,
+    userProvidedInstructions?: string,
+    clientOptions?: ClientOptions,
+    tools?: ToolSet,
+  ) {
+    super(type, modelName, userProvidedInstructions);
+
+    this.tools = tools;
+    // Process client options
+    this.apiKey =
+      (clientOptions?.apiKey as string) ||
+      process.env.GEMINI_API_KEY ||
+      process.env.GOOGLE_GENERATIVE_AI_API_KEY ||
+      process.env.GOOGLE_API_KEY ||
+      "";
+    this.baseURL = clientOptions?.baseURL as string | undefined;
+
+    // Initialize the Google Generative AI client
+    const genAIOptions: GoogleGenAIOptions = {
+      apiKey: this.apiKey,
+      ...(this.baseURL ? { httpOptions: { baseUrl: this.baseURL } } : {}),
+    };
+    this.client = new GoogleGenAI(genAIOptions);
+
+    // Get environment if specified
+    if (
+      clientOptions?.environment &&
+      typeof clientOptions.environment === "string"
+    ) {
+      this.environment = clientOptions.environment as typeof this.environment;
+    }
+
+    this.generateContentConfig = {
+      temperature: 1,
+      topP: 0.95,
+      topK: 40,
+      maxOutputTokens: 8192,
+      // systemInstruction: this.userProvidedInstructions
+      //   ? { parts: [{ text: this.userProvidedInstructions }] }
+      //   : { parts: [{ text: buildGoogleCUASystemPrompt() }] },
+      tools: [
+        {
+          computerUse: {
+            environment: this.environment,
+          },
+        } as Tool,
+      ],
+    };
+
+    // Store client options for reference
+    this.clientOptions = {
+      apiKey: this.apiKey,
+      ...(this.baseURL ? { baseURL: this.baseURL } : {}),
+    };
+
+    // Initialize tools if provided
+    if (this.tools && Object.keys(this.tools).length > 0) {
+      this.updateGenerateContentConfig();
+    }
+  }
+
+  public setViewport(width: number, height: number): void {
+    this.currentViewport = { width, height };
+  }
+
+  setCurrentUrl(url: string): void {
+    this.currentUrl = url;
+  }
+
+  setScreenshotProvider(provider: () => Promise<string>): void {
+    this.screenshotProvider = provider;
+  }
+
+  setActionHandler(handler: (action: AgentAction) => Promise<void>): void {
+    this.actionHandler = handler;
+  }
+
+  setTools(tools: ToolSet): void {
+    this.tools = tools;
+    this.updateGenerateContentConfig();
+  }
+
+  setSafetyConfirmationHandler(handler?: SafetyConfirmationHandler): void {
+    this.safetyConfirmationHandler = handler;
+  }
+
+  private async handleSafetyConfirmation(
+    safetyDecision: unknown,
+    logger: (message: LogLine) => void,
+  ): Promise<string | undefined> {
+    const safetyMessage =
+      typeof safetyDecision === "object"
+        ? JSON.stringify(safetyDecision, null, 2)
+        : String(safetyDecision);
+
+    const safetyChecks: SafetyCheck[] = [
+      {
+        id: "google-safety-decision",
+        code: "safety_decision",
+        message: safetyMessage,
+      },
+    ];
+
+    if (this.safetyConfirmationHandler) {
+      logger({
+        category: "agent",
+        message: `Requesting safety confirmation for Google safety decision: ${safetyMessage}`,
+        level: 1,
+      });
+
+      const response = await this.safetyConfirmationHandler(safetyChecks);
+
+      if (response.acknowledged) {
+        logger({
+          category: "agent",
+          message: `Safety decision acknowledged by user`,
+          level: 1,
+        });
+        return "true";
+      } else {
+        logger({
+          category: "agent",
+          message: `Safety decision rejected by user`,
+          level: 1,
+        });
+        return undefined;
+      }
+    }
+
+    logger({
+      category: "agent",
+      message: `Auto-acknowledging Google safety decision`,
+      level: 2,
+    });
+    return "true";
+  }
+
+  /**
+   * Update the generateContentConfig with current tools
+   */
+  private updateGenerateContentConfig(): void {
+    const functionDeclarations =
+      this.tools && Object.keys(this.tools).length > 0
+        ? convertToolSetToFunctionDeclarations(this.tools)
+        : [];
+
+    this.generateContentConfig = {
+      ...this.generateContentConfig,
+      tools: [
+        {
+          computerUse: {
+            environment: this.environment,
+          },
+          ...(functionDeclarations.length > 0 ? { functionDeclarations } : {}),
+        } as Tool,
+      ],
+    };
+  }
+
+  /**
+   * Execute a task with the Google CUA
+   * This is the main entry point for the agent
+   * @implements AgentClient.execute
+   */
+  async execute(executionOptions: AgentExecutionOptions): Promise<AgentResult> {
+    const { options, logger } = executionOptions;
+    const { instruction } = options;
+    const maxSteps = options.maxSteps || 10;
+
+    let currentStep = 0;
+    let completed = false;
+    const actions: AgentAction[] = [];
+    const messageList: string[] = [];
+    let finalMessage = "";
+    this.history = []; // Clear history for new execution
+
+    // Start with the initial instruction
+    await this.initializeHistory(instruction);
+
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalInferenceTime = 0;
+
+    try {
+      // Execute steps until completion or max steps reached
+      while (!completed && currentStep < maxSteps) {
+        logger({
+          category: "agent",
+          message: `Executing step ${currentStep + 1}/${maxSteps}`,
+          level: 1,
+        });
+
+        const result = await this.executeStep(logger);
+        totalInputTokens += result.usage.input_tokens;
+        totalOutputTokens += result.usage.output_tokens;
+        totalInferenceTime += result.usage.inference_time_ms;
+
+        // Add actions to the list
+        actions.push(...result.actions);
+
+        // Update completion status
+        completed = result.completed;
+
+        // Record any message for this step
+        if (result.message) {
+          messageList.push(result.message);
+          finalMessage = result.message;
+        }
+
+        // Increment step counter
+        currentStep++;
+      }
+
+      // Return the final result
+      return {
+        success: completed,
+        actions,
+        message: finalMessage,
+        completed,
+        usage: {
+          input_tokens: totalInputTokens,
+          output_tokens: totalOutputTokens,
+          inference_time_ms: totalInferenceTime,
+        },
+      };
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      logger({
+        category: "agent",
+        message: `Error executing agent task: ${errorMessage}`,
+        level: 0,
+      });
+
+      return {
+        success: false,
+        actions,
+        message: `Failed to execute task: ${errorMessage}`,
+        completed: false,
+        usage: {
+          input_tokens: totalInputTokens,
+          output_tokens: totalOutputTokens,
+          inference_time_ms: totalInferenceTime,
+        },
+      };
+    }
+  }
+
+  /**
+   * Initialize conversation history with the initial instruction
+   */
+  private async initializeHistory(instruction: string): Promise<void> {
+    const parts: Part[] = [{ text: instruction }];
+
+    // Note: The Python implementation doesn't include the initial screenshot
+    // Following the same pattern here
+
+    const systemPromptContent = this.userProvidedInstructions
+      ? this.userProvidedInstructions
+      : buildGoogleCUASystemPrompt().content;
+
+    this.history = [
+      {
+        role: "user",
+        parts: [
+          {
+            text: "System prompt: " + systemPromptContent,
+          },
+        ],
+      },
+      {
+        role: "user",
+        parts,
+      },
+    ];
+  }
+
+  /**
+   * Execute a single step of the agent
+   */
+  async executeStep(logger: (message: LogLine) => void): Promise<{
+    actions: AgentAction[];
+    message: string;
+    completed: boolean;
+    usage: {
+      input_tokens: number;
+      output_tokens: number;
+      inference_time_ms: number;
+    };
+  }> {
+    try {
+      const startTime = Date.now();
+
+      // Compress images in conversation history before sending to the model
+      const compressedResult = compressGoogleConversationImages(
+        this.history,
+        2,
+      );
+      const compressedHistory = compressedResult.items;
+
+      // Use the SDK's generateContent method with retry logic (matching Python's get_model_response)
+      const maxRetries = 5;
+      const baseDelayS = 1;
+      let lastError: Error | null = null;
+      let response: GenerateContentResponse | null = null;
+
+      // Log LLM request
+      const llmRequestId = uuidv7();
+      SessionFileLogger.logLlmRequest({
+        requestId: llmRequestId,
+        model: this.modelName,
+        operation: "CUA.generateContent",
+        prompt: formatCuaPromptPreview(compressedHistory),
+      });
+
+      for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+          // Add exponential backoff delay for retries
+          if (attempt > 0) {
+            const delay = baseDelayS * Math.pow(2, attempt) * 1000; // Convert to ms
+            logger({
+              category: "agent",
+              message: `Generating content failed on attempt ${attempt + 1}. Retrying in ${delay / 1000} seconds...`,
+              level: 2,
+            });
+            await new Promise((resolve) => setTimeout(resolve, delay));
+          }
+
+          // Use the SDK's generateContent method - following Python SDK pattern
+          response = await this.client.models.generateContent({
+            model: this.modelName,
+            contents: compressedHistory,
+            config: this.generateContentConfig,
+          });
+
+          // Check if we have valid response content
+          if (!response.candidates || response.candidates.length === 0) {
+            throw new LLMResponseError("agent", "Response has no candidates!");
+          }
+
+          const candidate = response.candidates[0];
+          if (!candidate.content || !candidate.content.parts) {
+            const reason = candidate.finishReason || "unknown";
+            throw new LLMResponseError(
+              "agent",
+              `Response has no content (finish reason: ${reason})`,
+            );
+          }
+
+          // Success - we have a valid response
+          break;
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          logger({
+            category: "agent",
+            message: `API call error: ${lastError.message}`,
+            level: 2,
+          });
+
+          // If this was the last attempt, throw the error
+          if (attempt === maxRetries - 1) {
+            logger({
+              category: "agent",
+              message: `Generating content failed after ${maxRetries} attempts.`,
+              level: 0,
+            });
+            throw lastError;
+          }
+        }
+      }
+
+      if (!response) {
+        throw (
+          lastError || new Error("Failed to get response after all retries")
+        );
+      }
+
+      const endTime = Date.now();
+      const elapsedMs = endTime - startTime;
+      const { usageMetadata } = response;
+
+      // Log LLM response
+      SessionFileLogger.logLlmResponse({
+        requestId: llmRequestId,
+        model: this.modelName,
+        operation: "CUA.generateContent",
+        output: formatCuaResponsePreview(response),
+        inputTokens: usageMetadata?.promptTokenCount,
+        outputTokens: usageMetadata?.candidatesTokenCount,
+      });
+
+      // Process the response
+      const result = await this.processResponse(response, logger);
+
+      // Add model response to history
+      if (response.candidates && response.candidates[0]) {
+        // Sanitize any out-of-range coordinates in function calls before adding to history
+        const sanitizedContent = JSON.parse(
+          JSON.stringify(response.candidates[0].content),
+        );
+        if (sanitizedContent.parts) {
+          for (const part of sanitizedContent.parts) {
+            if (part.functionCall?.args) {
+              if (
+                typeof part.functionCall.args.x === "number" &&
+                part.functionCall.args.x > 999
+              ) {
+                part.functionCall.args.x = 999;
+              }
+              if (
+                typeof part.functionCall.args.y === "number" &&
+                part.functionCall.args.y > 999
+              ) {
+                part.functionCall.args.y = 999;
+              }
+            }
+          }
+        }
+        this.history.push(sanitizedContent);
+      }
+
+      // Execute actions and collect function responses
+      const functionResponses: Part[] = [];
+
+      if (result.actions.length > 0) {
+        let hasError = false;
+
+        // Execute all actions
+        for (let i = 0; i < result.actions.length; i++) {
+          const action = result.actions[i];
+
+          logger({
+            category: "agent",
+            message: `Executing action ${i + 1}/${result.actions.length}: ${action.type}`,
+            level: 2,
+          });
+
+          // Special handling for open_web_browser - don't execute it
+          if (action.type === "open_web_browser") {
+            // Set pageUrl for open_web_browser since it doesn't go through action handler
+            action.pageUrl = this.currentUrl;
+            logger({
+              category: "agent",
+              message: "Skipping open_web_browser action",
+              level: 2,
+            });
+          } else if (action.type === "custom_tool") {
+            const toolName = action.name as string;
+            const toolArgs = action.arguments as Record<string, unknown>;
+
+            if (this.tools && toolName in this.tools) {
+              const correspondingFunctionCall = result.functionCalls.find(
+                (fc) => fc.name === toolName,
+              );
+
+              if (correspondingFunctionCall) {
+                const executionResult = await executeGoogleCustomTool(
+                  toolName,
+                  toolArgs,
+                  this.tools,
+                  correspondingFunctionCall,
+                  logger,
+                );
+
+                functionResponses.push(executionResult.functionResponse);
+
+                if (!executionResult.success) {
+                  hasError = true;
+                }
+              }
+            }
+          } else if (this.actionHandler) {
+            try {
+              await this.actionHandler(action);
+
+              // Add a delay between actions to ensure they complete properly
+              // Longer delay for typing actions to ensure fields are ready
+              if (i < result.actions.length - 1) {
+                const nextAction = result.actions[i + 1];
+                const isTypingAction =
+                  action.type === "type" || nextAction.type === "type";
+                const delay = isTypingAction ? 500 : 200;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+              }
+            } catch (actionError) {
+              if (actionError instanceof StagehandClosedError) {
+                throw actionError;
+              }
+              logger({
+                category: "agent",
+                message: `Error executing action ${action.type}: ${actionError}`,
+                level: 0,
+              });
+              hasError = true;
+              // Continue processing other actions even if one fails
+            }
+          }
+        }
+
+        // Create function responses for computer use actions (non-custom tools)
+        // We need exactly one response per function call, regardless of how many actions were generated
+        if (result.functionCalls.length > 0 || hasError) {
+          // Filter out custom tool function calls as they've already been handled
+          const computerUseFunctionCalls = result.functionCalls.filter(
+            (fc) => !isCustomTool(fc, this.tools),
+          );
+
+          if (computerUseFunctionCalls.length > 0) {
+            try {
+              logger({
+                category: "agent",
+                message: `Taking screenshot after executing ${result.actions.length} actions${hasError ? " (with errors)" : ""}`,
+                level: 2,
+              });
+
+              const screenshot = await this.captureScreenshot();
+              const base64Data = screenshot.replace(
+                /^data:image\/png;base64,/,
+                "",
+              );
+
+              // Create one function response for each computer use function call
+              // Following Python SDK pattern: FunctionResponse with parts containing inline_data
+              for (const functionCall of computerUseFunctionCalls) {
+                let safetyAcknowledgement: string | undefined;
+                if (functionCall.args?.safety_decision) {
+                  safetyAcknowledgement = await this.handleSafetyConfirmation(
+                    functionCall.args.safety_decision,
+                    logger,
+                  );
+                }
+
+                const functionResponsePart: Part = {
+                  functionResponse: {
+                    name: functionCall.name,
+                    response: {
+                      url: this.currentUrl || "",
+                      ...(safetyAcknowledgement !== undefined
+                        ? {
+                            safety_acknowledgement: safetyAcknowledgement,
+                          }
+                        : {}),
+                    },
+                    parts: [
+                      {
+                        inlineData: {
+                          mimeType: "image/png",
+                          data: base64Data,
+                        },
+                      },
+                    ],
+                  },
+                };
+                functionResponses.push(functionResponsePart);
+              }
+            } catch (error) {
+              logger({
+                category: "agent",
+                message: `Error capturing screenshot: ${error}`,
+                level: 0,
+              });
+            }
+          }
+        }
+
+        // Add all function responses to history in a single user message
+        if (functionResponses.length > 0) {
+          logger({
+            category: "agent",
+            message: `Adding ${functionResponses.length} function responses to history`,
+            level: 2,
+          });
+          this.history.push({
+            role: "user",
+            parts: functionResponses,
+          });
+        }
+      }
+
+      return {
+        actions: result.actions,
+        message: result.message,
+        completed: result.completed,
+        usage: {
+          input_tokens: usageMetadata?.promptTokenCount || 0,
+          output_tokens: usageMetadata?.candidatesTokenCount || 0,
+          inference_time_ms: elapsedMs,
+        },
+      };
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      logger({
+        category: "agent",
+        message: `Error executing step: ${errorMessage}`,
+        level: 0,
+      });
+
+      throw error;
+    }
+  }
+
+  /**
+   * Process the response from Google's API
+   */
+  private async processResponse(
+    response: GenerateContentResponse,
+    logger: (message: LogLine) => void,
+  ): Promise<{
+    actions: AgentAction[];
+    message: string;
+    completed: boolean;
+    functionCalls: FunctionCall[];
+  }> {
+    const actions: AgentAction[] = [];
+    let message = "";
+    const functionCalls: FunctionCall[] = [];
+
+    if (!response.candidates || response.candidates.length === 0) {
+      return {
+        actions: [],
+        message: "No candidates in response",
+        completed: true,
+        functionCalls: [],
+      };
+    }
+    const candidate = response.candidates[0];
+
+    // Log the raw response for debugging
+    logger({
+      category: "agent",
+      message: `Raw response from Google: ${JSON.stringify(candidate.content, null, 2)}`,
+      level: 2,
+    });
+
+    // Process all parts - Google can send multiple function calls
+    for (const part of candidate.content.parts) {
+      if (part.text) {
+        message += part.text + "\n";
+        logger({
+          category: "agent",
+          message: `Reasoning: ${part.text}`,
+          level: 1,
+        });
+      }
+      if (part.functionCall) {
+        functionCalls.push(part.functionCall);
+        logger({
+          category: "agent",
+          message: `Found function call: ${part.functionCall.name} with args: ${JSON.stringify(part.functionCall.args)}`,
+          level: 2,
+        });
+
+        // Convert function call to action(s)
+        const action = this.convertFunctionCallToAction(part.functionCall);
+        if (action) {
+          // Special handling for type_text_at - we need to click first
+          if (
+            part.functionCall.name === "type_text_at" &&
+            action.type === "type"
+          ) {
+            logger({
+              category: "agent",
+              message: `Adding action: ${JSON.stringify(action)}`,
+              level: 2,
+            });
+            // First add a click action at the same coordinates
+            actions.push({
+              type: "click",
+              x: action.x,
+              y: action.y,
+              button: "left",
+            });
+
+            // If clear_before_typing is true (default), add a select all
+            if (action.clearBeforeTyping) {
+              // Select all text in the field
+              actions.push({
+                type: "keypress",
+                keys: ["ControlOrMeta+A"],
+              });
+              actions.push({
+                type: "keypress",
+                keys: ["Backspace"],
+              });
+            }
+
+            // Then add the type action
+            actions.push(action);
+            if (action.pressEnter) {
+              actions.push({
+                type: "keypress",
+                keys: ["Enter"],
+              });
+            }
+          } else {
+            actions.push(action);
+          }
+        } else {
+          logger({
+            category: "agent",
+            message: `Warning: Could not convert function call ${part.functionCall.name} to action`,
+            level: 1,
+          });
+        }
+      }
+    }
+
+    // Log summary of what we found
+    logger({
+      category: "agent",
+      message: `Found ${functionCalls.length} function calls, converted to ${actions.length} actions`,
+      level: 2,
+    });
+
+    // Check if task is completed
+    const completed =
+      functionCalls.length === 0 ||
+      (candidate.finishReason && candidate.finishReason !== "STOP");
+
+    return {
+      actions,
+      message: message.trim(),
+      completed,
+      functionCalls,
+    };
+  }
+
+  /**
+   * Convert Google function call to Stagehand action
+   */
+  private convertFunctionCallToAction(
+    functionCall: FunctionCall,
+  ): AgentAction | null {
+    const { name, args } = functionCall;
+
+    if (!name || !args) {
+      return null;
+    }
+
+    switch (name) {
+      case "open_web_browser":
+        return {
+          type: "open_web_browser",
+          timestamp: Date.now(),
+        };
+
+      case "click_at": {
+        const { x, y } = this.normalizeCoordinates(
+          args.x as number,
+          args.y as number,
+        );
+        return {
+          type: "click",
+          x,
+          y,
+          button: args.button || "left",
+        };
+      }
+
+      case "type_text_at": {
+        const { x, y } = this.normalizeCoordinates(
+          args.x as number,
+          args.y as number,
+        );
+        // Google's type_text_at includes press_enter and clear_before_typing parameters
+        const pressEnter = (args.press_enter as boolean) ?? false;
+        const clearBeforeTyping = (args.clear_before_typing as boolean) ?? true;
+
+        // For type_text_at, we need to click first then type
+        // This matches the behavior expected by Google's CUA
+        // We'll handle this in the executeStep method by converting to two actions
+        return {
+          type: "type",
+          text: args.text as string,
+          x,
+          y,
+          pressEnter,
+          clearBeforeTyping,
+        };
+      }
+
+      case "key_combination": {
+        const keys = (args.keys as string)
+          .split("+")
+          .map((key: string) => key.trim())
+          .map((key: string) => mapKeyToPlaywright(key));
+        return {
+          type: "keypress",
+          keys,
+        };
+      }
+
+      case "scroll_document": {
+        const direction = (args.direction as string).toLowerCase();
+        return {
+          type: "keypress",
+          keys: [direction === "up" ? "PageUp" : "PageDown"],
+        };
+      }
+
+      case "scroll_at": {
+        const { x, y } = this.normalizeCoordinates(
+          args.x as number,
+          args.y as number,
+        );
+        const direction = ((args.direction as string) || "down").toLowerCase();
+        const magnitude =
+          typeof args.magnitude === "number" ? (args.magnitude as number) : 800;
+
+        let scroll_x = 0;
+        let scroll_y = 0;
+        if (direction === "up") {
+          scroll_y = -magnitude;
+        } else if (direction === "down") {
+          scroll_y = magnitude;
+        } else if (direction === "left") {
+          scroll_x = -magnitude;
+        } else if (direction === "right") {
+          scroll_x = magnitude;
+        } else {
+          // Default to down if unknown direction
+          scroll_y = magnitude;
+        }
+
+        return {
+          type: "scroll",
+          x,
+          y,
+          scroll_x,
+          scroll_y,
+        };
+      }
+
+      case "navigate":
+        return {
+          type: "goto",
+          url: args.url as string,
+        };
+
+      case "go_back":
+        return {
+          type: "back",
+        };
+
+      case "go_forward":
+        return {
+          type: "forward",
+        };
+
+      case "wait_5_seconds":
+        return {
+          type: "wait",
+          timeMs: 5000, // Google CUA waits for 5 seconds
+        };
+
+      case "hover_at": {
+        const { x, y } = this.normalizeCoordinates(
+          args.x as number,
+          args.y as number,
+        );
+        return {
+          type: "move",
+          x,
+          y,
+        };
+      }
+
+      case "search":
+        return {
+          type: "goto",
+          url: "https://www.google.com",
+        };
+
+      case "drag_and_drop": {
+        const startPoint = this.normalizeCoordinates(
+          args.x as number,
+          args.y as number,
+        );
+        const endPoint = this.normalizeCoordinates(
+          args.destination_x as number,
+          args.destination_y as number,
+        );
+        return {
+          type: "drag",
+          path: [
+            { x: startPoint.x, y: startPoint.y },
+            { x: endPoint.x, y: endPoint.y },
+          ],
+        };
+      }
+
+      default:
+        if (isCustomTool(functionCall, this.tools)) {
+          return {
+            type: "custom_tool",
+            name,
+            arguments: args,
+            timestamp: Date.now(),
+            pageUrl: this.currentUrl,
+          };
+        }
+        console.warn(`Unsupported Google CUA function: ${name}`);
+        return null;
+    }
+  }
+
+  /**
+   * Normalize coordinates from Google's 0-1000 range to viewport dimensions
+   */
+  private normalizeCoordinates(x: number, y: number): { x: number; y: number } {
+    const clampedX = Math.min(999, Math.max(0, x));
+    const clampedY = Math.min(999, Math.max(0, y));
+    return {
+      x: Math.floor((clampedX / 1000) * this.currentViewport.width),
+      y: Math.floor((clampedY / 1000) * this.currentViewport.height),
+    };
+  }
+
+  async captureScreenshot(options?: {
+    base64Image?: string;
+    currentUrl?: string;
+  }): Promise<string> {
+    // Update current URL if provided
+    if (options?.currentUrl) {
+      this.currentUrl = options.currentUrl;
+    }
+
+    // Use provided options if available
+    if (options?.base64Image) {
+      return `data:image/png;base64,${options.base64Image}`;
+    }
+
+    // Use the screenshot provider if available
+    if (this.screenshotProvider) {
+      try {
+        const base64Image = await this.screenshotProvider();
+        return `data:image/png;base64,${base64Image}`;
+      } catch (error) {
+        console.error("Error capturing screenshot:", error);
+        throw error;
+      }
+    }
+
+    throw new AgentScreenshotProviderError(
+      "`screenshotProvider` has not been set. " +
+        "Please call `setScreenshotProvider()` with a valid function that returns a base64-encoded image",
+    );
+  }
+}
diff --git a/packages/core/lib/v3/agent/MicrosoftCUAClient.ts b/packages/core/lib/v3/agent/MicrosoftCUAClient.ts
new file mode 100644
index 000000000..50ef2ff0c
--- /dev/null
+++ b/packages/core/lib/v3/agent/MicrosoftCUAClient.ts
@@ -0,0 +1,942 @@
+import OpenAI from "openai";
+import { LogLine } from "../types/public/logs.js";
+import {
+  AgentAction,
+  AgentResult,
+  AgentType,
+  AgentExecutionOptions,
+} from "../types/public/agent.js";
+import { ClientOptions } from "../types/public/model.js";
+import { AgentClient } from "./AgentClient.js";
+import { AgentScreenshotProviderError } from "../types/public/sdkErrors.js";
+import { mapKeyToPlaywright } from "./utils/cuaKeyMapping.js";
+import { ChatCompletionMessageParam } from "openai/resources/chat/completions";
+
+/**
+ * Message types for FARA agent
+ */
+interface FaraMessage {
+  role: "system" | "user" | "assistant";
+  content: string | FaraMessageContent[];
+}
+
+interface FaraMessageContent {
+  type: "text" | "image_url";
+  text?: string;
+  image_url?: {
+    url: string; // data:image/png;base64,...
+  };
+}
+
+/**
+ * FARA function call structure (parsed from XML tags)
+ */
+interface FaraFunctionCall {
+  name: string; // Always "computer_use"
+  arguments: {
+    action: string;
+    thoughts?: string;
+    [key: string]: unknown;
+  };
+}
+
+/**
+ * Client for FARA (Function-based Autonomous Research Agent) by Microsoft
+ * This implementation uses OpenAI-compatible API with XML-based tool calling
+ */
+export class MicrosoftCUAClient extends AgentClient {
+  private apiKey: string;
+  private baseURL: string;
+  private client: OpenAI;
+  private currentViewport = { width: 1288, height: 711 };
+  private currentUrl?: string;
+  private screenshotProvider?: () => Promise<string>;
+  private actionHandler?: (action: AgentAction) => Promise<void>;
+
+  // Dual history system
+  private conversationHistory: FaraMessage[] = []; // Conceptual flow
+  private actionHistory: FaraMessage[] = []; // Raw model responses
+
+  private maxImages: number = 3;
+  private temperature: number = 0;
+  private facts: string[] = [];
+
+  // FARA-specific MLM processor config
+  private readonly MLM_PROCESSOR_IM_CFG = {
+    min_pixels: 3136,
+    max_pixels: 12845056,
+    patch_size: 14,
+    merge_size: 2,
+  };
+
+  // Resized dimensions for model input
+  private resizedViewport = { width: 1288, height: 711 };
+
+  constructor(
+    type: AgentType,
+    modelName: string,
+    userProvidedInstructions?: string,
+    clientOptions?: ClientOptions,
+  ) {
+    super(type, modelName || "fara-7b", userProvidedInstructions);
+
+    // Process client options
+    this.apiKey =
+      (clientOptions?.apiKey as string) ||
+      process.env.AZURE_API_KEY ||
+      process.env.FIREWORKS_API_KEY ||
+      "";
+    this.baseURL =
+      (clientOptions?.baseURL as string) ||
+      process.env.AZURE_ENDPOINT ||
+      process.env.FIREWORKS_ENDPOINT ||
+      "";
+
+    // Store client options for reference
+    this.clientOptions = {
+      apiKey: this.apiKey,
+      baseURL: this.baseURL,
+    };
+
+    // Validate API key
+    if (!this.apiKey || this.apiKey === "") {
+      throw new Error(
+        "API key is required. Please provide it via clientOptions.apiKey or AZURE_API_KEY or FIREWORKS_API_KEY environment variables.",
+      );
+    }
+
+    // Initialize the OpenAI client (FARA uses OpenAI-compatible API)
+    this.client = new OpenAI({
+      apiKey: this.apiKey,
+      baseURL: this.baseURL,
+    });
+
+    // Max images to keep in history
+    if (clientOptions?.maxImages !== undefined) {
+      this.maxImages = clientOptions.maxImages as number;
+    }
+
+    // Temperature
+    if (clientOptions?.temperature !== undefined) {
+      this.temperature = clientOptions.temperature as number;
+    }
+  }
+
+  setViewport(width: number, height: number): void {
+    this.currentViewport = { width, height };
+    // Compute resized viewport using smart_resize logic
+    this.resizedViewport = this.smartResize(width, height);
+  }
+
+  setCurrentUrl(url: string): void {
+    this.currentUrl = url;
+  }
+
+  setScreenshotProvider(provider: () => Promise<string>): void {
+    this.screenshotProvider = provider;
+  }
+
+  setActionHandler(handler: (action: AgentAction) => Promise<void>): void {
+    this.actionHandler = handler;
+  }
+
+  /**
+   * Smart resize algorithm from FARA
+   * Ensures dimensions are divisible by factor and within pixel limits
+   */
+  private smartResize(
+    width: number,
+    height: number,
+  ): { width: number; height: number } {
+    const { patch_size, merge_size, min_pixels, max_pixels } =
+      this.MLM_PROCESSOR_IM_CFG;
+    const factor = patch_size * merge_size;
+
+    const roundByFactor = (num: number, f: number) => Math.round(num / f) * f;
+    const ceilByFactor = (num: number, f: number) => Math.ceil(num / f) * f;
+    const floorByFactor = (num: number, f: number) => Math.floor(num / f) * f;
+
+    let h_bar = Math.max(factor, roundByFactor(height, factor));
+    let w_bar = Math.max(factor, roundByFactor(width, factor));
+
+    if (h_bar * w_bar > max_pixels) {
+      const beta = Math.sqrt((height * width) / max_pixels);
+      h_bar = floorByFactor(height / beta, factor);
+      w_bar = floorByFactor(width / beta, factor);
+    } else if (h_bar * w_bar < min_pixels) {
+      const beta = Math.sqrt(min_pixels / (height * width));
+      h_bar = ceilByFactor(height * beta, factor);
+      w_bar = ceilByFactor(width * beta, factor);
+    }
+
+    return { width: w_bar, height: h_bar };
+  }
+
+  /**
+   * Generate system prompt with tool description
+   * Simplified to match Python's minimal approach
+   */
+  private generateSystemPrompt(): string {
+    const { width, height } = this.resizedViewport;
+
+    // Base prompt - Minimalist like Python
+    let basePrompt = "You are a helpful assistant.";
+
+    // Add user-provided instructions if available
+    if (this.userProvidedInstructions) {
+      basePrompt = `${basePrompt}\n\n${this.userProvidedInstructions}`;
+    }
+
+    // Tool description from FaraComputerUse
+    const toolDescription = `Use a mouse and keyboard to interact with a computer, and take screenshots.
+* This is an interface to a desktop GUI. You do not have access to a terminal or applications menu. You must click on desktop icons to start applications.
+* Some applications may take time to start or process actions, so you may need to wait and take successive screenshots to see the results of your actions. E.g. if you click on Firefox and a window doesn't open, try wait and taking another screenshot.
+* The screen's resolution is ${width}x${height}.
+* Whenever you intend to move the cursor to click on an element like an icon, you should consult a screenshot to determine the coordinates of the element before moving the cursor.
+* If you tried clicking on a program or link but it failed to load, even after waiting, try adjusting your cursor position so that the tip of the cursor visually falls on the element that you want to click.
+* Make sure to click any buttons, links, icons, etc with the cursor tip in the center of the element. Don't click boxes on their edges unless asked.
+* When a separate scrollable container prominently overlays the webpage, if you want to scroll within it, you typically need to mouse_move() over it first and then scroll().
+* If a popup window appears that you want to close, if left_click() on the 'X' or close button doesn't work, try key(keys=['Escape']) to close it.
+* On some search bars, when you type(), you may need to press_enter=False and instead separately call left_click() on the search button to submit the search query. This is especially true of search bars that have auto-suggest popups for e.g. locations
+* For calendar widgets, you usually need to left_click() on arrows to move between months and left_click() on dates to select them; type() is not typically used to input dates there.`;
+
+    // Tool parameters description
+    const actionsDescription = `The action to perform. The available actions are:
+* \`key\`: Performs key down presses on the arguments passed in order, then performs key releases in reverse order. Includes "Enter", "Alt", "Shift", "Tab", "Control", "Backspace", "Delete", "Escape", "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "PageDown", "PageUp", "Shift", etc.
+* \`type\`: Type a string of text on the keyboard.
+* \`mouse_move\`: Move the cursor to a specified (x, y) pixel coordinate on the screen.
+* \`left_click\`: Click the left mouse button.
+* \`scroll\`: Performs a scroll of the mouse scroll wheel.
+* \`history_back\`: Go back to the previous page in the browser history.
+* \`pause_and_memorize_fact\`: Pause and memorize a fact for future reference.
+* \`visit_url\`: Visit a specified URL.
+* \`web_search\`: Perform a web search with a specified query.
+* \`wait\`: Wait specified seconds for the change to happen.
+* \`terminate\`: Terminate the current task and report its completion status.`;
+
+    // Tool JSON schema
+    const toolSchema = {
+      name: "computer_use",
+      description: toolDescription,
+      parameters: {
+        type: "object",
+        required: ["action"],
+        properties: {
+          action: {
+            type: "string",
+            description: actionsDescription,
+            enum: [
+              "key",
+              "type",
+              "mouse_move",
+              "left_click",
+              "scroll",
+              "visit_url",
+              "web_search",
+              "history_back",
+              "pause_and_memorize_fact",
+              "wait",
+              "terminate",
+            ],
+          },
+          keys: {
+            type: "array",
+            description: "Required only by `action=key`.",
+          },
+          text: {
+            type: "string",
+            description: "Required only by `action=type`.",
+          },
+          press_enter: {
+            type: "boolean",
+            description:
+              "Whether to press the Enter key after typing. Required only by `action=type`.",
+          },
+          delete_existing_text: {
+            type: "boolean",
+            description:
+              "Whether to delete existing text before typing. Required only by `action=type`.",
+          },
+          coordinate: {
+            type: "array",
+            description:
+              "(x, y): The x (pixels from the left edge) and y (pixels from the top edge) coordinates to move the mouse to. Required only by `action=left_click`, `action=mouse_move`, and `action=type`.",
+          },
+          pixels: {
+            type: "number",
+            description:
+              "The amount of scrolling to perform. Positive values scroll up, negative values scroll down. Required only by `action=scroll`.",
+          },
+          fact: {
+            type: "string",
+            description:
+              "The fact to remember for the future. Required only by `action=pause_and_memorize_fact`.",
+          },
+          time: {
+            type: "number",
+            description: "The seconds to wait. Required only by `action=wait`.",
+          },
+          status: {
+            type: "string",
+            description:
+              "The status of the task. Required only by `action=terminate`.",
+            enum: ["success", "failure"],
+          },
+        },
+      },
+    };
+
+    // Format as FARA function calling template (FN_CALL_TEMPLATE format)
+    const toolDescs = JSON.stringify(toolSchema, null, 2);
+    const functionCallTemplate = `
+You are provided with function signatures within <tools></tools> XML tags:
+<tools>
+${toolDescs}
+</tools>
+
+For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
+<tool_call>
+{{"name": <function-name>, "arguments": <args-json-object>}}
+</tool_call>`;
+
+    return `${basePrompt}\n\n${functionCallTemplate}`;
+  }
+
+  /**
+   * Parse thoughts and action from model response
+   * FARA uses XML-based tool calling: <tool_call>\n{...}\n</tool_call>
+   */
+  private parseThoughtsAndAction(response: string): {
+    thoughts: string;
+    functionCall: FaraFunctionCall;
+  } {
+    try {
+      const parts = response.split("<tool_call>\n");
+      const thoughts = parts[0].trim();
+      const actionText = parts[1].split("\n</tool_call>")[0].trim();
+
+      let parsedAction;
+      try {
+        parsedAction = JSON.parse(actionText);
+      } catch (jsonError) {
+        // Fix common malformed JSON: double opening brackets {{"name": ...}}
+        // This happens when the model adds an extra opening brace
+        if (actionText.startsWith("{{") && actionText.endsWith("}")) {
+          // Remove the extra opening brace
+          const fixedText = actionText.slice(1);
+          try {
+            parsedAction = JSON.parse(fixedText);
+          } catch (retryError) {
+            throw new Error(
+              `Failed to parse action text even after fixing double brackets. Original: ${actionText}. Fixed: ${fixedText}. Error: ${retryError}`,
+              { cause: retryError },
+            );
+          }
+        } else {
+          throw new Error(
+            `Failed to parse action text as JSON: ${actionText}. Error: ${jsonError}`,
+            { cause: jsonError },
+          );
+        }
+      }
+
+      return {
+        thoughts,
+        functionCall: {
+          name: parsedAction.name || "computer_use",
+          arguments: {
+            ...parsedAction.arguments,
+            thoughts,
+          },
+        },
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to parse FARA tool call from response: ${response}. Error: ${error}`,
+        { cause: error },
+      );
+    }
+  }
+
+  /**
+   * Convert FARA function call to Stagehand AgentAction
+   */
+  private convertFunctionCallToAction(
+    functionCall: FaraFunctionCall,
+  ): AgentAction {
+    const args = functionCall.arguments;
+    const action = args.action as string;
+
+    // Transform coordinates from resized to original viewport
+    const transformCoordinate = (coord: number[]): number[] => {
+      if (!coord || coord.length !== 2) return coord;
+      const [x, y] = coord;
+      const scaleX = this.currentViewport.width / this.resizedViewport.width;
+      const scaleY = this.currentViewport.height / this.resizedViewport.height;
+      return [Math.round(x * scaleX), Math.round(y * scaleY)];
+    };
+
+    const baseAction = {
+      type: action,
+      reasoning: args.thoughts as string,
+    };
+
+    switch (action) {
+      case "left_click": {
+        const clickCoord = transformCoordinate(args.coordinate as number[]);
+        return {
+          ...baseAction,
+          type: "click",
+          x: clickCoord[0],
+          y: clickCoord[1],
+          button: "left" as const,
+        };
+      }
+
+      case "mouse_move": {
+        const moveCoord = transformCoordinate(args.coordinate as number[]);
+        return {
+          ...baseAction,
+          type: "move",
+          coordinate: moveCoord,
+        };
+      }
+
+      case "type": {
+        const typeCoord = args.coordinate
+          ? transformCoordinate(args.coordinate as number[])
+          : undefined;
+        return {
+          ...baseAction,
+          text: args.text as string,
+          ...(typeCoord && { x: typeCoord[0], y: typeCoord[1] }),
+          press_enter:
+            args.press_enter !== undefined
+              ? (args.press_enter as boolean)
+              : true,
+          ...(args.delete_existing_text !== undefined && {
+            delete_existing_text: args.delete_existing_text as boolean,
+          }),
+        };
+      }
+
+      case "key":
+      case "keypress": {
+        const keys = (args.keys as string[]) || [];
+        // Normalize keys to Playwright format
+        const normalizedKeys = keys.map((k) => mapKeyToPlaywright(k));
+        return {
+          ...baseAction,
+          type: "keypress",
+          keys: normalizedKeys,
+        };
+      }
+
+      case "scroll": {
+        const pixels = (args.pixels as number) || 0;
+        // FARA: positive = scroll up, negative = scroll down
+        // Convert to scroll_x/scroll_y
+        return {
+          ...baseAction,
+          scroll_x: 0,
+          scroll_y: -pixels, // Invert: negative pixels = scroll down
+        };
+      }
+
+      case "visit_url": {
+        let url = args.url as string;
+        // Enhanced URL processing like Python
+        if (
+          !url.startsWith("https://") &&
+          !url.startsWith("http://") &&
+          !url.startsWith("file://") &&
+          !url.startsWith("about:")
+        ) {
+          // If URL contains space, treat as search query
+          if (url.includes(" ")) {
+            url = `https://www.bing.com/search?q=${encodeURIComponent(url)}&FORM=QBLH`;
+          } else {
+            // Otherwise prefix with https://
+            url = "https://" + url;
+          }
+        }
+        return {
+          ...baseAction,
+          type: "goto",
+          url,
+        };
+      }
+
+      case "web_search": {
+        // Convert web search to visit_url with Bing search
+        const query = args.query as string;
+        const searchUrl = `https://www.bing.com/search?q=${encodeURIComponent(query)}&FORM=QBLH`;
+        return {
+          ...baseAction,
+          type: "goto",
+          url: searchUrl,
+        };
+      }
+
+      case "history_back":
+        return {
+          ...baseAction,
+          type: "back",
+        };
+
+      case "wait": {
+        // Support both 'time' and 'duration' parameters with default (matches Python)
+        const durationSeconds =
+          (args.time as number) || (args.duration as number) || 3.0;
+        return {
+          ...baseAction,
+          timeMs: durationSeconds * 1000, // Convert seconds to ms
+        };
+      }
+
+      case "pause_and_memorize_fact": {
+        // Store the fact for future reference (matches Python)
+        const fact = args.fact as string;
+        this.facts.push(fact);
+        return {
+          ...baseAction,
+          fact,
+        };
+      }
+
+      case "terminate":
+        return {
+          ...baseAction,
+          status: args.status as string,
+        };
+
+      default:
+        return {
+          ...baseAction,
+          ...args,
+        };
+    }
+  }
+
+  /**
+   * Capture a screenshot and return as base64 data URL
+   */
+  async captureScreenshot(): Promise<string> {
+    if (!this.screenshotProvider) {
+      throw new AgentScreenshotProviderError("Screenshot provider not set");
+    }
+
+    const base64Screenshot = await this.screenshotProvider();
+    return `data:image/png;base64,${base64Screenshot}`;
+  }
+
+  /**
+   * Remove old screenshots from history
+   * Matches Python's maybe_remove_old_screenshots
+   */
+  private maybeRemoveOldScreenshots(
+    history: FaraMessage[],
+    includesCurrent: boolean = false,
+  ): FaraMessage[] {
+    if (this.maxImages <= 0) {
+      return history;
+    }
+
+    const maxImages = includesCurrent ? this.maxImages : this.maxImages - 1;
+    const newHistory: FaraMessage[] = [];
+    let nImages = 0;
+
+    // Iterate backwards
+    for (let i = history.length - 1; i >= 0; i--) {
+      const msg = history[i];
+
+      // Check if message has image
+      let hasImage = false;
+      if (Array.isArray(msg.content)) {
+        hasImage = msg.content.some((c) => c.type === "image_url");
+      }
+
+      if (i === 0 && nImages >= maxImages) {
+        // First message (task) - preserve text, remove image
+        if (Array.isArray(msg.content)) {
+          const newContent = msg.content.filter((c) => c.type !== "image_url");
+          // If no content left, skip (unless it's the only message, but Python logic says continue)
+          if (newContent.length === 0) {
+            continue;
+          }
+          newHistory.push({ ...msg, content: newContent });
+        } else {
+          newHistory.push(msg);
+        }
+        continue;
+      }
+
+      if (hasImage) {
+        if (nImages < maxImages) {
+          newHistory.push(msg);
+          nImages++;
+        } else {
+          // Remove image, keep text
+          if (Array.isArray(msg.content)) {
+            const newContent = msg.content.filter(
+              (c) => c.type !== "image_url",
+            );
+            // If content becomes empty, we can skip this message entirely (unless it's meaningful text)
+            // Python logic: if msg is None continue.
+            if (newContent.length > 0) {
+              newHistory.push({ ...msg, content: newContent });
+            }
+          } else {
+            newHistory.push(msg);
+          }
+        }
+      } else {
+        newHistory.push(msg);
+      }
+    }
+
+    return newHistory.reverse();
+  }
+
+  /**
+   * Reconstruct history for API call
+   * Merges conceptual chat history with raw action history
+   */
+  private reconstructHistory(): FaraMessage[] {
+    const history: FaraMessage[] = [];
+    let actionTurn = 0;
+
+    for (let i = 0; i < this.conversationHistory.length; i++) {
+      const m = this.conversationHistory[i];
+      if (m.role === "assistant") {
+        if (actionTurn >= this.actionHistory.length) {
+          // Should not happen if synced correctly
+          console.warn("OUT OF SYNC: Action history shorter than chat history");
+          history.push(m);
+        } else {
+          history.push(this.actionHistory[actionTurn]);
+          actionTurn++;
+        }
+      } else {
+        history.push(m);
+      }
+    }
+
+    return this.maybeRemoveOldScreenshots(history);
+  }
+
+  /**
+   * Execute a single step
+   */
+  private async executeStep(
+    logger: (message: LogLine) => void,
+    isFirstRound: boolean = false,
+  ): Promise<{
+    actions: AgentAction[];
+    completed: boolean;
+    usage: {
+      input_tokens: number;
+      output_tokens: number;
+      inference_time_ms: number;
+    };
+  }> {
+    // Capture screenshot
+    const screenshotDataUrl = await this.captureScreenshot();
+
+    // Update conversation history with new screenshot/message
+    if (isFirstRound) {
+      // First round: modify the last message (initial user instruction) to include screenshot
+      const lastMessage =
+        this.conversationHistory[this.conversationHistory.length - 1];
+      if (lastMessage && lastMessage.role === "user") {
+        const originalContent =
+          typeof lastMessage.content === "string"
+            ? lastMessage.content
+            : (lastMessage.content.find((c) => c.type === "text")?.text ??
+              "Start task");
+
+        lastMessage.content = [
+          {
+            type: "image_url",
+            image_url: { url: screenshotDataUrl },
+          },
+          {
+            type: "text",
+            text: originalContent,
+          },
+        ];
+      }
+    } else {
+      // Subsequent rounds: add new user message with screenshot
+      const userContent: FaraMessageContent[] = [
+        {
+          type: "image_url",
+          image_url: { url: screenshotDataUrl },
+        },
+      ];
+
+      // Add current URL if available
+      let textPrompt =
+        "Here is the next screenshot. Think about what to do next.";
+      if (this.currentUrl) {
+        const trimmedUrl =
+          this.currentUrl.length > 100
+            ? this.currentUrl.slice(0, 100) + "..."
+            : this.currentUrl;
+        textPrompt = `Current URL: ${trimmedUrl}\n${textPrompt}`;
+      }
+
+      userContent.push({
+        type: "text",
+        text: textPrompt,
+      });
+
+      this.conversationHistory.push({
+        role: "user",
+        content: userContent,
+      });
+    }
+
+    // Reconstruct history for model call
+    let history = this.reconstructHistory();
+
+    // Prepend system prompt (generated fresh)
+    const systemMessage: FaraMessage = {
+      role: "system",
+      content: this.generateSystemPrompt(),
+    };
+    history = [systemMessage, ...history];
+
+    // Make API call
+    logger({
+      category: "agent",
+      message: `Making API call to FARA model with ${history.length} messages`,
+      level: 2,
+    });
+
+    const startTime = Date.now();
+    let response;
+    try {
+      response = await this.client.chat.completions.create({
+        model: this.modelName,
+        messages: history as unknown as ChatCompletionMessageParam[],
+        temperature: this.temperature,
+      });
+    } catch (apiError) {
+      logger({
+        category: "agent",
+        message: `API call failed: ${apiError instanceof Error ? apiError.message : String(apiError)}`,
+        level: 0,
+      });
+      throw apiError;
+    }
+    const inferenceTime = Date.now() - startTime;
+
+    logger({
+      category: "agent",
+      message: `API call completed in ${inferenceTime}ms`,
+      level: 2,
+    });
+
+    const content = response.choices[0].message.content || "";
+    const usage = response.usage || {
+      prompt_tokens: 0,
+      completion_tokens: 0,
+      total_tokens: 0,
+    };
+
+    // Add assistant response to both histories
+    const assistantMsg: FaraMessage = {
+      role: "assistant",
+      content,
+    };
+    this.conversationHistory.push(assistantMsg);
+    this.actionHistory.push(assistantMsg);
+
+    logger({
+      category: "agent",
+      message: `Model response: ${content}`,
+      level: 2,
+    });
+
+    // Parse tool call
+    const { thoughts, functionCall } = this.parseThoughtsAndAction(content);
+
+    logger({
+      category: "agent",
+      message: `Thoughts: ${thoughts}`,
+      level: 2,
+    });
+
+    logger({
+      category: "agent",
+      message: `Action: ${JSON.stringify(functionCall.arguments)}`,
+      level: 2,
+    });
+
+    // Convert to AgentAction
+    const agentAction = this.convertFunctionCallToAction(functionCall);
+
+    // Expand type action into multiple actions if it has coordinates
+    const actions: AgentAction[] = [];
+    if (
+      agentAction.type === "type" &&
+      typeof agentAction.x === "number" &&
+      typeof agentAction.y === "number"
+    ) {
+      // First, click at the coordinates to focus the field
+      actions.push({
+        type: "click",
+        x: agentAction.x,
+        y: agentAction.y,
+        button: "left",
+      });
+
+      // If delete_existing_text is true, clear the field first
+      if (agentAction.delete_existing_text) {
+        actions.push({
+          type: "keypress",
+          keys: ["Command+A"],
+        });
+        actions.push({
+          type: "keypress",
+          keys: ["Backspace"],
+        });
+      }
+
+      // Add the type action (without coordinates since we already clicked)
+      actions.push({
+        type: "type",
+        text: agentAction.text,
+      });
+
+      // If press_enter is true (default), press Enter after typing
+      if (agentAction.press_enter !== false) {
+        actions.push({
+          type: "keypress",
+          keys: ["Enter"],
+        });
+      }
+    } else {
+      // For all other actions, just add as-is
+      actions.push(agentAction);
+    }
+
+    // Execute all actions if handler is available
+    if (this.actionHandler && agentAction.type !== "terminate") {
+      for (const action of actions) {
+        await this.actionHandler(action);
+      }
+    }
+
+    // Check if completed
+    const completed = functionCall.arguments.action === "terminate";
+
+    return {
+      actions,
+      completed,
+      usage: {
+        input_tokens: usage.prompt_tokens,
+        output_tokens: usage.completion_tokens,
+        inference_time_ms: inferenceTime,
+      },
+    };
+  }
+
+  /**
+   * Execute a task with the FARA CUA
+   * This is the main entry point for the agent
+   * @implements AgentClient.execute
+   */
+  async execute(executionOptions: AgentExecutionOptions): Promise<AgentResult> {
+    const { options, logger } = executionOptions;
+    const { instruction } = options;
+    const maxSteps = options.maxSteps || 10;
+
+    let currentStep = 0;
+    let completed = false;
+    const actions: AgentAction[] = [];
+    const messageList: string[] = [];
+    let finalMessage: string;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalInferenceTime = 0;
+
+    // Initialize conversation with user instruction
+    // System prompt is NOT added here, it's added dynamically in executeStep
+    this.conversationHistory = [
+      {
+        role: "user",
+        content: instruction,
+      },
+    ];
+    this.actionHistory = [];
+
+    try {
+      // Execute steps until completion or max steps reached
+      while (!completed && currentStep < maxSteps) {
+        logger({
+          category: "agent",
+          message: `Executing step ${currentStep + 1}/${maxSteps}`,
+          level: 1,
+        });
+
+        const isFirstRound = currentStep === 0;
+        const result = await this.executeStep(logger, isFirstRound);
+        totalInputTokens += result.usage.input_tokens;
+        totalOutputTokens += result.usage.output_tokens;
+        totalInferenceTime += result.usage.inference_time_ms;
+
+        // Add actions to the list
+        actions.push(...result.actions);
+
+        // Update completion status
+        completed = result.completed;
+
+        currentStep++;
+
+        // Record message for this step
+        const lastAction = result.actions[result.actions.length - 1];
+        if (lastAction?.reasoning) {
+          messageList.push(lastAction.reasoning);
+        }
+      }
+
+      // Generate final message
+      if (completed) {
+        const lastAction = actions[actions.length - 1];
+        finalMessage =
+          (lastAction as { status?: string })?.status === "success"
+            ? "Task completed successfully."
+            : "Task completed with failures.";
+      } else {
+        finalMessage = `Reached maximum steps (${maxSteps}) without completion.`;
+      }
+
+      if (messageList.length > 0) {
+        finalMessage = `${messageList.join("\n\n")}\n\n${finalMessage}`;
+      }
+
+      return {
+        success: completed,
+        completed,
+        message: finalMessage,
+        actions,
+        usage: {
+          input_tokens: totalInputTokens,
+          output_tokens: totalOutputTokens,
+          inference_time_ms: totalInferenceTime,
+        },
+      };
+    } catch (error) {
+      logger({
+        category: "agent",
+        message: `Error during execution: ${error}`,
+        level: 0,
+      });
+
+      // Rethrow to allow eval runner's retry logic to handle transient errors
+      throw error;
+    }
+  }
+}
diff --git a/lib/agent/OpenAICUAClient.ts b/packages/core/lib/v3/agent/OpenAICUAClient.ts
similarity index 62%
rename from lib/agent/OpenAICUAClient.ts
rename to packages/core/lib/v3/agent/OpenAICUAClient.ts
index 6a494300b..638308e28 100644
--- a/lib/agent/OpenAICUAClient.ts
+++ b/packages/core/lib/v3/agent/OpenAICUAClient.ts
@@ -1,5 +1,5 @@
 import OpenAI from "openai";
-import { LogLine } from "../../types/log";
+import { LogLine } from "../types/public/logs.js";
 import {
   AgentAction,
   AgentResult,
@@ -9,9 +9,22 @@ import {
   ResponseItem,
   ComputerCallItem,
   FunctionCallItem,
-} from "@/types/agent";
-import { AgentClient } from "./AgentClient";
-import { AgentScreenshotProviderError } from "@/types/stagehandErrors";
+  SafetyCheck,
+  SafetyConfirmationHandler,
+} from "../types/public/agent.js";
+import { ClientOptions } from "../types/public/model.js";
+import { AgentClient } from "./AgentClient.js";
+import {
+  AgentScreenshotProviderError,
+  StagehandClosedError,
+} from "../types/public/sdkErrors.js";
+import { ToolSet } from "ai";
+import {
+  SessionFileLogger,
+  formatCuaPromptPreview,
+  formatCuaResponsePreview,
+} from "../flowLogger.js";
+import { v7 as uuidv7 } from "uuid";
 
 /**
  * Client for OpenAI's Computer Use Assistant API
@@ -23,24 +36,28 @@ export class OpenAICUAClient extends AgentClient {
   private baseURL: string;
   private client: OpenAI;
   public lastResponseId?: string;
-  private currentViewport = { width: 1024, height: 768 };
+  private currentViewport = { width: 1288, height: 711 };
   private currentUrl?: string;
   private screenshotProvider?: () => Promise<string>;
   private actionHandler?: (action: AgentAction) => Promise<void>;
   private reasoningItems: Map<string, ResponseItem> = new Map();
   private environment: string = "browser"; // "browser", "mac", "windows", or "ubuntu"
+  private tools?: ToolSet;
+  private safetyConfirmationHandler?: SafetyConfirmationHandler;
 
   constructor(
     type: AgentType,
     modelName: string,
     userProvidedInstructions?: string,
-    clientOptions?: Record<string, unknown>,
+    clientOptions?: ClientOptions,
+    tools?: ToolSet,
   ) {
     super(type, modelName, userProvidedInstructions);
 
     // Process client options
     this.apiKey =
       (clientOptions?.apiKey as string) || process.env.OPENAI_API_KEY || "";
+    this.baseURL = (clientOptions?.baseURL as string) || undefined;
     this.organization =
       (clientOptions?.organization as string) || process.env.OPENAI_ORG;
 
@@ -57,8 +74,14 @@ export class OpenAICUAClient extends AgentClient {
       apiKey: this.apiKey,
     };
 
+    if (this.baseURL) {
+      this.clientOptions.baseURL = this.baseURL;
+    }
+
     // Initialize the OpenAI client
     this.client = new OpenAI(this.clientOptions);
+
+    this.tools = tools;
   }
 
   setViewport(width: number, height: number): void {
@@ -77,6 +100,14 @@ export class OpenAICUAClient extends AgentClient {
     this.actionHandler = handler;
   }
 
+  setTools(tools: ToolSet): void {
+    this.tools = tools;
+  }
+
+  setSafetyConfirmationHandler(handler?: SafetyConfirmationHandler): void {
+    this.safetyConfirmationHandler = handler;
+  }
+
   /**
    * Execute a task with the OpenAI CUA
    * This is the main entry point for the agent
@@ -97,6 +128,9 @@ export class OpenAICUAClient extends AgentClient {
     // Start with the initial instruction
     let inputItems = this.createInitialInputItems(instruction);
     let previousResponseId: string | undefined = undefined;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalInferenceTime = 0;
 
     try {
       // Execute steps until completion or max steps reached
@@ -104,7 +138,7 @@ export class OpenAICUAClient extends AgentClient {
         logger({
           category: "agent",
           message: `Executing step ${currentStep + 1}/${maxSteps}`,
-          level: 2,
+          level: 1,
         });
 
         const result = await this.executeStep(
@@ -112,6 +146,9 @@ export class OpenAICUAClient extends AgentClient {
           previousResponseId,
           logger,
         );
+        totalInputTokens += result.usage.input_tokens;
+        totalOutputTokens += result.usage.output_tokens;
+        totalInferenceTime += result.usage.inference_time_ms;
 
         // Add actions to the list
         actions.push(...result.actions);
@@ -143,6 +180,11 @@ export class OpenAICUAClient extends AgentClient {
         actions,
         message: finalMessage,
         completed,
+        usage: {
+          input_tokens: totalInputTokens,
+          output_tokens: totalOutputTokens,
+          inference_time_ms: totalInferenceTime,
+        },
       };
     } catch (error) {
       const errorMessage =
@@ -158,6 +200,11 @@ export class OpenAICUAClient extends AgentClient {
         actions,
         message: `Failed to execute task: ${errorMessage}`,
         completed: false,
+        usage: {
+          input_tokens: totalInputTokens,
+          output_tokens: totalOutputTokens,
+          inference_time_ms: totalInferenceTime,
+        },
       };
     }
   }
@@ -176,17 +223,32 @@ export class OpenAICUAClient extends AgentClient {
     completed: boolean;
     nextInputItems: ResponseInputItem[];
     responseId: string;
+    usage: {
+      input_tokens: number;
+      output_tokens: number;
+      inference_time_ms: number;
+    };
   }> {
     try {
       // Get response from the model
       const result = await this.getAction(inputItems, previousResponseId);
       const output = result.output;
       const responseId = result.responseId;
+      const usage = {
+        input_tokens: result.usage.input_tokens,
+        output_tokens: result.usage.output_tokens,
+        inference_time_ms: result.usage.inference_time_ms,
+      };
 
       // Add any reasoning items to our map
       for (const item of output) {
         if (item.type === "reasoning") {
           this.reasoningItems.set(item.id, item);
+          logger({
+            category: "agent",
+            message: `Reasoning: ${String(item.content || "")}`,
+            level: 1,
+          });
         }
       }
 
@@ -194,17 +256,37 @@ export class OpenAICUAClient extends AgentClient {
       const stepActions: AgentAction[] = [];
       for (const item of output) {
         if (item.type === "computer_call" && this.isComputerCallItem(item)) {
+          logger({
+            category: "agent",
+            message: `Found computer_call: ${item.action.type}, call_id: ${item.call_id}`,
+            level: 2,
+          });
           const action = this.convertComputerCallToAction(item);
           if (action) {
             stepActions.push(action);
+            logger({
+              category: "agent",
+              message: `Converted computer_call to action: ${action.type}`,
+              level: 2,
+            });
           }
         } else if (
           item.type === "function_call" &&
           this.isFunctionCallItem(item)
         ) {
+          logger({
+            category: "agent",
+            message: `Found function_call: ${item.name}, call_id: ${item.call_id}`,
+            level: 2,
+          });
           const action = this.convertFunctionCallToAction(item);
           if (action) {
             stepActions.push(action);
+            logger({
+              category: "agent",
+              message: `Converted function_call to action: ${action.type}`,
+              level: 2,
+            });
           }
         }
       }
@@ -213,10 +295,20 @@ export class OpenAICUAClient extends AgentClient {
       let message = "";
       for (const item of output) {
         if (item.type === "message") {
+          logger({
+            category: "agent",
+            message: `Found message block`,
+            level: 2,
+          });
           if (item.content && Array.isArray(item.content)) {
             for (const content of item.content) {
               if (content.type === "output_text" && content.text) {
                 message += content.text + "\n";
+                logger({
+                  category: "agent",
+                  message: `Message text: ${String(content.text || "")}`,
+                  level: 1,
+                });
               }
             }
           }
@@ -239,6 +331,7 @@ export class OpenAICUAClient extends AgentClient {
         completed,
         nextInputItems,
         responseId,
+        usage: usage,
       };
     } catch (error) {
       const errorMessage =
@@ -262,6 +355,45 @@ export class OpenAICUAClient extends AgentClient {
     );
   }
 
+  private async handleSafetyConfirmation(
+    pendingSafetyChecks: SafetyCheck[],
+    logger: (message: LogLine) => void,
+  ): Promise<SafetyCheck[] | undefined> {
+    if (this.safetyConfirmationHandler) {
+      logger({
+        category: "agent",
+        message: `Requesting safety confirmation for ${pendingSafetyChecks.length} check(s): ${pendingSafetyChecks.map((c) => c.code).join(", ")}`,
+        level: 1,
+      });
+
+      const response =
+        await this.safetyConfirmationHandler(pendingSafetyChecks);
+
+      if (response.acknowledged) {
+        logger({
+          category: "agent",
+          message: `Safety checks acknowledged by user`,
+          level: 1,
+        });
+        return pendingSafetyChecks;
+      } else {
+        logger({
+          category: "agent",
+          message: `Safety checks rejected by user`,
+          level: 1,
+        });
+        return undefined;
+      }
+    }
+
+    logger({
+      category: "agent",
+      message: `Auto-acknowledging ${pendingSafetyChecks.length} safety check(s)`,
+      level: 2,
+    });
+    return pendingSafetyChecks;
+  }
+
   private isFunctionCallItem(item: ResponseItem): item is FunctionCallItem {
     return (
       item.type === "function_call" &&
@@ -291,6 +423,7 @@ export class OpenAICUAClient extends AgentClient {
   ): Promise<{
     output: ResponseItem[];
     responseId: string;
+    usage: Record<string, number>;
   }> {
     try {
       // Create the request parameters
@@ -308,14 +441,61 @@ export class OpenAICUAClient extends AgentClient {
         truncation: "auto",
       };
 
+      // Add custom tools if available
+      if (this.tools && Object.keys(this.tools).length > 0) {
+        const customTools = Object.entries(this.tools).map(([name, tool]) => ({
+          type: "function" as const,
+          name,
+          function: {
+            name,
+            description: tool.description,
+            parameters: tool.inputSchema,
+          },
+        }));
+
+        requestParams.tools = [
+          ...(requestParams.tools as Record<string, unknown>[]),
+          ...customTools,
+        ];
+      }
+
       // Add previous_response_id if available
       if (previousResponseId) {
         requestParams.previous_response_id = previousResponseId;
       }
 
+      // Log LLM request
+      const llmRequestId = uuidv7();
+      SessionFileLogger.logLlmRequest({
+        requestId: llmRequestId,
+        model: this.modelName,
+        operation: "CUA.getAction",
+        prompt: formatCuaPromptPreview(inputItems),
+      });
+
+      const startTime = Date.now();
       // Create the response using the OpenAI Responses API
       // @ts-expect-error - Force type to match what the OpenAI SDK expects
       const response = await this.client.responses.create(requestParams);
+      const endTime = Date.now();
+      const elapsedMs = endTime - startTime;
+
+      // Extract only the input_tokens and output_tokens
+      const usage = {
+        input_tokens: response.usage.input_tokens,
+        output_tokens: response.usage.output_tokens,
+        inference_time_ms: elapsedMs,
+      };
+
+      // Log LLM response
+      SessionFileLogger.logLlmResponse({
+        requestId: llmRequestId,
+        model: this.modelName,
+        operation: "CUA.getAction",
+        output: formatCuaResponsePreview(response.output),
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+      });
 
       // Store the response ID for future use
       this.lastResponseId = response.id;
@@ -324,6 +504,7 @@ export class OpenAICUAClient extends AgentClient {
       return {
         output: response.output as unknown as ResponseItem[],
         responseId: response.id,
+        usage,
       };
     } catch (error) {
       console.error("Error getting action from OpenAI:", error);
@@ -337,14 +518,19 @@ export class OpenAICUAClient extends AgentClient {
   ): Promise<ResponseInputItem[]> {
     const nextInputItems: ResponseInputItem[] = [];
 
-    // Add any computer calls to process
+    // Process each output item
     for (const item of output) {
       if (item.type === "computer_call" && this.isComputerCallItem(item)) {
-        // Execute the action
+        // Handle computer calls
         try {
           const action = this.convertComputerCallToAction(item);
 
           if (action && this.actionHandler) {
+            logger({
+              category: "agent",
+              message: `Executing computer action: ${action.type}`,
+              level: 1,
+            });
             await this.actionHandler(action);
           }
 
@@ -361,6 +547,12 @@ export class OpenAICUAClient extends AgentClient {
             },
           } as ResponseInputItem;
 
+          logger({
+            category: "agent",
+            message: `Added computer_call_output for call_id: ${item.call_id}`,
+            level: 2,
+          });
+
           // Add current URL if available
           if (this.currentUrl) {
             const computerCallOutput = outputItem as {
@@ -371,39 +563,40 @@ export class OpenAICUAClient extends AgentClient {
                 image_url: string;
                 current_url?: string;
               };
-              acknowledged_safety_checks?: Array<{
-                id: string;
-                code: string;
-                message: string;
-              }>;
+              acknowledged_safety_checks?: SafetyCheck[];
             };
             computerCallOutput.output.current_url = this.currentUrl;
           }
 
-          // Add any safety checks that need to be acknowledged
           if (
             item.pending_safety_checks &&
             item.pending_safety_checks.length > 0
           ) {
-            const computerCallOutput = outputItem as {
-              type: "computer_call_output";
-              call_id: string;
-              output: {
-                type: "input_image";
-                image_url: string;
+            const acknowledgedChecks = await this.handleSafetyConfirmation(
+              item.pending_safety_checks,
+              logger,
+            );
+
+            if (acknowledgedChecks) {
+              const computerCallOutput = outputItem as {
+                type: "computer_call_output";
+                call_id: string;
+                output: {
+                  type: "input_image";
+                  image_url: string;
+                };
+                acknowledged_safety_checks?: SafetyCheck[];
               };
-              acknowledged_safety_checks?: Array<{
-                id: string;
-                code: string;
-                message: string;
-              }>;
-            };
-            computerCallOutput.acknowledged_safety_checks =
-              item.pending_safety_checks;
+              computerCallOutput.acknowledged_safety_checks =
+                acknowledgedChecks;
+            }
           }
 
           nextInputItems.push(outputItem);
         } catch (error) {
+          if (error instanceof StagehandClosedError) {
+            throw error;
+          }
           const errorMessage =
             error instanceof Error ? error.message : String(error);
 
@@ -437,39 +630,40 @@ export class OpenAICUAClient extends AgentClient {
                   image_url: string;
                   current_url?: string;
                 };
-                acknowledged_safety_checks?: Array<{
-                  id: string;
-                  code: string;
-                  message: string;
-                }>;
+                acknowledged_safety_checks?: SafetyCheck[];
               };
               computerCallOutput.output.current_url = this.currentUrl;
             }
 
-            // Add any safety checks that need to be acknowledged
             if (
               item.pending_safety_checks &&
               item.pending_safety_checks.length > 0
             ) {
-              const computerCallOutput = errorOutputItem as {
-                type: "computer_call_output";
-                call_id: string;
-                output: {
-                  type: "input_image";
-                  image_url: string;
+              const acknowledgedChecks = await this.handleSafetyConfirmation(
+                item.pending_safety_checks,
+                logger,
+              );
+
+              if (acknowledgedChecks) {
+                const computerCallOutput = errorOutputItem as {
+                  type: "computer_call_output";
+                  call_id: string;
+                  output: {
+                    type: "input_image";
+                    image_url: string;
+                  };
+                  acknowledged_safety_checks?: SafetyCheck[];
                 };
-                acknowledged_safety_checks?: Array<{
-                  id: string;
-                  code: string;
-                  message: string;
-                }>;
-              };
-              computerCallOutput.acknowledged_safety_checks =
-                item.pending_safety_checks;
+                computerCallOutput.acknowledged_safety_checks =
+                  acknowledgedChecks;
+              }
             }
 
             nextInputItems.push(errorOutputItem);
           } catch (screenshotError) {
+            if (screenshotError instanceof StagehandClosedError) {
+              throw screenshotError;
+            }
             // If we can't capture a screenshot, just send the error
             logger({
               category: "agent",
@@ -489,7 +683,7 @@ export class OpenAICUAClient extends AgentClient {
         item.type === "function_call" &&
         this.isFunctionCallItem(item)
       ) {
-        // Execute the function
+        // Handle function calls (tool calls)
         try {
           const action = this.convertFunctionCallToAction(item);
 
@@ -497,13 +691,57 @@ export class OpenAICUAClient extends AgentClient {
             await this.actionHandler(action);
           }
 
-          // Add the result
-          nextInputItems.push({
+          // Execute the tool if available
+          let toolResult = "Tool executed successfully";
+          if (this.tools && item.name in this.tools) {
+            try {
+              const tool = this.tools[item.name];
+              const args = JSON.parse(item.arguments);
+
+              logger({
+                category: "agent",
+                message: `Executing tool call: ${item.name} with args: ${item.arguments}`,
+                level: 1,
+              });
+
+              const result = await tool.execute(args, {
+                toolCallId: item.call_id,
+                messages: [],
+              });
+              toolResult = JSON.stringify(result);
+
+              logger({
+                category: "agent",
+                message: `Tool ${item.name} completed successfully. Result: ${toolResult}`,
+                level: 1,
+              });
+            } catch (toolError) {
+              const errorMessage =
+                toolError instanceof Error
+                  ? toolError.message
+                  : String(toolError);
+              toolResult = `Error executing tool: ${errorMessage}`;
+
+              logger({
+                category: "agent",
+                message: `Error executing tool ${item.name}: ${errorMessage}`,
+                level: 0,
+              });
+            }
+          }
+
+          // Create a function_call_output for the next request
+          const outputItem: ResponseInputItem = {
             type: "function_call_output",
             call_id: item.call_id,
-            output: "success",
-          });
+            output: toolResult,
+          };
+
+          nextInputItems.push(outputItem);
         } catch (error) {
+          if (error instanceof StagehandClosedError) {
+            throw error;
+          }
           const errorMessage =
             error instanceof Error ? error.message : String(error);
 
@@ -513,11 +751,14 @@ export class OpenAICUAClient extends AgentClient {
             level: 0,
           });
 
-          nextInputItems.push({
+          // Send error result back
+          const errorOutputItem: ResponseInputItem = {
             type: "function_call_output",
             call_id: item.call_id,
             output: `Error: ${errorMessage}`,
-          });
+          };
+
+          nextInputItems.push(errorOutputItem);
         }
       }
     }
diff --git a/packages/core/lib/v3/agent/prompts/agentSystemPrompt.ts b/packages/core/lib/v3/agent/prompts/agentSystemPrompt.ts
new file mode 100644
index 000000000..7f236b117
--- /dev/null
+++ b/packages/core/lib/v3/agent/prompts/agentSystemPrompt.ts
@@ -0,0 +1,273 @@
+import type { AgentToolMode, Variables } from "../../types/public/agent.js";
+
+export interface AgentSystemPromptOptions {
+  url: string;
+  executionInstruction: string;
+  mode: AgentToolMode;
+  systemInstructions?: string;
+  /** Whether running on Browserbase (enables captcha solver messaging) */
+  isBrowserbase?: boolean;
+  /** Tools to exclude from the system prompt */
+  excludeTools?: string[];
+  /** Variables available to the agent for use in act/type tools */
+  variables?: Variables;
+}
+
+/**
+ * Builds the system prompt for the agent based on the tool mode.
+ *
+ * @param options - The prompt configuration options
+ * @returns The formatted system prompt string
+ */
+interface ToolDefinition {
+  name: string;
+  description: string;
+}
+
+function buildToolsSection(
+  isHybridMode: boolean,
+  hasSearch: boolean,
+  excludeTools?: string[],
+): string {
+  const excludeSet = new Set(excludeTools ?? []);
+
+  const hybridTools: ToolDefinition[] = [
+    {
+      name: "screenshot",
+      description: "Take a compressed JPEG screenshot for quick visual context",
+    },
+    {
+      name: "ariaTree",
+      description:
+        "Get an accessibility (ARIA) hybrid tree for full page context",
+    },
+    {
+      name: "click",
+      description:
+        "Click on an element (PREFERRED - more reliable when element is visible in viewport)",
+    },
+    {
+      name: "type",
+      description:
+        "Type text into an element (PREFERRED - more reliable when element is visible in viewport)",
+    },
+    {
+      name: "act",
+      description:
+        "Perform a specific atomic action (click, type, etc.) - ONLY use when element is in ariaTree but NOT visible in screenshot. Less reliable but can interact with out-of-viewport elements.",
+    },
+    { name: "dragAndDrop", description: "Drag and drop an element" },
+    { name: "clickAndHold", description: "Click and hold on an element" },
+    { name: "keys", description: "Press a keyboard key" },
+    {
+      name: "fillFormVision",
+      description: "Fill out a form using coordinates",
+    },
+    { name: "think", description: "Think about the task" },
+    { name: "extract", description: "Extract structured data" },
+    { name: "goto", description: "Navigate to a URL" },
+    { name: "wait", description: "Wait for a specified time" },
+    { name: "navback", description: "Navigate back in browser history" },
+    { name: "scroll", description: "Scroll the page x pixels up or down" },
+  ];
+
+  const domTools: ToolDefinition[] = [
+    {
+      name: "screenshot",
+      description: "Take a compressed JPEG screenshot for quick visual context",
+    },
+    {
+      name: "ariaTree",
+      description:
+        "Get an accessibility (ARIA) hybrid tree for full page context",
+    },
+    {
+      name: "act",
+      description: "Perform a specific atomic action (click, type)",
+    },
+    { name: "keys", description: "Press a keyboard key" },
+    { name: "fillForm", description: "Fill out a form" },
+    { name: "think", description: "Think about the task" },
+    { name: "extract", description: "Extract structured data" },
+    { name: "goto", description: "Navigate to a URL" },
+    { name: "wait", description: "Wait for a specified time" },
+    { name: "navback", description: "Navigate back in browser history" },
+    { name: "scroll", description: "Scroll the page x pixels up or down" },
+  ];
+
+  const baseTools = isHybridMode ? hybridTools : domTools;
+
+  if (hasSearch) {
+    baseTools.push({
+      name: "search",
+      description:
+        "Perform a web search and return results. Prefer this over navigating to Google and searching within the page for reliability and efficiency.",
+    });
+  }
+
+  const filteredTools = baseTools.filter((tool) => !excludeSet.has(tool.name));
+
+  const toolLines = filteredTools
+    .map((tool) => `    <tool name="${tool.name}">${tool.description}</tool>`)
+    .join("\n");
+
+  return `<tools>\n${toolLines}\n  </tools>`;
+}
+
+export function buildAgentSystemPrompt(
+  options: AgentSystemPromptOptions,
+): string {
+  const {
+    url,
+    executionInstruction,
+    mode,
+    systemInstructions,
+    isBrowserbase = false,
+    excludeTools,
+    variables,
+  } = options;
+  const localeDate = new Date().toLocaleDateString();
+  const isoDate = new Date().toISOString();
+  const cdata = (text: string) => `<![CDATA[${text}]]>`;
+
+  const isHybridMode = mode === "hybrid";
+  const hasSearch = Boolean(process.env.BRAVE_API_KEY);
+
+  // Tools section differs based on mode and excluded tools
+  const toolsSection = buildToolsSection(isHybridMode, hasSearch, excludeTools);
+
+  // Strategy differs based on mode
+  const strategyItems = isHybridMode
+    ? [
+        `<item>Tool selection priority: Use specific tools (click, type) when elements are visible in viewport for maximum reliability.</item>`,
+        `<item>Always use screenshot to get proper grounding of the coordinates you want to type/click into.</item>`,
+        `<item>When interacting with an input, always use the type tool to type into the input, over clicking and then typing into it.</item>`,
+        `<item>Use ariaTree as a secondary tool when elements aren't visible in screenshot or to get full page context.</item>`,
+        `<item>Only use act when element is in ariaTree but NOT visible in screenshot.</item>`,
+      ]
+    : [
+        `<item>Tool selection priority: Use act tool for all clicking and typing on a page.</item>`,
+        `<item>Always check ariaTree first to understand full page content without scrolling - it shows all elements including those below the fold.</item>`,
+        `<item>When interacting with an input, always use the act tool to type into the input, over clicking and then typing.</item>`,
+        `<item>If an element is present in the ariaTree, use act to interact with it directly - this eliminates the need to scroll.</item>`,
+        `<item>Use screenshot for visual confirmation when needed, but rely primarily on ariaTree for element detection.</item>`,
+      ];
+
+  const strategySection = strategyItems.join("\n    ");
+
+  const commonStrategyItems = `
+    <item>CRITICAL: Use extract ONLY when the task explicitly requires structured data output (e.g., "get job listings", "extract product details"). For reading page content or understanding elements, always use ${isHybridMode ? "screenshot or ariaTree" : "ariaTree"} instead - it's faster and more reliable.</item>
+    <item>Keep actions atomic and verify outcomes before proceeding.</item>
+    <item>For each action, provide clear reasoning about why you're taking that step.</item>
+    <item>When you need to input text that could be entered character-by-character or through multiple separate inputs, prefer using the keys tool to type the entire sequence at once. This is more efficient for scenarios like verification codes split across multiple fields, or when virtual keyboards are present but direct typing would be faster.</item>
+    `;
+
+  // Page understanding protocol differs based on mode
+  const pageUnderstandingProtocol = isHybridMode
+    ? `<page_understanding_protocol>
+    <step_1>
+      <title>UNDERSTAND THE PAGE</title>
+      <primary_tool>
+        <name>screenshot</name>
+        <usage>Visual confirmation when needed. Ideally after navigating to a new page.</usage>
+        </primary_tool>
+      <secondary_tool>
+        <name>ariaTree</name>
+        <usage>Get complete page context before taking actions</usage>
+        <benefit>Eliminates the need to scroll and provides full accessible content</benefit>
+      </secondary_tool>
+    </step_1>
+  </page_understanding_protocol>`
+    : `<page_understanding_protocol>
+    <step_1>
+      <title>UNDERSTAND THE PAGE</title>
+      <primary_tool>
+        <name>ariaTree</name>
+        <usage>Get complete page context before taking actions</usage>
+        <benefit>Eliminates the need to scroll and provides full accessible content</benefit>
+        </primary_tool>
+      <secondary_tool>
+        <name>screenshot</name>
+        <usage>Visual confirmation when needed. Ideally after navigating to a new page.</usage>
+      </secondary_tool>
+    </step_1>
+  </page_understanding_protocol>`;
+
+  // Roadblocks section only shown when running on Browserbase (has captcha solver)
+  const roadblocksSection = isBrowserbase
+    ? `<roadblocks>
+    <note>captchas, popups, etc.</note>
+    <captcha>If you see a captcha, use the wait tool. It will automatically be solved by our internal solver.</captcha>
+  </roadblocks>`
+    : "";
+
+  // Build customInstructions block only if provided
+  const customInstructionsBlock = systemInstructions
+    ? `<customInstructions>${cdata(systemInstructions)}</customInstructions>\n  `
+    : "";
+
+  // Build variables section only if variables are provided
+  const hasVariables = variables && Object.keys(variables).length > 0;
+  const variableToolsNote = isHybridMode
+    ? "Use %variableName% syntax in the type, fillFormVision, or act tool's value/text/action fields."
+    : "Use %variableName% syntax in the act or fillForm tool's value/action fields.";
+  const variablesSection = hasVariables
+    ? `<variables>
+    <note>You have access to the following variables. Use %variableName% syntax to substitute variable values. This is especially important for sensitive data like passwords.</note>
+    <usage>${variableToolsNote}</usage>
+    <example>To type a password, use: type %password% into the password field</example>
+    ${Object.entries(variables)
+      .map(([name, v]) => {
+        const description =
+          typeof v === "object" && v !== null && "value" in v
+            ? v.description
+            : undefined;
+        return description
+          ? `<variable name="${name}">${description}</variable>`
+          : `<variable name="${name}" />`;
+      })
+      .join("\n    ")}
+  </variables>`
+    : "";
+
+  return `<system>
+  <identity>You are a web automation assistant using browser automation tools to accomplish the user's goal.</identity>
+  ${customInstructionsBlock}<task>
+    <goal>${cdata(executionInstruction)}</goal>
+    <date display="local" iso="${isoDate}">${localeDate}</date>
+    <note>You may think the date is different due to knowledge cutoff, but this is the actual date.</note>
+  </task>
+  <page>
+    <startingUrl>you are starting your task on this url: ${url}</startingUrl>
+  </page>
+  <mindset>
+    <note>Be very intentional about your action. The initial instruction is very important, and slight variations of the actual goal can lead to failures.</note>
+    <importantNote>If something fails to meet a single condition of the task, move on from it rather than seeing if it meets other criteria. We only care that it meets all of it</importantNote>
+    <note>When the task is complete, do not seek more information; you have completed the task.</note>
+  </mindset>
+  <guidelines>
+    <item>Always start by understanding the current page state</item>
+    <item>Use the screenshot tool to verify page state when needed</item>
+    <item>Use appropriate tools for each action</item>
+  </guidelines>
+  ${pageUnderstandingProtocol}
+  <navigation>
+    <rule>If you are confident in the URL, navigate directly to it.</rule>
+    ${hasSearch ? `<rule>If you are not confident in the URL, use the search tool to find it.</rule>` : ``}
+  </navigation>
+  ${toolsSection}
+  <strategy>
+    ${strategySection}
+    ${commonStrategyItems}
+  </strategy>
+  ${roadblocksSection}
+  ${variablesSection}
+  <completion>
+    <note>When you complete the task, explain any information that was found that was relevant to the original task.</note>
+    <examples>
+      <example>If you were asked for specific flights, list the flights you found.</example>
+      <example>If you were asked for information about a product, list the product information you were asked for.</example>
+    </examples>
+  </completion>
+</system>`;
+}
diff --git a/packages/core/lib/v3/agent/tools/README.md b/packages/core/lib/v3/agent/tools/README.md
new file mode 100644
index 000000000..0b8d866a2
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/README.md
@@ -0,0 +1,4 @@
+This folder provides v3-native agent tools for the AISDK-based agent flow.
+They mirror the v2 tools but operate on the V3 CDP-native APIs.
+
+Files are placed under lib/v3/agent/tools and consumed by V3AgentHandler.
diff --git a/packages/core/lib/v3/agent/tools/act.ts b/packages/core/lib/v3/agent/tools/act.ts
new file mode 100644
index 000000000..0f0edfe10
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/act.ts
@@ -0,0 +1,85 @@
+import { tool } from "ai";
+import { z } from "zod";
+import type { V3 } from "../../v3.js";
+import type { Action } from "../../types/public/methods.js";
+import type { AgentModelConfig, Variables } from "../../types/public/agent.js";
+import { TimeoutError } from "../../types/public/sdkErrors.js";
+
+export const actTool = (
+  v3: V3,
+  executionModel?: string | AgentModelConfig,
+  variables?: Variables,
+  toolTimeout?: number,
+) => {
+  const hasVariables = variables && Object.keys(variables).length > 0;
+  const actionDescription = hasVariables
+    ? `Describe what to click or type, e.g. "click the Login button" or "type %variableName% into the input". Available variables: ${Object.keys(variables).join(", ")}`
+    : 'Describe what to click or type, e.g. "click the Login button" or "type "John" into the first name input"';
+
+  return tool({
+    description:
+      "Perform an action on the page (click, type). Provide a short, specific phrase that mentions the element type.",
+    inputSchema: z.object({
+      action: z.string().describe(actionDescription),
+    }),
+    execute: async ({ action }) => {
+      try {
+        v3.logger({
+          category: "agent",
+          message: `Agent calling tool: act`,
+          level: 1,
+          auxiliary: {
+            arguments: {
+              value: action,
+              type: "string",
+            },
+          },
+        });
+        const options = executionModel
+          ? { model: executionModel, variables, timeout: toolTimeout }
+          : { variables, timeout: toolTimeout };
+
+        const result = await v3.act(action, options);
+        const actions = (result.actions as Action[] | undefined) ?? [];
+        v3.recordAgentReplayStep({
+          type: "act",
+          instruction: action,
+          actions,
+          actionDescription: result.actionDescription,
+          message: result.message,
+        });
+        // Only include playwrightArguments when actions exist
+        // (undefined is not valid JSON and breaks AI SDK validation)
+        const response: {
+          success: boolean;
+          action: string;
+          playwrightArguments?: Action;
+        } = {
+          success: result.success ?? true,
+          action: result?.actionDescription ?? action,
+        };
+        if (actions.length > 0) {
+          response.playwrightArguments = actions[0];
+        }
+        return response;
+      } catch (error) {
+        if (error instanceof TimeoutError) {
+          const timeoutMessage = `TimeoutError while waiting for act() to complete (it may continue executing in the background)`;
+          v3.logger({
+            category: "agent",
+            message: timeoutMessage,
+            level: 0,
+          });
+          return {
+            success: false,
+            error: `${timeoutMessage} — try using a different description for the action`,
+          };
+        }
+        return {
+          success: false,
+          error: error?.message ?? String(error),
+        };
+      }
+    },
+  });
+};
diff --git a/packages/core/lib/v3/agent/tools/ariaTree.ts b/packages/core/lib/v3/agent/tools/ariaTree.ts
new file mode 100644
index 000000000..a1a3655e4
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/ariaTree.ts
@@ -0,0 +1,76 @@
+import { tool } from "ai";
+import { z } from "zod";
+import type { V3 } from "../../v3.js";
+import { TimeoutError } from "../../types/public/sdkErrors.js";
+
+export const ariaTreeTool = (v3: V3, toolTimeout?: number) =>
+  tool({
+    description:
+      "gets the accessibility (ARIA) hybrid tree text for the current page. use this to understand structure and content.",
+    inputSchema: z.object({}),
+    execute: async () => {
+      try {
+        v3.logger({
+          category: "agent",
+          message: `Agent calling tool: ariaTree`,
+          level: 1,
+        });
+        const page = await v3.context.awaitActivePage();
+        const extractOptions = toolTimeout
+          ? { timeout: toolTimeout }
+          : undefined;
+        const { pageText } = (await v3.extract(extractOptions)) as {
+          pageText: string;
+        };
+        const pageUrl = page.url();
+
+        let content = pageText;
+        const MAX_TOKENS = 70000; // rough cap, assume ~4 chars per token for conservative truncation
+        const estimatedTokens = Math.ceil(content.length / 4);
+        if (estimatedTokens > MAX_TOKENS) {
+          const maxChars = MAX_TOKENS * 4;
+          content =
+            content.substring(0, maxChars) +
+            "\n\n[CONTENT TRUNCATED: Exceeded 70,000 token limit]";
+        }
+
+        return { success: true, content, pageUrl };
+      } catch (error) {
+        if (error instanceof TimeoutError) {
+          const timeoutMessage = `TimeoutError: ariaTree() timed out — the page may be too large`;
+          v3.logger({
+            category: "agent",
+            message: timeoutMessage,
+            level: 0,
+          });
+          return {
+            content: "",
+            error: timeoutMessage,
+            success: false,
+            pageUrl: "",
+          };
+        }
+        return {
+          content: "",
+          error: error?.message ?? String(error),
+          success: false,
+          pageUrl: "",
+        };
+      }
+    },
+    toModelOutput: (result) => {
+      if (result.success === false || result.error !== undefined) {
+        return {
+          type: "content",
+          value: [{ type: "text", text: JSON.stringify(result) }],
+        };
+      }
+
+      return {
+        type: "content",
+        value: [
+          { type: "text", text: `Accessibility Tree:\n${result.content}` },
+        ],
+      };
+    },
+  });
diff --git a/packages/core/lib/v3/agent/tools/click.ts b/packages/core/lib/v3/agent/tools/click.ts
new file mode 100644
index 000000000..d6c8529ec
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/click.ts
@@ -0,0 +1,116 @@
+import { tool } from "ai";
+import { z } from "zod";
+import type { V3 } from "../../v3.js";
+import type { Action } from "../../types/public/methods.js";
+import type {
+  ClickToolResult,
+  ModelOutputContentItem,
+} from "../../types/public/agent.js";
+import { processCoordinates } from "../utils/coordinateNormalization.js";
+import { ensureXPath } from "../utils/xpath.js";
+import { waitAndCaptureScreenshot } from "../utils/screenshotHandler.js";
+
+export const clickTool = (v3: V3, provider?: string) =>
+  tool({
+    description:
+      "Click on an element using its coordinates (this is the most reliable way to click on an element, always use this over act, unless the element is not visible in the screenshot, but shown in ariaTree)",
+    inputSchema: z.object({
+      describe: z
+        .string()
+        .describe(
+          "Describe the element to click on in a short, specific phrase that mentions the element type and a good visual description",
+        ),
+      coordinates: z
+        .array(z.number())
+        .describe("The (x, y) coordinates to click on"),
+    }),
+    execute: async ({ describe, coordinates }): Promise<ClickToolResult> => {
+      try {
+        const page = await v3.context.awaitActivePage();
+        const processed = processCoordinates(
+          coordinates[0],
+          coordinates[1],
+          provider,
+          v3,
+        );
+
+        v3.logger({
+          category: "agent",
+          message: `Agent calling tool: click`,
+          level: 1,
+          auxiliary: {
+            arguments: {
+              value: JSON.stringify({ describe }),
+              type: "object",
+            },
+          },
+        });
+
+        // Only request XPath when caching is enabled to avoid unnecessary computation
+        const shouldCollectXpath = v3.isAgentReplayActive();
+        const xpath = await page.click(processed.x, processed.y, {
+          returnXpath: shouldCollectXpath,
+        });
+
+        const screenshotBase64 = await waitAndCaptureScreenshot(page);
+
+        // Record as an "act" step with proper Action for deterministic replay (only when caching)
+        if (shouldCollectXpath) {
+          const normalizedXpath = ensureXPath(xpath);
+          if (normalizedXpath) {
+            const action: Action = {
+              selector: normalizedXpath,
+              description: describe,
+              method: "click",
+              arguments: [],
+            };
+            v3.recordAgentReplayStep({
+              type: "act",
+              instruction: describe,
+              actions: [action],
+              actionDescription: describe,
+            });
+          }
+        }
+
+        return {
+          success: true,
+          describe,
+          coordinates: [processed.x, processed.y],
+          screenshotBase64,
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Error clicking: ${(error as Error).message}`,
+        };
+      }
+    },
+    toModelOutput: (result) => {
+      if (result.success === false || result.error !== undefined) {
+        return {
+          type: "content",
+          value: [{ type: "text", text: JSON.stringify(result) }],
+        };
+      }
+
+      const content: ModelOutputContentItem[] = [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: result.success,
+            describe: result.describe,
+            coordinates: result.coordinates,
+          }),
+        },
+      ];
+      if (result.screenshotBase64) {
+        content.push({
+          type: "media",
+          mediaType: "image/png",
+          data: result.screenshotBase64,
+        });
+      }
+      return { type: "content", value: content };
+    },
+  });
diff --git a/packages/core/lib/v3/agent/tools/clickAndHold.ts b/packages/core/lib/v3/agent/tools/clickAndHold.ts
new file mode 100644
index 000000000..53a19b19a
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/clickAndHold.ts
@@ -0,0 +1,88 @@
+import { tool } from "ai";
+import { z } from "zod";
+import type { V3 } from "../../v3.js";
+import type { Action } from "../../types/public/methods.js";
+import { processCoordinates } from "../utils/coordinateNormalization.js";
+import { ensureXPath } from "../utils/xpath.js";
+
+export const clickAndHoldTool = (v3: V3, provider?: string) =>
+  tool({
+    description: "Click and hold on an element using its coordinates",
+    inputSchema: z.object({
+      describe: z
+        .string()
+        .describe(
+          "Describe the element to click on in a short, specific phrase that mentions the element type and a good visual description",
+        ),
+      duration: z
+        .number()
+        .describe("The duration to hold the element in milliseconds"),
+      coordinates: z
+        .array(z.number())
+        .describe("The (x, y) coordinates to click on"),
+    }),
+    execute: async ({ describe, coordinates, duration }) => {
+      try {
+        const page = await v3.context.awaitActivePage();
+        const processed = processCoordinates(
+          coordinates[0],
+          coordinates[1],
+          provider,
+          v3,
+        );
+
+        v3.logger({
+          category: "agent",
+          message: `Agent calling tool: clickAndHold`,
+          level: 1,
+          auxiliary: {
+            arguments: {
+              value: JSON.stringify({
+                describe,
+                duration,
+              }),
+              type: "object",
+            },
+          },
+        });
+
+        // Only request XPath when caching is enabled to avoid unnecessary computation
+        const shouldCollectXpath = v3.isAgentReplayActive();
+
+        // Use dragAndDrop from same point to same point with delay to simulate click and hold
+        const [xpath] = await page.dragAndDrop(
+          processed.x,
+          processed.y,
+          processed.x,
+          processed.y,
+          { delay: duration, returnXpath: shouldCollectXpath },
+        );
+
+        // Record as "act" step with proper Action for deterministic replay (only when caching)
+        if (shouldCollectXpath) {
+          const normalizedXpath = ensureXPath(xpath);
+          if (normalizedXpath) {
+            const action: Action = {
+              selector: normalizedXpath,
+              description: describe,
+              method: "clickAndHold",
+              arguments: [String(duration)],
+            };
+            v3.recordAgentReplayStep({
+              type: "act",
+              instruction: describe,
+              actions: [action],
+              actionDescription: describe,
+            });
+          }
+        }
+
+        return { success: true, describe };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Error clicking and holding: ${(error as Error).message}`,
+        };
+      }
+    },
+  });
diff --git a/packages/core/lib/v3/agent/tools/dragAndDrop.ts b/packages/core/lib/v3/agent/tools/dragAndDrop.ts
new file mode 100644
index 000000000..bff050e96
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/dragAndDrop.ts
@@ -0,0 +1,130 @@
+import { tool } from "ai";
+import { z } from "zod";
+import type { V3 } from "../../v3.js";
+import type { Action } from "../../types/public/methods.js";
+import type {
+  DragAndDropToolResult,
+  ModelOutputContentItem,
+} from "../../types/public/agent.js";
+import { processCoordinates } from "../utils/coordinateNormalization.js";
+import { ensureXPath } from "../utils/xpath.js";
+import { waitAndCaptureScreenshot } from "../utils/screenshotHandler.js";
+
+export const dragAndDropTool = (v3: V3, provider?: string) =>
+  tool({
+    description:
+      "Drag and drop an element using its coordinates (this is the most reliable way to drag and drop an element, always use this over act, unless the element is not visible in the screenshot, but shown in ariaTree)",
+    inputSchema: z.object({
+      describe: z.string().describe("Describe the element to drag and drop"),
+      startCoordinates: z
+        .array(z.number())
+        .describe("The (x, y) coordinates to start the drag and drop from"),
+      endCoordinates: z
+        .array(z.number())
+        .describe("The (x, y) coordinates to end the drag and drop at"),
+    }),
+    execute: async ({
+      describe,
+      startCoordinates,
+      endCoordinates,
+    }): Promise<DragAndDropToolResult> => {
+      try {
+        const page = await v3.context.awaitActivePage();
+        const processedStart = processCoordinates(
+          startCoordinates[0],
+          startCoordinates[1],
+          provider,
+          v3,
+        );
+        const processedEnd = processCoordinates(
+          endCoordinates[0],
+          endCoordinates[1],
+          provider,
+          v3,
+        );
+
+        v3.logger({
+          category: "agent",
+          message: `Agent calling tool: dragAndDrop`,
+          level: 1,
+          auxiliary: {
+            arguments: {
+              value: JSON.stringify({
+                describe,
+              }),
+              type: "object",
+            },
+          },
+        });
+
+        // Only request XPath when caching is enabled to avoid unnecessary computation
+        const shouldCollectXpath = v3.isAgentReplayActive();
+        const [fromXpath, toXpath] = await page.dragAndDrop(
+          processedStart.x,
+          processedStart.y,
+          processedEnd.x,
+          processedEnd.y,
+          { returnXpath: shouldCollectXpath },
+        );
+
+        const screenshotBase64 = await waitAndCaptureScreenshot(page);
+
+        // Record as "act" step with proper Action for deterministic replay (only when caching)
+        if (shouldCollectXpath) {
+          const normalizedFrom = ensureXPath(fromXpath);
+          const normalizedTo = ensureXPath(toXpath);
+          if (normalizedFrom && normalizedTo) {
+            const action: Action = {
+              selector: normalizedFrom,
+              description: describe,
+              method: "dragAndDrop",
+              arguments: [normalizedTo],
+            };
+            v3.recordAgentReplayStep({
+              type: "act",
+              instruction: describe,
+              actions: [action],
+              actionDescription: describe,
+            });
+          }
+        }
+
+        return {
+          success: true,
+          describe,
+          screenshotBase64,
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Error dragging: ${(error as Error).message}`,
+        };
+      }
+    },
+    toModelOutput: (result) => {
+      if (result.success === false || result.error !== undefined) {
+        return {
+          type: "content",
+          value: [{ type: "text", text: JSON.stringify(result) }],
+        };
+      }
+
+      const content: ModelOutputContentItem[] = [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: result.success,
+            describe: result.describe,
+          }),
+        },
+      ];
+      if (result.screenshotBase64) {
+        content.push({
+          type: "media",
+          mediaType: "image/png",
+          data: result.screenshotBase64,
+        });
+      }
+      return { type: "content", value: content };
+    },
+  });
diff --git a/packages/core/lib/v3/agent/tools/extract.ts b/packages/core/lib/v3/agent/tools/extract.ts
new file mode 100644
index 000000000..06c385607
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/extract.ts
@@ -0,0 +1,118 @@
+import { tool } from "ai";
+import { z, ZodTypeAny } from "zod";
+import type { V3 } from "../../v3.js";
+import type { AgentModelConfig } from "../../types/public/agent.js";
+import { TimeoutError } from "../../types/public/sdkErrors.js";
+
+interface JsonSchema {
+  type?: string;
+  properties?: Record<string, JsonSchema>;
+  items?: JsonSchema;
+  enum?: string[];
+  format?: "url" | "email" | "uuid";
+}
+
+function jsonSchemaToZod(schema: JsonSchema): ZodTypeAny {
+  switch (schema.type) {
+    case "object": {
+      const shape: Record<string, ZodTypeAny> = {};
+      if (schema.properties) {
+        for (const [key, value] of Object.entries(schema.properties)) {
+          shape[key] = jsonSchemaToZod(value);
+        }
+      }
+      return z.object(shape);
+    }
+    case "array":
+      return z.array(schema.items ? jsonSchemaToZod(schema.items) : z.any());
+    case "string": {
+      let s = z.string();
+      if (schema.format === "url") s = s.url();
+      if (schema.format === "email") s = s.email();
+      if (schema.format === "uuid") s = s.uuid();
+      if (schema.enum && schema.enum.length > 0)
+        return z.enum(schema.enum as [string, ...string[]]);
+      return s;
+    }
+    case "number":
+    case "integer":
+      return z.number();
+    case "boolean":
+      return z.boolean();
+    case "null":
+      return z.null();
+    default:
+      return z.any();
+  }
+}
+
+export const extractTool = (
+  v3: V3,
+  executionModel?: string | AgentModelConfig,
+  toolTimeout?: number,
+) =>
+  tool({
+    description: `Extract structured data from the current page based on a provided schema.
+    
+    USAGE GUIDELINES:
+    - Keep schemas MINIMAL - only include fields essential for the task
+    - IMPORTANT: only use this if explicitly asked for structured output. In most scenarios, you should use the aria tree tool over this.
+    - For URL fields, use format: "url"
+    
+    EXAMPLES:
+    1. Extract a single value:
+       instruction: "extract the product price"
+       schema: { type: "object", properties: { price: { type: "number" } } }
+    
+    2. Extract multiple fields:
+       instruction: "extract product name and price"
+       schema: { type: "object", properties: { name: { type: "string" }, price: { type: "number" } } }
+    
+    3. Extract arrays:
+       instruction: "extract all product names and prices"
+       schema: { type: "object", properties: { products: { type: "array", items: { type: "object", properties: { name: { type: "string" }, price: { type: "number" } } } } } }
+    
+    4. Extract a URL:
+       instruction: "extract the link"
+       schema: { type: "object", properties: { url: { type: "string", format: "url" } } }`,
+    inputSchema: z.object({
+      instruction: z.string(),
+      schema: z
+        .object({
+          type: z.string().optional(),
+          properties: z.record(z.string(), z.unknown()).optional(),
+          items: z.unknown().optional(),
+          enum: z.array(z.string()).optional(),
+          format: z.enum(["url", "email", "uuid"]).optional(),
+        })
+        .passthrough()
+        .optional()
+        .describe("JSON Schema object describing the structure to extract"),
+    }),
+    execute: async ({ instruction, schema }) => {
+      try {
+        const parsedSchema = schema
+          ? jsonSchemaToZod(schema as JsonSchema)
+          : undefined;
+        const result = await v3.extract(instruction, parsedSchema, {
+          ...(executionModel ? { model: executionModel } : {}),
+          timeout: toolTimeout,
+        });
+        return { success: true, result };
+      } catch (error) {
+        if (error instanceof TimeoutError) {
+          const timeoutMessage = `TimeoutError: extract() timed out — try using a smaller or simpler schema`;
+          v3.logger({
+            category: "agent",
+            message: timeoutMessage,
+            level: 0,
+          });
+          return {
+            success: false,
+            error: timeoutMessage,
+          };
+        }
+        return { success: false, error: error?.message ?? String(error) };
+      }
+    },
+  });
diff --git a/packages/core/lib/v3/agent/tools/fillFormVision.ts b/packages/core/lib/v3/agent/tools/fillFormVision.ts
new file mode 100644
index 000000000..7bad60219
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/fillFormVision.ts
@@ -0,0 +1,188 @@
+import { tool } from "ai";
+import { z } from "zod";
+import type { V3 } from "../../v3.js";
+import type { Action } from "../../types/public/methods.js";
+import type {
+  FillFormVisionToolResult,
+  ModelOutputContentItem,
+  Variables,
+} from "../../types/public/agent.js";
+import { processCoordinates } from "../utils/coordinateNormalization.js";
+import { ensureXPath } from "../utils/xpath.js";
+import { waitAndCaptureScreenshot } from "../utils/screenshotHandler.js";
+import { substituteVariables } from "../utils/variables.js";
+
+export const fillFormVisionTool = (
+  v3: V3,
+  provider?: string,
+  variables?: Variables,
+) => {
+  const hasVariables = variables && Object.keys(variables).length > 0;
+  const valueDescription = hasVariables
+    ? `Text to type into the target field. Use %variableName% to substitute a variable value. Available: ${Object.keys(variables).join(", ")}`
+    : "Text to type into the target field";
+
+  return tool({
+    description: `FORM FILL - SPECIALIZED MULTI-FIELD INPUT TOOL
+
+CRITICAL: Use this for ANY form with 2+ input fields (text inputs, textareas, etc.)
+IMPORTANT: Ensure the fields are visible within the current viewport
+
+WHY THIS TOOL EXISTS:
+- Forms are the #1 use case for multi-field input
+- Optimized specifically for input/textarea elements
+- 4-6x faster than individual typing actions
+
+Use fillFormVision: Pure form filling (inputs, textareas only)
+MANDATORY USE CASES (always use fillFormVision for these):
+- Registration forms: name, email, password fields
+- Contact forms: name, email, message fields
+- Checkout forms: address, payment info fields
+- Profile updates: multiple user data fields
+- Search filters: multiple criteria inputs`,
+    inputSchema: z.object({
+      fields: z
+        .array(
+          z.object({
+            action: z
+              .string()
+              .describe(
+                "Description of the typing action, e.g. 'type foo into the bar field'",
+              ),
+            value: z.string().describe(valueDescription),
+            coordinates: z
+              .object({
+                x: z.number(),
+                y: z.number(),
+              })
+              .describe("Coordinates of the target field"),
+          }),
+        )
+        .min(2, "Provide at least two fields to fill"),
+    }),
+    execute: async ({ fields }): Promise<FillFormVisionToolResult> => {
+      try {
+        const page = await v3.context.awaitActivePage();
+
+        // Process coordinates and substitute variables for each field
+        // Keep original values (with %tokens%) for logging/caching, substituted values for typing
+        const processedFields = fields.map((field) => {
+          const processed = processCoordinates(
+            field.coordinates.x,
+            field.coordinates.y,
+            provider,
+            v3,
+          );
+          return {
+            ...field,
+            originalValue: field.value, // Keep original with %tokens% for cache
+            value: substituteVariables(field.value, variables),
+            coordinates: { x: processed.x, y: processed.y },
+          };
+        });
+
+        v3.logger({
+          category: "agent",
+          message: `Agent calling tool: fillFormVision`,
+          level: 1,
+          auxiliary: {
+            arguments: {
+              value: JSON.stringify({ fields }), // Don't log substituted values
+              type: "object",
+            },
+          },
+        });
+
+        // Only request XPath when caching is enabled to avoid unnecessary computation
+        const shouldCollectXpath = v3.isAgentReplayActive();
+        const actions: Action[] = [];
+
+        for (const field of processedFields) {
+          // Click the field, only requesting XPath when caching is enabled
+          const xpath = await page.click(
+            field.coordinates.x,
+            field.coordinates.y,
+            {
+              returnXpath: shouldCollectXpath,
+            },
+          );
+          await page.type(field.value);
+
+          // Build Action with XPath for deterministic replay (only when caching)
+          // Use originalValue (with %tokens%) so cache stores references, not sensitive values
+          if (shouldCollectXpath) {
+            const normalizedXpath = ensureXPath(xpath);
+            if (normalizedXpath) {
+              actions.push({
+                selector: normalizedXpath,
+                description: field.action,
+                method: "type",
+                arguments: [field.originalValue],
+              });
+            }
+          }
+
+          // Small delay between fields
+          await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+
+        const screenshotBase64 = await waitAndCaptureScreenshot(page, 100);
+
+        // Record as "act" step with proper Actions for deterministic replay (only when caching)
+        if (shouldCollectXpath && actions.length > 0) {
+          v3.recordAgentReplayStep({
+            type: "act",
+            instruction: `Fill ${fields.length} form fields`,
+            actions,
+            actionDescription: `Fill ${fields.length} form fields`,
+          });
+        }
+
+        return {
+          success: true,
+          playwrightArguments: processedFields,
+          screenshotBase64,
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Error filling form: ${(error as Error).message}`,
+        };
+      }
+    },
+    toModelOutput: (result) => {
+      if (result.success === false || result.error !== undefined) {
+        return {
+          type: "content",
+          value: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: result.success,
+                error: result.error,
+              }),
+            },
+          ],
+        };
+      }
+
+      const content: ModelOutputContentItem[] = [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: result.success,
+            fieldsCount: result.playwrightArguments?.length ?? 0,
+          }),
+        },
+      ];
+      if (result.screenshotBase64) {
+        content.push({
+          type: "media",
+          mediaType: "image/png",
+          data: result.screenshotBase64,
+        });
+      }
+      return { type: "content", value: content };
+    },
+  });
+};
diff --git a/packages/core/lib/v3/agent/tools/fillform.ts b/packages/core/lib/v3/agent/tools/fillform.ts
new file mode 100644
index 000000000..b7e0c9198
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/fillform.ts
@@ -0,0 +1,100 @@
+import { tool } from "ai";
+import { z } from "zod";
+import type { V3 } from "../../v3.js";
+import type { Action } from "../../types/public/methods.js";
+import type { AgentModelConfig, Variables } from "../../types/public/agent.js";
+import { TimeoutError } from "../../types/public/sdkErrors.js";
+
+export const fillFormTool = (
+  v3: V3,
+  executionModel?: string | AgentModelConfig,
+  variables?: Variables,
+  toolTimeout?: number,
+) => {
+  const hasVariables = variables && Object.keys(variables).length > 0;
+  const valueDescription = hasVariables
+    ? `Text to type into the target. Use %variableName% to substitute a variable value. Available: ${Object.keys(variables).join(", ")}`
+    : "Text to type into the target";
+
+  return tool({
+    description: `📝 FORM FILL - MULTI-FIELD INPUT TOOL\nFor any form with 2+ inputs/textareas. Faster than individual typing.`,
+    inputSchema: z.object({
+      fields: z
+        .array(
+          z.object({
+            action: z
+              .string()
+              .describe(
+                'Description of typing action, e.g. "type foo into the email field"',
+              ),
+            value: z.string().describe(valueDescription),
+          }),
+        )
+        .min(1, "Provide at least one field to fill"),
+    }),
+    execute: async ({ fields }) => {
+      try {
+        v3.logger({
+          category: "agent",
+          message: `Agent calling tool: fillForm`,
+          level: 1,
+          auxiliary: {
+            arguments: {
+              value: JSON.stringify(fields),
+              type: "object",
+            },
+          },
+        });
+        const instruction = `Return observation results for the following actions: ${fields
+          .map((f) => f.action)
+          .join(", ")}`;
+
+        const observeOptions = executionModel
+          ? { model: executionModel, timeout: toolTimeout }
+          : { timeout: toolTimeout };
+        const observeResults = await v3.observe(instruction, observeOptions);
+
+        const completed = [] as unknown[];
+        const replayableActions: Action[] = [];
+        for (const res of observeResults) {
+          const actOptions = variables
+            ? { variables, timeout: toolTimeout }
+            : { timeout: toolTimeout };
+          const actResult = await v3.act(res, actOptions);
+          completed.push(actResult);
+          if (Array.isArray(actResult.actions)) {
+            replayableActions.push(...(actResult.actions as Action[]));
+          }
+        }
+        v3.recordAgentReplayStep({
+          type: "fillForm",
+          fields,
+          observeResults,
+          actions: replayableActions,
+        });
+        return {
+          success: true,
+          actions: completed,
+          playwrightArguments: replayableActions,
+        };
+      } catch (error) {
+        if (error instanceof TimeoutError) {
+          const timeoutMessage = `TimeoutError while waiting for fillForm() to complete (it may continue executing in the background)`;
+          v3.logger({
+            category: "agent",
+            message: timeoutMessage,
+            level: 0,
+          });
+          return {
+            success: false,
+            error: `${timeoutMessage} — try filling fewer fields at once or use a different tool`,
+          };
+        }
+        return {
+          success: false,
+          error: error?.message ?? String(error),
+        };
+      }
+    },
+  });
+};
diff --git a/packages/core/lib/v3/agent/tools/goto.ts b/packages/core/lib/v3/agent/tools/goto.ts
new file mode 100644
index 000000000..ac8900b35
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/goto.ts
@@ -0,0 +1,32 @@
+import { tool } from "ai";
+import { z } from "zod";
+import type { V3 } from "../../v3.js";
+
+export const gotoTool = (v3: V3) =>
+  tool({
+    description: "Navigate to a specific URL",
+    inputSchema: z.object({
+      url: z.string().describe("The URL to navigate to"),
+    }),
+    execute: async ({ url }) => {
+      try {
+        v3.logger({
+          category: "agent",
+          message: `Agent calling tool: goto`,
+          level: 1,
+          auxiliary: {
+            arguments: {
+              value: url,
+              type: "string",
+            },
+          },
+        });
+        const page = await v3.context.awaitActivePage();
+        await page.goto(url, { waitUntil: "load" });
+        v3.recordAgentReplayStep({ type: "goto", url, waitUntil: "load" });
+        return { success: true, url };
+      } catch (error) {
+        return { success: false, error: error?.message ?? String(error) };
+      }
+    },
+  });
diff --git a/packages/core/lib/v3/agent/tools/index.ts b/packages/core/lib/v3/agent/tools/index.ts
new file mode 100644
index 000000000..0d5cd34f8
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/index.ts
@@ -0,0 +1,180 @@
+import { gotoTool } from "./goto.js";
+import { actTool } from "./act.js";
+import { screenshotTool } from "./screenshot.js";
+import { waitTool } from "./wait.js";
+import { navBackTool } from "./navback.js";
+import { ariaTreeTool } from "./ariaTree.js";
+import { fillFormTool } from "./fillform.js";
+import { scrollTool, scrollVisionTool } from "./scroll.js";
+import { extractTool } from "./extract.js";
+import { clickTool } from "./click.js";
+import { typeTool } from "./type.js";
+import { dragAndDropTool } from "./dragAndDrop.js";
+import { clickAndHoldTool } from "./clickAndHold.js";
+import { keysTool } from "./keys.js";
+import { fillFormVisionTool } from "./fillFormVision.js";
+import { thinkTool } from "./think.js";
+import { searchTool } from "./search.js";
+
+import type { ToolSet, InferUITools } from "ai";
+import type { V3 } from "../../v3.js";
+import type { LogLine } from "../../types/public/logs.js";
+import type {
+  AgentToolMode,
+  AgentModelConfig,
+  Variables,
+} from "../../types/public/agent.js";
+
+export interface V3AgentToolOptions {
+  executionModel?: string | AgentModelConfig;
+  logger?: (message: LogLine) => void;
+  /**
+   * Tool mode determines which set of tools are available.
+   * - 'dom' (default): Uses DOM-based tools (act, fillForm) - removes coordinate-based tools
+   * - 'hybrid': Uses coordinate-based tools (click, type, dragAndDrop, etc.) - removes fillForm
+   */
+  mode?: AgentToolMode;
+  /**
+   * The model provider. Used for model-specific coordinate handling
+   */
+  provider?: string;
+  /**
+   * Tools to exclude from the available toolset.
+   * These tools will be filtered out after mode-based filtering.
+   */
+  excludeTools?: string[];
+  /**
+   * Variables available to the agent for use in act/type tools.
+   * When provided, these tools will have an optional useVariable field.
+   */
+  variables?: Variables;
+  /**
+   * Timeout in milliseconds for tool calls that invoke v3 methods (act, extract, fillForm, ariaTree).
+   * Forwarded to the underlying v3 call's `timeout` option.
+   */
+  toolTimeout?: number;
+}
+
+/**
+ * Filters tools based on mode and explicit exclusions.
+ * - 'dom' mode: Removes coordinate-based tools (click, type, dragAndDrop, clickAndHold, fillFormVision)
+ * - 'hybrid' mode: Removes DOM-based form tool (fillForm) in favor of coordinate-based fillFormVision
+ * - excludeTools: Additional tools to remove from the toolset
+ */
+function filterTools(
+  tools: ToolSet,
+  mode: AgentToolMode,
+  excludeTools?: string[],
+): ToolSet {
+  const filtered: ToolSet = { ...tools };
+
+  // Mode-based filtering
+  if (mode === "hybrid") {
+    delete filtered.fillForm;
+  } else {
+    // DOM mode (default)
+    delete filtered.click;
+    delete filtered.type;
+    delete filtered.dragAndDrop;
+    delete filtered.clickAndHold;
+    delete filtered.fillFormVision;
+  }
+
+  if (excludeTools) {
+    for (const toolName of excludeTools) {
+      delete filtered[toolName];
+    }
+  }
+
+  return filtered;
+}
+
+export function createAgentTools(v3: V3, options?: V3AgentToolOptions) {
+  const executionModel = options?.executionModel;
+  const mode = options?.mode ?? "dom";
+  const provider = options?.provider;
+  const excludeTools = options?.excludeTools;
+  const variables = options?.variables;
+  const toolTimeout = options?.toolTimeout;
+
+  const allTools: ToolSet = {
+    act: actTool(v3, executionModel, variables, toolTimeout),
+    ariaTree: ariaTreeTool(v3, toolTimeout),
+    click: clickTool(v3, provider),
+    clickAndHold: clickAndHoldTool(v3, provider),
+    dragAndDrop: dragAndDropTool(v3, provider),
+    extract: extractTool(v3, executionModel, toolTimeout),
+    fillForm: fillFormTool(v3, executionModel, variables, toolTimeout),
+    fillFormVision: fillFormVisionTool(v3, provider, variables),
+    goto: gotoTool(v3),
+    keys: keysTool(v3),
+    navback: navBackTool(v3),
+    screenshot: screenshotTool(v3),
+    scroll: mode === "hybrid" ? scrollVisionTool(v3, provider) : scrollTool(v3),
+    think: thinkTool(),
+    type: typeTool(v3, provider, variables),
+    wait: waitTool(v3, mode),
+  };
+
+  if (process.env.BRAVE_API_KEY) {
+    allTools.search = searchTool(v3);
+  }
+
+  return filterTools(allTools, mode, excludeTools);
+}
+
+export type AgentTools = ReturnType<typeof createAgentTools>;
+
+/**
+ * Type map of all agent tools for strong typing of tool calls and results.
+ * Note: `search` is optional as it's only available when BRAVE_API_KEY is configured.
+ */
+export type AgentToolTypesMap = {
+  act: ReturnType<typeof actTool>;
+  ariaTree: ReturnType<typeof ariaTreeTool>;
+  click: ReturnType<typeof clickTool>;
+  clickAndHold: ReturnType<typeof clickAndHoldTool>;
+  dragAndDrop: ReturnType<typeof dragAndDropTool>;
+  extract: ReturnType<typeof extractTool>;
+  fillForm: ReturnType<typeof fillFormTool>;
+  fillFormVision: ReturnType<typeof fillFormVisionTool>;
+  goto: ReturnType<typeof gotoTool>;
+  keys: ReturnType<typeof keysTool>;
+  navback: ReturnType<typeof navBackTool>;
+  screenshot: ReturnType<typeof screenshotTool>;
+  scroll: ReturnType<typeof scrollTool> | ReturnType<typeof scrollVisionTool>;
+  search?: ReturnType<typeof searchTool>;
+  think: ReturnType<typeof thinkTool>;
+  type: ReturnType<typeof typeTool>;
+  wait: ReturnType<typeof waitTool>;
+};
+
+/**
+ * Inferred UI tools type for type-safe tool inputs and outputs.
+ * Use with UIMessage for full type safety in UI contexts.
+ */
+export type AgentUITools = InferUITools<AgentToolTypesMap>;
+
+/**
+ * Union type for all possible agent tool calls.
+ * Provides type-safe access to tool call arguments.
+ */
+export type AgentToolCall = {
+  [K in keyof AgentToolTypesMap]: {
+    toolName: K;
+    toolCallId: string;
+    args: AgentUITools[K]["input"];
+  };
+}[keyof AgentToolTypesMap];
+
+/**
+ * Union type for all possible agent tool results.
+ * Provides type-safe access to tool result values.
+ */
+export type AgentToolResult = {
+  [K in keyof AgentToolTypesMap]: {
+    toolName: K;
+    toolCallId: string;
+    result: AgentUITools[K]["output"];
+  };
+}[keyof AgentToolTypesMap];
diff --git a/packages/core/lib/v3/agent/tools/keys.ts b/packages/core/lib/v3/agent/tools/keys.ts
new file mode 100644
index 000000000..c1a5a3aed
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/keys.ts
@@ -0,0 +1,67 @@
+import { tool } from "ai";
+import { z } from "zod";
+import type { V3 } from "../../v3.js";
+
+export const keysTool = (v3: V3) =>
+  tool({
+    description: `Send keyboard input to the page without targeting a specific element. Unlike the type tool which clicks then types into coordinates, this sends keystrokes directly to wherever focus currently is.
+
+Use method="type" to enter text into the currently focused element. Preferred when: input is already focused, text needs to flow across multiple fields (e.g., verification codes)
+
+Use method="press" for navigation keys (Enter, Tab, Escape, Backspace, arrows) and keyboard shortcuts (Cmd+A, Ctrl+C, Shift+Tab).`,
+    inputSchema: z.object({
+      method: z.enum(["press", "type"]),
+      value: z
+        .string()
+        .describe(
+          "The text to type, or the key/combo to press (Enter, Tab, Cmd+A)",
+        ),
+      repeat: z.number().optional(),
+    }),
+    execute: async ({ method, value, repeat }) => {
+      try {
+        const page = await v3.context.awaitActivePage();
+        v3.logger({
+          category: "agent",
+          message: `Agent calling tool: keys`,
+          level: 1,
+          auxiliary: {
+            arguments: {
+              value: JSON.stringify({ method, value, repeat }),
+              type: "object",
+            },
+          },
+        });
+
+        const times = Math.max(1, repeat ?? 1);
+
+        if (method === "type") {
+          for (let i = 0; i < times; i++) {
+            await page.type(value, { delay: 100 });
+          }
+          v3.recordAgentReplayStep({
+            type: "keys",
+            instruction: `type "${value}"`,
+            playwrightArguments: { method, text: value, times },
+          });
+          return { success: true, method, value, times };
+        }
+
+        if (method === "press") {
+          for (let i = 0; i < times; i++) {
+            await page.keyPress(value, { delay: 100 });
+          }
+          v3.recordAgentReplayStep({
+            type: "keys",
+            instruction: `press ${value}`,
+            playwrightArguments: { method, keys: value, times },
+          });
+          return { success: true, method, value, times };
+        }
+
+        return { success: false, error: `Unsupported method: ${method}` };
+      } catch (error) {
+        return { success: false, error: (error as Error).message };
+      }
+    },
+  });
diff --git a/packages/core/lib/v3/agent/tools/navback.ts b/packages/core/lib/v3/agent/tools/navback.ts
new file mode 100644
index 000000000..147212a78
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/navback.ts
@@ -0,0 +1,25 @@
+import { tool } from "ai";
+import { z } from "zod";
+import type { V3 } from "../../v3.js";
+
+export const navBackTool = (v3: V3) =>
+  tool({
+    description: "Navigate back to the previous page",
+    inputSchema: z.object({
+      reasoningText: z.string().describe("Why you're going back"),
+    }),
+    execute: async () => {
+      v3.logger({
+        category: "agent",
+        message: `Agent calling tool: navback`,
+        level: 1,
+      });
+      const page = await v3.context.awaitActivePage();
+      await page.goBack({ waitUntil: "domcontentloaded" });
+      v3.recordAgentReplayStep({
+        type: "navback",
+        waitUntil: "domcontentloaded",
+      });
+      return { success: true };
+    },
+  });
diff --git a/packages/core/lib/v3/agent/tools/screenshot.ts b/packages/core/lib/v3/agent/tools/screenshot.ts
new file mode 100644
index 000000000..198e51a9f
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/screenshot.ts
@@ -0,0 +1,46 @@
+import { tool } from "ai";
+import { z } from "zod";
+import type { V3 } from "../../v3.js";
+
+export const screenshotTool = (v3: V3) =>
+  tool({
+    description:
+      "Takes a screenshot (PNG) of the current page. Use this to quickly verify page state.",
+    inputSchema: z.object({}),
+    execute: async () => {
+      try {
+        v3.logger({
+          category: "agent",
+          message: `Agent calling tool: screenshot`,
+          level: 1,
+        });
+        const page = await v3.context.awaitActivePage();
+        const buffer = await page.screenshot({ fullPage: false });
+        const pageUrl = page.url();
+        return {
+          success: true,
+          base64: buffer.toString("base64"),
+          timestamp: Date.now(),
+          pageUrl,
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Error taking screenshot: ${(error as Error).message}`,
+        };
+      }
+    },
+    toModelOutput: (result) => {
+      if (result.success === false || result.error !== undefined) {
+        return {
+          type: "content",
+          value: [{ type: "text", text: JSON.stringify(result) }],
+        };
+      }
+
+      return {
+        type: "content",
+        value: [{ type: "media", mediaType: "image/png", data: result.base64 }],
+      };
+    },
+  });
diff --git a/packages/core/lib/v3/agent/tools/scroll.ts b/packages/core/lib/v3/agent/tools/scroll.ts
new file mode 100644
index 000000000..0abe4f882
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/scroll.ts
@@ -0,0 +1,199 @@
+import { tool } from "ai";
+import { z } from "zod";
+import type { V3 } from "../../v3.js";
+import type {
+  ScrollToolResult,
+  ScrollVisionToolResult,
+  ModelOutputContentItem,
+} from "../../types/public/agent.js";
+import { processCoordinates } from "../utils/coordinateNormalization.js";
+import { waitAndCaptureScreenshot } from "../utils/screenshotHandler.js";
+
+/**
+ * Simple scroll tool for DOM mode (non-grounding models).
+ * No coordinates - scrolls from viewport center.
+ */
+export const scrollTool = (v3: V3) =>
+  tool({
+    description:
+      "Scroll the page up or down by a percentage of the viewport height. Default is 80%, and what should be typically used for general page scrolling",
+    inputSchema: z.object({
+      direction: z.enum(["up", "down"]),
+      percentage: z.number().min(1).max(200).optional(),
+    }),
+    execute: async ({
+      direction,
+      percentage = 80,
+    }): Promise<ScrollToolResult> => {
+      v3.logger({
+        category: "agent",
+        message: `Agent calling tool: scroll`,
+        level: 1,
+        auxiliary: {
+          arguments: {
+            value: JSON.stringify({ direction, percentage }),
+            type: "object",
+          },
+        },
+      });
+
+      const page = await v3.context.awaitActivePage();
+
+      const { w, h } = await page.mainFrame().evaluate<{
+        w: number;
+        h: number;
+      }>("({ w: window.innerWidth, h: window.innerHeight })");
+
+      const scrollDistance = Math.round((h * percentage) / 100);
+      const cx = Math.floor(w / 2);
+      const cy = Math.floor(h / 2);
+      const deltaY = direction === "up" ? -scrollDistance : scrollDistance;
+
+      await page.scroll(cx, cy, 0, deltaY);
+
+      v3.recordAgentReplayStep({
+        type: "scroll",
+        deltaX: 0,
+        deltaY,
+        anchor: { x: cx, y: cy },
+      });
+
+      return {
+        success: true,
+        message: `Scrolled ${percentage}% ${direction} (${scrollDistance}px)`,
+        scrolledPixels: scrollDistance,
+      };
+    },
+    toModelOutput: (result) => {
+      if (result.success === false || result.error !== undefined) {
+        return {
+          type: "content",
+          value: [{ type: "text", text: JSON.stringify(result) }],
+        };
+      }
+
+      return {
+        type: "json",
+        value: {
+          success: result.success,
+          message: result.message,
+          scrolledPixels: result.scrolledPixels,
+        },
+      };
+    },
+  });
+
+/**
+ * Scroll tool for hybrid mode (grounding models).
+ * Supports optional coordinates for scrolling within nested scrollable elements.
+ */
+export const scrollVisionTool = (v3: V3, provider?: string) =>
+  tool({
+    description: `Scroll the page up or down. For general page scrolling, no coordinates needed. Only provide coordinates when scrolling inside a nested scrollable element (e.g., a dropdown menu, modal with overflow, or scrollable sidebar). Default is 80%, and what should be typically used for general page scrolling`,
+    inputSchema: z.object({
+      direction: z.enum(["up", "down"]),
+      coordinates: z
+        .array(z.number())
+        .optional()
+        .describe(
+          "Only use coordinates for scrolling inside a nested scrollable element - provide (x, y) within that element",
+        ),
+      percentage: z.number().min(1).max(200).optional(),
+    }),
+    execute: async ({
+      direction,
+      coordinates,
+      percentage = 80,
+    }): Promise<ScrollVisionToolResult> => {
+      const page = await v3.context.awaitActivePage();
+
+      const { w, h } = await page.mainFrame().evaluate<{
+        w: number;
+        h: number;
+      }>("({ w: window.innerWidth, h: window.innerHeight })");
+
+      // Process coordinates if provided, otherwise use viewport center
+      let cx: number;
+      let cy: number;
+      if (coordinates) {
+        const processed = processCoordinates(
+          coordinates[0],
+          coordinates[1],
+          provider,
+          v3,
+        );
+        cx = processed.x;
+        cy = processed.y;
+      } else {
+        cx = Math.floor(w / 2);
+        cy = Math.floor(h / 2);
+      }
+
+      v3.logger({
+        category: "agent",
+        message: `Agent calling tool: scroll`,
+        level: 1,
+        auxiliary: {
+          arguments: {
+            value: JSON.stringify({
+              direction,
+              coordinates,
+              percentage,
+              processed: { cx, cy },
+            }),
+            type: "object",
+          },
+        },
+      });
+
+      const scrollDistance = Math.round((h * percentage) / 100);
+      const deltaY = direction === "up" ? -scrollDistance : scrollDistance;
+
+      await page.scroll(cx, cy, 0, deltaY);
+
+      const screenshotBase64 = await waitAndCaptureScreenshot(page, 100);
+
+      v3.recordAgentReplayStep({
+        type: "scroll",
+        deltaX: 0,
+        deltaY,
+        anchor: { x: cx, y: cy },
+      });
+
+      return {
+        success: true,
+        message: coordinates
+          ? `Scrolled ${percentage}% ${direction} at (${cx}, ${cy})`
+          : `Scrolled ${percentage}% ${direction}`,
+        scrolledPixels: scrollDistance,
+        screenshotBase64,
+      };
+    },
+    toModelOutput: (result) => {
+      if (result.success === false || result.error !== undefined) {
+        return {
+          type: "content",
+          value: [{ type: "text", text: JSON.stringify(result) }],
+        };
+      }
+
+      const content: ModelOutputContentItem[] = [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: result.success,
+            message: result.message,
+            scrolledPixels: result.scrolledPixels,
+          }),
+        },
+      ];
+      if (result.screenshotBase64) {
+        content.push({
+          type: "media",
+          mediaType: "image/png",
+          data: result.screenshotBase64,
+        });
+      }
+      return { type: "content", value: content };
+    },
+  });
diff --git a/packages/core/lib/v3/agent/tools/search.ts b/packages/core/lib/v3/agent/tools/search.ts
new file mode 100644
index 000000000..58e1f611a
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/search.ts
@@ -0,0 +1,116 @@
+import { tool } from "ai";
+import { z } from "zod";
+import type { V3 } from "../../v3.js";
+
+export interface BraveSearchResult {
+  title: string;
+  url: string;
+  description?: string;
+}
+
+interface SearchResponse {
+  data?: {
+    results: BraveSearchResult[];
+  };
+  error?: string;
+}
+
+interface BraveWebResult {
+  title?: string;
+  url?: string;
+  description?: string;
+  age?: string;
+  meta_url?: {
+    favicon?: string;
+  };
+}
+
+interface BraveApiResponse {
+  web?: {
+    results?: BraveWebResult[];
+  };
+}
+
+async function performBraveSearch(query: string): Promise<SearchResponse> {
+  try {
+    const encodedQuery = encodeURIComponent(query);
+    const response = await fetch(
+      `https://api.search.brave.com/res/v1/web/search?q=${encodedQuery}`,
+      {
+        method: "GET",
+        headers: {
+          Accept: "application/json",
+          "Accept-Encoding": "gzip",
+          "X-Subscription-Token": process.env.BRAVE_API_KEY!,
+        },
+      },
+    );
+
+    if (!response.ok) {
+      return {
+        error: `Brave API error: ${response.status} ${response.statusText}`,
+        data: { results: [] },
+      };
+    }
+
+    const data = (await response.json()) as BraveApiResponse;
+    const results: BraveSearchResult[] = [];
+
+    if (data?.web?.results && Array.isArray(data.web.results)) {
+      for (const item of data.web.results.slice(0, 5)) {
+        if (item.title && item.url) {
+          results.push({
+            title: item.title,
+            url: item.url,
+            description: item.description,
+          });
+        }
+      }
+    }
+
+    return { data: { results } };
+  } catch (error) {
+    console.error("Search error", error);
+    return {
+      error: `Error performing search: ${(error as Error).message}`,
+      data: { results: [] },
+    };
+  }
+}
+
+export const searchTool = (v3: V3) =>
+  tool({
+    description:
+      "Perform a web search and returns results. Use this tool when you need information from the web or when you are unsure of the exact URL you want to navigate to. This can be used to find the ideal entry point, resulting in a task that is easier to complete due to starting further in the process.",
+    inputSchema: z.object({
+      query: z.string().describe("The search query to look for on the web"),
+    }),
+    execute: async ({ query }) => {
+      v3.logger({
+        category: "agent",
+        message: `Agent calling tool: search`,
+        level: 1,
+        auxiliary: {
+          arguments: {
+            value: JSON.stringify({ query }),
+            type: "object",
+          },
+        },
+      });
+
+      const result = await performBraveSearch(query);
+
+      v3.recordAgentReplayStep({
+        type: "search",
+        instruction: query,
+        playwrightArguments: { query },
+        message:
+          result.error ?? `Found ${result.data?.results.length ?? 0} results`,
+      });
+
+      return {
+        ...result,
+        timestamp: Date.now(),
+      };
+    },
+  });
diff --git a/packages/core/lib/v3/agent/tools/think.ts b/packages/core/lib/v3/agent/tools/think.ts
new file mode 100644
index 000000000..b759311d3
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/think.ts
@@ -0,0 +1,27 @@
+import { tool } from "ai";
+import { z } from "zod";
+
+export const thinkTool = () =>
+  tool({
+    description: `Use this tool to think through complex problems or plan a sequence of steps. This is for internal reasoning only and doesn't perform any actions. Use this to:
+
+1. Plan a multi-step approach before taking action
+2. Break down complex tasks
+3. Reason through edge cases
+4. Evaluate options when you're unsure what to do next
+
+The output is only visible to you; use it to track your own reasoning process.`,
+    inputSchema: z.object({
+      reasoning: z
+        .string()
+        .describe(
+          "Your step-by-step reasoning or planning process. Be as detailed as needed.",
+        ),
+    }),
+    execute: async ({ reasoning }) => {
+      return {
+        acknowledged: true,
+        message: reasoning,
+      };
+    },
+  });
diff --git a/packages/core/lib/v3/agent/tools/type.ts b/packages/core/lib/v3/agent/tools/type.ts
new file mode 100644
index 000000000..6185522cc
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/type.ts
@@ -0,0 +1,134 @@
+import { tool } from "ai";
+import { z } from "zod";
+import type { V3 } from "../../v3.js";
+import type { Action } from "../../types/public/methods.js";
+import type {
+  TypeToolResult,
+  ModelOutputContentItem,
+  Variables,
+} from "../../types/public/agent.js";
+import { processCoordinates } from "../utils/coordinateNormalization.js";
+import { ensureXPath } from "../utils/xpath.js";
+import { waitAndCaptureScreenshot } from "../utils/screenshotHandler.js";
+import { substituteVariables } from "../utils/variables.js";
+
+export const typeTool = (v3: V3, provider?: string, variables?: Variables) => {
+  const hasVariables = variables && Object.keys(variables).length > 0;
+  const textDescription = hasVariables
+    ? `The text to type into the element. Use %variableName% to substitute a variable value. Available: ${Object.keys(variables).join(", ")}`
+    : "The text to type into the element";
+
+  return tool({
+    description:
+      "Type text into an element using its coordinates. This will click the element and then type the text into it (this is the most reliable way to type into an element, always use this over act, unless the element is not visible in the screenshot, but shown in ariaTree)",
+    inputSchema: z.object({
+      describe: z
+        .string()
+        .describe(
+          "Describe the element to type into in a short, specific phrase that mentions the element type and a good visual description",
+        ),
+      text: z.string().describe(textDescription),
+      coordinates: z
+        .array(z.number())
+        .describe("The (x, y) coordinates to type into the element"),
+    }),
+    execute: async ({
+      describe,
+      coordinates,
+      text,
+    }): Promise<TypeToolResult> => {
+      try {
+        const page = await v3.context.awaitActivePage();
+        const processed = processCoordinates(
+          coordinates[0],
+          coordinates[1],
+          provider,
+          v3,
+        );
+
+        // Substitute any %variableName% tokens in the text
+        const actualText = substituteVariables(text, variables);
+
+        v3.logger({
+          category: "agent",
+          message: `Agent calling tool: type`,
+          level: 1,
+          auxiliary: {
+            arguments: {
+              value: JSON.stringify({ describe, text }),
+              type: "object",
+            },
+          },
+        });
+
+        // Only request XPath when caching is enabled to avoid unnecessary computation
+        const shouldCollectXpath = v3.isAgentReplayActive();
+        const xpath = await page.click(processed.x, processed.y, {
+          returnXpath: shouldCollectXpath,
+        });
+
+        await page.type(actualText);
+
+        const screenshotBase64 = await waitAndCaptureScreenshot(page);
+
+        // Record as an "act" step with proper Action for deterministic replay (only when caching)
+        if (shouldCollectXpath) {
+          const normalizedXpath = ensureXPath(xpath);
+          if (normalizedXpath) {
+            const action: Action = {
+              selector: normalizedXpath,
+              description: describe,
+              method: "type",
+              arguments: [text],
+            };
+            v3.recordAgentReplayStep({
+              type: "act",
+              instruction: describe,
+              actions: [action],
+              actionDescription: describe,
+            });
+          }
+        }
+
+        return {
+          success: true,
+          describe,
+          text, // Return original text (with %variableName% tokens) to avoid exposing sensitive values to LLM
+          screenshotBase64,
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Error typing: ${(error as Error).message}`,
+        };
+      }
+    },
+    toModelOutput: (result) => {
+      if (result.success === false || result.error !== undefined) {
+        return {
+          type: "content",
+          value: [{ type: "text", text: JSON.stringify(result) }],
+        };
+      }
+
+      const content: ModelOutputContentItem[] = [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: result.success,
+            describe: result.describe,
+            text: result.text,
+          }),
+        },
+      ];
+      if (result.screenshotBase64) {
+        content.push({
+          type: "media",
+          mediaType: "image/png",
+          data: result.screenshotBase64,
+        });
+      }
+      return { type: "content", value: content };
+    },
+  });
+};
diff --git a/packages/core/lib/v3/agent/tools/wait.ts b/packages/core/lib/v3/agent/tools/wait.ts
new file mode 100644
index 000000000..41d684ed6
--- /dev/null
+++ b/packages/core/lib/v3/agent/tools/wait.ts
@@ -0,0 +1,69 @@
+import { tool } from "ai";
+import { z } from "zod";
+import type { V3 } from "../../v3.js";
+import type {
+  AgentToolMode,
+  WaitToolResult,
+  ModelOutputContentItem,
+} from "../../types/public/agent.js";
+import { waitAndCaptureScreenshot } from "../utils/screenshotHandler.js";
+
+export const waitTool = (v3: V3, mode?: AgentToolMode) =>
+  tool({
+    description: "Wait for a specified time",
+    inputSchema: z.object({
+      timeMs: z.number().describe("Time in milliseconds"),
+    }),
+    execute: async ({ timeMs }): Promise<WaitToolResult> => {
+      v3.logger({
+        category: "agent",
+        message: `Agent calling tool: wait`,
+        level: 1,
+        auxiliary: {
+          arguments: {
+            value: `Waiting for ${timeMs} milliseconds`,
+            type: "string",
+          },
+        },
+      });
+      await new Promise((resolve) => setTimeout(resolve, timeMs));
+      if (timeMs > 0) {
+        v3.recordAgentReplayStep({ type: "wait", timeMs });
+      }
+
+      // Take screenshot after wait in hybrid mode for visual feedback
+      if (mode === "hybrid") {
+        const page = await v3.context.awaitActivePage();
+        const screenshotBase64 = await waitAndCaptureScreenshot(page, 0);
+        return { success: true, waited: timeMs, screenshotBase64 };
+      }
+
+      return { success: true, waited: timeMs };
+    },
+    toModelOutput: (result) => {
+      if (result.success === false || result.error !== undefined) {
+        return {
+          type: "content",
+          value: [{ type: "text", text: JSON.stringify(result) }],
+        };
+      }
+
+      const content: ModelOutputContentItem[] = [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: result.success,
+            waited: result.waited,
+          }),
+        },
+      ];
+      if (result.screenshotBase64) {
+        content.push({
+          type: "media",
+          mediaType: "image/png",
+          data: result.screenshotBase64,
+        });
+      }
+      return { type: "content", value: content };
+    },
+  });
diff --git a/packages/core/lib/v3/agent/utils/actionMapping.ts b/packages/core/lib/v3/agent/utils/actionMapping.ts
new file mode 100644
index 000000000..866a4a0fa
--- /dev/null
+++ b/packages/core/lib/v3/agent/utils/actionMapping.ts
@@ -0,0 +1,150 @@
+import { AgentAction } from "../../types/public/agent.js";
+import { ActionMappingOptions } from "../../types/private/agent.js";
+
+/**
+ * Keys to exclude from tool outputs when mapping to actions.
+ * These are large data fields that shouldn't be included in the actions array.
+ * Users can access this data through result.messages if needed.
+ */
+const EXCLUDED_OUTPUT_KEYS = ["screenshotBase64"] as const;
+
+/**
+ * Strips excluded keys (like screenshotBase64) from a tool output object.
+ */
+function stripExcludedKeys(
+  output: Record<string, unknown>,
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(output)) {
+    if (
+      !EXCLUDED_OUTPUT_KEYS.includes(
+        key as (typeof EXCLUDED_OUTPUT_KEYS)[number],
+      )
+    ) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+export function mapToolResultToActions({
+  toolCallName,
+  toolResult,
+  args,
+  reasoning,
+}: ActionMappingOptions): AgentAction[] {
+  switch (toolCallName) {
+    case "act":
+      return mapActToolResult(toolResult, args, reasoning);
+    case "fillForm":
+      return mapFillFormToolResult(toolResult, args, reasoning);
+    default:
+      return [createStandardAction(toolCallName, toolResult, args, reasoning)];
+  }
+}
+
+function mapActToolResult(
+  toolResult: unknown,
+  args: Record<string, unknown>,
+  reasoning?: string,
+): AgentAction[] {
+  if (!toolResult || typeof toolResult !== "object") {
+    return [createStandardAction("act", toolResult, args, reasoning)];
+  }
+
+  const result = toolResult as Record<string, unknown>;
+
+  // AI SDK wraps the tool result in an output property
+  const output = (result.output as Record<string, unknown>) || result;
+
+  // Extract playwright arguments if they exist
+  const action: AgentAction = {
+    type: "act",
+    reasoning,
+    taskCompleted: false,
+    ...args,
+  };
+
+  if (output.playwrightArguments) {
+    action.playwrightArguments = output.playwrightArguments;
+  }
+
+  return [action];
+}
+
+function mapFillFormToolResult(
+  toolResult: unknown,
+  args: Record<string, unknown>,
+  reasoning?: string,
+): AgentAction[] {
+  if (!toolResult || typeof toolResult !== "object") {
+    return [createStandardAction("fillForm", toolResult, args, reasoning)];
+  }
+
+  const result = toolResult as Record<string, unknown>;
+
+  // AI SDK wraps the tool result in an output property
+  const output = (result.output as Record<string, unknown>) || result;
+
+  const observeResults = Array.isArray(output?.playwrightArguments)
+    ? output.playwrightArguments
+    : [];
+
+  const actions: AgentAction[] = [];
+
+  actions.push({
+    type: "fillForm",
+    reasoning,
+    taskCompleted: false,
+    ...args,
+  });
+
+  for (const observeResult of observeResults) {
+    actions.push({
+      type: "act",
+      reasoning: "acting from fillform tool",
+      taskCompleted: false,
+      playwrightArguments: observeResult,
+    });
+  }
+
+  return actions;
+}
+
+function createStandardAction(
+  toolCallName: string,
+  toolResult: unknown,
+  args: Record<string, unknown>,
+  reasoning?: string,
+): AgentAction {
+  const action: AgentAction = {
+    type: toolCallName,
+    reasoning,
+    taskCompleted:
+      toolCallName === "done" ? (args?.taskComplete as boolean) : false,
+    ...args,
+  };
+
+  // For screenshot tool, exclude base64 data and just indicate a screenshot was taken,
+  // if somebody really wants the base64 data, they can access it through messages
+  if (toolCallName === "screenshot") {
+    action.result = "screenshotTaken";
+    return action;
+  }
+
+  // Spread the output from the tool result if it exists
+  // Exclude ariaTree tool result as it is very large and unnecessary
+  if (toolCallName !== "ariaTree" && toolResult) {
+    const result = toolResult as { output?: unknown };
+    const output = result.output;
+
+    if (output && typeof output === "object" && !Array.isArray(output)) {
+      const cleanedOutput = stripExcludedKeys(
+        output as Record<string, unknown>,
+      );
+      Object.assign(action, cleanedOutput);
+    }
+  }
+
+  return action;
+}
diff --git a/packages/core/lib/v3/agent/utils/coordinateNormalization.ts b/packages/core/lib/v3/agent/utils/coordinateNormalization.ts
new file mode 100644
index 000000000..718c6883d
--- /dev/null
+++ b/packages/core/lib/v3/agent/utils/coordinateNormalization.ts
@@ -0,0 +1,40 @@
+import type { V3 } from "../../v3.js";
+
+// Default viewport for advancedStealth mode
+const STEALTH_VIEWPORT = { width: 1288, height: 711 };
+
+export function isGoogleProvider(provider?: string): boolean {
+  if (!provider) return false;
+  return provider.toLowerCase().includes("google");
+}
+
+// Google returns coordinates in a 0-1000 range, we need to normalize
+// them to the viewport dimensions
+export function normalizeGoogleCoordinates(
+  x: number,
+  y: number,
+  viewport: { width: number; height: number },
+): { x: number; y: number } {
+  const clampedX = Math.min(999, Math.max(0, x));
+  const clampedY = Math.min(999, Math.max(0, y));
+  return {
+    x: Math.floor((clampedX / 1000) * viewport.width),
+    y: Math.floor((clampedY / 1000) * viewport.height),
+  };
+}
+
+export function processCoordinates(
+  x: number,
+  y: number,
+  provider?: string,
+  v3?: V3,
+): { x: number; y: number } {
+  if (isGoogleProvider(provider) && v3) {
+    // advancedStealth uses fixed viewport, otherwise use configured viewport
+    const viewport = v3.isAdvancedStealth
+      ? STEALTH_VIEWPORT
+      : v3.configuredViewport;
+    return normalizeGoogleCoordinates(x, y, viewport);
+  }
+  return { x, y };
+}
diff --git a/packages/core/lib/v3/agent/utils/cuaKeyMapping.ts b/packages/core/lib/v3/agent/utils/cuaKeyMapping.ts
new file mode 100644
index 000000000..442df5eab
--- /dev/null
+++ b/packages/core/lib/v3/agent/utils/cuaKeyMapping.ts
@@ -0,0 +1,62 @@
+/**
+ * Universal key mapping utility for converting various key representations
+ * to Playwright-compatible key names. Used by all CUA clients and handlers.
+ */
+
+/**
+ * map of key variations to Playwright key names
+ * This handles keys from both Anthropic and OpenAI CUA APIs
+ */
+const KEY_MAP: Record<string, string> = {
+  ENTER: "Enter",
+  RETURN: "Enter",
+  ESCAPE: "Escape",
+  ESC: "Escape",
+  BACKSPACE: "Backspace",
+  TAB: "Tab",
+  SPACE: " ",
+  DELETE: "Delete",
+  DEL: "Delete",
+  ARROWUP: "ArrowUp",
+  ARROWDOWN: "ArrowDown",
+  ARROWLEFT: "ArrowLeft",
+  ARROWRIGHT: "ArrowRight",
+  ARROW_UP: "ArrowUp",
+  ARROW_DOWN: "ArrowDown",
+  ARROW_LEFT: "ArrowLeft",
+  ARROW_RIGHT: "ArrowRight",
+  UP: "ArrowUp",
+  DOWN: "ArrowDown",
+  LEFT: "ArrowLeft",
+  RIGHT: "ArrowRight",
+  SHIFT: "Shift",
+  CONTROL: "Control",
+  CTRL: "Control",
+  ALT: "Alt",
+  OPTION: "Alt", // macOS alternative name
+  META: "Meta",
+  COMMAND: "Meta", // macOS
+  CMD: "Meta", // macOS shorthand
+  SUPER: "Meta", // Linux
+  WINDOWS: "Meta", // Windows
+  WIN: "Meta", // Windows shorthand
+  HOME: "Home",
+  END: "End",
+  PAGEUP: "PageUp",
+  PAGEDOWN: "PageDown",
+  PAGE_UP: "PageUp",
+  PAGE_DOWN: "PageDown",
+  PGUP: "PageUp",
+  PGDN: "PageDown",
+};
+
+/**
+ * Maps a key name from various formats to Playwright-compatible format
+ * @param key The key name in any supported format
+ * @returns The Playwright-compatible key name
+ */
+export function mapKeyToPlaywright(key: string): string {
+  if (!key) return key;
+  const upperKey = key.toUpperCase();
+  return KEY_MAP[upperKey] || key;
+}
diff --git a/packages/core/lib/v3/agent/utils/googleCustomToolHandler.ts b/packages/core/lib/v3/agent/utils/googleCustomToolHandler.ts
new file mode 100644
index 000000000..986aa187e
--- /dev/null
+++ b/packages/core/lib/v3/agent/utils/googleCustomToolHandler.ts
@@ -0,0 +1,206 @@
+import { Part, FunctionCall, FunctionDeclaration, Type } from "@google/genai";
+import { ToolSet } from "ai";
+import { LogLine } from "../../types/public/logs.js";
+import { toJsonSchema } from "../../zodCompat.js";
+import type { StagehandZodSchema } from "../../zodCompat.js";
+
+/**
+ * Result of executing a custom tool for Google CUA
+ */
+export interface CustomToolExecutionResult {
+  functionResponse: Part;
+  success: boolean;
+}
+
+/**
+ * Execute a custom tool and format the response for Google's API
+ * This handles tool execution, result formatting, and error handling
+ * specific to Google's function response format
+ */
+export async function executeGoogleCustomTool(
+  toolName: string,
+  toolArgs: Record<string, unknown>,
+  tools: ToolSet,
+  functionCall: FunctionCall,
+  logger: (message: LogLine) => void,
+): Promise<CustomToolExecutionResult> {
+  try {
+    logger({
+      category: "agent",
+      message: `Executing custom tool: ${toolName} with args: ${JSON.stringify(toolArgs)}`,
+      level: 1,
+    });
+
+    const tool = tools[toolName];
+    const toolResult = await tool.execute(toolArgs, {
+      toolCallId: `tool_${Date.now()}`,
+      messages: [],
+    });
+
+    logger({
+      category: "agent",
+      message: `Tool ${toolName} completed successfully. Result: ${JSON.stringify(toolResult)}`,
+      level: 1,
+    });
+
+    // Create function response with the result
+    const functionResponsePart: Part = {
+      functionResponse: {
+        name: toolName,
+        response: {
+          result: JSON.stringify(toolResult),
+        },
+      },
+    };
+
+    return {
+      functionResponse: functionResponsePart,
+      success: true,
+    };
+  } catch (toolError) {
+    const errorMessage =
+      toolError instanceof Error ? toolError.message : String(toolError);
+
+    logger({
+      category: "agent",
+      message: `Error executing custom tool ${toolName}: ${errorMessage}`,
+      level: 0,
+    });
+
+    // Create error function response
+    const functionResponsePart: Part = {
+      functionResponse: {
+        name: toolName,
+        response: {
+          error: errorMessage,
+        },
+      },
+    };
+
+    return {
+      functionResponse: functionResponsePart,
+      success: false,
+    };
+  }
+}
+
+/**
+ * Check if a function call is a custom tool
+ */
+export function isCustomTool(
+  functionCall: FunctionCall,
+  tools?: ToolSet,
+): boolean {
+  return !!(tools && functionCall.name && functionCall.name in tools);
+}
+
+/**
+ * Convert ToolSet to Google's FunctionDeclaration array
+ * Handles the conversion of Zod schemas to Google's parameter format
+ */
+export function convertToolSetToFunctionDeclarations(
+  tools: ToolSet,
+): FunctionDeclaration[] {
+  const functionDeclarations: FunctionDeclaration[] = [];
+
+  for (const [name, tool] of Object.entries(tools)) {
+    const functionDeclaration = convertToolToFunctionDeclaration(name, tool);
+    if (functionDeclaration) {
+      functionDeclarations.push(functionDeclaration);
+    }
+  }
+
+  return functionDeclarations;
+}
+
+/**
+ * Convert a single ToolSet tool to Google's FunctionDeclaration format
+ */
+function convertToolToFunctionDeclaration(
+  name: string,
+  tool: { description?: string; inputSchema: unknown },
+): FunctionDeclaration | null {
+  try {
+    // Convert Zod schema to JSON schema
+    const schema = tool.inputSchema as StagehandZodSchema;
+    const jsonSchema = toJsonSchema(schema) as {
+      properties?: Record<string, unknown>;
+      required?: string[];
+      type?: string;
+    };
+
+    const parameters = convertJsonSchemaToGoogleParameters(jsonSchema);
+
+    return {
+      name,
+      description: tool.description || `Execute ${name}`,
+      parameters,
+    };
+  } catch (error) {
+    console.error(
+      `Error converting tool ${name} to function declaration:`,
+      error,
+    );
+    return null;
+  }
+}
+
+/**
+ * Convert JSON schema to Google's parameter format
+ */
+function convertJsonSchemaToGoogleParameters(schema: {
+  properties?: Record<string, unknown>;
+  required?: string[];
+  type?: string;
+}): {
+  type: Type;
+  properties: Record<string, { type: Type; description?: string }>;
+  required?: string[];
+} {
+  const properties: Record<string, { type: Type; description?: string }> = {};
+
+  if (schema.properties) {
+    for (const [key, value] of Object.entries(schema.properties)) {
+      const propSchema = value as {
+        type?: string;
+        description?: string;
+        items?: { type?: string };
+      };
+      properties[key] = {
+        type: mapJsonTypeToGoogleType(propSchema.type || "string"),
+        ...(propSchema.description
+          ? { description: propSchema.description }
+          : {}),
+      };
+    }
+  }
+
+  return {
+    type: Type.OBJECT,
+    properties,
+    ...(schema.required && schema.required.length > 0
+      ? { required: schema.required }
+      : {}),
+  };
+}
+
+/**
+ * Map JSON schema types to Google's Type enum
+ */
+function mapJsonTypeToGoogleType(jsonType: string): Type {
+  switch (jsonType.toLowerCase()) {
+    case "string":
+      return Type.STRING;
+    case "number":
+    case "integer":
+      return Type.NUMBER;
+    case "boolean":
+      return Type.BOOLEAN;
+    case "array":
+      return Type.ARRAY;
+    case "object":
+      return Type.OBJECT;
+    default:
+      return Type.STRING;
+  }
+}
diff --git a/packages/core/lib/v3/agent/utils/handleDoneToolCall.ts b/packages/core/lib/v3/agent/utils/handleDoneToolCall.ts
new file mode 100644
index 000000000..2011c8bbb
--- /dev/null
+++ b/packages/core/lib/v3/agent/utils/handleDoneToolCall.ts
@@ -0,0 +1,143 @@
+import { generateText, ModelMessage, LanguageModel, ToolSet } from "ai";
+import { z } from "zod";
+import { tool } from "ai";
+import { LogLine } from "../../types/public/logs.js";
+import { StagehandZodObject } from "../../zodCompat.js";
+import { getZFactory } from "../../../utils.js";
+import type { StagehandZodSchema } from "../../zodCompat.js";
+
+interface DoneResult {
+  reasoning: string;
+  taskComplete: boolean;
+  messages: ModelMessage[];
+  output?: Record<string, unknown>;
+}
+
+function buildBaseDoneSchema(factory: typeof z) {
+  return factory.object({
+    reasoning: factory
+      .string()
+      .describe("Brief summary of what actions were taken and the outcome"),
+    taskComplete: factory
+      .boolean()
+      .describe("true if the task was fully completed, false otherwise"),
+  });
+}
+
+/**
+ * Force a done tool call at the end of an agent run.
+ * This ensures we always get a structured final response,
+ * even if the main loop ended without calling done.
+ */
+export async function handleDoneToolCall(options: {
+  model: LanguageModel;
+  inputMessages: ModelMessage[];
+  instruction: string;
+  outputSchema?: StagehandZodObject;
+  logger: (message: LogLine) => void;
+}): Promise<DoneResult> {
+  const { model, inputMessages, instruction, outputSchema, logger } = options;
+
+  logger({
+    category: "agent",
+    message: "Agent calling tool: done",
+    level: 1,
+  });
+  // Use the same Zod version as the user's outputSchema to avoid v3/v4 mixing
+  const factory = outputSchema
+    ? getZFactory(outputSchema as StagehandZodSchema)
+    : z;
+  const baseDoneSchema = buildBaseDoneSchema(factory);
+
+  // Merge base done schema with user-provided output schema if present
+  const doneToolSchema = outputSchema
+    ? baseDoneSchema.extend({
+        output: outputSchema.describe(
+          "The specific data the user requested from this task",
+        ),
+      })
+    : baseDoneSchema;
+
+  const outputInstructions = outputSchema
+    ? `\n\nThe user also requested the following information from this task. Provide it in the "output" field:\n${JSON.stringify(
+        Object.fromEntries(
+          Object.entries(outputSchema.shape).map(
+            ([key, value]: [string, StagehandZodSchema]) => [
+              key,
+              value.description || "no description",
+            ],
+          ),
+        ),
+        null,
+        2,
+      )}`
+    : "";
+
+  const systemPrompt = `You are a web automation assistant that was tasked with completing a task.
+
+The task was:
+"${instruction}"
+
+Review what was accomplished and provide your final assessment in whether the task was completed successfully. you have been provided with the history of the actions taken so far, use this to determine if the task was completed successfully.${outputInstructions}
+
+Call the "done" tool with:
+1. A brief summary of what was done
+2. Whether the task was completed successfully${outputSchema ? "\n3. The requested output data based on what you found" : ""}`;
+
+  const doneTool = tool({
+    description: outputSchema
+      ? "Complete the task with your assessment and the requested output data."
+      : "Complete the task with your final assessment.",
+    inputSchema: doneToolSchema,
+    execute: async (params) => {
+      return { success: true, ...params };
+    },
+  });
+
+  const userPrompt: ModelMessage = {
+    role: "user",
+    content: outputSchema
+      ? "Provide your final assessment and the requested output data."
+      : "Provide your final assessment.",
+  };
+
+  const result = await generateText({
+    model,
+    system: systemPrompt,
+    messages: [...inputMessages, userPrompt],
+    tools: { done: doneTool } as ToolSet,
+    toolChoice: { type: "tool", toolName: "done" },
+  });
+
+  const doneToolCall = result.toolCalls.find((tc) => tc.toolName === "done");
+  const outputMessages: ModelMessage[] = [
+    userPrompt,
+    ...(result.response?.messages || []),
+  ];
+
+  if (!doneToolCall) {
+    return {
+      reasoning: result.text || "Task execution completed",
+      taskComplete: false,
+      messages: outputMessages,
+    };
+  }
+
+  const input = doneToolCall.input as {
+    reasoning: string;
+    taskComplete: boolean;
+    output?: Record<string, unknown>;
+  };
+  logger({
+    category: "agent",
+    message: `Task completed`,
+    level: 1,
+  });
+
+  return {
+    reasoning: input.reasoning,
+    taskComplete: input.taskComplete,
+    messages: outputMessages,
+    output: input.output,
+  };
+}
diff --git a/packages/core/lib/v3/agent/utils/imageCompression.ts b/packages/core/lib/v3/agent/utils/imageCompression.ts
new file mode 100644
index 000000000..c9a783cdf
--- /dev/null
+++ b/packages/core/lib/v3/agent/utils/imageCompression.ts
@@ -0,0 +1,303 @@
+import {
+  AnthropicMessage,
+  AnthropicContentBlock,
+  AnthropicToolResult,
+  ResponseInputItem as OpenAIResponseInputItem,
+} from "../../types/public/agent.js";
+import type {
+  Content as GoogleContent,
+  Part as GooglePart,
+} from "@google/genai";
+
+export type ResponseInputItem = AnthropicMessage | AnthropicToolResult;
+
+interface FunctionResponseData {
+  inlineData?: {
+    mimeType?: string;
+    data?: string;
+  };
+}
+export type AnthropicResponseInputItem = AnthropicMessage | AnthropicToolResult;
+export type SupportedInputItem =
+  | AnthropicResponseInputItem
+  | OpenAIResponseInputItem
+  | GoogleContent;
+
+/**
+ * Finds all items in the conversation history that contain images
+ * @param items - Array of conversation items to check
+ * @returns Array of indices where images were found
+ */
+export function findItemsWithImages(items: ResponseInputItem[]): number[] {
+  const itemsWithImages: number[] = [];
+
+  items.forEach((item, index) => {
+    let hasImage = false;
+
+    if (Array.isArray(item.content)) {
+      hasImage = item.content.some(
+        (contentItem: AnthropicContentBlock) =>
+          contentItem.type === "tool_result" &&
+          "content" in contentItem &&
+          Array.isArray(contentItem.content) &&
+          (contentItem.content as AnthropicContentBlock[]).some(
+            (nestedItem: AnthropicContentBlock) => nestedItem.type === "image",
+          ),
+      );
+    }
+
+    if (hasImage) {
+      itemsWithImages.push(index);
+    }
+  });
+
+  return itemsWithImages;
+}
+
+/**
+ * Compresses conversation history by removing images from older items
+ * while keeping the most recent images intact
+ * @param items - Array of conversation items to process
+ * @param keepMostRecentCount - Number of most recent image-containing items to preserve (default: 2)
+ * @returns Object with processed items
+ */
+export function compressConversationImages(
+  items: ResponseInputItem[],
+  keepMostRecentCount: number = 2,
+): { items: ResponseInputItem[] } {
+  const itemsWithImages = findItemsWithImages(items);
+
+  items.forEach((item, index) => {
+    const imageIndex = itemsWithImages.indexOf(index);
+    const shouldCompress =
+      imageIndex >= 0 &&
+      imageIndex < itemsWithImages.length - keepMostRecentCount;
+
+    if (shouldCompress) {
+      if (Array.isArray(item.content)) {
+        item.content = item.content.map(
+          (contentItem: AnthropicContentBlock) => {
+            if (
+              contentItem.type === "tool_result" &&
+              "content" in contentItem &&
+              Array.isArray(contentItem.content) &&
+              (contentItem.content as AnthropicContentBlock[]).some(
+                (nestedItem: AnthropicContentBlock) =>
+                  nestedItem.type === "image",
+              )
+            ) {
+              return {
+                ...contentItem,
+                content: "screenshot taken",
+              } as AnthropicContentBlock;
+            }
+            return contentItem;
+          },
+        );
+      }
+    }
+  });
+
+  return {
+    items,
+  };
+}
+
+/**
+ * Finds all items in the conversation history that contain images (Google format)
+ * @param items - Array of conversation items to check
+ * @returns Array of indices where images were found
+ */
+export function findGoogleItemsWithImages(items: GoogleContent[]): number[] {
+  const itemsWithImages: number[] = [];
+
+  items.forEach((item, index) => {
+    let hasImage = false;
+
+    if (item.parts && Array.isArray(item.parts)) {
+      hasImage = item.parts.some((part: GooglePart) => {
+        // Check for functionResponse with data containing images
+        if (part.functionResponse?.response?.data) {
+          const data = part.functionResponse.response
+            .data as FunctionResponseData[];
+          return data.some((dataItem) =>
+            dataItem.inlineData?.mimeType?.startsWith("image/"),
+          );
+        }
+
+        // Check for functionResponse with parts containing images
+        if (part.functionResponse?.parts) {
+          return part.functionResponse.parts.some((responsePart) =>
+            responsePart.inlineData?.mimeType?.startsWith("image/"),
+          );
+        }
+
+        // Check for direct inline data
+        return part.inlineData?.mimeType?.startsWith("image/");
+      });
+    }
+
+    if (hasImage) {
+      itemsWithImages.push(index);
+    }
+  });
+
+  return itemsWithImages;
+}
+
+/**
+ * Finds all items in the conversation history that contain images (OpenAI format)
+ * @param items - Array of conversation items to check
+ * @returns Array of indices where images were found
+ */
+export function findOpenAIItemsWithImages(
+  items: OpenAIResponseInputItem[],
+): number[] {
+  const itemsWithImages: number[] = [];
+
+  items.forEach((item, index) => {
+    let hasImage = false;
+
+    // Check for computer_call_output with image
+    if (
+      "type" in item &&
+      item.type === "computer_call_output" &&
+      "output" in item
+    ) {
+      const output = item.output as unknown as {
+        type: string;
+        image_url: string;
+      };
+      hasImage = output?.type === "input_image" && !!output?.image_url;
+    }
+
+    if (hasImage) {
+      itemsWithImages.push(index);
+    }
+  });
+
+  return itemsWithImages;
+}
+
+/**
+ * Compresses OpenAI conversation history by removing images from older items
+ * while keeping the most recent images intact
+ * @param items - Array of conversation items to process
+ * @param keepMostRecentCount - Number of most recent image-containing items to preserve (default: 2)
+ * @returns Object with processed items
+ */
+export function compressOpenAIConversationImages(
+  items: OpenAIResponseInputItem[],
+  keepMostRecentCount: number = 2,
+): { items: OpenAIResponseInputItem[] } {
+  const itemsWithImages = findOpenAIItemsWithImages(items);
+
+  items.forEach((item, index) => {
+    const imageIndex = itemsWithImages.indexOf(index);
+    const shouldCompress =
+      imageIndex >= 0 &&
+      imageIndex < itemsWithImages.length - keepMostRecentCount;
+
+    if (shouldCompress) {
+      // For computer_call_output with image, replace with text
+      if (
+        "type" in item &&
+        item.type === "computer_call_output" &&
+        "output" in item
+      ) {
+        const output = item.output as unknown as { type: string };
+        if (output?.type === "input_image") {
+          // Replace the image with a text message
+          (item as unknown as { output: string }).output = "screenshot taken";
+        }
+      }
+    }
+  });
+
+  return {
+    items,
+  };
+}
+
+/**
+ * Compresses Google conversation history by removing images from older items
+ * while keeping the most recent images intact
+ * @param items - Array of conversation items to process
+ * @param keepMostRecentCount - Number of most recent image-containing items to preserve (default: 2)
+ * @returns Object with processed items
+ */
+export function compressGoogleConversationImages(
+  items: GoogleContent[],
+  keepMostRecentCount: number = 2,
+): { items: GoogleContent[] } {
+  const itemsWithImages = findGoogleItemsWithImages(items);
+
+  items.forEach((item, index) => {
+    const imageIndex = itemsWithImages.indexOf(index);
+    const shouldCompress =
+      imageIndex >= 0 &&
+      imageIndex < itemsWithImages.length - keepMostRecentCount;
+
+    if (shouldCompress && item.parts && Array.isArray(item.parts)) {
+      item.parts = item.parts.map((part: GooglePart) => {
+        // Replace functionResponse with data containing images
+        if (part.functionResponse?.response?.data) {
+          const data = part.functionResponse.response
+            .data as FunctionResponseData[];
+          const hasImage = data.some((dataItem) =>
+            dataItem.inlineData?.mimeType?.startsWith("image/"),
+          );
+          if (hasImage) {
+            return {
+              ...part,
+              functionResponse: {
+                ...part.functionResponse,
+                data: [] as FunctionResponseData[],
+                response: {
+                  ...part.functionResponse.response,
+                  compressed: "screenshot taken",
+                },
+              },
+            };
+          }
+        }
+
+        // Replace functionResponse with parts containing images
+        if (part.functionResponse?.parts) {
+          const hasImageInParts = part.functionResponse.parts.some(
+            (responsePart) =>
+              responsePart.inlineData?.mimeType?.startsWith("image/"),
+          );
+          if (hasImageInParts) {
+            return {
+              ...part,
+              functionResponse: {
+                ...part.functionResponse,
+                parts: part.functionResponse.parts.filter(
+                  (responsePart) =>
+                    !responsePart.inlineData?.mimeType?.startsWith("image/"),
+                ),
+                response: {
+                  ...part.functionResponse.response,
+                  compressed: "screenshot taken",
+                },
+              },
+            };
+          }
+        }
+
+        // Replace direct inline data images
+        if (part.inlineData?.mimeType?.startsWith("image/")) {
+          return {
+            text: "screenshot taken",
+          };
+        }
+        return part;
+      });
+    }
+  });
+
+  return {
+    items,
+  };
+}
diff --git a/packages/core/lib/v3/agent/utils/messageProcessing.ts b/packages/core/lib/v3/agent/utils/messageProcessing.ts
new file mode 100644
index 000000000..c98f97931
--- /dev/null
+++ b/packages/core/lib/v3/agent/utils/messageProcessing.ts
@@ -0,0 +1,222 @@
+import type { ModelMessage } from "ai";
+
+// Vision action tools that include screenshots in their results
+const VISION_ACTION_TOOLS = [
+  "click",
+  "type",
+  "dragAndDrop",
+  "wait",
+  "fillFormVision",
+  "scroll",
+];
+
+function isToolMessage(
+  message: unknown,
+): message is { role: "tool"; content: unknown[] } {
+  return (
+    !!message &&
+    typeof message === "object" &&
+    (message as { role?: unknown }).role === "tool" &&
+    Array.isArray((message as { content?: unknown }).content)
+  );
+}
+
+function isScreenshotPart(part: unknown): boolean {
+  return (
+    !!part &&
+    typeof part === "object" &&
+    (part as { toolName?: unknown }).toolName === "screenshot"
+  );
+}
+
+function isVisionActionPart(part: unknown): boolean {
+  if (!part || typeof part !== "object") return false;
+  const toolName = (part as { toolName?: unknown }).toolName;
+  return typeof toolName === "string" && VISION_ACTION_TOOLS.includes(toolName);
+}
+
+function isVisionPart(part: unknown): boolean {
+  return isScreenshotPart(part) || isVisionActionPart(part);
+}
+
+function isAriaTreePart(part: unknown): boolean {
+  return (
+    !!part &&
+    typeof part === "object" &&
+    (part as { toolName?: unknown }).toolName === "ariaTree"
+  );
+}
+
+/**
+ * Compress old screenshot/ariaTree data in messages in-place.
+ *
+ * Strategy:
+ * - Keep only the 2 most recent vision results (screenshots OR vision action tools like click/type/etc)
+ * - Keep only the 1 most recent ariaTree (replace older ones with placeholder)
+ *
+ * @param messages - The messages array to modify in-place
+ * @returns Number of items compressed
+ */
+export function processMessages(messages: ModelMessage[]): number {
+  let compressedCount = 0;
+
+  // Find indices of all vision-related tool results (screenshots + vision actions)
+  // and ariaTree results
+  const visionIndices: number[] = [];
+  const ariaTreeIndices: number[] = [];
+
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+    if (isToolMessage(message)) {
+      const content = message.content as unknown[];
+      if (content.some(isVisionPart)) {
+        visionIndices.push(i);
+      }
+      if (content.some(isAriaTreePart)) {
+        ariaTreeIndices.push(i);
+      }
+    }
+  }
+
+  // Compress old vision results (keep 2 most recent across all vision tools)
+  if (visionIndices.length > 2) {
+    const toCompress = visionIndices.slice(0, visionIndices.length - 2);
+    for (const index of toCompress) {
+      const message = messages[index];
+      if (isToolMessage(message)) {
+        // Both functions are safe to call - they only modify their respective part types
+        compressScreenshotMessage(message);
+        compressVisionActionMessage(message);
+        compressedCount++;
+      }
+    }
+  }
+
+  // Compress old ariaTree results (keep 1 most recent)
+  if (ariaTreeIndices.length > 1) {
+    const toCompress = ariaTreeIndices.slice(0, ariaTreeIndices.length - 1);
+    for (const idx of toCompress) {
+      const message = messages[idx];
+      if (isToolMessage(message)) {
+        compressAriaTreeMessage(message);
+        compressedCount++;
+      }
+    }
+  }
+
+  return compressedCount;
+}
+
+/**
+ * Tool result part structure from AI SDK.
+ * The output field uses a discriminated union - type determines value format:
+ * - type: "content" -> value: Array<{type: "text", ...} | {type: "media", ...}>
+ * - type: "text" -> value: string
+ * - type: "json" -> value: JSONValue
+ * - type: "error-text" -> value: string
+ * - type: "error-json" -> value: JSONValue
+ */
+interface ToolResultPart {
+  output?: {
+    type: string;
+    value?: unknown;
+  };
+}
+
+/**
+ * Check if output has type "content" (array-based value format).
+ * Only outputs with type "content" should have array values.
+ */
+function isContentTypeOutput(output: {
+  type: string;
+  value?: unknown;
+}): boolean {
+  return output.type === "content";
+}
+
+/**
+ * Compress screenshot message content in-place.
+ * Only modifies outputs with type "content" to maintain schema validity.
+ * Replaces entire output object to ensure type/value consistency.
+ */
+function compressScreenshotMessage(message: {
+  role: "tool";
+  content: unknown[];
+}): void {
+  for (const part of message.content) {
+    if (isScreenshotPart(part)) {
+      const typedPart = part as ToolResultPart;
+      // Only compress if output exists and has type "content"
+      if (typedPart.output && isContentTypeOutput(typedPart.output)) {
+        // Replace entire output to ensure type/value consistency
+        typedPart.output = {
+          type: "content",
+          value: [{ type: "text", text: "screenshot taken" }],
+        };
+      }
+    }
+  }
+}
+
+/**
+ * Compress vision action message content in-place by removing the screenshot
+ * but keeping the action result text.
+ * Only modifies outputs with type "content" to maintain schema validity.
+ */
+function compressVisionActionMessage(message: {
+  role: "tool";
+  content: unknown[];
+}): void {
+  for (const part of message.content) {
+    if (isVisionActionPart(part)) {
+      const typedPart = part as ToolResultPart;
+
+      // Only compress if output is type "content" (array-based value)
+      if (
+        typedPart.output &&
+        isContentTypeOutput(typedPart.output) &&
+        Array.isArray(typedPart.output.value)
+      ) {
+        // Filter out media content but keep text results
+        const filteredValue = (
+          typedPart.output.value as Array<{ type?: string }>
+        ).filter(
+          (item) => item && typeof item === "object" && item.type !== "media",
+        );
+        // Replace entire output to ensure type/value consistency
+        typedPart.output = {
+          type: "content",
+          value: filteredValue,
+        };
+      }
+    }
+  }
+}
+
+/**
+ * Compress ariaTree message content in-place.
+ * Only modifies outputs with type "content" to maintain schema validity.
+ * Replaces entire output object to ensure type/value consistency.
+ */
+function compressAriaTreeMessage(message: {
+  role: "tool";
+  content: unknown[];
+}): void {
+  for (const part of message.content) {
+    if (isAriaTreePart(part)) {
+      const typedPart = part as ToolResultPart;
+      // Only compress if output exists and has type "content"
+      if (typedPart.output && isContentTypeOutput(typedPart.output)) {
+        typedPart.output = {
+          type: "content",
+          value: [
+            {
+              type: "text",
+              text: "ARIA tree extracted for context of page elements",
+            },
+          ],
+        };
+      }
+    }
+  }
+}
diff --git a/packages/core/lib/v3/agent/utils/screenshotHandler.ts b/packages/core/lib/v3/agent/utils/screenshotHandler.ts
new file mode 100644
index 000000000..fc3c6c4c7
--- /dev/null
+++ b/packages/core/lib/v3/agent/utils/screenshotHandler.ts
@@ -0,0 +1,31 @@
+import type { Page } from "../../understudy/page.js";
+
+/**
+ * Default delay in milliseconds to wait after vision actions before capturing screenshot.
+ * Allows the page to settle after interactions.
+ */
+const DEFAULT_DELAY_MS = 500;
+
+/**
+ * Waits for the page to settle and captures a screenshot.
+ * If the screenshot fails (e.g., page closed, navigation in progress),
+ * returns undefined instead of throwing - allowing the action to still succeed.
+ *
+ * @param page - The page to capture
+ * @param delayMs - Delay before capturing (default: 500ms, pass 0 to skip delay)
+ */
+export async function waitAndCaptureScreenshot(
+  page: Page,
+  delayMs: number = DEFAULT_DELAY_MS,
+): Promise<string | undefined> {
+  if (delayMs > 0) {
+    await page.waitForTimeout(delayMs);
+  }
+
+  try {
+    const buffer = await page.screenshot({ fullPage: false });
+    return buffer.toString("base64");
+  } catch {
+    return undefined;
+  }
+}
diff --git a/packages/core/lib/v3/agent/utils/validateExperimentalFeatures.ts b/packages/core/lib/v3/agent/utils/validateExperimentalFeatures.ts
new file mode 100644
index 000000000..cfcad7140
--- /dev/null
+++ b/packages/core/lib/v3/agent/utils/validateExperimentalFeatures.ts
@@ -0,0 +1,129 @@
+import {
+  ExperimentalNotConfiguredError,
+  StagehandInvalidArgumentError,
+} from "../../types/public/sdkErrors.js";
+import type {
+  AgentConfig,
+  AgentExecuteOptionsBase,
+} from "../../types/public/index.js";
+
+export interface AgentValidationOptions {
+  /** Whether experimental mode is enabled */
+  isExperimental: boolean;
+  /** Agent config options (integrations, tools, stream, cua, etc.) */
+  agentConfig?: Partial<AgentConfig>;
+  /** Execute options (callbacks, signal, messages, etc.) */
+  executeOptions?:
+    | (Partial<AgentExecuteOptionsBase> & { callbacks?: unknown })
+    | null;
+  /** Whether this is streaming mode (can be derived from agentConfig.stream) */
+  isStreaming?: boolean;
+}
+
+/**
+ * Validates agent configuration and experimental feature usage.
+ *
+ * This utility consolidates all validation checks for both CUA and non-CUA agent paths:
+ * - Invalid argument errors for CUA (streaming, abort signal, message continuation, excludeTools, output schema are not supported)
+ * - Experimental feature checks for integrations and tools (both CUA and non-CUA)
+ * - Experimental feature checks for hybrid mode (requires experimental: true)
+ * - Experimental feature checks for non-CUA only (callbacks, signal, messages, streaming, excludeTools, output schema)
+ *
+ * Throws StagehandInvalidArgumentError for invalid/unsupported configurations.
+ * Throws ExperimentalNotConfiguredError if experimental features are used without experimental mode.
+ */
+export function validateExperimentalFeatures(
+  options: AgentValidationOptions,
+): void {
+  const { isExperimental, agentConfig, executeOptions, isStreaming } = options;
+
+  // Check if CUA mode is enabled (via mode: "cua" or deprecated cua: true)
+  const isCuaMode =
+    agentConfig?.mode !== undefined
+      ? agentConfig.mode === "cua"
+      : agentConfig?.cua === true;
+
+  // CUA-specific validation: certain features are not available at all
+  if (isCuaMode) {
+    const unsupportedFeatures: string[] = [];
+
+    if (agentConfig?.stream) {
+      unsupportedFeatures.push("streaming");
+    }
+    if (executeOptions?.signal) {
+      unsupportedFeatures.push("abort signal");
+    }
+    if (executeOptions?.messages) {
+      unsupportedFeatures.push("message continuation");
+    }
+    if (
+      executeOptions?.excludeTools &&
+      executeOptions.excludeTools.length > 0
+    ) {
+      unsupportedFeatures.push("excludeTools");
+    }
+    if (executeOptions?.output) {
+      unsupportedFeatures.push("output schema");
+    }
+    if (
+      executeOptions?.variables &&
+      Object.keys(executeOptions.variables).length > 0
+    ) {
+      unsupportedFeatures.push("variables");
+    }
+
+    if (unsupportedFeatures.length > 0) {
+      throw new StagehandInvalidArgumentError(
+        `${unsupportedFeatures.join(", ")} ${unsupportedFeatures.length === 1 ? "is" : "are"} not supported with CUA (Computer Use Agent) mode.`,
+      );
+    }
+  }
+
+  // Skip experimental checks if already in experimental mode
+  if (isExperimental) return;
+
+  const features: string[] = [];
+
+  // Check agent config features (check array length to avoid false positives for empty arrays)
+  const hasIntegrations =
+    agentConfig?.integrations && agentConfig.integrations.length > 0;
+  const hasTools =
+    agentConfig?.tools && Object.keys(agentConfig.tools).length > 0;
+  if (hasIntegrations || hasTools) {
+    features.push("MCP integrations and custom tools");
+  }
+
+  // Check streaming mode (either explicit or derived from config) - only for non-CUA
+  if (!isCuaMode && (isStreaming || agentConfig?.stream)) {
+    features.push("streaming");
+  }
+
+  // Check execute options features - only for non-CUA
+  if (executeOptions && !isCuaMode) {
+    if (executeOptions.callbacks) {
+      features.push("callbacks");
+    }
+    if (executeOptions.signal) {
+      features.push("abort signal");
+    }
+    if (executeOptions.messages) {
+      features.push("message continuation");
+    }
+    if (executeOptions.excludeTools && executeOptions.excludeTools.length > 0) {
+      features.push("excludeTools");
+    }
+    if (executeOptions.output) {
+      features.push("output schema");
+    }
+    if (
+      executeOptions.variables &&
+      Object.keys(executeOptions.variables).length > 0
+    ) {
+      features.push("variables");
+    }
+  }
+
+  if (features.length > 0) {
+    throw new ExperimentalNotConfiguredError(`Agent ${features.join(", ")}`);
+  }
+}
diff --git a/packages/core/lib/v3/agent/utils/variables.ts b/packages/core/lib/v3/agent/utils/variables.ts
new file mode 100644
index 000000000..9f46b1951
--- /dev/null
+++ b/packages/core/lib/v3/agent/utils/variables.ts
@@ -0,0 +1,55 @@
+import type { Variables, VariableValue } from "../../types/public/agent.js";
+
+/**
+ * Resolves a VariableValue to its primitive string value.
+ * Handles both simple primitives ("secret") and rich objects ({ value: "secret", description: "..." }).
+ */
+export function resolveVariableValue(v: VariableValue): string {
+  if (typeof v === "object" && v !== null && "value" in v) {
+    return String(v.value);
+  }
+  return String(v);
+}
+
+/**
+ * Extracts the optional description from a VariableValue.
+ * Returns undefined for simple primitive values.
+ */
+export function getVariableDescription(v: VariableValue): string | undefined {
+  if (typeof v === "object" && v !== null && "value" in v) {
+    return v.description;
+  }
+  return undefined;
+}
+
+/**
+ * Substitutes %variableName% tokens in text with resolved variable values.
+ * Works with both simple and rich variable formats.
+ */
+export function substituteVariables(
+  text: string,
+  variables?: Variables,
+): string {
+  if (!variables) return text;
+  let result = text;
+  for (const [key, v] of Object.entries(variables)) {
+    const token = `%${key}%`;
+    result = result.split(token).join(resolveVariableValue(v));
+  }
+  return result;
+}
+
+/**
+ * Flattens Variables to Record<string, string> for internal consumers
+ * that only need key→value mappings (e.g., actHandler, cache replay).
+ */
+export function flattenVariables(
+  variables?: Variables,
+): Record<string, string> | undefined {
+  if (!variables || Object.keys(variables).length === 0) return undefined;
+  const result: Record<string, string> = {};
+  for (const [key, v] of Object.entries(variables)) {
+    result[key] = resolveVariableValue(v);
+  }
+  return result;
+}
diff --git a/packages/core/lib/v3/agent/utils/xpath.ts b/packages/core/lib/v3/agent/utils/xpath.ts
new file mode 100644
index 000000000..f311b899e
--- /dev/null
+++ b/packages/core/lib/v3/agent/utils/xpath.ts
@@ -0,0 +1,17 @@
+/**
+ * Utility functions for XPath handling in agent tools.
+ */
+
+/**
+ * Ensures a value is properly formatted as an XPath selector.
+ * Returns null if the value is not a valid string.
+ *
+ * @param value - The value to normalize as an XPath
+ * @returns The normalized XPath string prefixed with "xpath=" or null
+ */
+export function ensureXPath(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  return trimmed.startsWith("xpath=") ? trimmed : `xpath=${trimmed}`;
+}
diff --git a/packages/core/lib/v3/api.ts b/packages/core/lib/v3/api.ts
new file mode 100644
index 000000000..9fe289208
--- /dev/null
+++ b/packages/core/lib/v3/api.ts
@@ -0,0 +1,886 @@
+import makeFetchCookie from "fetch-cookie";
+import { loadApiKeyFromEnv } from "../utils.js";
+import { STAGEHAND_VERSION } from "../version.js";
+import {
+  StagehandAPIError,
+  StagehandAPIUnauthorizedError,
+  StagehandHttpError,
+  StagehandResponseBodyError,
+  StagehandResponseParseError,
+  StagehandServerError,
+  ExperimentalNotConfiguredError,
+} from "./types/public/index.js";
+import type {
+  ActResult,
+  AgentConfig,
+  AgentExecuteOptions,
+  AgentResult,
+  ExtractResult,
+  ObserveResult,
+  LogLine,
+  StagehandMetrics,
+  BrowserbaseRegion,
+  ActOptions,
+  ExtractOptions,
+  ObserveOptions,
+  Api,
+} from "./types/public/index.js";
+import type {
+  SerializableResponse,
+  AgentCacheTransferPayload,
+} from "./types/private/index.js";
+import type { ModelConfiguration } from "./types/public/model.js";
+import { toJsonSchema } from "./zodCompat.js";
+import type { StagehandZodSchema } from "./zodCompat.js";
+
+// =============================================================================
+// Multi-region API URL mapping
+// =============================================================================
+
+/**
+ * Mapping of Browserbase regions to their corresponding Stagehand API base URLs.
+ * Users should configure their client to hit the API endpoint that matches
+ * the region where their browser session is running.
+ */
+export const REGION_API_URLS: Record<BrowserbaseRegion, string> = {
+  "us-west-2": "https://api.stagehand.browserbase.com",
+  "us-east-1": "https://api.use1.stagehand.browserbase.com",
+  "eu-central-1": "https://api.euc1.stagehand.browserbase.com",
+  "ap-southeast-1": "https://api.apse1.stagehand.browserbase.com",
+};
+
+/**
+ * Returns the full API URL (with /v1 suffix) for a given Browserbase region.
+ * If no region is specified or the region is unknown, defaults to us-west-2.
+ *
+ * @param region - The Browserbase region (e.g., "us-west-2", "eu-central-1")
+ * @returns The full API URL including /v1 suffix
+ */
+export function getApiUrlForRegion(
+  region: BrowserbaseRegion | undefined,
+): string {
+  const baseUrl =
+    REGION_API_URLS[region as BrowserbaseRegion] ??
+    REGION_API_URLS["us-west-2"];
+  return `${baseUrl}/v1`;
+}
+
+// =============================================================================
+// Client-specific types (can't be Zod schemas due to functions/Page objects)
+// =============================================================================
+//
+// These types mirror the Api.* schemas from types/public/api.ts but include
+// non-serializable SDK fields (like Page objects) that get stripped before
+// sending requests over the wire.
+//
+// Relationship to wire format:
+// - Client accepts: SDK types (ActOptions, ExtractOptions, etc.) with optional `page`
+// - Wire sends: Api.* types (page stripped, Zod schema converted to JSON schema)
+// - Client returns: SDK result types (ActResult, ExtractResult, etc.)
+// =============================================================================
+
+/**
+ * Constructor parameters for StagehandAPIClient
+ */
+interface StagehandAPIConstructorParams {
+  apiKey: string;
+  projectId?: string;
+  logger: (message: LogLine) => void;
+  /**
+   * When true, enables server-side caching by default for all requests.
+   * When false, disables server-side caching.
+   * Defaults to true (caching enabled).
+   * Can be overridden per-method in act(), extract(), and observe() options.
+   */
+  serverCache?: boolean;
+}
+
+/**
+ * Parameters for starting a session via the API client.
+ * Extends Api.SessionStartRequest with client-specific field (modelApiKey).
+ *
+ * Wire format: Api.SessionStartRequest (modelApiKey sent via header, not body)
+ */
+interface ClientSessionStartParams extends Api.SessionStartRequest {
+  /** Model API key - sent via x-model-api-key header, not in request body */
+  modelApiKey: string;
+}
+
+/**
+ * Generic API response wrapper matching Api.*Response schemas
+ */
+type ApiResponse<T> =
+  | { success: true; data: T }
+  | { success: false; message: string };
+
+/**
+ * Union of all API request body types for type-safe execute() calls
+ */
+type ApiRequestBody =
+  | Api.ActRequest
+  | Api.ExtractRequest
+  | Api.ObserveRequest
+  | Api.NavigateRequest
+  | Api.AgentExecuteRequest;
+
+/**
+ * Parameters for executing an action via the streaming API
+ */
+interface ExecuteActionParams {
+  method: "act" | "extract" | "observe" | "navigate" | "end" | "agentExecute";
+  args?: ApiRequestBody;
+  params?: Record<string, string>;
+  /**
+   * Override the instance-level serverCache setting for this request.
+   * When true, enables server-side caching.
+   * When false, disables server-side caching.
+   */
+  serverCache?: boolean;
+}
+
+/**
+ * Client parameters for act() method.
+ * Derives structure from Api.ActRequest but uses SDK's ActOptions (which includes `page`).
+ * Before serialization, `page` is stripped to produce Api.ActRequest wire format.
+ */
+interface ClientActParameters {
+  input: Api.ActRequest["input"];
+  options?: ActOptions;
+  frameId?: Api.ActRequest["frameId"];
+}
+
+/**
+ * Client parameters for extract() method.
+ * Derives structure from Api.ExtractRequest but uses SDK's ExtractOptions (which includes `page`)
+ * and accepts Zod schema (converted to JSON schema for wire format).
+ */
+interface ClientExtractParameters {
+  instruction?: Api.ExtractRequest["instruction"];
+  schema?: StagehandZodSchema;
+  options?: ExtractOptions;
+  frameId?: Api.ExtractRequest["frameId"];
+}
+
+/**
+ * Client parameters for observe() method.
+ * Derives structure from Api.ObserveRequest but uses SDK's ObserveOptions (which includes `page`).
+ * Before serialization, `page` is stripped to produce Api.ObserveRequest wire format.
+ */
+interface ClientObserveParameters {
+  instruction?: Api.ObserveRequest["instruction"];
+  options?: ObserveOptions;
+  frameId?: Api.ObserveRequest["frameId"];
+}
+
+export class StagehandAPIClient {
+  private apiKey: string;
+  private projectId?: string;
+  private sessionId?: string;
+  private modelApiKey: string;
+  private modelProvider?: string;
+  private region?: BrowserbaseRegion;
+  private logger: (message: LogLine) => void;
+  private fetchWithCookies;
+  private serverCache: boolean;
+  private lastFinishedEventData: Record<string, unknown> | null = null;
+  private latestAgentCacheEntry: AgentCacheTransferPayload | null = null;
+
+  constructor({
+    apiKey,
+    projectId,
+    logger,
+    serverCache,
+  }: StagehandAPIConstructorParams) {
+    this.apiKey = apiKey;
+    this.projectId = projectId;
+    this.logger = logger;
+    this.serverCache = serverCache ?? true;
+    // Create a single cookie jar instance that will persist across all requests
+    this.fetchWithCookies = makeFetchCookie(fetch);
+  }
+
+  async init({
+    modelName,
+    modelApiKey,
+    domSettleTimeoutMs,
+    verbose,
+    systemPrompt,
+    selfHeal,
+    browserbaseSessionCreateParams,
+    browserbaseSessionID,
+    // browser,  TODO for local browsers
+  }: ClientSessionStartParams): Promise<Api.SessionStartResult> {
+    if (!modelApiKey) {
+      throw new StagehandAPIError("modelApiKey is required");
+    }
+    this.modelApiKey = modelApiKey;
+    // Extract provider from modelName (e.g., "openai/gpt-5-nano" -> "openai")
+    this.modelProvider = modelName?.includes("/")
+      ? modelName.split("/")[0]
+      : undefined;
+
+    // Store the region for multi-region API URL resolution
+    this.region = browserbaseSessionCreateParams?.region;
+
+    this.logger({
+      category: "init",
+      message: "Creating new browserbase session...",
+      level: 1,
+    });
+
+    // Build wire-format request body (Api.SessionStartRequest shape)
+    const requestBody: Api.SessionStartRequest = {
+      modelName,
+      domSettleTimeoutMs,
+      verbose,
+      systemPrompt,
+      selfHeal,
+      browserbaseSessionCreateParams,
+      browserbaseSessionID,
+      // browser, TODO: only send when connected to local fastify
+    };
+
+    const sessionResponse = await this.request("/sessions/start", {
+      method: "POST",
+      body: JSON.stringify(requestBody),
+    });
+
+    if (sessionResponse.status === 401) {
+      throw new StagehandAPIUnauthorizedError(
+        "Unauthorized. Ensure you provided a valid API key.",
+      );
+    } else if (sessionResponse.status !== 200) {
+      const errorText = await sessionResponse.text();
+      this.logger({
+        category: "api",
+        message: `API error (${sessionResponse.status}): ${errorText}`,
+        level: 0,
+      });
+      throw new StagehandHttpError(`Unknown error: ${sessionResponse.status}`);
+    }
+
+    const sessionResponseBody =
+      (await sessionResponse.json()) as ApiResponse<Api.SessionStartResult>;
+
+    if (sessionResponseBody.success === false) {
+      throw new StagehandAPIError(sessionResponseBody.message);
+    }
+
+    // Temporary reroute for rollout
+    if (!sessionResponseBody.data?.available && browserbaseSessionID) {
+      sessionResponseBody.data.sessionId = browserbaseSessionID;
+    }
+
+    this.sessionId = sessionResponseBody.data.sessionId;
+
+    return sessionResponseBody.data;
+  }
+
+  async act({
+    input,
+    options,
+    frameId,
+  }: ClientActParameters): Promise<ActResult> {
+    // Strip non-serializable `page` and SDK-only fields from options before wire serialization
+    let wireOptions: Api.ActRequest["options"];
+    let serverCache: boolean | undefined;
+    if (options) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { page: _, serverCache: enableCache, ...restOptions } = options;
+      serverCache = enableCache;
+      if (Object.keys(restOptions).length > 0) {
+        if (restOptions.model) {
+          restOptions.model = this.prepareModelConfig(restOptions.model);
+        }
+        wireOptions = restOptions as unknown as Api.ActRequest["options"];
+      }
+    }
+
+    // Build wire-format request body
+    const requestBody: Api.ActRequest = {
+      input,
+      options: wireOptions,
+      frameId,
+    };
+
+    return this.execute<ActResult>({
+      method: "act",
+      args: requestBody,
+      serverCache,
+    });
+  }
+
+  async extract<T extends StagehandZodSchema>({
+    instruction,
+    schema: zodSchema,
+    options,
+    frameId,
+  }: ClientExtractParameters): Promise<ExtractResult<T>> {
+    // Convert Zod schema to JSON schema for wire format
+    const jsonSchema = zodSchema ? toJsonSchema(zodSchema) : undefined;
+
+    // Strip non-serializable `page` and SDK-only fields from options before wire serialization
+    let wireOptions: Api.ExtractRequest["options"];
+    let serverCache: boolean | undefined;
+    if (options) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { page: _, serverCache: enableCache, ...restOptions } = options;
+      serverCache = enableCache;
+      if (Object.keys(restOptions).length > 0) {
+        if (restOptions.model) {
+          restOptions.model = this.prepareModelConfig(restOptions.model);
+        }
+        wireOptions = restOptions as unknown as Api.ExtractRequest["options"];
+      }
+    }
+
+    // Build wire-format request body
+    const requestBody: Api.ExtractRequest = {
+      instruction,
+      schema: jsonSchema,
+      options: wireOptions,
+      frameId,
+    };
+
+    return this.execute<ExtractResult<T>>({
+      method: "extract",
+      args: requestBody,
+      serverCache,
+    });
+  }
+
+  async observe({
+    instruction,
+    options,
+    frameId,
+  }: ClientObserveParameters): Promise<ObserveResult> {
+    // Strip non-serializable `page` and SDK-only fields from options before wire serialization
+    let wireOptions: Api.ObserveRequest["options"];
+    let serverCache: boolean | undefined;
+    if (options) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { page: _, serverCache: enableCache, ...restOptions } = options;
+      serverCache = enableCache;
+      if (Object.keys(restOptions).length > 0) {
+        if (restOptions.model) {
+          restOptions.model = this.prepareModelConfig(restOptions.model);
+        }
+        wireOptions = restOptions as unknown as Api.ObserveRequest["options"];
+      }
+    }
+
+    // Build wire-format request body
+    const requestBody: Api.ObserveRequest = {
+      instruction,
+      options: wireOptions,
+      frameId,
+    };
+
+    return this.execute<ObserveResult>({
+      method: "observe",
+      args: requestBody,
+      serverCache,
+    });
+  }
+
+  async goto(
+    url: string,
+    options?: Api.NavigateRequest["options"],
+    frameId?: string,
+  ): Promise<SerializableResponse | null> {
+    const requestBody: Api.NavigateRequest = { url, options, frameId };
+
+    return this.execute<SerializableResponse | null>({
+      method: "navigate",
+      args: requestBody,
+    });
+  }
+
+  async agentExecute(
+    agentConfig: AgentConfig,
+    executeOptions: AgentExecuteOptions | string,
+    frameId?: string,
+    shouldCache?: boolean,
+  ): Promise<AgentResult> {
+    // Check if integrations are being used in API mode (not supported)
+    if (agentConfig.integrations && agentConfig.integrations.length > 0) {
+      throw new ExperimentalNotConfiguredError("MCP integrations");
+    }
+
+    // Strip non-serializable `page` from executeOptions before wire serialization
+    let wireExecuteOptions: Api.AgentExecuteRequest["executeOptions"];
+    if (typeof executeOptions === "string") {
+      wireExecuteOptions = { instruction: executeOptions };
+    } else if (executeOptions.page) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { page: _, ...rest } = executeOptions;
+      wireExecuteOptions = rest;
+    } else {
+      wireExecuteOptions = executeOptions;
+    }
+
+    const wireAgentConfig: Api.AgentExecuteRequest["agentConfig"] = {
+      systemPrompt: agentConfig.systemPrompt,
+      mode: agentConfig.mode ?? (agentConfig.cua === true ? "cua" : undefined),
+      cua: agentConfig.mode === undefined ? agentConfig.cua : undefined,
+      model: agentConfig.model
+        ? this.prepareModelConfig(agentConfig.model)
+        : undefined,
+      executionModel: agentConfig.executionModel
+        ? this.prepareModelConfig(agentConfig.executionModel)
+        : undefined,
+    };
+
+    // Build wire-format request body
+    const requestBody: Api.AgentExecuteRequest = {
+      agentConfig: wireAgentConfig,
+      executeOptions: wireExecuteOptions,
+      frameId,
+      shouldCache,
+    };
+
+    const result = await this.execute<AgentResult>({
+      method: "agentExecute",
+      args: requestBody,
+    });
+
+    const finishedData =
+      this.consumeFinishedEventData<Api.AgentExecuteResult>() ?? null;
+    this.latestAgentCacheEntry =
+      finishedData?.cacheEntry !== undefined
+        ? (finishedData.cacheEntry as AgentCacheTransferPayload)
+        : null;
+    return result;
+  }
+
+  consumeLatestAgentCacheEntry(): AgentCacheTransferPayload | null {
+    const entry = this.latestAgentCacheEntry;
+    this.latestAgentCacheEntry = null;
+    return entry;
+  }
+
+  async end(): Promise<Response> {
+    const url = `/sessions/${this.sessionId}/end`;
+    const response = await this.request(url, {
+      method: "POST",
+    });
+    return response;
+  }
+
+  async getReplayMetrics(): Promise<StagehandMetrics> {
+    if (!this.sessionId) {
+      throw new StagehandAPIError("sessionId is required to fetch metrics.");
+    }
+
+    const response = await this.request(`/sessions/${this.sessionId}/replay`, {
+      method: "GET",
+    });
+
+    if (response.status !== 200) {
+      const errorText = await response.text();
+      this.logger({
+        category: "api",
+        message: `Failed to fetch metrics. Status ${response.status}: ${errorText}`,
+        level: 0,
+      });
+      throw new StagehandHttpError(
+        `Failed to fetch metrics with status ${response.status}: ${errorText}`,
+      );
+    }
+
+    const data = (await response.json()) as
+      | Api.ReplayResponse
+      | { success: false; error?: string };
+
+    if (!data.success) {
+      const errorData = data as { success: false; error?: string };
+      throw new StagehandAPIError(
+        `Failed to fetch metrics: ${errorData.error || "Unknown error"}`,
+      );
+    }
+
+    // Parse the API data into StagehandMetrics format
+    const apiData = (data as Api.ReplayResponse).data;
+    const metrics: StagehandMetrics = {
+      actPromptTokens: 0,
+      actCompletionTokens: 0,
+      actReasoningTokens: 0,
+      actCachedInputTokens: 0,
+      actInferenceTimeMs: 0,
+      extractPromptTokens: 0,
+      extractCompletionTokens: 0,
+      extractReasoningTokens: 0,
+      extractCachedInputTokens: 0,
+      extractInferenceTimeMs: 0,
+      observePromptTokens: 0,
+      observeCompletionTokens: 0,
+      observeReasoningTokens: 0,
+      observeCachedInputTokens: 0,
+      observeInferenceTimeMs: 0,
+      agentPromptTokens: 0,
+      agentCompletionTokens: 0,
+      agentReasoningTokens: 0,
+      agentCachedInputTokens: 0,
+      agentInferenceTimeMs: 0,
+      totalPromptTokens: 0,
+      totalCompletionTokens: 0,
+      totalReasoningTokens: 0,
+      totalCachedInputTokens: 0,
+      totalInferenceTimeMs: 0,
+    };
+
+    // Parse pages and their actions
+    const pages = apiData?.pages || [];
+    for (const page of pages) {
+      const actions = page.actions || [];
+      for (const action of actions) {
+        // Get method name and token usage
+        const method = (action.method || "").toLowerCase();
+        const tokenUsage = action.tokenUsage;
+
+        if (tokenUsage) {
+          const inputTokens = tokenUsage.inputTokens || 0;
+          const outputTokens = tokenUsage.outputTokens || 0;
+          const reasoningTokens =
+            "reasoningTokens" in tokenUsage
+              ? Number(
+                  (tokenUsage as { reasoningTokens?: number })
+                    .reasoningTokens ?? 0,
+                )
+              : 0;
+          const cachedInputTokens =
+            "cachedInputTokens" in tokenUsage
+              ? Number(
+                  (tokenUsage as { cachedInputTokens?: number })
+                    .cachedInputTokens ?? 0,
+                )
+              : 0;
+          const timeMs = tokenUsage.timeMs || 0;
+
+          // Map method to metrics fields
+          if (method === "act") {
+            metrics.actPromptTokens += inputTokens;
+            metrics.actCompletionTokens += outputTokens;
+            metrics.actReasoningTokens += reasoningTokens;
+            metrics.actCachedInputTokens += cachedInputTokens;
+            metrics.actInferenceTimeMs += timeMs;
+          } else if (method === "extract") {
+            metrics.extractPromptTokens += inputTokens;
+            metrics.extractCompletionTokens += outputTokens;
+            metrics.extractReasoningTokens += reasoningTokens;
+            metrics.extractCachedInputTokens += cachedInputTokens;
+            metrics.extractInferenceTimeMs += timeMs;
+          } else if (method === "observe") {
+            metrics.observePromptTokens += inputTokens;
+            metrics.observeCompletionTokens += outputTokens;
+            metrics.observeReasoningTokens += reasoningTokens;
+            metrics.observeCachedInputTokens += cachedInputTokens;
+            metrics.observeInferenceTimeMs += timeMs;
+          } else if (method === "agent") {
+            metrics.agentPromptTokens += inputTokens;
+            metrics.agentCompletionTokens += outputTokens;
+            metrics.agentReasoningTokens += reasoningTokens;
+            metrics.agentCachedInputTokens += cachedInputTokens;
+            metrics.agentInferenceTimeMs += timeMs;
+          }
+
+          // Always update totals for any method with token usage
+          metrics.totalPromptTokens += inputTokens;
+          metrics.totalCompletionTokens += outputTokens;
+          metrics.totalReasoningTokens += reasoningTokens;
+          metrics.totalCachedInputTokens += cachedInputTokens;
+          metrics.totalInferenceTimeMs += timeMs;
+        }
+      }
+    }
+
+    return metrics;
+  }
+
+  /**
+   * Prepares a model configuration for the API payload by ensuring the `apiKey`
+   * is included. If the model is passed as a string, converts it to an object
+   * with `modelName` and `apiKey`.
+   *
+   * In API mode, we only attempt to load an API key from env vars when the
+   * model provider differs from the one used to init the session.
+   */
+  private prepareModelConfig(
+    model: ModelConfiguration,
+  ): { modelName: string; apiKey: string } & Record<string, unknown> {
+    if (typeof model === "string") {
+      // Extract provider from model string (e.g., "openai/gpt-5-nano" -> "openai")
+      const provider = model.includes("/") ? model.split("/")[0] : undefined;
+      const apiKey =
+        provider && provider !== this.modelProvider
+          ? (loadApiKeyFromEnv(provider, this.logger) ?? this.modelApiKey)
+          : this.modelApiKey;
+      return {
+        modelName: model,
+        apiKey,
+      };
+    }
+
+    if (!model.apiKey) {
+      const provider = model.modelName?.includes("/")
+        ? model.modelName.split("/")[0]
+        : undefined;
+      const apiKey =
+        provider && provider !== this.modelProvider
+          ? (loadApiKeyFromEnv(provider, this.logger) ?? this.modelApiKey)
+          : this.modelApiKey;
+      return {
+        ...model,
+        apiKey,
+      };
+    }
+
+    return model as { modelName: string; apiKey: string } & Record<
+      string,
+      unknown
+    >;
+  }
+
+  private consumeFinishedEventData<T>(): T | null {
+    const data = this.lastFinishedEventData as T | null;
+    this.lastFinishedEventData = null;
+    return data;
+  }
+
+  private async execute<T>({
+    method,
+    args,
+    params,
+    serverCache,
+  }: ExecuteActionParams): Promise<T> {
+    this.lastFinishedEventData = null;
+    const urlParams = new URLSearchParams(params as Record<string, string>);
+    const queryString = urlParams.toString();
+    const url = `/sessions/${this.sessionId}/${method}${queryString ? `?${queryString}` : ""}`;
+
+    const response = await this.request(
+      url,
+      {
+        method: "POST",
+        body: JSON.stringify(args),
+      },
+      serverCache,
+    );
+
+    // Capture cache status from response header
+    const cacheStatus = response.headers.get("browserbase-cache-status") as
+      | "HIT"
+      | "MISS"
+      | null;
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new StagehandHttpError(
+        `HTTP error! status: ${response.status}, body: ${errorBody}`,
+      );
+    }
+
+    if (!response.body) {
+      throw new StagehandResponseBodyError();
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    while (true) {
+      const { value, done } = await reader.read();
+
+      if (done && !buffer) {
+        throw new StagehandServerError(
+          "Stream ended without completion signal",
+        );
+      }
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+
+        try {
+          const eventData = JSON.parse(line.slice(6));
+
+          if (eventData.type === "system") {
+            if (eventData.data.status === "error") {
+              const { error: errorMsg } = eventData.data;
+              // Throw plain Error to match local SDK behavior (useApi: false)
+              throw new Error(errorMsg);
+            }
+            if (eventData.data.status === "finished") {
+              this.lastFinishedEventData = eventData.data;
+
+              // If caching was bypassed for this request, suppress cache status
+              // so we don't log or surface a MISS that the server emits anyway.
+              const cacheEnabled = this.shouldUseCache(serverCache);
+              return this.attachCacheStatus(
+                eventData.data.result as T,
+                method,
+                cacheEnabled ? cacheStatus : null,
+                cacheEnabled ? eventData : { data: {} },
+              );
+            }
+          } else if (eventData.type === "log") {
+            const msg = eventData.data.message;
+            // Skip server-side internal logs that don't apply to API mode
+            if (msg?.message === "Connecting to local browser") {
+              continue;
+            }
+            this.logger(eventData.data.message);
+          }
+        } catch (e) {
+          // Let Error instances pass through (server errors thrown above)
+          // Only wrap SyntaxError from JSON.parse as parse errors
+          if (e instanceof Error && !(e instanceof SyntaxError)) {
+            throw e;
+          }
+
+          const errorMessage = e instanceof Error ? e.message : String(e);
+          this.logger({
+            category: "api",
+            message: `Failed to parse SSE event: ${errorMessage}`,
+            level: 0,
+          });
+          throw new StagehandResponseParseError(
+            `Failed to parse server response: ${errorMessage}`,
+          );
+        }
+      }
+
+      if (done) {
+        // Process any remaining data in buffer before exiting
+        if (buffer.trim() && buffer.startsWith("data: ")) {
+          try {
+            const eventData = JSON.parse(buffer.slice(6));
+            if (
+              eventData.type === "system" &&
+              eventData.data.status === "finished"
+            ) {
+              return this.attachCacheStatus(
+                eventData.data.result as T,
+                method,
+                cacheStatus,
+                eventData,
+              );
+            }
+          } catch {
+            this.logger({
+              category: "api",
+              message: `Incomplete data in final buffer: ${buffer.substring(0, 100)}`,
+              level: 0,
+            });
+          }
+        }
+        throw new StagehandServerError(
+          "Stream ended without completion signal",
+        );
+      }
+    }
+  }
+
+  /**
+   * Resolves the final cache status from the response header or SSE event data,
+   * logs it, and attaches it to act/extract results before returning.
+   */
+  private attachCacheStatus<T>(
+    result: T,
+    method: string,
+    cacheStatus: "HIT" | "MISS" | null,
+    eventData: { data: { cacheHit?: boolean } },
+  ): T {
+    const finalCacheStatus =
+      cacheStatus ||
+      (typeof eventData.data.cacheHit === "boolean"
+        ? eventData.data.cacheHit
+          ? "HIT"
+          : "MISS"
+        : undefined);
+    if (
+      finalCacheStatus &&
+      (method === "act" || method === "extract" || method === "observe")
+    ) {
+      this.logger({
+        category: "cache",
+        message: `${method} server cache ${finalCacheStatus.toLowerCase()}`,
+        level: 1,
+      });
+    }
+    if (
+      finalCacheStatus &&
+      result &&
+      typeof result === "object" &&
+      (method === "act" || method === "extract" || method === "observe")
+    ) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (result as ActResult | ExtractResult<any> | ObserveResult).cacheStatus =
+        finalCacheStatus;
+    }
+    return result;
+  }
+
+  /**
+   * Determine if caching should be enabled for a request.
+   * Method-level setting takes precedence over instance-level setting.
+   */
+  private shouldUseCache(methodServerCache?: boolean): boolean {
+    // If method-level setting is explicitly provided, use it
+    if (methodServerCache !== undefined) {
+      return methodServerCache;
+    }
+    // Otherwise, use instance-level setting
+    return this.serverCache;
+  }
+
+  private async request(
+    path: string,
+    options: RequestInit,
+    serverCache?: boolean,
+  ): Promise<Response> {
+    const defaultHeaders: Record<string, string> = {
+      "x-bb-api-key": this.apiKey,
+      ...(this.projectId ? { "x-bb-project-id": this.projectId } : {}),
+      "x-bb-session-id": this.sessionId,
+      // we want real-time logs, so we stream the response
+      "x-stream-response": "true",
+      "x-model-api-key": this.modelApiKey,
+      "x-language": "typescript",
+      "x-sdk-version": STAGEHAND_VERSION,
+    };
+
+    // Add cache bypass header if caching is disabled
+    if (!this.shouldUseCache(serverCache)) {
+      defaultHeaders["browserbase-cache-bypass"] = "true";
+    }
+
+    if (options.method === "POST" && options.body) {
+      defaultHeaders["Content-Type"] = "application/json";
+    }
+
+    // Use STAGEHAND_API_URL env var if set, otherwise use region-based URL
+    // Ensure /v1 suffix is present for consistency
+    let baseUrl: string;
+    if (process.env.STAGEHAND_API_URL) {
+      const envUrl = process.env.STAGEHAND_API_URL.replace(/\/+$/, "");
+      // Append /v1 if not already present
+      baseUrl = envUrl.endsWith("/v1") ? envUrl : `${envUrl}/v1`;
+    } else {
+      baseUrl = getApiUrlForRegion(this.region);
+    }
+
+    const response = await this.fetchWithCookies(`${baseUrl}${path}`, {
+      ...options,
+      headers: {
+        ...defaultHeaders,
+        ...options.headers,
+      },
+    });
+
+    return response;
+  }
+}
diff --git a/packages/core/lib/v3/cache/ActCache.ts b/packages/core/lib/v3/cache/ActCache.ts
new file mode 100644
index 000000000..d11ba9cc0
--- /dev/null
+++ b/packages/core/lib/v3/cache/ActCache.ts
@@ -0,0 +1,386 @@
+import { createHash } from "crypto";
+import type { ActHandler } from "../handlers/actHandler.js";
+import type { LLMClient } from "../llm/LLMClient.js";
+import type { Action, ActResult, Logger } from "../types/public/index.js";
+import type { Page } from "../understudy/page.js";
+import { CacheStorage } from "./CacheStorage.js";
+import { safeGetPageUrl, waitForCachedSelector } from "./utils.js";
+import {
+  ActCacheContext,
+  ActCacheDeps,
+  CachedActEntry,
+} from "../types/private/index.js";
+import { StagehandNotInitializedError } from "../types/public/sdkErrors.js";
+import { withTimeout } from "../timeoutConfig.js";
+
+export class ActCache {
+  private readonly storage: CacheStorage;
+  private readonly logger: Logger;
+  private readonly getActHandler: () => ActHandler | null;
+  private readonly getDefaultLlmClient: () => LLMClient;
+  private readonly domSettleTimeoutMs?: number;
+
+  constructor({
+    storage,
+    logger,
+    getActHandler,
+    getDefaultLlmClient,
+    domSettleTimeoutMs,
+  }: ActCacheDeps) {
+    this.storage = storage;
+    this.logger = logger;
+    this.getActHandler = getActHandler;
+    this.getDefaultLlmClient = getDefaultLlmClient;
+    this.domSettleTimeoutMs = domSettleTimeoutMs;
+  }
+
+  get enabled(): boolean {
+    return this.storage.enabled;
+  }
+
+  async prepareContext(
+    instruction: string,
+    page: Page,
+    variables?: Record<string, string>,
+  ): Promise<ActCacheContext | null> {
+    if (!this.enabled) return null;
+    const sanitizedInstruction = instruction.trim();
+    const sanitizedVariables = variables ? { ...variables } : undefined;
+    const variableKeys = sanitizedVariables
+      ? Object.keys(sanitizedVariables).sort()
+      : [];
+    const pageUrl = await safeGetPageUrl(page);
+    const cacheKey = this.buildActCacheKey(
+      sanitizedInstruction,
+      pageUrl,
+      variableKeys,
+    );
+    return {
+      instruction: sanitizedInstruction,
+      cacheKey,
+      pageUrl,
+      variableKeys,
+      variables: sanitizedVariables,
+    };
+  }
+
+  async tryReplay(
+    context: ActCacheContext,
+    page: Page,
+    timeout?: number,
+    llmClientOverride?: LLMClient,
+  ): Promise<ActResult | null> {
+    if (!this.enabled) return null;
+
+    const {
+      value: entry,
+      error,
+      path,
+    } = await this.storage.readJson<CachedActEntry>(`${context.cacheKey}.json`);
+    if (error && path) {
+      this.logger({
+        category: "cache",
+        message: `failed to read act cache entry: ${path}`,
+        level: 2,
+        auxiliary: {
+          error: { value: String(error), type: "string" },
+        },
+      });
+      return null;
+    }
+    if (!entry) return null;
+    if (entry.version !== 1) return null;
+    if (!Array.isArray(entry.actions) || entry.actions.length === 0) {
+      return null;
+    }
+
+    const entryVariableKeys = Array.isArray(entry.variableKeys)
+      ? [...entry.variableKeys].sort()
+      : [];
+    const contextVariableKeys = [...context.variableKeys];
+
+    if (!this.doVariableKeysMatch(entryVariableKeys, contextVariableKeys)) {
+      return null;
+    }
+
+    if (
+      contextVariableKeys.length > 0 &&
+      (!context.variables ||
+        !this.hasAllVariableValues(contextVariableKeys, context.variables))
+    ) {
+      this.logger({
+        category: "cache",
+        message: "act cache miss: missing variables for replay",
+        level: 2,
+        auxiliary: {
+          instruction: { value: context.instruction, type: "string" },
+        },
+      });
+      return null;
+    }
+
+    this.logger({
+      category: "cache",
+      message: "act cache hit",
+      level: 1,
+      auxiliary: {
+        instruction: { value: context.instruction, type: "string" },
+        url: {
+          value: entry.url ?? context.pageUrl,
+          type: "string",
+        },
+      },
+    });
+
+    return await this.replayCachedActions(
+      context,
+      entry,
+      page,
+      timeout,
+      llmClientOverride,
+    );
+  }
+
+  async store(context: ActCacheContext, result: ActResult): Promise<void> {
+    if (!this.enabled) return;
+
+    const entry: CachedActEntry = {
+      version: 1,
+      instruction: context.instruction,
+      url: context.pageUrl,
+      variableKeys: context.variableKeys,
+      actions: result.actions ?? [],
+      actionDescription: result.actionDescription,
+      message: result.message,
+    };
+
+    const { error, path } = await this.storage.writeJson(
+      `${context.cacheKey}.json`,
+      entry,
+    );
+    if (error && path) {
+      this.logger({
+        category: "cache",
+        message: "failed to write act cache entry",
+        level: 1,
+        auxiliary: {
+          error: { value: String(error), type: "string" },
+        },
+      });
+      return;
+    }
+
+    this.logger({
+      category: "cache",
+      message: "act cache stored",
+      level: 2,
+      auxiliary: {
+        instruction: { value: context.instruction, type: "string" },
+        url: { value: context.pageUrl, type: "string" },
+      },
+    });
+  }
+
+  private buildActCacheKey(
+    instruction: string,
+    url: string,
+    variableKeys: string[],
+  ): string {
+    const payload = JSON.stringify({
+      instruction,
+      url,
+      variableKeys,
+    });
+    return createHash("sha256").update(payload).digest("hex");
+  }
+
+  private async replayCachedActions(
+    context: ActCacheContext,
+    entry: CachedActEntry,
+    page: Page,
+    timeout?: number,
+    llmClientOverride?: LLMClient,
+  ): Promise<ActResult> {
+    const handler = this.getActHandler();
+    if (!handler) {
+      throw new StagehandNotInitializedError("act()");
+    }
+    const effectiveClient = llmClientOverride ?? this.getDefaultLlmClient();
+
+    const execute = async (): Promise<ActResult> => {
+      const actionResults: ActResult[] = [];
+      for (const action of entry.actions) {
+        await waitForCachedSelector({
+          page,
+          selector: action.selector,
+          timeout: this.domSettleTimeoutMs,
+          logger: this.logger,
+          context: "act",
+        });
+        const result = await handler.takeDeterministicAction(
+          action,
+          page,
+          this.domSettleTimeoutMs,
+          effectiveClient,
+          undefined,
+          context.variables,
+        );
+        actionResults.push(result);
+        if (!result.success) {
+          break;
+        }
+      }
+
+      if (actionResults.length === 0) {
+        return {
+          success: false,
+          message: "Failed to perform act: cached entry has no actions",
+          actionDescription: entry.actionDescription ?? entry.instruction,
+          actions: [],
+        };
+      }
+
+      const success = actionResults.every((r) => r.success);
+      const actions = actionResults.flatMap((r) => r.actions ?? []);
+      const message =
+        actionResults
+          .map((r) => r.message)
+          .filter((m) => m && m.trim().length > 0)
+          .join(" → ") ||
+        entry.message ||
+        `Replayed ${entry.actions.length} cached action${
+          entry.actions.length === 1 ? "" : "s"
+        }.`;
+      const actionDescription =
+        entry.actionDescription ||
+        actionResults[actionResults.length - 1]?.actionDescription ||
+        entry.actions[entry.actions.length - 1]?.description ||
+        entry.instruction;
+
+      if (
+        success &&
+        actions.length > 0 &&
+        this.haveActionsChanged(entry.actions, actions)
+      ) {
+        await this.refreshCacheEntry(context, {
+          ...entry,
+          actions,
+          message,
+          actionDescription,
+        });
+      }
+      return {
+        success,
+        message,
+        actionDescription,
+        actions,
+      };
+    };
+
+    return await withTimeout(execute(), timeout, "act()");
+  }
+
+  private haveActionsChanged(original: Action[], updated: Action[]): boolean {
+    if (original.length !== updated.length) {
+      return true;
+    }
+
+    for (let i = 0; i < original.length; i += 1) {
+      const orig = original[i];
+      const next = updated[i];
+      if (!next) {
+        return true;
+      }
+
+      if (orig.selector !== next.selector) {
+        return true;
+      }
+
+      if (orig.description !== next.description) {
+        return true;
+      }
+
+      if ((orig.method ?? "") !== (next.method ?? "")) {
+        return true;
+      }
+
+      const origArgs = orig.arguments ?? [];
+      const nextArgs = next.arguments ?? [];
+      if (origArgs.length !== nextArgs.length) {
+        return true;
+      }
+
+      for (let j = 0; j < origArgs.length; j += 1) {
+        if (origArgs[j] !== nextArgs[j]) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  private async refreshCacheEntry(
+    context: ActCacheContext,
+    entry: CachedActEntry,
+  ): Promise<void> {
+    const { error, path } = await this.storage.writeJson(
+      `${context.cacheKey}.json`,
+      {
+        ...entry,
+        variableKeys: context.variableKeys,
+      },
+    );
+
+    if (error && path) {
+      this.logger({
+        category: "cache",
+        message: "failed to update act cache entry after self-heal",
+        level: 0,
+        auxiliary: {
+          error: { value: String(error), type: "string" },
+        },
+      });
+      return;
+    }
+
+    this.logger({
+      category: "cache",
+      message: "act cache entry updated after self-heal",
+      level: 2,
+      auxiliary: {
+        instruction: { value: context.instruction, type: "string" },
+        url: { value: context.pageUrl, type: "string" },
+      },
+    });
+  }
+
+  private doVariableKeysMatch(
+    entryKeys: string[],
+    contextKeys: string[],
+  ): boolean {
+    if (entryKeys.length !== contextKeys.length) {
+      return false;
+    }
+
+    for (let i = 0; i < entryKeys.length; i += 1) {
+      if (entryKeys[i] !== contextKeys[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  private hasAllVariableValues(
+    variableKeys: string[],
+    variables: Record<string, string>,
+  ): boolean {
+    for (const key of variableKeys) {
+      if (!(key in variables)) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
diff --git a/packages/core/lib/v3/cache/AgentCache.ts b/packages/core/lib/v3/cache/AgentCache.ts
new file mode 100644
index 000000000..e922be6c4
--- /dev/null
+++ b/packages/core/lib/v3/cache/AgentCache.ts
@@ -0,0 +1,898 @@
+import { createHash } from "crypto";
+import type { ActHandler } from "../handlers/actHandler.js";
+import type { LLMClient } from "../llm/LLMClient.js";
+import type {
+  AgentReplayActStep,
+  AgentReplayFillFormStep,
+  AgentReplayGotoStep,
+  AgentReplayKeysStep,
+  AgentReplayNavBackStep,
+  AgentReplayScrollStep,
+  AgentReplayStep,
+  AgentReplayWaitStep,
+  CachedAgentEntry,
+  SanitizedAgentExecuteOptions,
+  ActFn,
+  AgentCacheContext,
+  AgentCacheDeps,
+  AgentCacheTransferPayload,
+} from "../types/private/index.js";
+import type {
+  Action,
+  AgentResult,
+  AgentStreamResult,
+  AgentConfig,
+  AgentExecuteOptionsBase,
+  AvailableModel,
+  Logger,
+} from "../types/public/index.js";
+import type { Page } from "../understudy/page.js";
+import type { V3Context } from "../understudy/context.js";
+import { CacheStorage } from "./CacheStorage.js";
+import {
+  cloneForCache,
+  safeGetPageUrl,
+  waitForCachedSelector,
+} from "./utils.js";
+
+const SENSITIVE_CONFIG_KEYS = new Set(["apikey", "api_key", "api-key"]);
+
+export class AgentCache {
+  private readonly storage: CacheStorage;
+  private readonly logger: Logger;
+  private readonly getActHandler: () => ActHandler | null;
+  private readonly getContext: () => V3Context | null;
+  private readonly getDefaultLlmClient: () => LLMClient;
+  private readonly getBaseModelName: () => AvailableModel;
+  private readonly getSystemPrompt: () => string | undefined;
+  private readonly domSettleTimeoutMs?: number;
+  private readonly act: ActFn;
+  private readonly bufferLatestEntry: boolean;
+
+  private recording: AgentReplayStep[] | null = null;
+  private latestEntry: AgentCacheTransferPayload | null = null;
+
+  constructor({
+    storage,
+    logger,
+    getActHandler,
+    getContext,
+    getDefaultLlmClient,
+    getBaseModelName,
+    getSystemPrompt,
+    domSettleTimeoutMs,
+    act,
+    bufferLatestEntry,
+  }: AgentCacheDeps) {
+    this.storage = storage;
+    this.logger = logger;
+    this.getActHandler = getActHandler;
+    this.getContext = getContext;
+    this.getDefaultLlmClient = getDefaultLlmClient;
+    this.getBaseModelName = getBaseModelName;
+    this.getSystemPrompt = getSystemPrompt;
+    this.domSettleTimeoutMs = domSettleTimeoutMs;
+    this.act = act;
+    this.bufferLatestEntry = bufferLatestEntry ?? false;
+  }
+
+  get enabled(): boolean {
+    return this.storage.enabled;
+  }
+
+  shouldAttemptCache(instruction: string): boolean {
+    return this.enabled && instruction.trim().length > 0;
+  }
+
+  sanitizeExecuteOptions(
+    options?: AgentExecuteOptionsBase,
+  ): SanitizedAgentExecuteOptions {
+    if (!options) return {};
+    const sanitized: SanitizedAgentExecuteOptions = {};
+    if (typeof options.maxSteps === "number") {
+      sanitized.maxSteps = options.maxSteps;
+    }
+    if (
+      "highlightCursor" in options &&
+      typeof (options as { highlightCursor?: unknown }).highlightCursor ===
+        "boolean"
+    ) {
+      sanitized.highlightCursor = (
+        options as { highlightCursor?: boolean }
+      ).highlightCursor;
+    }
+    return sanitized;
+  }
+
+  buildConfigSignature(agentOptions?: AgentConfig): string {
+    const toolKeys = agentOptions?.tools
+      ? Object.keys(agentOptions.tools).sort()
+      : undefined;
+    const integrationSignatures = agentOptions?.integrations
+      ? agentOptions.integrations.map((integration) =>
+          typeof integration === "string" ? integration : "client",
+        )
+      : undefined;
+    const serializedModel = this.serializeAgentModelForCache(
+      agentOptions?.model,
+    );
+    const serializedExecutionModel = this.serializeAgentModelForCache(
+      agentOptions?.executionModel,
+    );
+
+    const isCuaMode =
+      agentOptions?.mode !== undefined
+        ? agentOptions.mode === "cua"
+        : agentOptions?.cua === true;
+
+    return JSON.stringify({
+      v3Model: this.getBaseModelName(),
+      systemPrompt: this.getSystemPrompt() ?? "",
+      agent: {
+        cua: isCuaMode,
+        model: serializedModel ?? null,
+        executionModel: isCuaMode ? null : serializedExecutionModel,
+        systemPrompt: agentOptions?.systemPrompt ?? null,
+        toolKeys,
+        integrations: integrationSignatures,
+      },
+    });
+  }
+
+  async prepareContext(params: {
+    instruction: string;
+    options: SanitizedAgentExecuteOptions;
+    configSignature: string;
+    page: Page;
+    variables?: Record<string, string>;
+  }): Promise<AgentCacheContext | null> {
+    if (!this.shouldAttemptCache(params.instruction)) {
+      return null;
+    }
+    const instruction = params.instruction.trim();
+    const startUrl = await safeGetPageUrl(params.page);
+    const variableKeys = params.variables
+      ? Object.keys(params.variables).sort()
+      : [];
+    const cacheKey = this.buildAgentCacheKey(
+      instruction,
+      startUrl,
+      params.options,
+      params.configSignature,
+      variableKeys,
+    );
+    return {
+      instruction,
+      startUrl,
+      options: params.options,
+      configSignature: params.configSignature,
+      cacheKey,
+      variableKeys,
+      variables: params.variables,
+    };
+  }
+
+  async tryReplay(
+    context: AgentCacheContext,
+    llmClientOverride?: LLMClient,
+  ): Promise<AgentResult | null> {
+    if (!this.enabled) return null;
+
+    const {
+      value: entry,
+      error,
+      path,
+    } = await this.storage.readJson<CachedAgentEntry>(
+      `agent-${context.cacheKey}.json`,
+    );
+    if (error && path) {
+      this.logger({
+        category: "cache",
+        message: `failed to read agent cache entry: ${path}`,
+        level: 1,
+        auxiliary: {
+          error: { value: String(error), type: "string" },
+        },
+      });
+      return null;
+    }
+    if (!entry || entry.version !== 1) {
+      return null;
+    }
+
+    this.logger({
+      category: "cache",
+      message: "agent cache hit",
+      level: 1,
+      auxiliary: {
+        instruction: { value: context.instruction, type: "string" },
+        url: { value: context.startUrl, type: "string" },
+      },
+    });
+
+    return await this.replayAgentCacheEntry(context, entry, llmClientOverride);
+  }
+
+  /**
+   * Attempts to replay a cached agent execution and returns it as a stream result.
+   *
+   * This method exists because the agent API exposes two execution modes:
+   * - `execute()` - Returns a Promise<AgentResult> directly
+   * - `stream()` - Returns an AgentStreamResult with async iterables for real-time output
+   *
+   * When a cache hit occurs, we need to return the appropriate type for each mode:
+   * - For `execute()`, we use `tryReplay()` which returns AgentResult
+   * - For `stream()`, we use `tryReplayAsStream()` which wraps the result in a
+   *   stream-compatible interface
+   *
+   * This ensures consumers using `stream()` can still iterate over `textStream`
+   * and await `result` even when the response comes from cache, maintaining
+   * API consistency regardless of whether the result was cached or live.
+   */
+  async tryReplayAsStream(
+    context: AgentCacheContext,
+    llmClientOverride?: LLMClient,
+  ): Promise<AgentStreamResult | null> {
+    const result = await this.tryReplay(context, llmClientOverride);
+    if (!result) return null;
+    return this.createCachedStreamResult(result);
+  }
+
+  /**
+   * Creates a mock AgentStreamResult that wraps a cached AgentResult.
+   *
+   * AgentStreamResult (from the AI SDK) is a complex type with multiple async
+   * iterables and promises. When serving from cache, we don't have an actual
+   * LLM stream to consume - we just have the final result. This method creates
+   * a "fake" stream
+
+   * This approach lets cached responses be transparent to the consumer -
+   * they can use the same iteration patterns whether the result is live or cached.
+   */
+  private createCachedStreamResult(
+    cachedResult: AgentResult,
+  ): AgentStreamResult {
+    const message = cachedResult.message ?? "";
+
+    async function* textStreamGenerator(): AsyncGenerator<string> {
+      yield message;
+    }
+
+    async function* fullStreamGenerator(): AsyncGenerator<{
+      type: string;
+      textDelta?: string;
+    }> {
+      yield { type: "text-delta", textDelta: message };
+      yield { type: "finish" };
+    }
+
+    const mockStreamResult = {
+      textStream: textStreamGenerator(),
+      fullStream: fullStreamGenerator(),
+      result: Promise.resolve(cachedResult),
+      text: Promise.resolve(message),
+      usage: Promise.resolve({
+        promptTokens: 0,
+        completionTokens: 0,
+        totalTokens: 0,
+      }),
+      finishReason: Promise.resolve("stop" as const),
+      experimental_providerMetadata: Promise.resolve(undefined),
+      response: Promise.resolve({
+        id: "cached",
+        timestamp: new Date(),
+        modelId: "cached",
+      }),
+      rawResponse: Promise.resolve({ headers: {} }),
+      warnings: Promise.resolve([]),
+      steps: Promise.resolve([]),
+      toolCalls: Promise.resolve([]),
+      toolResults: Promise.resolve([]),
+      [Symbol.asyncIterator]: () => textStreamGenerator(),
+    } as unknown as AgentStreamResult;
+
+    return mockStreamResult;
+  }
+
+  /**
+   * Wraps an AgentStreamResult with caching logic.
+   *
+   * This method handles the complexity of caching for streaming responses:
+   * 1. Begins recording agent replay steps
+   * 2. Wraps the stream's result promise to capture completion
+   * 3. On success: ends recording and stores the cache entry
+   * 4. On error: discards the recording
+   *
+   * This keeps the caching orchestration in AgentCache rather than
+   * spreading it across the V3 class.
+   *
+   * @param context - The cache context for this execution
+   * @param streamResult - The stream result from the agent handler
+   * @param beginRecording - Callback to start recording (from V3)
+   * @param endRecording - Callback to end recording and get steps (from V3)
+   * @param discardRecording - Callback to discard recording on error (from V3)
+   * @returns The wrapped stream result with caching enabled
+   */
+  wrapStreamForCaching(
+    context: AgentCacheContext,
+    streamResult: AgentStreamResult,
+    beginRecording: () => void,
+    endRecording: () => AgentReplayStep[],
+    discardRecording: () => void,
+  ): AgentStreamResult {
+    beginRecording();
+
+    const originalResultPromise = streamResult.result;
+    const wrappedResultPromise = originalResultPromise.then(
+      async (result) => {
+        const agentSteps = endRecording();
+
+        if (result.success && agentSteps.length > 0) {
+          await this.store(context, agentSteps, result);
+        }
+
+        return result;
+      },
+      (error) => {
+        discardRecording();
+        throw error;
+      },
+    );
+
+    streamResult.result = wrappedResultPromise;
+    return streamResult;
+  }
+
+  async store(
+    context: AgentCacheContext,
+    steps: AgentReplayStep[],
+    result: AgentResult,
+  ): Promise<void> {
+    if (!this.enabled) return;
+
+    const entry: CachedAgentEntry = {
+      version: 1,
+      instruction: context.instruction,
+      startUrl: context.startUrl,
+      options: context.options,
+      configSignature: context.configSignature,
+      steps: cloneForCache(steps),
+      result: this.pruneAgentResult(result),
+      timestamp: new Date().toISOString(),
+    };
+
+    const { error, path } = await this.storage.writeJson(
+      `agent-${context.cacheKey}.json`,
+      entry,
+    );
+    if (error && path) {
+      this.logger({
+        category: "cache",
+        message: "failed to write agent cache entry",
+        level: 1,
+        auxiliary: {
+          error: { value: String(error), type: "string" },
+        },
+      });
+      return;
+    }
+
+    this.logger({
+      category: "cache",
+      message: "agent cache stored",
+      level: 2,
+      auxiliary: {
+        instruction: { value: context.instruction, type: "string" },
+        steps: { value: String(steps.length), type: "string" },
+      },
+    });
+
+    if (this.bufferLatestEntry) {
+      this.latestEntry = {
+        cacheKey: context.cacheKey,
+        entry: cloneForCache(entry),
+      };
+    }
+  }
+
+  consumeBufferedEntry(): AgentCacheTransferPayload | null {
+    if (!this.bufferLatestEntry || !this.latestEntry) {
+      return null;
+    }
+
+    const payload = this.latestEntry;
+    this.latestEntry = null;
+    return payload;
+  }
+
+  async storeTransferredEntry(
+    payload: AgentCacheTransferPayload | null,
+  ): Promise<void> {
+    if (!this.enabled || !payload) return;
+
+    const entry = cloneForCache(payload.entry);
+    const { error, path } = await this.storage.writeJson(
+      `agent-${payload.cacheKey}.json`,
+      entry,
+    );
+    if (error && path) {
+      this.logger({
+        category: "cache",
+        message: "failed to import remote agent cache entry",
+        level: 0,
+        auxiliary: {
+          error: { value: String(error), type: "string" },
+        },
+      });
+      return;
+    }
+
+    this.logger({
+      category: "cache",
+      message: "agent cache imported from server",
+      level: 2,
+      auxiliary: {
+        instruction: { value: entry.instruction, type: "string" },
+        steps: { value: String(entry.steps?.length ?? 0), type: "string" },
+      },
+    });
+  }
+
+  /**
+   * Clone the agent result and prune bulky fields (e.g. screenshot base64 blobs)
+   * before persisting it to disk. This keeps cache entries compact without
+   * mutating the live AgentResult returned to callers.
+   */
+  private pruneAgentResult(result: AgentResult): AgentResult {
+    const cloned = cloneForCache(result);
+    if (!Array.isArray(cloned.actions)) {
+      return cloned;
+    }
+
+    for (const action of cloned.actions) {
+      if (action?.type === "screenshot") {
+        delete action.base64;
+      }
+    }
+
+    return cloned;
+  }
+
+  beginRecording(): void {
+    this.recording = [];
+  }
+
+  endRecording(): AgentReplayStep[] {
+    if (!this.recording) return [];
+    const steps = cloneForCache(this.recording);
+    this.recording = null;
+    return steps;
+  }
+
+  discardRecording(): void {
+    this.recording = null;
+  }
+
+  isRecording(): boolean {
+    return Array.isArray(this.recording);
+  }
+
+  recordStep(step: AgentReplayStep): void {
+    if (!this.isRecording()) return;
+    try {
+      this.recording!.push(cloneForCache(step));
+    } catch (err) {
+      this.logger({
+        category: "cache",
+        message: "failed to record agent replay step",
+        level: 2,
+        auxiliary: {
+          error: { value: String(err), type: "string" },
+        },
+      });
+    }
+  }
+
+  isReplayActive(): boolean {
+    return this.isRecording();
+  }
+
+  private serializeAgentModelForCache(
+    model?: AgentConfig["model"],
+  ): null | string | { modelName: string; options?: Record<string, unknown> } {
+    if (!model) return null;
+    if (typeof model === "string") return model;
+
+    const { modelName, ...modelOptions } = model;
+    const sanitizedOptions =
+      Object.keys(modelOptions).length > 0
+        ? this.sanitizeModelOptionsForCache(
+            modelOptions as Record<string, unknown>,
+          )
+        : undefined;
+    return sanitizedOptions
+      ? { modelName, options: sanitizedOptions }
+      : modelName;
+  }
+
+  private buildAgentCacheKey(
+    instruction: string,
+    startUrl: string,
+    options: SanitizedAgentExecuteOptions,
+    configSignature: string,
+    variableKeys?: string[],
+  ): string {
+    const payload = {
+      instruction,
+      startUrl,
+      options,
+      configSignature,
+      variableKeys: variableKeys ?? [],
+    };
+    return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
+  }
+
+  private sanitizeModelOptionsForCache(
+    value: Record<string, unknown>,
+  ): Record<string, unknown> | undefined {
+    const sanitizedEntries: Record<string, unknown> = {};
+    for (const [key, rawValue] of Object.entries(value)) {
+      if (SENSITIVE_CONFIG_KEYS.has(key.toLowerCase())) {
+        continue;
+      }
+
+      const sanitizedValue = this.sanitizeModelValueForCache(rawValue);
+      if (sanitizedValue !== undefined) {
+        sanitizedEntries[key] = sanitizedValue;
+      }
+    }
+
+    return Object.keys(sanitizedEntries).length > 0
+      ? sanitizedEntries
+      : undefined;
+  }
+
+  private sanitizeModelValueForCache(value: unknown): unknown {
+    if (Array.isArray(value)) {
+      const sanitizedArray = value
+        .map((item) => this.sanitizeModelValueForCache(item))
+        .filter((item) => item !== undefined);
+      return sanitizedArray;
+    }
+
+    if (value && typeof value === "object") {
+      return this.sanitizeModelOptionsForCache(
+        value as Record<string, unknown>,
+      );
+    }
+
+    return value;
+  }
+
+  private async replayAgentCacheEntry(
+    context: AgentCacheContext,
+    entry: CachedAgentEntry,
+    llmClientOverride?: LLMClient,
+  ): Promise<AgentResult | null> {
+    const ctx = this.getContext();
+    const handler = this.getActHandler();
+    if (!ctx || !handler) return null;
+    const effectiveClient = llmClientOverride ?? this.getDefaultLlmClient();
+    try {
+      const updatedSteps: AgentReplayStep[] = [];
+      let stepsChanged = false;
+      for (const step of entry.steps ?? []) {
+        const replayedStep =
+          (await this.executeAgentReplayStep(
+            step,
+            ctx,
+            handler,
+            effectiveClient,
+            context.variables,
+          )) ?? step;
+        stepsChanged ||= replayedStep !== step;
+        updatedSteps.push(replayedStep);
+      }
+      const result = cloneForCache(entry.result);
+      result.usage = {
+        input_tokens: 0,
+        output_tokens: 0,
+        reasoning_tokens: 0,
+        cached_input_tokens: 0,
+        inference_time_ms: 0,
+      };
+      result.metadata = {
+        ...(result.metadata ?? {}),
+        cacheHit: true,
+        cacheTimestamp: entry.timestamp,
+      };
+      if (stepsChanged) {
+        await this.refreshAgentCacheEntry(context, entry, updatedSteps);
+      }
+      return result;
+    } catch (err) {
+      this.logger({
+        category: "cache",
+        message: "agent cache replay failed",
+        level: 1,
+        auxiliary: {
+          error: { value: String(err), type: "string" },
+        },
+      });
+      return null;
+    }
+  }
+
+  private async executeAgentReplayStep(
+    step: AgentReplayStep,
+    ctx: V3Context,
+    handler: ActHandler,
+    llmClient: LLMClient,
+    variables?: Record<string, string>,
+  ): Promise<AgentReplayStep> {
+    switch (step.type) {
+      case "act":
+        return await this.replayAgentActStep(
+          step as AgentReplayActStep,
+          ctx,
+          handler,
+          llmClient,
+          variables,
+        );
+      case "fillForm":
+        return await this.replayAgentFillFormStep(
+          step as AgentReplayFillFormStep,
+          ctx,
+          handler,
+          llmClient,
+          variables,
+        );
+      case "goto":
+        await this.replayAgentGotoStep(step as AgentReplayGotoStep, ctx);
+        return step;
+      case "scroll":
+        await this.replayAgentScrollStep(step as AgentReplayScrollStep, ctx);
+        return step;
+      case "wait":
+        await this.replayAgentWaitStep(step as AgentReplayWaitStep);
+        return step;
+      case "navback":
+        await this.replayAgentNavBackStep(step as AgentReplayNavBackStep, ctx);
+        return step;
+      case "keys":
+        await this.replayAgentKeysStep(step as AgentReplayKeysStep, ctx);
+        return step;
+      case "done":
+      case "extract":
+      case "screenshot":
+      case "ariaTree":
+        return step;
+      default:
+        this.logger({
+          category: "cache",
+          message: `agent cache skipping step type: ${step.type}`,
+          level: 2,
+        });
+        return step;
+    }
+  }
+
+  private async replayAgentActStep(
+    step: AgentReplayActStep,
+    ctx: V3Context,
+    handler: ActHandler,
+    llmClient: LLMClient,
+    variables?: Record<string, string>,
+  ): Promise<AgentReplayActStep> {
+    const actions = Array.isArray(step.actions) ? step.actions : [];
+    if (actions.length > 0) {
+      const page = await ctx.awaitActivePage();
+      const updatedActions: Action[] = [];
+      for (const action of actions) {
+        await waitForCachedSelector({
+          page,
+          selector: action.selector,
+          timeout: this.domSettleTimeoutMs,
+          logger: this.logger,
+          context: "agent act",
+        });
+        const result = await handler.takeDeterministicAction(
+          action,
+          page,
+          this.domSettleTimeoutMs,
+          llmClient,
+          undefined,
+          variables,
+        );
+        if (result.success && Array.isArray(result.actions)) {
+          updatedActions.push(...cloneForCache(result.actions));
+        } else {
+          updatedActions.push(cloneForCache(action));
+        }
+      }
+      if (this.haveActionsChanged(actions, updatedActions)) {
+        return { ...step, actions: updatedActions };
+      }
+      return step;
+    }
+    await this.act(step.instruction, { timeout: step.timeout, variables });
+    return step;
+  }
+
+  private async replayAgentFillFormStep(
+    step: AgentReplayFillFormStep,
+    ctx: V3Context,
+    handler: ActHandler,
+    llmClient: LLMClient,
+    variables?: Record<string, string>,
+  ): Promise<AgentReplayFillFormStep> {
+    const actions =
+      Array.isArray(step.actions) && step.actions.length > 0
+        ? step.actions
+        : (step.observeResults ?? []);
+    if (!Array.isArray(actions) || actions.length === 0) {
+      return step;
+    }
+    const page = await ctx.awaitActivePage();
+    const updatedActions: Action[] = [];
+    for (const action of actions) {
+      await waitForCachedSelector({
+        page,
+        selector: action.selector,
+        timeout: this.domSettleTimeoutMs,
+        logger: this.logger,
+        context: "fillForm",
+      });
+      const result = await handler.takeDeterministicAction(
+        action,
+        page,
+        this.domSettleTimeoutMs,
+        llmClient,
+        undefined, // ensureTimeRemaining is not used in this context
+        variables,
+      );
+      if (result.success && Array.isArray(result.actions)) {
+        updatedActions.push(...cloneForCache(result.actions));
+      } else {
+        updatedActions.push(cloneForCache(action));
+      }
+    }
+    if (this.haveActionsChanged(actions, updatedActions)) {
+      return { ...step, actions: updatedActions };
+    }
+    return step;
+  }
+
+  private async replayAgentGotoStep(
+    step: AgentReplayGotoStep,
+    ctx: V3Context,
+  ): Promise<void> {
+    const page = await ctx.awaitActivePage();
+    await page.goto(step.url, { waitUntil: step.waitUntil ?? "load" });
+  }
+
+  private async replayAgentScrollStep(
+    step: AgentReplayScrollStep,
+    ctx: V3Context,
+  ): Promise<void> {
+    const page = await ctx.awaitActivePage();
+    let anchor = step.anchor;
+    if (!anchor) {
+      anchor = await page
+        .mainFrame()
+        .evaluate<{ x: number; y: number }>(() => ({
+          x: Math.max(0, Math.floor(window.innerWidth / 2)),
+          y: Math.max(0, Math.floor(window.innerHeight / 2)),
+        }));
+    }
+    const deltaX = step.deltaX ?? 0;
+    const deltaY = step.deltaY ?? 0;
+    await page.scroll(
+      Math.round(anchor.x ?? 0),
+      Math.round(anchor.y ?? 0),
+      deltaX,
+      deltaY,
+    );
+  }
+
+  private async replayAgentWaitStep(step: AgentReplayWaitStep): Promise<void> {
+    if (!step.timeMs || step.timeMs <= 0) return;
+    await new Promise((resolve) => setTimeout(resolve, step.timeMs));
+  }
+
+  private async replayAgentNavBackStep(
+    step: AgentReplayNavBackStep,
+    ctx: V3Context,
+  ): Promise<void> {
+    const page = await ctx.awaitActivePage();
+    await page.goBack({ waitUntil: step.waitUntil ?? "domcontentloaded" });
+  }
+
+  private async replayAgentKeysStep(
+    step: AgentReplayKeysStep,
+    ctx: V3Context,
+  ): Promise<void> {
+    const page = await ctx.awaitActivePage();
+    const { method, text, keys, times } = step.playwrightArguments;
+    const repeatCount = Math.max(1, times ?? 1);
+
+    if (method === "type" && text) {
+      for (let i = 0; i < repeatCount; i++) {
+        await page.type(text, { delay: 100 });
+      }
+    } else if (method === "press" && keys) {
+      for (let i = 0; i < repeatCount; i++) {
+        await page.keyPress(keys, { delay: 100 });
+      }
+    }
+  }
+
+  private haveActionsChanged(original: Action[], updated: Action[]): boolean {
+    if (original.length !== updated.length) {
+      return true;
+    }
+    for (let i = 0; i < original.length; i += 1) {
+      const orig = original[i];
+      const next = updated[i];
+      if (!orig || !next) {
+        return true;
+      }
+      if (orig.selector !== next.selector) {
+        return true;
+      }
+      if ((orig.description ?? "") !== (next.description ?? "")) {
+        return true;
+      }
+      if ((orig.method ?? "") !== (next.method ?? "")) {
+        return true;
+      }
+      const origArgs = Array.isArray(orig.arguments) ? orig.arguments : [];
+      const nextArgs = Array.isArray(next.arguments) ? next.arguments : [];
+      if (origArgs.length !== nextArgs.length) {
+        return true;
+      }
+      for (let j = 0; j < origArgs.length; j += 1) {
+        if (origArgs[j] !== nextArgs[j]) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  private async refreshAgentCacheEntry(
+    context: AgentCacheContext,
+    entry: CachedAgentEntry,
+    updatedSteps: AgentReplayStep[],
+  ): Promise<void> {
+    const updatedEntry: CachedAgentEntry = {
+      ...entry,
+      steps: cloneForCache(updatedSteps),
+      timestamp: new Date().toISOString(),
+    };
+    const { error, path } = await this.storage.writeJson(
+      `agent-${context.cacheKey}.json`,
+      updatedEntry,
+    );
+    if (error && path) {
+      this.logger({
+        category: "cache",
+        message: "failed to update agent cache entry after self-heal",
+        level: 0,
+        auxiliary: {
+          error: { value: String(error), type: "string" },
+        },
+      });
+      return;
+    }
+    this.logger({
+      category: "cache",
+      message: "agent cache entry updated after self-heal",
+      level: 2,
+      auxiliary: {
+        instruction: { value: context.instruction, type: "string" },
+        steps: { value: String(updatedSteps.length), type: "string" },
+      },
+    });
+  }
+}
diff --git a/packages/core/lib/v3/cache/CacheStorage.ts b/packages/core/lib/v3/cache/CacheStorage.ts
new file mode 100644
index 000000000..d15b5753e
--- /dev/null
+++ b/packages/core/lib/v3/cache/CacheStorage.ts
@@ -0,0 +1,114 @@
+import fs from "fs";
+import path from "path";
+import type { Logger } from "../types/public/index.js";
+import { ReadJsonResult, WriteJsonResult } from "../types/private/index.js";
+
+const jsonClone = <T>(value: T): T => {
+  const serialized = JSON.stringify(value);
+  if (serialized === undefined) {
+    return value;
+  }
+  return JSON.parse(serialized) as T;
+};
+
+export class CacheStorage {
+  private constructor(
+    private readonly logger: Logger,
+    private readonly dir?: string,
+    private readonly memoryStore?: Map<string, unknown>,
+  ) {}
+
+  static create(
+    cacheDir: string | undefined,
+    logger: Logger,
+    options?: { label?: string },
+  ): CacheStorage {
+    if (!cacheDir) {
+      return new CacheStorage(logger);
+    }
+
+    const resolved = path.resolve(cacheDir);
+    try {
+      fs.mkdirSync(resolved, { recursive: true });
+      return new CacheStorage(logger, resolved);
+    } catch (err) {
+      const label = options?.label ?? "cache directory";
+      logger({
+        category: "cache",
+        message: `unable to initialize ${label}: ${resolved}`,
+        level: 1,
+        auxiliary: {
+          error: { value: String(err), type: "string" },
+        },
+      });
+      return new CacheStorage(logger);
+    }
+  }
+
+  static createMemory(logger: Logger): CacheStorage {
+    return new CacheStorage(logger, undefined, new Map());
+  }
+
+  get directory(): string | undefined {
+    return this.dir;
+  }
+
+  get enabled(): boolean {
+    return !!this.dir || !!this.memoryStore;
+  }
+
+  private resolvePath(fileName: string): string | null {
+    if (!this.dir) return null;
+    return path.join(this.dir, fileName);
+  }
+
+  async readJson<T>(fileName: string): Promise<ReadJsonResult<T>> {
+    if (this.memoryStore) {
+      if (!this.memoryStore.has(fileName)) {
+        return { value: null };
+      }
+      const existing = this.memoryStore.get(fileName) as T;
+      return { value: jsonClone(existing) };
+    }
+
+    const filePath = this.resolvePath(fileName);
+    if (!filePath) {
+      return { value: null };
+    }
+
+    try {
+      const raw = await fs.promises.readFile(filePath, "utf8");
+      return { value: JSON.parse(raw) as T };
+    } catch (err) {
+      const code = (err as NodeJS.ErrnoException)?.code;
+      if (code === "ENOENT") {
+        return { value: null };
+      }
+      return { value: null, error: err, path: filePath };
+    }
+  }
+
+  async writeJson(fileName: string, data: unknown): Promise<WriteJsonResult> {
+    if (this.memoryStore) {
+      this.memoryStore.set(fileName, jsonClone(data));
+      return {};
+    }
+
+    const filePath = this.resolvePath(fileName);
+    if (!filePath) {
+      return {};
+    }
+
+    try {
+      await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+      await fs.promises.writeFile(
+        filePath,
+        JSON.stringify(data, null, 2),
+        "utf8",
+      );
+      return {};
+    } catch (err) {
+      return { error: err, path: filePath };
+    }
+  }
+}
diff --git a/packages/core/lib/v3/cache/serverAgentCache.ts b/packages/core/lib/v3/cache/serverAgentCache.ts
new file mode 100644
index 000000000..dbac69d9f
--- /dev/null
+++ b/packages/core/lib/v3/cache/serverAgentCache.ts
@@ -0,0 +1,77 @@
+import { AgentCache } from "./AgentCache.js";
+import { CacheStorage } from "./CacheStorage.js";
+import type { V3 } from "../v3.js";
+import type { AgentCacheTransferPayload } from "../types/private/index.js";
+import type { ActHandler } from "../handlers/actHandler.js";
+import type { V3Context } from "../understudy/context.js";
+import type { AvailableModel, V3Options } from "../types/public/index.js";
+import type { ModelConfiguration } from "../types/public/model.js";
+import type { LLMClient } from "../llm/LLMClient.js";
+
+export interface ServerAgentCacheHandle {
+  complete(): AgentCacheTransferPayload | null;
+  discard(): void;
+}
+
+// TODO (refactor-caching): this reflective access is a known temporary escape hatch.
+// Once the caching internals are reworked, replace it with proper V3 helpers so
+// we stop poking private fields from the outside.
+function getInternalField<T>(instance: V3, key: string): T {
+  return (instance as unknown as Record<string, unknown>)[key] as T;
+}
+
+function setInternalField(instance: V3, key: string, value: unknown): void {
+  (instance as unknown as Record<string, unknown>)[key] = value;
+}
+
+function createMemoryAgentCache(stagehand: V3): AgentCache {
+  const resolveLlmClient = getInternalField<
+    (model?: ModelConfiguration) => LLMClient
+  >(stagehand, "resolveLlmClient");
+
+  return new AgentCache({
+    storage: CacheStorage.createMemory(stagehand.logger),
+    logger: stagehand.logger,
+    getActHandler: () =>
+      getInternalField<ActHandler | null>(stagehand, "actHandler"),
+    getContext: () => getInternalField<V3Context | null>(stagehand, "ctx"),
+    getDefaultLlmClient: () => resolveLlmClient.call(stagehand),
+    getBaseModelName: () =>
+      getInternalField<AvailableModel>(stagehand, "modelName"),
+    getSystemPrompt: () =>
+      getInternalField<V3Options>(stagehand, "opts").systemPrompt,
+    domSettleTimeoutMs: getInternalField<number | undefined>(
+      stagehand,
+      "domSettleTimeoutMs",
+    ),
+    act: stagehand.act.bind(stagehand),
+    bufferLatestEntry: true,
+  });
+}
+
+export function __internalCreateInMemoryAgentCacheHandle(
+  stagehand: V3,
+): ServerAgentCacheHandle {
+  const originalCache = getInternalField<AgentCache>(stagehand, "agentCache");
+  const memoryCache = createMemoryAgentCache(stagehand);
+
+  setInternalField(stagehand, "agentCache", memoryCache);
+  let restored = false;
+  const restore = () => {
+    if (!restored) {
+      setInternalField(stagehand, "agentCache", originalCache);
+      restored = true;
+    }
+  };
+
+  return {
+    complete: () => {
+      const entry = memoryCache.consumeBufferedEntry();
+      restore();
+      return entry;
+    },
+    discard: () => {
+      restore();
+    },
+  };
+}
diff --git a/packages/core/lib/v3/cache/utils.ts b/packages/core/lib/v3/cache/utils.ts
new file mode 100644
index 000000000..b4490b171
--- /dev/null
+++ b/packages/core/lib/v3/cache/utils.ts
@@ -0,0 +1,48 @@
+import type { Logger } from "../types/public/index.js";
+import { Page } from "../understudy/page.js";
+
+const DEFAULT_WAIT_TIMEOUT_MS = 15000;
+
+export function cloneForCache<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+export async function safeGetPageUrl(page: Page): Promise<string> {
+  try {
+    return page.url();
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Waits for a cached action's selector to be attached to the DOM before executing.
+ * Logs a warning and proceeds if the wait times out (non-blocking).
+ */
+export async function waitForCachedSelector(params: {
+  page: Page;
+  selector: string | undefined;
+  timeout: number | undefined;
+  logger: Logger;
+  context?: string;
+}): Promise<void> {
+  const { page, selector, timeout, logger, context } = params;
+  if (!selector) return;
+
+  try {
+    await page.waitForSelector(selector, {
+      state: "attached",
+      timeout: timeout ?? DEFAULT_WAIT_TIMEOUT_MS,
+    });
+  } catch (err) {
+    logger({
+      category: "cache",
+      message: `waitForSelector failed for ${context ?? "cached"} action selector, proceeding anyway`,
+      level: 2,
+      auxiliary: {
+        selector: { value: selector, type: "string" },
+        error: { value: String(err), type: "string" },
+      },
+    });
+  }
+}
diff --git a/packages/core/lib/v3/cli.js b/packages/core/lib/v3/cli.js
new file mode 100644
index 000000000..89f375e17
--- /dev/null
+++ b/packages/core/lib/v3/cli.js
@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+import process from "node:process";
+import { maybeRunShutdownSupervisorFromArgv } from "./shutdown/supervisor.js";
+
+// currently the CLI is only used to spawn the shutdown supervisor
+// in the future, we may want to add more CLI commands here
+if (!maybeRunShutdownSupervisorFromArgv(process.argv.slice(2))) {
+  console.error(
+    "Unsupported stagehand CLI invocation. Expected --supervisor with valid args.",
+  );
+  process.exit(1);
+}
diff --git a/packages/core/lib/v3/dom/a11yScripts/index.ts b/packages/core/lib/v3/dom/a11yScripts/index.ts
new file mode 100644
index 000000000..6c9a3d0d4
--- /dev/null
+++ b/packages/core/lib/v3/dom/a11yScripts/index.ts
@@ -0,0 +1,116 @@
+export function getScrollOffsets(): { sx: number; sy: number } {
+  try {
+    const sx =
+      window.scrollX ??
+      window.pageXOffset ??
+      document.documentElement?.scrollLeft ??
+      0;
+    const sy =
+      window.scrollY ??
+      window.pageYOffset ??
+      document.documentElement?.scrollTop ??
+      0;
+    return { sx: Number(sx) || 0, sy: Number(sy) || 0 };
+  } catch {
+    return { sx: 0, sy: 0 };
+  }
+}
+
+export function getBoundingRectLite(this: Element): {
+  left: number;
+  top: number;
+} {
+  try {
+    const rect = this.getBoundingClientRect();
+    return {
+      left: Number(rect?.left ?? 0) || 0,
+      top: Number(rect?.top ?? 0) || 0,
+    };
+  } catch {
+    return { left: 0, top: 0 };
+  }
+}
+
+export function resolveDeepActiveElement(): Element | null {
+  try {
+    const deepActive = (doc: Document | ShadowRoot): Element | null => {
+      let el: Element | null = doc.activeElement ?? null;
+      while (el && el.shadowRoot && el.shadowRoot.activeElement) {
+        el = el.shadowRoot.activeElement;
+      }
+      return el ?? null;
+    };
+    return deepActive(document);
+  } catch {
+    return null;
+  }
+}
+
+export function nodeToAbsoluteXPath(this: Node | null | undefined): string {
+  const compute = (node: Node | null | undefined): string => {
+    try {
+      const sibIndex = (n: Node | null | undefined): number => {
+        if (!n || !n.parentNode) return 1;
+        let i = 1;
+        const targetKey = `${n.nodeType}:${(n.nodeName || "").toLowerCase()}`;
+        for (let p = n.previousSibling; p; p = p.previousSibling) {
+          const key = `${p.nodeType}:${(p.nodeName || "").toLowerCase()}`;
+          if (key === targetKey) i += 1;
+        }
+        return i;
+      };
+
+      const step = (n: Node | null | undefined): string => {
+        if (!n) return "";
+        if (n.nodeType === Node.DOCUMENT_NODE) return "";
+        if (n.nodeType === Node.DOCUMENT_FRAGMENT_NODE) return "//";
+        if (n.nodeType === Node.TEXT_NODE) return `text()[${sibIndex(n)}]`;
+        if (n.nodeType === Node.COMMENT_NODE)
+          return `comment()[${sibIndex(n)}]`;
+        const tag = (n.nodeName || "").toLowerCase();
+        const name = tag.includes(":") ? `*[name()='${tag}']` : tag;
+        return `${name}[${sibIndex(n)}]`;
+      };
+
+      const parts: string[] = [];
+      let cur: Node | null | undefined = node;
+      while (cur) {
+        if (cur.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+          parts.push("//");
+          cur = (cur as ShadowRoot).host ?? null;
+          continue;
+        }
+        const s = step(cur);
+        if (s) parts.push(s);
+        cur = cur.parentNode;
+      }
+      parts.reverse();
+
+      let out = "";
+      for (const part of parts) {
+        if (part === "//") {
+          out = out ? (out.endsWith("/") ? `${out}/` : `${out}//`) : "//";
+        } else {
+          out = out
+            ? out.endsWith("/")
+              ? `${out}${part}`
+              : `${out}/${part}`
+            : `/${part}`;
+        }
+      }
+      return out || "/";
+    } catch {
+      return "/";
+    }
+  };
+
+  return compute(this);
+}
+
+export function documentHasFocusStrict(): boolean {
+  try {
+    return document.hasFocus() === true;
+  } catch {
+    return false;
+  }
+}
diff --git a/packages/core/lib/v3/dom/genA11yScripts.ts b/packages/core/lib/v3/dom/genA11yScripts.ts
new file mode 100644
index 000000000..4a192cf46
--- /dev/null
+++ b/packages/core/lib/v3/dom/genA11yScripts.ts
@@ -0,0 +1,76 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import esbuild from "esbuild";
+import { getCurrentDirPath } from "../runtimePaths.js";
+
+const here = getCurrentDirPath();
+const srcDir = path.join(here, "./a11yScripts");
+const outDir = path.join(here, "./build");
+const entry = path.join(srcDir, "index.ts");
+const moduleOut = path.join(outDir, "a11yScripts.mjs");
+const bundleOut = path.join(outDir, "a11yScripts.bundle.js");
+
+async function main(): Promise<void> {
+  fs.mkdirSync(outDir, { recursive: true });
+
+  esbuild.buildSync({
+    entryPoints: [entry],
+    bundle: true,
+    format: "esm",
+    platform: "browser",
+    target: "es2020",
+    minify: true,
+    outfile: moduleOut,
+  });
+
+  esbuild.buildSync({
+    entryPoints: [entry],
+    bundle: true,
+    format: "iife",
+    platform: "browser",
+    target: "es2020",
+    globalName: "__stagehandA11yScriptsFactory",
+    minify: true,
+    outfile: bundleOut,
+  });
+
+  const bundleRaw = fs.readFileSync(bundleOut, "utf8").trim();
+  const bootstrap = `if (!globalThis.__stagehandA11yScripts) { ${bundleRaw}\n  globalThis.__stagehandA11yScripts = __stagehandA11yScriptsFactory;\n}`;
+
+  const compiledModule = (await import(
+    pathToFileURL(moduleOut).href
+  )) as Record<string, unknown>;
+
+  const entries = Object.entries(compiledModule).filter(
+    ([, value]) => typeof value === "function",
+  );
+  const sorted = entries.sort(([a], [b]) => a.localeCompare(b));
+
+  const scriptMap: Record<string, string> = Object.fromEntries(
+    sorted.map(([name, fn]) => {
+      const callable = fn as (...args: unknown[]) => unknown;
+      return [name, callable.toString()];
+    }),
+  );
+
+  const banner = `/*\n * AUTO-GENERATED FILE. DO NOT EDIT.\n * Update sources in lib/v3/dom/a11yScripts and run genA11yScripts.ts.\n */`;
+
+  const globalRefs: Record<string, string> = Object.fromEntries(
+    sorted.map(([name]) => [name, `globalThis.__stagehandA11yScripts.${name}`]),
+  );
+
+  const content = `${banner}
+export const a11yScriptBootstrap = ${JSON.stringify(bootstrap)};
+export const a11yScriptSources = ${JSON.stringify(scriptMap, null, 2)} as const;
+export const a11yScriptGlobalRefs = ${JSON.stringify(globalRefs, null, 2)} as const;
+export type A11yScriptName = keyof typeof a11yScriptSources;
+`;
+
+  fs.writeFileSync(path.join(outDir, "a11yScripts.generated.ts"), content);
+
+  await fs.promises.unlink(moduleOut).catch(() => {});
+  await fs.promises.unlink(bundleOut).catch(() => {});
+}
+
+void main();
diff --git a/packages/core/lib/v3/dom/genDomScripts.ts b/packages/core/lib/v3/dom/genDomScripts.ts
new file mode 100644
index 000000000..bf7766db2
--- /dev/null
+++ b/packages/core/lib/v3/dom/genDomScripts.ts
@@ -0,0 +1,51 @@
+/**
+ * Build the v3 DOM script into a single JS file and then export its contents
+ * as a string constant (`v3ScriptContent`) for CDP injection (document-start).
+ */
+import fs from "node:fs";
+import path from "node:path";
+import esbuild from "esbuild";
+import { getCurrentDirPath } from "../runtimePaths.js";
+
+const here = getCurrentDirPath();
+const outDir = path.join(here, "./build");
+fs.mkdirSync(outDir, { recursive: true });
+
+esbuild.buildSync({
+  entryPoints: [path.join(here, "piercer.entry.ts")],
+  bundle: true,
+  format: "iife",
+  platform: "browser",
+  target: "es2020",
+  minify: true,
+  legalComments: "none",
+  outfile: path.join(outDir, "v3-index.js"),
+});
+
+const script = fs.readFileSync(path.join(outDir, "v3-index.js"), "utf8");
+const content = `export const v3ScriptContent = ${JSON.stringify(script)};`;
+
+fs.writeFileSync(path.join(outDir, "scriptV3Content.ts"), content);
+
+esbuild.buildSync({
+  entryPoints: [path.join(here, "rerenderMissingShadows.entry.ts")],
+  bundle: true,
+  format: "iife",
+  platform: "browser",
+  target: "es2020",
+  minify: true,
+  legalComments: "none",
+  outfile: path.join(outDir, "rerender-index.js"),
+});
+
+const rerenderScript = fs.readFileSync(
+  path.join(outDir, "rerender-index.js"),
+  "utf8",
+);
+const rerenderContent = `export const reRenderScriptContent = ${JSON.stringify(
+  rerenderScript,
+)};`;
+fs.writeFileSync(
+  path.join(outDir, "reRenderScriptContent.ts"),
+  rerenderContent,
+);
diff --git a/packages/core/lib/v3/dom/genLocatorScripts.ts b/packages/core/lib/v3/dom/genLocatorScripts.ts
new file mode 100644
index 000000000..ad38a7960
--- /dev/null
+++ b/packages/core/lib/v3/dom/genLocatorScripts.ts
@@ -0,0 +1,73 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import esbuild from "esbuild";
+import { getCurrentDirPath } from "../runtimePaths.js";
+
+const here = getCurrentDirPath();
+const outDir = path.join(here, "./build");
+const entry = path.join(here, "./locatorScripts/index.ts");
+const moduleOutfile = path.join(outDir, "locatorScripts.mjs");
+const bundleOutfile = path.join(outDir, "locatorScripts.bundle.js");
+
+async function main(): Promise<void> {
+  fs.mkdirSync(outDir, { recursive: true });
+
+  esbuild.buildSync({
+    entryPoints: [entry],
+    bundle: true,
+    format: "esm",
+    platform: "browser",
+    target: "es2020",
+    minify: true,
+    outfile: moduleOutfile,
+  });
+
+  esbuild.buildSync({
+    entryPoints: [entry],
+    bundle: true,
+    format: "iife",
+    platform: "browser",
+    target: "es2020",
+    globalName: "__stagehandLocatorScriptsFactory",
+    minify: true,
+    outfile: bundleOutfile,
+  });
+
+  const bundleRaw = fs.readFileSync(bundleOutfile, "utf8").trim();
+  const bootstrap = `if (!globalThis.__stagehandLocatorScripts) { ${bundleRaw}\n  globalThis.__stagehandLocatorScripts = __stagehandLocatorScriptsFactory;\n}`;
+
+  const compiledModule = (await import(
+    pathToFileURL(moduleOutfile).href
+  )) as Record<string, unknown>;
+
+  const entries = Object.entries(compiledModule).filter(
+    ([, value]) => typeof value === "function",
+  );
+  const sorted = entries.sort(([a], [b]) => a.localeCompare(b));
+
+  const scriptMap: Record<string, string> = Object.fromEntries(
+    sorted.map(([name, fn]) => {
+      const callable = fn as (...args: unknown[]) => unknown;
+      return [name, callable.toString()];
+    }),
+  );
+
+  const banner = `/*\n * AUTO-GENERATED FILE. DO NOT EDIT.\n * Update sources in lib/v3/dom/locatorScripts and run genLocatorScripts.ts.\n */`;
+
+  const globalRefs: Record<string, string> = Object.fromEntries(
+    sorted.map(([name]) => [
+      name,
+      `globalThis.__stagehandLocatorScripts.${name}`,
+    ]),
+  );
+
+  const content = `${banner}\nexport const locatorScriptBootstrap = ${JSON.stringify(bootstrap)};\nexport const locatorScriptSources = ${JSON.stringify(scriptMap, null, 2)} as const;\nexport const locatorScriptGlobalRefs = ${JSON.stringify(globalRefs, null, 2)} as const;\nexport type LocatorScriptName = keyof typeof locatorScriptSources;\n`;
+
+  fs.writeFileSync(path.join(outDir, "locatorScripts.generated.ts"), content);
+
+  await fs.promises.unlink(moduleOutfile).catch(() => {});
+  await fs.promises.unlink(bundleOutfile).catch(() => {});
+}
+
+void main();
diff --git a/packages/core/lib/v3/dom/genScreenshotScripts.ts b/packages/core/lib/v3/dom/genScreenshotScripts.ts
new file mode 100644
index 000000000..c014d999f
--- /dev/null
+++ b/packages/core/lib/v3/dom/genScreenshotScripts.ts
@@ -0,0 +1,57 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import esbuild from "esbuild";
+import { getCurrentDirPath } from "../runtimePaths.js";
+
+const here = getCurrentDirPath();
+const srcDir = path.join(here, "./screenshotScripts");
+const outDir = path.join(here, "./build");
+const entry = path.join(srcDir, "index.ts");
+const moduleOut = path.join(outDir, "screenshotScripts.mjs");
+
+async function main(): Promise<void> {
+  fs.mkdirSync(outDir, { recursive: true });
+
+  esbuild.buildSync({
+    entryPoints: [entry],
+    bundle: true,
+    format: "esm",
+    platform: "browser",
+    target: "es2020",
+    minify: true,
+    outfile: moduleOut,
+  });
+
+  const compiledModule = (await import(
+    pathToFileURL(moduleOut).href
+  )) as Record<string, unknown>;
+
+  const entries = Object.entries(compiledModule).filter(
+    ([, value]) => typeof value === "function",
+  );
+  const sorted = entries.sort(([a], [b]) => a.localeCompare(b));
+
+  const scriptMap: Record<string, string> = Object.fromEntries(
+    sorted.map(([name, fn]) => {
+      const callable = fn as (...args: unknown[]) => unknown;
+      return [name, callable.toString()];
+    }),
+  );
+
+  const banner = `/*\n * AUTO-GENERATED FILE. DO NOT EDIT.\n * Update sources in lib/v3/dom/screenshotScripts and run genScreenshotScripts.ts.\n */`;
+
+  const content = `${banner}
+export const screenshotScriptSources = ${JSON.stringify(scriptMap, null, 2)} as const;
+export type ScreenshotScriptName = keyof typeof screenshotScriptSources;
+`;
+
+  fs.writeFileSync(
+    path.join(outDir, "screenshotScripts.generated.ts"),
+    content,
+  );
+
+  await fs.promises.unlink(moduleOut).catch(() => {});
+}
+
+void main();
diff --git a/packages/core/lib/v3/dom/global.d.ts b/packages/core/lib/v3/dom/global.d.ts
new file mode 100644
index 000000000..3a1177dc5
--- /dev/null
+++ b/packages/core/lib/v3/dom/global.d.ts
@@ -0,0 +1,19 @@
+export interface StagehandV3Backdoor {
+  /** Closed shadow-root accessors */
+  getClosedRoot(host: Element): ShadowRoot | undefined;
+  /** Stats + quick health check */
+  stats(): {
+    installed: true;
+    url: string;
+    isTop: boolean;
+    open: number;
+    closed: number;
+  };
+}
+
+declare global {
+  interface Window {
+    __stagehandV3Injected?: boolean;
+    __stagehandV3__?: StagehandV3Backdoor;
+  }
+}
diff --git a/packages/core/lib/v3/dom/index.ts b/packages/core/lib/v3/dom/index.ts
new file mode 100644
index 000000000..a8e3d1ba6
--- /dev/null
+++ b/packages/core/lib/v3/dom/index.ts
@@ -0,0 +1 @@
+export * from "./piercer.runtime.js";
diff --git a/packages/core/lib/v3/dom/locatorScripts/counts.ts b/packages/core/lib/v3/dom/locatorScripts/counts.ts
new file mode 100644
index 000000000..454381458
--- /dev/null
+++ b/packages/core/lib/v3/dom/locatorScripts/counts.ts
@@ -0,0 +1,305 @@
+import { countXPathMatches } from "./xpathResolver.js";
+
+export interface TextMatchSample {
+  tag: string;
+  id: string;
+  class: string;
+  text: string;
+}
+
+export interface TextMatchResult {
+  count: number;
+  sample: TextMatchSample[];
+  error: null;
+}
+
+export function countCssMatchesPrimary(selectorRaw: string): number {
+  const selector = String(selectorRaw ?? "").trim();
+  if (!selector) return 0;
+
+  const seen = new WeakSet<Node>();
+
+  const visit = (root: Node | null | undefined): number => {
+    if (!root || seen.has(root)) return 0;
+    seen.add(root);
+
+    let total = 0;
+    try {
+      const queryable = root as unknown as ParentNode & {
+        querySelectorAll?: Document["querySelectorAll"];
+      };
+      if (typeof queryable.querySelectorAll === "function") {
+        total += queryable.querySelectorAll(selector).length;
+      }
+    } catch {
+      // ignore query errors
+    }
+
+    try {
+      const doc =
+        root instanceof Document
+          ? root
+          : ((root as Element)?.ownerDocument ?? document);
+      const walker = doc.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
+      let node: Node | null;
+      while ((node = walker.nextNode())) {
+        if (node instanceof Element && node.shadowRoot) {
+          total += visit(node.shadowRoot);
+        }
+      }
+    } catch {
+      // ignore traversal errors
+    }
+
+    return total;
+  };
+
+  try {
+    return visit(document);
+  } catch {
+    try {
+      return document.querySelectorAll(selector).length;
+    } catch {
+      return 0;
+    }
+  }
+}
+
+export function countCssMatchesPierce(selectorRaw: string): number {
+  const selector = String(selectorRaw ?? "").trim();
+  if (!selector) return 0;
+
+  const backdoor = window.__stagehandV3__;
+  if (!backdoor || typeof backdoor.getClosedRoot !== "function") {
+    try {
+      return document.querySelectorAll(selector).length;
+    } catch {
+      return 0;
+    }
+  }
+
+  const seen = new WeakSet<Node>();
+  const queue: Node[] = [];
+
+  const enqueue = (node: Node | null | undefined) => {
+    if (!node || seen.has(node)) return;
+    seen.add(node);
+    queue.push(node);
+  };
+
+  enqueue(document);
+  let total = 0;
+
+  const visitElement = (element: Element) => {
+    const open = element.shadowRoot;
+    if (open) enqueue(open);
+    try {
+      const closed = backdoor.getClosedRoot(element);
+      if (closed) enqueue(closed);
+    } catch {
+      // ignore
+    }
+  };
+
+  while (queue.length) {
+    const root = queue.shift();
+    if (!root) continue;
+
+    try {
+      const queryable = root as unknown as ParentNode & {
+        querySelectorAll?: Document["querySelectorAll"];
+      };
+      if (typeof queryable.querySelectorAll === "function") {
+        total += queryable.querySelectorAll(selector).length;
+      }
+    } catch {
+      // ignore query errors
+    }
+
+    try {
+      const doc =
+        root instanceof Document
+          ? root
+          : root instanceof ShadowRoot
+            ? (root.host?.ownerDocument ?? document)
+            : ((root as Element).ownerDocument ?? document);
+      const walker = doc.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
+      let node: Node | null;
+      while ((node = walker.nextNode())) {
+        if (node instanceof Element) {
+          visitElement(node);
+        }
+      }
+    } catch {
+      // ignore traversal errors
+    }
+  }
+
+  return total;
+}
+
+export function countTextMatches(rawNeedle: string): TextMatchResult {
+  const needle = String(rawNeedle ?? "");
+  if (!needle) {
+    return { count: 0, sample: [], error: null };
+  }
+
+  const needleLc = needle.toLowerCase();
+  const skipTags = new Set([
+    "SCRIPT",
+    "STYLE",
+    "TEMPLATE",
+    "NOSCRIPT",
+    "HEAD",
+    "TITLE",
+    "LINK",
+    "META",
+    "HTML",
+    "BODY",
+  ]);
+
+  const shouldSkip = (node: Element | null | undefined): boolean => {
+    if (!node) return false;
+    const tag = node.tagName?.toUpperCase() ?? "";
+    return skipTags.has(tag);
+  };
+
+  const extractText = (element: Element): string => {
+    try {
+      if (shouldSkip(element)) return "";
+      const inner = (element as HTMLElement).innerText;
+      if (typeof inner === "string" && inner.trim()) return inner.trim();
+    } catch {
+      // ignore
+    }
+    try {
+      const text = element.textContent;
+      if (typeof text === "string") return text.trim();
+    } catch {
+      // ignore
+    }
+    return "";
+  };
+
+  const matches = (element: Element): boolean => {
+    const text = extractText(element);
+    return !!text && text.toLowerCase().includes(needleLc);
+  };
+
+  const backdoor = window.__stagehandV3__;
+  const getClosedRoot: (host: Element) => ShadowRoot | null =
+    backdoor && typeof backdoor.getClosedRoot === "function"
+      ? (host: Element): ShadowRoot | null => {
+          try {
+            return backdoor.getClosedRoot(host) ?? null;
+          } catch {
+            return null;
+          }
+        }
+      : (host: Element): ShadowRoot | null => {
+          void host;
+          return null;
+        };
+
+  const seen = new WeakSet<Node>();
+  const queue: Node[] = [];
+
+  const enqueue = (node: Node | null | undefined) => {
+    if (!node || seen.has(node)) return;
+    seen.add(node);
+    queue.push(node);
+  };
+
+  const walkerFor = (root: Node): TreeWalker | null => {
+    try {
+      const doc =
+        root instanceof Document
+          ? root
+          : ((root as Element)?.ownerDocument ?? document);
+      return doc.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
+    } catch {
+      return null;
+    }
+  };
+
+  const matchesList: Array<{
+    element: Element;
+    tag: string;
+    id: string;
+    className: string;
+    text: string;
+  }> = [];
+
+  enqueue(document);
+
+  while (queue.length) {
+    const root = queue.shift();
+    if (!root) continue;
+
+    if (root instanceof Element && matches(root)) {
+      matchesList.push({
+        element: root,
+        tag: root.tagName ?? "",
+        id: root.id ?? "",
+        className: (root as HTMLElement).className ?? "",
+        text: extractText(root),
+      });
+    }
+
+    const walker = walkerFor(root);
+    if (!walker) continue;
+
+    let node: Node | null;
+    while ((node = walker.nextNode())) {
+      if (!(node instanceof Element)) continue;
+
+      if (matches(node)) {
+        matchesList.push({
+          element: node,
+          tag: node.tagName ?? "",
+          id: node.id ?? "",
+          className: (node as HTMLElement).className ?? "",
+          text: extractText(node),
+        });
+      }
+
+      const open = node.shadowRoot;
+      if (open) enqueue(open);
+
+      const closed = getClosedRoot(node);
+      if (closed) enqueue(closed);
+    }
+  }
+
+  const innermost: typeof matchesList = [];
+  for (const item of matchesList) {
+    const el = item.element;
+    let skip = false;
+    for (const other of matchesList) {
+      if (item === other) continue;
+      try {
+        if (el.contains(other.element)) {
+          skip = true;
+          break;
+        }
+      } catch {
+        // ignore containment errors
+      }
+    }
+    if (!skip) innermost.push(item);
+  }
+
+  const count = innermost.length;
+  const sample = innermost.slice(0, 5).map((item) => ({
+    tag: item.tag,
+    id: item.id,
+    class: item.className,
+    text: item.text,
+  }));
+
+  return { count, sample, error: null };
+}
+
+export function countXPathMatchesMainWorld(rawXp: string): number {
+  return countXPathMatches(rawXp, { pierceShadow: true });
+}
diff --git a/packages/core/lib/v3/dom/locatorScripts/index.ts b/packages/core/lib/v3/dom/locatorScripts/index.ts
new file mode 100644
index 000000000..4d6c1784b
--- /dev/null
+++ b/packages/core/lib/v3/dom/locatorScripts/index.ts
@@ -0,0 +1,4 @@
+export * from "./scripts.js";
+export * from "./selectors.js";
+export * from "./counts.js";
+export * from "./waitForSelector.js";
diff --git a/packages/core/lib/v3/dom/locatorScripts/scripts.ts b/packages/core/lib/v3/dom/locatorScripts/scripts.ts
new file mode 100644
index 000000000..ce32035e5
--- /dev/null
+++ b/packages/core/lib/v3/dom/locatorScripts/scripts.ts
@@ -0,0 +1,520 @@
+/*
+ * DOM-side helpers used by Locator Runtime.callFunctionOn invocations.
+ *
+ * NOTE: These functions run inside the page context. Keep them dependency-free
+ * and resilient to exceptions (match the best-effort semantics of the old
+ * inline string snippets).
+ */
+
+export interface ClickEventOptions {
+  bubbles?: boolean;
+  cancelable?: boolean;
+  composed?: boolean;
+  detail?: number;
+}
+
+export function ensureFileInputElement(this: Element): boolean {
+  try {
+    const tag = (this as HTMLElement).tagName?.toLowerCase() ?? "";
+    if (tag !== "input") return false;
+    const type = String((this as HTMLInputElement).type ?? "").toLowerCase();
+    return type === "file";
+  } catch {
+    return false;
+  }
+}
+
+export interface SerializedFilePayload {
+  name: string;
+  mimeType: string;
+  base64: string;
+  lastModified?: number;
+}
+
+/** Attach File objects created from serialized payloads to an <input type="file">. */
+export function assignFilePayloadsToInputElement(
+  this: Element,
+  payloads: SerializedFilePayload[],
+): boolean {
+  try {
+    const input = this as HTMLInputElement;
+    if (!input || input.tagName?.toLowerCase() !== "input") return false;
+    if ((input.type ?? "").toLowerCase() !== "file") return false;
+
+    const transfer: DataTransfer | null = (() => {
+      try {
+        return new DataTransfer();
+      } catch {
+        return null;
+      }
+    })();
+    if (!transfer) return false;
+
+    const entries = Array.isArray(payloads) ? payloads : [];
+    for (const payload of entries) {
+      if (!payload) continue;
+      const name = payload.name || "upload.bin";
+      const mimeType = payload.mimeType || "application/octet-stream";
+      const lastModified =
+        typeof payload.lastModified === "number"
+          ? payload.lastModified
+          : Date.now();
+
+      const binary = window.atob(payload.base64 ?? "");
+      const bytes = new Uint8Array(binary.length);
+      for (let i = 0; i < binary.length; i += 1) {
+        bytes[i] = binary.charCodeAt(i);
+      }
+      const blob = new Blob([bytes], { type: mimeType });
+      const file = new File([blob], name, { type: mimeType, lastModified });
+      transfer.items.add(file);
+    }
+
+    input.files = transfer.files;
+    input.dispatchEvent(new Event("input", { bubbles: true }));
+    input.dispatchEvent(new Event("change", { bubbles: true }));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function dispatchDomClick(
+  this: Element,
+  options?: ClickEventOptions,
+): void {
+  const opts = options ?? {};
+  try {
+    const event = new MouseEvent("click", {
+      bubbles: !!opts.bubbles,
+      cancelable: !!opts.cancelable,
+      composed: !!opts.composed,
+      detail: typeof opts.detail === "number" ? opts.detail : 1,
+      view: this?.ownerDocument?.defaultView ?? window,
+    });
+    this.dispatchEvent(event);
+  } catch {
+    try {
+      // Fallback to native click if MouseEvent construction fails.
+      (this as HTMLElement).click();
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+export function scrollElementToPercent(
+  this: Element,
+  percent: number | string,
+): boolean {
+  const normalize = (value: unknown): number => {
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    const str = String(value ?? "").trim();
+    if (!str) return 0;
+    const numeric = parseFloat(str.replace("%", ""));
+    if (Number.isNaN(numeric) || !Number.isFinite(numeric)) return 0;
+    return numeric;
+  };
+
+  try {
+    const pct = Math.max(0, Math.min(normalize(percent), 100));
+    const element = this as HTMLElement;
+    const tag = element.tagName?.toLowerCase() ?? "";
+
+    const scrollWindow = tag === "html" || tag === "body";
+    if (scrollWindow) {
+      const root =
+        element.ownerDocument?.scrollingElement ||
+        element.ownerDocument?.documentElement ||
+        element.ownerDocument?.body ||
+        document.scrollingElement ||
+        document.documentElement ||
+        document.body;
+      const scrollHeight =
+        root?.scrollHeight ?? document.body.scrollHeight ?? 0;
+      const viewportHeight =
+        element.ownerDocument?.defaultView?.innerHeight ?? window.innerHeight;
+      const maxTop = Math.max(0, scrollHeight - viewportHeight);
+      const top = maxTop * (pct / 100);
+      element.ownerDocument?.defaultView?.scrollTo({
+        top,
+        left:
+          element.ownerDocument?.defaultView?.scrollX ?? window.scrollX ?? 0,
+        behavior: "smooth",
+      });
+      return true;
+    }
+
+    const scrollHeight = element.scrollHeight ?? 0;
+    const clientHeight = element.clientHeight ?? 0;
+    const maxTop = Math.max(0, scrollHeight - clientHeight);
+    const top = maxTop * (pct / 100);
+    element.scrollTo({
+      top,
+      left: element.scrollLeft ?? 0,
+      behavior: "smooth",
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+const inputTypesToSetValue = new Set([
+  "color",
+  "date",
+  "datetime-local",
+  "month",
+  "range",
+  "time",
+  "week",
+]);
+
+const inputTypesToTypeInto = new Set([
+  "",
+  "email",
+  "number",
+  "password",
+  "search",
+  "tel",
+  "text",
+  "url",
+]);
+
+export type FillElementResult =
+  | { status: "done" }
+  | { status: "needsinput"; value: string; reason?: string }
+  | { status: "error"; reason: string };
+
+export function prepareElementForTyping(this: Element): boolean {
+  try {
+    const element = this as HTMLElement;
+    if (!element.isConnected) return false;
+
+    const doc = element.ownerDocument || document;
+    const win = doc.defaultView || window;
+
+    try {
+      if (typeof element.focus === "function") {
+        element.focus();
+      }
+    } catch {
+      /* ignore */
+    }
+
+    if (
+      element instanceof win.HTMLInputElement ||
+      element instanceof win.HTMLTextAreaElement
+    ) {
+      try {
+        if (typeof element.select === "function") {
+          element.select();
+          return true;
+        }
+      } catch {
+        /* ignore */
+      }
+
+      try {
+        const length = (element.value ?? "").length;
+        if (typeof element.setSelectionRange === "function") {
+          element.setSelectionRange(0, length);
+          return true;
+        }
+      } catch {
+        /* ignore */
+      }
+
+      return true;
+    }
+
+    if (element.isContentEditable) {
+      const selection = doc.getSelection?.();
+      const range = doc.createRange?.();
+      if (selection && range) {
+        try {
+          range.selectNodeContents(element);
+          selection.removeAllRanges();
+          selection.addRange(range);
+        } catch {
+          /* ignore */
+        }
+      }
+      return true;
+    }
+
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+export function fillElementValue(
+  this: Element,
+  rawValue: string,
+): FillElementResult {
+  const element = this as HTMLElement;
+  if (!element.isConnected) {
+    return { status: "error", reason: "notconnected" };
+  }
+
+  const doc = element.ownerDocument || document;
+  const win = doc.defaultView || window;
+  let fallbackValue = rawValue ?? "";
+
+  try {
+    const dispatchInputAndChange = (eventValue: string): void => {
+      let inputEvent: Event;
+      if (typeof win.InputEvent === "function") {
+        try {
+          inputEvent = new win.InputEvent("input", {
+            bubbles: true,
+            composed: true,
+            data: eventValue,
+            inputType: "insertText",
+          });
+        } catch {
+          inputEvent = new win.Event("input", {
+            bubbles: true,
+            composed: true,
+          });
+        }
+      } else {
+        inputEvent = new win.Event("input", { bubbles: true, composed: true });
+      }
+
+      element.dispatchEvent(inputEvent);
+
+      const changeEvent = new win.Event("change", { bubbles: true });
+      element.dispatchEvent(changeEvent);
+    };
+
+    if (element instanceof win.HTMLInputElement) {
+      const type = (element.type || "").toLowerCase();
+
+      if (!inputTypesToTypeInto.has(type) && !inputTypesToSetValue.has(type)) {
+        return { status: "error", reason: `unsupported-input-type:${type}` };
+      }
+
+      let valueForTyping = rawValue;
+
+      if (type === "number") {
+        const trimmed = rawValue.trim();
+        if (trimmed !== "" && Number.isNaN(Number(trimmed))) {
+          return { status: "error", reason: "invalid-number-value" };
+        }
+        valueForTyping = trimmed;
+      }
+
+      fallbackValue = valueForTyping;
+
+      if (inputTypesToSetValue.has(type)) {
+        const trimmed = rawValue.trim();
+        fallbackValue = trimmed;
+        prepareElementForTyping.call(element);
+
+        const prototype = win.HTMLInputElement.prototype;
+        const descriptor = Object.getOwnPropertyDescriptor(prototype, "value");
+        const nativeSetter = descriptor?.set;
+
+        if (typeof nativeSetter === "function") {
+          nativeSetter.call(element, trimmed);
+        } else {
+          element.value = trimmed;
+        }
+
+        const tracker = (
+          element as unknown as {
+            _valueTracker?: { setValue?: (next: string) => void };
+          }
+        )._valueTracker;
+        tracker?.setValue?.(trimmed);
+
+        if (element.value !== trimmed) {
+          return { status: "error", reason: "malformed-value" };
+        }
+
+        dispatchInputAndChange(trimmed);
+        return { status: "done" };
+      }
+
+      prepareElementForTyping.call(element);
+      return { status: "needsinput", value: valueForTyping };
+    }
+
+    if (element instanceof win.HTMLTextAreaElement) {
+      prepareElementForTyping.call(element);
+      fallbackValue = rawValue;
+      return { status: "needsinput", value: rawValue };
+    }
+
+    if (element instanceof win.HTMLSelectElement) {
+      // Select elements use setInputFiles/selectOption instead.
+      return { status: "error", reason: "unsupported-element" };
+    }
+
+    if (element.isContentEditable) {
+      prepareElementForTyping.call(element);
+      fallbackValue = rawValue;
+      return { status: "needsinput", value: rawValue };
+    }
+
+    return { status: "error", reason: "unsupported-element" };
+  } catch (error) {
+    let reason = "exception";
+    if (error && typeof error === "object") {
+      const message = (error as { message?: unknown }).message;
+      if (typeof message === "string" && message.trim().length > 0) {
+        reason = `exception:${message}`;
+      }
+    }
+    return { status: "needsinput", value: fallbackValue, reason };
+  }
+}
+
+export function focusElement(this: Element): void {
+  try {
+    if (typeof (this as HTMLElement).focus === "function") {
+      (this as HTMLElement).focus();
+    }
+  } catch {
+    /* ignore */
+  }
+}
+
+export function selectElementOptions(
+  this: Element,
+  rawValues: string | string[],
+): string[] {
+  try {
+    if (!(this instanceof HTMLSelectElement)) return [];
+
+    const desired = Array.isArray(rawValues) ? rawValues : [rawValues];
+    const wanted = new Set(desired.map((v) => String(v ?? "").trim()));
+
+    const matches = (option: HTMLOptionElement): boolean => {
+      const label = (option.label || option.textContent || "").trim();
+      const value = String(option.value ?? "").trim();
+      return wanted.has(label) || wanted.has(value);
+    };
+
+    if (this.multiple) {
+      for (const option of Array.from(this.options)) {
+        option.selected = matches(option);
+      }
+    } else {
+      let chosen = false;
+      for (const option of Array.from(this.options)) {
+        if (!chosen && matches(option)) {
+          option.selected = true;
+          this.value = option.value;
+          chosen = true;
+        } else {
+          option.selected = false;
+        }
+      }
+    }
+
+    const inputEvent = new Event("input", { bubbles: true });
+    const changeEvent = new Event("change", { bubbles: true });
+    this.dispatchEvent(inputEvent);
+    this.dispatchEvent(changeEvent);
+
+    return Array.from(this.selectedOptions).map((opt) => opt.value);
+  } catch {
+    return [];
+  }
+}
+
+export function isElementVisible(this: Element): boolean {
+  try {
+    const element = this as HTMLElement;
+    if (!element.isConnected) return false;
+
+    const style =
+      element.ownerDocument?.defaultView?.getComputedStyle(element) ??
+      window.getComputedStyle(element);
+    if (!style) return false;
+    if (style.display === "none" || style.visibility === "hidden") return false;
+    const opacity = parseFloat(style.opacity ?? "1");
+    if (!Number.isFinite(opacity) || opacity === 0) return false;
+
+    const rect = element.getBoundingClientRect();
+    if (!rect) return false;
+    if (Math.max(rect.width, rect.height) === 0) return false;
+
+    if (element.getClientRects().length === 0) return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function isElementChecked(this: Element): boolean {
+  try {
+    const element = this as HTMLElement;
+    const tag = (element.tagName || "").toLowerCase();
+    if (tag === "input") {
+      const type = (element as HTMLInputElement).type?.toLowerCase() ?? "";
+      if (type === "checkbox" || type === "radio") {
+        return !!(element as HTMLInputElement).checked;
+      }
+    }
+    const aria = element.getAttribute?.("aria-checked");
+    if (aria != null) return aria === "true";
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+export function readElementInputValue(this: Element): string {
+  try {
+    const element = this as HTMLElement;
+    const tag = (element.tagName || "").toLowerCase();
+    if (tag === "input" || tag === "textarea") {
+      return String(
+        (element as HTMLInputElement | HTMLTextAreaElement).value ?? "",
+      );
+    }
+    if (tag === "select") {
+      return String((element as HTMLSelectElement).value ?? "");
+    }
+    if (element.isContentEditable) {
+      return String(element.textContent ?? "");
+    }
+    return "";
+  } catch {
+    return "";
+  }
+}
+
+export function readElementTextContent(this: Element): string {
+  try {
+    return String(this.textContent ?? "");
+  } catch {
+    return "";
+  }
+}
+
+export function readElementInnerHTML(this: Element): string {
+  try {
+    return String((this as HTMLElement).innerHTML ?? "");
+  } catch {
+    return "";
+  }
+}
+
+export function readElementInnerText(this: Element): string {
+  try {
+    const element = this as HTMLElement;
+    const inner = (element as HTMLElement & { innerText?: unknown }).innerText;
+    if (typeof inner === "string" && inner.length > 0) {
+      return inner;
+    }
+    const fallback = element.textContent;
+    return typeof fallback === "string" ? fallback : "";
+  } catch {
+    return "";
+  }
+}
diff --git a/packages/core/lib/v3/dom/locatorScripts/selectors.ts b/packages/core/lib/v3/dom/locatorScripts/selectors.ts
new file mode 100644
index 000000000..e89e51484
--- /dev/null
+++ b/packages/core/lib/v3/dom/locatorScripts/selectors.ts
@@ -0,0 +1,312 @@
+import { resolveXPathAtIndex } from "./xpathResolver.js";
+
+const parseTargetIndex = (value: unknown): number => {
+  const num = Number(value ?? 0);
+  if (!Number.isFinite(num) || num < 0) return 0;
+  return Math.floor(num);
+};
+
+const collectCssMatches = (selector: string, limit: number): Element[] => {
+  if (!selector) return [];
+  const seenRoots = new WeakSet<Node>();
+  const seenElements = new Set<Element>();
+  const results: Element[] = [];
+  const queue: Array<Document | ShadowRoot> = [document];
+
+  const visit = (root: Document | ShadowRoot): void => {
+    if (!root || seenRoots.has(root) || results.length >= limit) return;
+    seenRoots.add(root);
+
+    try {
+      const matches = root.querySelectorAll(selector);
+      for (const element of matches) {
+        if (seenElements.has(element)) continue;
+        seenElements.add(element);
+        results.push(element);
+        if (results.length >= limit) return;
+      }
+    } catch {
+      // ignore querySelectorAll issues
+    }
+
+    try {
+      const ownerDocument =
+        root instanceof Document
+          ? root
+          : (root.host?.ownerDocument ?? document);
+      const walker = ownerDocument.createTreeWalker(
+        root,
+        NodeFilter.SHOW_ELEMENT,
+      );
+      let node: Node | null;
+      while ((node = walker.nextNode())) {
+        if (!(node instanceof Element)) continue;
+        const open = node.shadowRoot;
+        if (open) queue.push(open);
+      }
+    } catch {
+      // ignore traversal issues
+    }
+  };
+
+  while (queue.length && results.length < limit) {
+    const next = queue.shift();
+    if (next) visit(next);
+  }
+
+  return results;
+};
+
+export function resolveCssSelector(
+  selectorRaw: string,
+  targetIndexRaw?: number,
+): Element | null {
+  const selector = String(selectorRaw ?? "").trim();
+  if (!selector) return null;
+
+  const targetIndex = parseTargetIndex(targetIndexRaw);
+  const matches = collectCssMatches(selector, targetIndex + 1);
+  return matches[targetIndex] ?? null;
+}
+
+export function resolveCssSelectorPierce(
+  selectorRaw: string,
+  targetIndexRaw?: number,
+): Element | null {
+  const selector = String(selectorRaw ?? "").trim();
+  if (!selector) return null;
+
+  const targetIndex = parseTargetIndex(targetIndexRaw);
+  const backdoor = window.__stagehandV3__;
+  if (!backdoor || typeof backdoor.getClosedRoot !== "function") {
+    const matches = collectCssMatches(selector, targetIndex + 1);
+    return matches[targetIndex] ?? null;
+  }
+
+  const getClosedRoot: (host: Element) => ShadowRoot | null = (
+    host: Element,
+  ) => {
+    try {
+      return backdoor.getClosedRoot(host) ?? null;
+    } catch {
+      return null;
+    }
+  };
+
+  const seenRoots = new WeakSet<Node>();
+  const seenElements = new Set<Element>();
+  const results: Element[] = [];
+  const queue: Array<Document | ShadowRoot> = [document];
+
+  const visit = (root: Document | ShadowRoot): void => {
+    if (!root || seenRoots.has(root) || results.length >= targetIndex + 1)
+      return;
+    seenRoots.add(root);
+
+    try {
+      const matches = root.querySelectorAll(selector);
+      for (const element of matches) {
+        if (seenElements.has(element)) continue;
+        seenElements.add(element);
+        results.push(element);
+        if (results.length >= targetIndex + 1) return;
+      }
+    } catch {
+      // ignore query errors
+    }
+
+    try {
+      const ownerDocument =
+        root instanceof Document
+          ? root
+          : (root.host?.ownerDocument ?? document);
+      const walker = ownerDocument.createTreeWalker(
+        root,
+        NodeFilter.SHOW_ELEMENT,
+      );
+      let node: Node | null;
+      while ((node = walker.nextNode())) {
+        if (!(node instanceof Element)) continue;
+        const open = node.shadowRoot;
+        if (open) queue.push(open);
+        const closed = getClosedRoot(node);
+        if (closed) queue.push(closed);
+      }
+    } catch {
+      // ignore traversal issues
+    }
+  };
+
+  while (queue.length && results.length < targetIndex + 1) {
+    const next = queue.shift();
+    if (next) visit(next);
+  }
+
+  return results[targetIndex] ?? null;
+}
+
+export function resolveTextSelector(
+  rawNeedle: string,
+  targetIndexRaw?: number,
+): Element | null {
+  const needle = String(rawNeedle ?? "");
+  if (!needle) return null;
+  const needleLc = needle.toLowerCase();
+  const targetIndex = parseTargetIndex(targetIndexRaw);
+
+  const skipTags = new Set([
+    "SCRIPT",
+    "STYLE",
+    "TEMPLATE",
+    "NOSCRIPT",
+    "HEAD",
+    "TITLE",
+    "LINK",
+    "META",
+    "HTML",
+    "BODY",
+  ]);
+
+  const shouldSkip = (node: Element | null | undefined): boolean => {
+    if (!node) return false;
+    const tag = node.tagName?.toUpperCase() ?? "";
+    return skipTags.has(tag);
+  };
+
+  const extractText = (node: Element): string => {
+    try {
+      if (shouldSkip(node)) return "";
+      const inner = (node as HTMLElement).innerText;
+      if (typeof inner === "string" && inner.trim()) return inner.trim();
+    } catch {
+      // ignore
+    }
+    try {
+      const text = node.textContent;
+      if (typeof text === "string") return text.trim();
+    } catch {
+      // ignore
+    }
+    return "";
+  };
+
+  const matches = (node: Element): boolean => {
+    const text = extractText(node);
+    return !!text && text.toLowerCase().includes(needleLc);
+  };
+
+  const backdoor = window.__stagehandV3__;
+  const getClosedRoot: (host: Element) => ShadowRoot | null =
+    backdoor && typeof backdoor.getClosedRoot === "function"
+      ? (host: Element): ShadowRoot | null => {
+          try {
+            return backdoor.getClosedRoot(host) ?? null;
+          } catch {
+            return null;
+          }
+        }
+      : (host: Element): ShadowRoot | null => {
+          void host;
+          return null;
+        };
+
+  const seen = new WeakSet<Node>();
+  const queue: Node[] = [];
+  const matchesList: Array<{
+    element: Element;
+    tag: string;
+    id: string;
+    className: string;
+    text: string;
+  }> = [];
+
+  const enqueue = (node: Node | null | undefined) => {
+    if (!node || seen.has(node)) return;
+    seen.add(node);
+    queue.push(node);
+  };
+
+  const walkerFor = (root: Node): TreeWalker | null => {
+    try {
+      const doc =
+        root instanceof Document
+          ? root
+          : ((root as Element)?.ownerDocument ?? document);
+      return doc.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
+    } catch {
+      return null;
+    }
+  };
+
+  enqueue(document);
+
+  while (queue.length) {
+    const root = queue.shift();
+    if (!root) continue;
+
+    if (root instanceof Element && matches(root)) {
+      matchesList.push({
+        element: root,
+        tag: root.tagName ?? "",
+        id: root.id ?? "",
+        className: (root as HTMLElement).className ?? "",
+        text: extractText(root),
+      });
+    }
+
+    const walker = walkerFor(root);
+    if (!walker) continue;
+
+    let node: Node | null;
+    while ((node = walker.nextNode())) {
+      if (!(node instanceof Element)) continue;
+
+      if (matches(node)) {
+        matchesList.push({
+          element: node,
+          tag: node.tagName ?? "",
+          id: node.id ?? "",
+          className: (node as HTMLElement).className ?? "",
+          text: extractText(node),
+        });
+      }
+
+      const open = node.shadowRoot;
+      if (open) enqueue(open);
+
+      const closed = getClosedRoot(node);
+      if (closed) enqueue(closed);
+    }
+  }
+
+  const innermost: typeof matchesList = [];
+  for (const item of matchesList) {
+    const el = item.element;
+    let skip = false;
+    for (const other of matchesList) {
+      if (item === other) continue;
+      try {
+        if (el.contains(other.element)) {
+          skip = true;
+          break;
+        }
+      } catch {
+        // ignore containment errors
+      }
+    }
+    if (!skip) {
+      innermost.push(item);
+    }
+  }
+
+  const target = innermost[targetIndex];
+  return target?.element ?? null;
+}
+
+export function resolveXPathMainWorld(
+  rawXp: string,
+  targetIndexRaw?: number,
+): Element | null {
+  const targetIndex = parseTargetIndex(targetIndexRaw);
+  return resolveXPathAtIndex(rawXp, targetIndex, { pierceShadow: true });
+}
diff --git a/packages/core/lib/v3/dom/locatorScripts/waitForSelector.ts b/packages/core/lib/v3/dom/locatorScripts/waitForSelector.ts
new file mode 100644
index 000000000..185cf44f6
--- /dev/null
+++ b/packages/core/lib/v3/dom/locatorScripts/waitForSelector.ts
@@ -0,0 +1,337 @@
+/**
+ * waitForSelector - Waits for an element matching a selector to reach a specific state.
+ * Supports both CSS selectors and XPath expressions.
+ * Uses MutationObserver for efficiency and integrates with the V3 piercer for closed shadow roots.
+ *
+ * NOTE: This function runs inside the page context. Keep it dependency-free
+ * and resilient to exceptions.
+ */
+
+import { resolveXPathFirst } from "./xpathResolver.js";
+
+type WaitForSelectorState = "attached" | "detached" | "visible" | "hidden";
+
+/**
+ * Check if a selector is an XPath expression.
+ */
+const isXPath = (selector: string): boolean => {
+  return selector.startsWith("xpath=") || selector.startsWith("/");
+};
+
+/**
+ * Get closed shadow root via the V3 piercer if available.
+ */
+const getClosedRoot = (element: Element): ShadowRoot | null => {
+  try {
+    const backdoor = window.__stagehandV3__;
+    if (backdoor && typeof backdoor.getClosedRoot === "function") {
+      return backdoor.getClosedRoot(element) ?? null;
+    }
+  } catch {
+    // ignore
+  }
+  return null;
+};
+
+/**
+ * Get shadow root (open or closed via piercer).
+ */
+const getShadowRoot = (element: Element): ShadowRoot | null => {
+  // First try open shadow root
+  if (element.shadowRoot) return element.shadowRoot;
+  // Then try closed shadow root via piercer
+  return getClosedRoot(element);
+};
+
+/**
+ * Deep querySelector that pierces shadow DOM (both open and closed via piercer).
+ */
+const deepQuerySelector = (
+  root: Document | ShadowRoot,
+  selector: string,
+  pierceShadow: boolean,
+): Element | null => {
+  // Try regular querySelector first
+  try {
+    const el = root.querySelector(selector);
+    if (el) return el;
+  } catch {
+    // ignore query errors
+  }
+
+  if (!pierceShadow) return null;
+
+  // BFS queue to search all shadow roots (open and closed)
+  const seenRoots = new WeakSet<Node>();
+  const queue: Array<Document | ShadowRoot> = [root];
+
+  while (queue.length > 0) {
+    const currentRoot = queue.shift();
+    if (!currentRoot || seenRoots.has(currentRoot)) continue;
+    seenRoots.add(currentRoot);
+
+    // Try querySelector on this root
+    try {
+      const found = currentRoot.querySelector(selector);
+      if (found) return found;
+    } catch {
+      // ignore query errors
+    }
+
+    // Walk all elements in this root to find shadow hosts
+    try {
+      const ownerDoc =
+        currentRoot instanceof Document
+          ? currentRoot
+          : (currentRoot.host?.ownerDocument ?? document);
+      const walker = ownerDoc.createTreeWalker(
+        currentRoot,
+        NodeFilter.SHOW_ELEMENT,
+      );
+      let node: Node | null;
+      while ((node = walker.nextNode())) {
+        if (!(node instanceof Element)) continue;
+        const shadowRoot = getShadowRoot(node);
+        if (shadowRoot && !seenRoots.has(shadowRoot)) {
+          queue.push(shadowRoot);
+        }
+      }
+    } catch {
+      // ignore traversal errors
+    }
+  }
+
+  return null;
+};
+
+/**
+ * Resolve XPath with shadow DOM piercing support.
+ */
+const deepXPathQuery = (
+  xpath: string,
+  pierceShadow: boolean,
+): Element | null => {
+  return resolveXPathFirst(xpath, { pierceShadow });
+};
+
+/**
+ * Find element by selector (CSS or XPath) with optional shadow DOM piercing.
+ */
+const findElement = (
+  selector: string,
+  pierceShadow: boolean,
+): Element | null => {
+  if (isXPath(selector)) {
+    return deepXPathQuery(selector, pierceShadow);
+  }
+  return deepQuerySelector(document, selector, pierceShadow);
+};
+
+/**
+ * Check if element matches the desired state.
+ */
+const checkState = (
+  el: Element | null,
+  state: WaitForSelectorState,
+): boolean => {
+  if (state === "detached") return el === null;
+  if (state === "attached") return el !== null;
+  if (el === null) return false;
+
+  if (state === "hidden") {
+    try {
+      const style = window.getComputedStyle(el);
+      const rect = el.getBoundingClientRect();
+      return (
+        style.display === "none" ||
+        style.visibility === "hidden" ||
+        style.opacity === "0" ||
+        rect.width === 0 ||
+        rect.height === 0
+      );
+    } catch {
+      return false;
+    }
+  }
+
+  // state === "visible"
+  try {
+    const style = window.getComputedStyle(el);
+    const rect = el.getBoundingClientRect();
+    return (
+      style.display !== "none" &&
+      style.visibility !== "hidden" &&
+      style.opacity !== "0" &&
+      rect.width > 0 &&
+      rect.height > 0
+    );
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Set up MutationObservers on all shadow roots to detect changes.
+ */
+const setupShadowObservers = (
+  callback: () => void,
+  observers: MutationObserver[],
+): void => {
+  const seenRoots = new WeakSet<Node>();
+
+  const observeShadowRoots = (node: Element): void => {
+    const shadowRoot = getShadowRoot(node);
+    if (shadowRoot && !seenRoots.has(shadowRoot)) {
+      seenRoots.add(shadowRoot);
+      const shadowObserver = new MutationObserver(callback);
+      shadowObserver.observe(shadowRoot, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        attributeFilter: ["style", "class", "hidden", "disabled"],
+      });
+      observers.push(shadowObserver);
+
+      // Recurse into shadow root children
+      for (const child of Array.from(shadowRoot.children)) {
+        observeShadowRoots(child);
+      }
+    }
+
+    // Recurse into regular children
+    for (const child of Array.from(node.children)) {
+      observeShadowRoots(child);
+    }
+  };
+
+  const root = document.documentElement || document.body;
+  if (root) {
+    observeShadowRoots(root);
+  }
+};
+
+/**
+ * Wait for an element matching the selector to reach the specified state.
+ * Supports both CSS selectors and XPath expressions (prefix with "xpath=" or start with "/").
+ *
+ * @param selectorRaw - CSS selector or XPath expression to wait for
+ * @param stateRaw - Element state: 'attached' | 'detached' | 'visible' | 'hidden'
+ * @param timeoutRaw - Maximum time to wait in milliseconds
+ * @param pierceShadowRaw - Whether to search inside shadow DOM
+ * @returns Promise that resolves to true when condition is met, or rejects on timeout
+ */
+export function waitForSelector(
+  selectorRaw: string,
+  stateRaw?: string,
+  timeoutRaw?: number,
+  pierceShadowRaw?: boolean,
+): Promise<boolean> {
+  const selector = String(selectorRaw ?? "").trim();
+  const state =
+    (String(stateRaw ?? "visible") as WaitForSelectorState) || "visible";
+  const timeout =
+    typeof timeoutRaw === "number" && timeoutRaw > 0 ? timeoutRaw : 30000;
+  const pierceShadow = pierceShadowRaw !== false;
+
+  return new Promise<boolean>((resolve, reject) => {
+    let timeoutId: ReturnType<typeof setTimeout> | null = null;
+    let domReadyHandler: (() => void) | null = null;
+    let settled = false;
+    const clearTimer = (): void => {
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    };
+
+    // Check immediately
+    const el = findElement(selector, pierceShadow);
+    if (checkState(el, state)) {
+      settled = true;
+      resolve(true);
+      return;
+    }
+
+    const observers: MutationObserver[] = [];
+
+    const cleanup = (): void => {
+      for (const obs of observers) {
+        obs.disconnect();
+      }
+      if (domReadyHandler) {
+        document.removeEventListener("DOMContentLoaded", domReadyHandler);
+        domReadyHandler = null;
+      }
+    };
+
+    const check = (): void => {
+      if (settled) return;
+      const el = findElement(selector, pierceShadow);
+      if (checkState(el, state)) {
+        settled = true;
+        clearTimer();
+        cleanup();
+        resolve(true);
+      }
+    };
+
+    // Handle case where document.body is not ready yet
+    const observeRoot = document.body || document.documentElement;
+    if (!observeRoot) {
+      domReadyHandler = (): void => {
+        document.removeEventListener("DOMContentLoaded", domReadyHandler!);
+        domReadyHandler = null;
+        check();
+        setupObservers();
+      };
+      document.addEventListener("DOMContentLoaded", domReadyHandler);
+      timeoutId = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        clearTimer();
+        cleanup();
+        reject(
+          new Error(
+            `waitForSelector: Timeout ${timeout}ms exceeded waiting for "${selector}" to be ${state}`,
+          ),
+        );
+      }, timeout);
+      return;
+    }
+
+    const setupObservers = (): void => {
+      const root = document.body || document.documentElement;
+      if (!root) return;
+
+      // Main document observer
+      const mainObserver = new MutationObserver(check);
+      mainObserver.observe(root, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        attributeFilter: ["style", "class", "hidden", "disabled"],
+      });
+      observers.push(mainObserver);
+
+      // Shadow DOM observers (if piercing)
+      if (pierceShadow) {
+        setupShadowObservers(check, observers);
+      }
+    };
+
+    setupObservers();
+
+    // Set up timeout
+    timeoutId = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      clearTimer();
+      cleanup();
+      reject(
+        new Error(
+          `waitForSelector: Timeout ${timeout}ms exceeded waiting for "${selector}" to be ${state}`,
+        ),
+      );
+    }, timeout);
+  });
+}
diff --git a/packages/core/lib/v3/dom/locatorScripts/xpathParser.ts b/packages/core/lib/v3/dom/locatorScripts/xpathParser.ts
new file mode 100644
index 000000000..e388c2943
--- /dev/null
+++ b/packages/core/lib/v3/dom/locatorScripts/xpathParser.ts
@@ -0,0 +1,460 @@
+export type XPathPredicate =
+  | { type: "index"; index: number }
+  | { type: "attrEquals"; name: string; value: string; normalize?: boolean }
+  | { type: "attrExists"; name: string }
+  | {
+      type: "attrContains";
+      name: string;
+      value: string;
+      normalize?: boolean;
+    }
+  | {
+      type: "attrStartsWith";
+      name: string;
+      value: string;
+      normalize?: boolean;
+    }
+  | { type: "textEquals"; value: string; normalize?: boolean }
+  | { type: "textContains"; value: string; normalize?: boolean }
+  | { type: "and"; predicates: XPathPredicate[] }
+  | { type: "or"; predicates: XPathPredicate[] }
+  | { type: "not"; predicate: XPathPredicate };
+
+export interface XPathStep {
+  axis: "child" | "desc";
+  tag: string;
+  predicates: XPathPredicate[];
+}
+
+/**
+ * Parse an XPath expression into a list of traversal steps.
+ *
+ * This is a subset parser designed for composed DOM traversal (including
+ * shadow roots). It intentionally does not implement the full XPath spec.
+ *
+ * Supported:
+ *  - Child (`/`) and descendant (`//`) axes
+ *  - Tag names and wildcard (`*`)
+ *  - Positional indices (`[n]`)
+ *  - Attribute equality predicates (`[@attr='value']`, `[@attr="value"]`)
+ *  - Attribute existence (`[@attr]`)
+ *  - Attribute contains/starts-with (`contains(@attr,'v')`, `starts-with(@attr,'v')`)
+ *  - Text equality/contains (`[text()='v']`, `[contains(text(),'v')]`, `[.='v']`)
+ *  - normalize-space on text/attributes (`[normalize-space(text())='v']`)
+ *  - Basic boolean predicates (`and`, `or`, `not(...)`)
+ *  - Multiple predicates per step (`[@class='foo'][2]`)
+ *  - Optional `xpath=` prefix
+ *
+ * Not supported:
+ *  - Position functions (`[position() > n]`, `[last()]`)
+ *  - Axes beyond child/descendant (`ancestor::`, `parent::`, `self::`,
+ *    `preceding-sibling::`, `following-sibling::`)
+ *  - Union operator (`|`)
+ *  - Grouped expressions (`(//div)[n]`)
+ *
+ * Unsupported predicates are silently ignored — the step still matches
+ * by tag name, but the unrecognized predicate has no filtering effect.
+ */
+export function parseXPathSteps(input: string): XPathStep[] {
+  const path = String(input || "")
+    .trim()
+    .replace(/^xpath=/i, "");
+  if (!path) return [];
+
+  const steps: XPathStep[] = [];
+  let i = 0;
+
+  while (i < path.length) {
+    let axis: "child" | "desc" = "child";
+    if (path.startsWith("//", i)) {
+      axis = "desc";
+      i += 2;
+    } else if (path[i] === "/") {
+      axis = "child";
+      i += 1;
+    }
+
+    const start = i;
+    let bracketDepth = 0;
+    let quote: string | null = null;
+    while (i < path.length) {
+      const ch = path[i];
+      if (quote) {
+        if (ch === quote) quote = null;
+      } else if (ch === "'" || ch === '"') {
+        quote = ch;
+      } else if (ch === "[") {
+        bracketDepth++;
+      } else if (ch === "]") {
+        bracketDepth--;
+      } else if (ch === "/" && bracketDepth === 0) {
+        break;
+      }
+      i += 1;
+    }
+    const rawStep = path.slice(start, i).trim();
+    if (!rawStep) continue;
+
+    const { tag, predicates } = parseStep(rawStep);
+    steps.push({ axis, tag, predicates });
+  }
+
+  return steps;
+}
+
+/**
+ * Extract predicate contents from a string like `[@attr='val'][2]`.
+ * Handles `]` inside quoted attribute values (e.g. `[@title='a[0]']`).
+ */
+function extractPredicates(str: string): string[] {
+  const results: string[] = [];
+  let i = 0;
+  while (i < str.length) {
+    if (str[i] !== "[") {
+      i++;
+      continue;
+    }
+    i++; // skip opening [
+    const start = i;
+    let quote: string | null = null;
+    while (i < str.length) {
+      const ch = str[i];
+      if (quote) {
+        if (ch === quote) quote = null;
+      } else if (ch === "'" || ch === '"') {
+        quote = ch;
+      } else if (ch === "]") {
+        break;
+      }
+      i++;
+    }
+    results.push(str.slice(start, i).trim());
+    i++; // skip closing ]
+  }
+  return results;
+}
+
+function parseStep(raw: string): {
+  tag: string;
+  predicates: XPathPredicate[];
+} {
+  const bracketPos = raw.indexOf("[");
+  if (bracketPos === -1) {
+    const tag = raw === "" ? "*" : raw.toLowerCase();
+    return { tag, predicates: [] };
+  }
+
+  const tagPart = raw.slice(0, bracketPos).trim();
+  const tag = tagPart === "" ? "*" : tagPart.toLowerCase();
+  const predicateStr = raw.slice(bracketPos);
+
+  const predicates: XPathPredicate[] = [];
+
+  for (const inner of extractPredicates(predicateStr)) {
+    const parsed = parsePredicateExpression(inner);
+    if (parsed) predicates.push(parsed);
+  }
+
+  return { tag, predicates };
+}
+
+function parsePredicateExpression(input: string): XPathPredicate | null {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+
+  const orParts = splitTopLevel(trimmed, "or");
+  if (orParts.length > 1) {
+    const preds = orParts
+      .map((part) => parsePredicateExpression(part))
+      .filter(Boolean) as XPathPredicate[];
+    if (preds.length !== orParts.length) return null;
+    return { type: "or", predicates: preds };
+  }
+
+  const andParts = splitTopLevel(trimmed, "and");
+  if (andParts.length > 1) {
+    const preds = andParts
+      .map((part) => parsePredicateExpression(part))
+      .filter(Boolean) as XPathPredicate[];
+    if (preds.length !== andParts.length) return null;
+    return { type: "and", predicates: preds };
+  }
+
+  const notInner = unwrapFunctionCall(trimmed, "not");
+  if (notInner != null) {
+    const predicate = parsePredicateExpression(notInner);
+    return predicate ? { type: "not", predicate } : null;
+  }
+
+  return parseAtomicPredicate(trimmed);
+}
+
+function parseAtomicPredicate(input: string): XPathPredicate | null {
+  const valueMatch = /^(?:'([^']*)'|"([^"]*)")$/;
+  const attrName = "[a-zA-Z_][\\w.-]*";
+  const quoted = "(?:'([^']*)'|\"([^\"]*)\")";
+
+  if (/^\d+$/.test(input)) {
+    return { type: "index", index: Math.max(1, Number(input)) };
+  }
+
+  const normalizeAttrMatch = input.match(
+    new RegExp(
+      `^normalize-space\\(\\s*@(${attrName})\\s*\\)\\s*=\\s*${quoted}$`,
+    ),
+  );
+  if (normalizeAttrMatch) {
+    return {
+      type: "attrEquals",
+      name: normalizeAttrMatch[1],
+      value: normalizeAttrMatch[2] ?? normalizeAttrMatch[3] ?? "",
+      normalize: true,
+    };
+  }
+
+  const normalizeTextMatch = input.match(
+    new RegExp(
+      `^normalize-space\\(\\s*(?:text\\(\\)|\\.)\\s*\\)\\s*=\\s*${quoted}$`,
+    ),
+  );
+  if (normalizeTextMatch) {
+    return {
+      type: "textEquals",
+      value: normalizeTextMatch[1] ?? normalizeTextMatch[2] ?? "",
+      normalize: true,
+    };
+  }
+
+  const attrEqualsMatch = input.match(
+    new RegExp(`^@(${attrName})\\s*=\\s*${quoted}$`),
+  );
+  if (attrEqualsMatch) {
+    return {
+      type: "attrEquals",
+      name: attrEqualsMatch[1],
+      value: attrEqualsMatch[2] ?? attrEqualsMatch[3] ?? "",
+    };
+  }
+
+  const attrExistsMatch = input.match(new RegExp(`^@(${attrName})$`));
+  if (attrExistsMatch) {
+    return { type: "attrExists", name: attrExistsMatch[1] };
+  }
+
+  const attrContainsMatch = input.match(
+    new RegExp(`^contains\\(\\s*@(${attrName})\\s*,\\s*${quoted}\\s*\\)$`),
+  );
+  if (attrContainsMatch) {
+    return {
+      type: "attrContains",
+      name: attrContainsMatch[1],
+      value: attrContainsMatch[2] ?? attrContainsMatch[3] ?? "",
+    };
+  }
+
+  const attrStartsMatch = input.match(
+    new RegExp(`^starts-with\\(\\s*@(${attrName})\\s*,\\s*${quoted}\\s*\\)$`),
+  );
+  if (attrStartsMatch) {
+    return {
+      type: "attrStartsWith",
+      name: attrStartsMatch[1],
+      value: attrStartsMatch[2] ?? attrStartsMatch[3] ?? "",
+    };
+  }
+
+  const textEqualsMatch = input.match(
+    new RegExp(`^(?:text\\(\\)|\\.)\\s*=\\s*${quoted}$`),
+  );
+  if (textEqualsMatch) {
+    return {
+      type: "textEquals",
+      value: textEqualsMatch[1] ?? textEqualsMatch[2] ?? "",
+    };
+  }
+
+  const textContainsMatch = input.match(
+    new RegExp(`^contains\\(\\s*(?:text\\(\\)|\\.)\\s*,\\s*${quoted}\\s*\\)$`),
+  );
+  if (textContainsMatch) {
+    return {
+      type: "textContains",
+      value: textContainsMatch[1] ?? textContainsMatch[2] ?? "",
+    };
+  }
+
+  if (valueMatch.test(input)) {
+    return null;
+  }
+
+  return null;
+}
+
+function splitTopLevel(input: string, keyword: string): string[] {
+  const parts: string[] = [];
+  let start = 0;
+  let depth = 0;
+  let quote: string | null = null;
+  let i = 0;
+
+  while (i < input.length) {
+    const ch = input[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+      i += 1;
+      continue;
+    }
+
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      i += 1;
+      continue;
+    }
+
+    if (ch === "(") {
+      depth += 1;
+      i += 1;
+      continue;
+    }
+
+    if (ch === ")") {
+      depth = Math.max(0, depth - 1);
+      i += 1;
+      continue;
+    }
+
+    if (depth === 0 && isKeywordAt(input, i, keyword)) {
+      parts.push(input.slice(start, i).trim());
+      i += keyword.length;
+      start = i;
+      continue;
+    }
+
+    i += 1;
+  }
+
+  parts.push(input.slice(start).trim());
+  return parts.filter((part) => part.length > 0);
+}
+
+function isKeywordAt(input: string, index: number, keyword: string): boolean {
+  if (!input.startsWith(keyword, index)) return false;
+  const before = index > 0 ? input[index - 1] : " ";
+  if (before === "@") return false;
+  const after =
+    index + keyword.length < input.length ? input[index + keyword.length] : " ";
+  return isBoundary(before) && isBoundary(after);
+}
+
+function isBoundary(ch: string): boolean {
+  return !/[a-zA-Z0-9_.-]/.test(ch);
+}
+
+function unwrapFunctionCall(input: string, name: string): string | null {
+  const prefix = `${name}(`;
+  if (!input.startsWith(prefix) || !input.endsWith(")")) return null;
+  const inner = input.slice(prefix.length, -1);
+  return hasBalancedParens(inner) ? inner : null;
+}
+
+function hasBalancedParens(input: string): boolean {
+  let depth = 0;
+  let quote: string | null = null;
+  for (let i = 0; i < input.length; i += 1) {
+    const ch = input[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      continue;
+    }
+    if (ch === "(") depth += 1;
+    else if (ch === ")") depth -= 1;
+    if (depth < 0) return false;
+  }
+  return depth === 0;
+}
+
+const normalizeSpace = (value: string): string =>
+  value.replace(/\s+/g, " ").trim();
+
+function textValue(element: Element): string {
+  return String(element.textContent ?? "");
+}
+
+function normalizeMaybe(value: string, normalize?: boolean): string {
+  return normalize ? normalizeSpace(value) : value;
+}
+
+export function evaluatePredicate(
+  element: Element,
+  predicate: XPathPredicate,
+): boolean {
+  switch (predicate.type) {
+    case "and":
+      return predicate.predicates.every((p) => evaluatePredicate(element, p));
+    case "or":
+      return predicate.predicates.some((p) => evaluatePredicate(element, p));
+    case "not":
+      return !evaluatePredicate(element, predicate.predicate);
+    case "attrExists":
+      return element.getAttribute(predicate.name) !== null;
+    case "attrEquals": {
+      const attr = element.getAttribute(predicate.name);
+      if (attr === null) return false;
+      return (
+        normalizeMaybe(attr, predicate.normalize) ===
+        normalizeMaybe(predicate.value, predicate.normalize)
+      );
+    }
+    case "attrContains": {
+      const attr = element.getAttribute(predicate.name);
+      if (attr === null) return false;
+      return normalizeMaybe(attr, predicate.normalize).includes(
+        normalizeMaybe(predicate.value, predicate.normalize),
+      );
+    }
+    case "attrStartsWith": {
+      const attr = element.getAttribute(predicate.name);
+      if (attr === null) return false;
+      return normalizeMaybe(attr, predicate.normalize).startsWith(
+        normalizeMaybe(predicate.value, predicate.normalize),
+      );
+    }
+    case "textEquals": {
+      const value = normalizeMaybe(textValue(element), predicate.normalize);
+      return value === normalizeMaybe(predicate.value, predicate.normalize);
+    }
+    case "textContains": {
+      const value = normalizeMaybe(textValue(element), predicate.normalize);
+      return value.includes(
+        normalizeMaybe(predicate.value, predicate.normalize),
+      );
+    }
+    case "index":
+      return true;
+    default:
+      return true;
+  }
+}
+
+export function applyPredicates(
+  elements: Element[],
+  predicates: XPathPredicate[],
+): Element[] {
+  let current = elements;
+  for (const predicate of predicates) {
+    if (!current.length) return [];
+
+    if (predicate.type === "index") {
+      const idx = predicate.index - 1;
+      current = idx >= 0 && idx < current.length ? [current[idx]!] : [];
+      continue;
+    }
+
+    current = current.filter((el) => evaluatePredicate(el, predicate));
+  }
+  return current;
+}
diff --git a/packages/core/lib/v3/dom/locatorScripts/xpathResolver.ts b/packages/core/lib/v3/dom/locatorScripts/xpathResolver.ts
new file mode 100644
index 000000000..6ae8936ac
--- /dev/null
+++ b/packages/core/lib/v3/dom/locatorScripts/xpathResolver.ts
@@ -0,0 +1,270 @@
+import {
+  applyPredicates,
+  parseXPathSteps,
+  type XPathStep,
+} from "./xpathParser.js";
+
+type ClosedRootGetter = (host: Element) => ShadowRoot | null;
+
+export type XPathResolveOptions = {
+  pierceShadow?: boolean;
+};
+
+type ShadowContext = {
+  getClosedRoot: ClosedRootGetter | null;
+  hasShadow: boolean;
+};
+
+const normalizeXPath = (selector: string): string => {
+  const raw = String(selector ?? "").trim();
+  if (!raw) return "";
+  return raw.replace(/^xpath=/i, "").trim();
+};
+
+export function resolveXPathFirst(
+  rawXp: string,
+  options?: XPathResolveOptions,
+): Element | null {
+  return resolveXPathAtIndex(rawXp, 0, options);
+}
+
+export function resolveXPathAtIndex(
+  rawXp: string,
+  index: number,
+  options?: XPathResolveOptions,
+): Element | null {
+  if (!Number.isFinite(index) || index < 0) return null;
+  const xp = normalizeXPath(rawXp);
+  if (!xp) return null;
+
+  const targetIndex = Math.floor(index);
+  const pierceShadow = options?.pierceShadow !== false;
+  const shadowCtx = pierceShadow ? getShadowContext() : null;
+
+  if (!pierceShadow) {
+    return resolveNativeAtIndexWithError(xp, targetIndex).value;
+  }
+
+  if (!shadowCtx?.hasShadow) {
+    const native = resolveNativeAtIndexWithError(xp, targetIndex);
+    if (!native.error) return native.value;
+    const composed = resolveXPathComposedMatches(xp, shadowCtx?.getClosedRoot);
+    return composed[targetIndex] ?? null;
+  }
+
+  const composed = resolveXPathComposedMatches(xp, shadowCtx.getClosedRoot);
+  return composed[targetIndex] ?? null;
+}
+
+export function countXPathMatches(
+  rawXp: string,
+  options?: XPathResolveOptions,
+): number {
+  const xp = normalizeXPath(rawXp);
+  if (!xp) return 0;
+
+  const pierceShadow = options?.pierceShadow !== false;
+  const shadowCtx = pierceShadow ? getShadowContext() : null;
+
+  if (!pierceShadow) {
+    return resolveNativeCountWithError(xp).count;
+  }
+
+  if (!shadowCtx?.hasShadow) {
+    const count = resolveNativeCountWithError(xp);
+    if (!count.error) return count.count;
+    return resolveXPathComposedMatches(xp, shadowCtx?.getClosedRoot).length;
+  }
+
+  return resolveXPathComposedMatches(xp, shadowCtx.getClosedRoot).length;
+}
+
+export function resolveXPathComposedMatches(
+  rawXp: string,
+  getClosedRoot?: ClosedRootGetter | null,
+): Element[] {
+  const xp = normalizeXPath(rawXp);
+  if (!xp) return [];
+
+  const steps = parseXPathSteps(xp);
+  if (!steps.length) return [];
+
+  const closedRoot = getClosedRoot ?? null;
+
+  let current: Array<Document | Element | ShadowRoot | DocumentFragment> = [
+    document,
+  ];
+
+  for (const step of steps) {
+    const next: Element[] = [];
+    const seen = new Set<Element>();
+
+    for (const root of current) {
+      if (!root) continue;
+      const pool =
+        step.axis === "child"
+          ? composedChildren(root, closedRoot)
+          : composedDescendants(root, closedRoot);
+      if (!pool.length) continue;
+
+      const tagMatches = pool.filter((candidate) =>
+        matchesTag(candidate, step),
+      );
+      const matches = applyPredicates(tagMatches, step.predicates);
+
+      for (const candidate of matches) {
+        if (!seen.has(candidate)) {
+          seen.add(candidate);
+          next.push(candidate);
+        }
+      }
+    }
+
+    if (!next.length) return [];
+    current = next;
+  }
+
+  return current as Element[];
+}
+
+function matchesTag(element: Element, step: XPathStep): boolean {
+  if (step.tag === "*") return true;
+  return element.localName === step.tag;
+}
+
+function getShadowContext(): ShadowContext {
+  const backdoor = window.__stagehandV3__;
+  const getClosedRoot: ClosedRootGetter | null =
+    backdoor && typeof backdoor.getClosedRoot === "function"
+      ? (host: Element): ShadowRoot | null => {
+          try {
+            return backdoor.getClosedRoot(host) ?? null;
+          } catch {
+            return null;
+          }
+        }
+      : null;
+
+  let hasShadow = false;
+  try {
+    if (backdoor && typeof backdoor.stats === "function") {
+      const stats = backdoor.stats();
+      hasShadow = (stats?.open ?? 0) > 0 || (stats?.closed ?? 0) > 0;
+    }
+  } catch {
+    // ignore stats errors
+  }
+
+  if (!hasShadow) {
+    try {
+      const walker = document.createTreeWalker(
+        document,
+        NodeFilter.SHOW_ELEMENT,
+      );
+      while (walker.nextNode()) {
+        const el = walker.currentNode as Element;
+        if (el.shadowRoot) {
+          hasShadow = true;
+          break;
+        }
+      }
+    } catch {
+      // ignore scan errors
+    }
+  }
+
+  return { getClosedRoot, hasShadow };
+}
+
+function composedChildren(
+  node: Node | null | undefined,
+  getClosedRoot: ClosedRootGetter | null,
+): Element[] {
+  const out: Element[] = [];
+  if (!node) return out;
+
+  if (node instanceof Document) {
+    if (node.documentElement) out.push(node.documentElement);
+    return out;
+  }
+
+  if (node instanceof ShadowRoot || node instanceof DocumentFragment) {
+    out.push(...Array.from(node.children ?? []));
+    return out;
+  }
+
+  if (node instanceof Element) {
+    out.push(...Array.from(node.children ?? []));
+    const open = node.shadowRoot;
+    if (open) out.push(...Array.from(open.children ?? []));
+    if (getClosedRoot) {
+      const closed = getClosedRoot(node);
+      if (closed) out.push(...Array.from(closed.children ?? []));
+    }
+    return out;
+  }
+
+  return out;
+}
+
+function composedDescendants(
+  node: Node | null | undefined,
+  getClosedRoot: ClosedRootGetter | null,
+): Element[] {
+  const out: Element[] = [];
+  const seen = new Set<Element>();
+  const stack = [...composedChildren(node, getClosedRoot)].reverse();
+
+  while (stack.length) {
+    const next = stack.pop();
+    if (!next || seen.has(next)) continue;
+    seen.add(next);
+    out.push(next);
+
+    const children = composedChildren(next, getClosedRoot);
+    for (let i = children.length - 1; i >= 0; i -= 1) {
+      stack.push(children[i]!);
+    }
+  }
+
+  return out;
+}
+
+function resolveNativeAtIndexWithError(
+  xp: string,
+  index: number,
+): { value: Element | null; error: boolean } {
+  try {
+    const snapshot = document.evaluate(
+      xp,
+      document,
+      null,
+      XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,
+      null,
+    );
+    return {
+      value: snapshot.snapshotItem(index) as Element | null,
+      error: false,
+    };
+  } catch {
+    return { value: null, error: true };
+  }
+}
+
+function resolveNativeCountWithError(xp: string): {
+  count: number;
+  error: boolean;
+} {
+  try {
+    const snapshot = document.evaluate(
+      xp,
+      document,
+      null,
+      XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,
+      null,
+    );
+    return { count: snapshot.snapshotLength, error: false };
+  } catch {
+    return { count: 0, error: true };
+  }
+}
diff --git a/packages/core/lib/v3/dom/piercer.entry.ts b/packages/core/lib/v3/dom/piercer.entry.ts
new file mode 100644
index 000000000..6e6232646
--- /dev/null
+++ b/packages/core/lib/v3/dom/piercer.entry.ts
@@ -0,0 +1,3 @@
+import { installV3ShadowPiercer } from "./piercer.runtime.js";
+
+installV3ShadowPiercer({ debug: true, tagExisting: false });
diff --git a/packages/core/lib/v3/dom/piercer.runtime.ts b/packages/core/lib/v3/dom/piercer.runtime.ts
new file mode 100644
index 000000000..56db4e9a7
--- /dev/null
+++ b/packages/core/lib/v3/dom/piercer.runtime.ts
@@ -0,0 +1,138 @@
+export interface V3ShadowPatchOptions {
+  debug?: boolean;
+  tagExisting?: boolean;
+}
+
+export interface StagehandV3Backdoor {
+  /** Closed shadow-root accessors */
+  getClosedRoot(host: Element): ShadowRoot | undefined;
+  /** Stats + quick health check */
+  stats(): {
+    installed: true;
+    url: string;
+    isTop: boolean;
+    open: number;
+    closed: number;
+  };
+}
+
+type V3InternalState = {
+  hostToRoot: WeakMap<Element, ShadowRoot>;
+  openCount: number;
+  closedCount: number;
+  debug: boolean;
+};
+
+declare global {
+  interface Window {
+    __stagehandV3Injected?: boolean;
+    __stagehandV3__?: StagehandV3Backdoor;
+  }
+}
+
+export function installV3ShadowPiercer(opts: V3ShadowPatchOptions = {}): void {
+  // hardcoded debug (remove later if desired)
+  const DEBUG = true;
+
+  type PatchedFn = Element["attachShadow"] & {
+    __v3Patched?: boolean;
+    __v3State?: V3InternalState;
+  };
+
+  const bindBackdoor = (state: V3InternalState): void => {
+    const { hostToRoot } = state;
+
+    window.__stagehandV3__ = {
+      getClosedRoot: (host: Element) => hostToRoot.get(host),
+      stats: () => ({
+        installed: true,
+        url: location.href,
+        isTop: window.top === window,
+        open: state.openCount,
+        closed: state.closedCount,
+      }),
+    } satisfies StagehandV3Backdoor;
+  };
+
+  // Look at the *current* function on the prototype. If it's already our patched
+  // function, reuse its shared state and rebind the backdoor (no new WeakMap).
+  const currentFn = Element.prototype.attachShadow as PatchedFn;
+  if (currentFn.__v3Patched && currentFn.__v3State) {
+    currentFn.__v3State.debug = DEBUG; // keep debug toggle consistent
+    bindBackdoor(currentFn.__v3State);
+    // idempotent: do not log "installed" again
+    return;
+  }
+
+  // First-time install: create shared state and replace the prototype method
+  const state: V3InternalState = {
+    hostToRoot: new WeakMap<Element, ShadowRoot>(),
+    openCount: 0,
+    closedCount: 0,
+    debug: DEBUG,
+  };
+
+  const original = currentFn; // keep a reference to call through
+  const patched: PatchedFn = function (
+    this: Element,
+    init: ShadowRootInit,
+  ): ShadowRoot {
+    const mode = init?.mode ?? "open";
+    const root = original.call(this, init);
+    try {
+      state.hostToRoot.set(this, root);
+      if (mode === "closed") state.closedCount++;
+      else state.openCount++;
+      if (state.debug) {
+        console.info("[v3-piercer] attachShadow", {
+          tag: (this as Element).tagName?.toLowerCase() ?? "",
+          mode,
+          url: location.href,
+        });
+      }
+    } catch {
+      //
+    }
+    return root;
+  } as PatchedFn;
+
+  // Mark the *patched* function with metadata so re-entry sees it
+  patched.__v3Patched = true;
+  patched.__v3State = state;
+
+  Object.defineProperty(Element.prototype, "attachShadow", {
+    configurable: true,
+    writable: true,
+    value: patched,
+  });
+
+  // Optionally tag existing open roots (closed cannot be discovered post-hoc)
+  if (opts.tagExisting) {
+    try {
+      const walker = document.createTreeWalker(
+        document,
+        NodeFilter.SHOW_ELEMENT,
+      );
+      while (walker.nextNode()) {
+        const el = walker.currentNode as Element;
+        if (el.shadowRoot) {
+          state.hostToRoot.set(el, el.shadowRoot);
+          state.openCount++;
+        }
+      }
+    } catch {
+      //
+    }
+  }
+
+  window.__stagehandV3Injected = true;
+  bindBackdoor(state);
+
+  if (state.debug) {
+    console.info("[v3-piercer] installed", {
+      url: location.href,
+      isTop: window.top === window,
+      readyState: document.readyState,
+    });
+  }
+}
diff --git a/packages/core/lib/v3/dom/rerenderMissingShadows.entry.ts b/packages/core/lib/v3/dom/rerenderMissingShadows.entry.ts
new file mode 100644
index 000000000..4535fcc90
--- /dev/null
+++ b/packages/core/lib/v3/dom/rerenderMissingShadows.entry.ts
@@ -0,0 +1,3 @@
+import { rerenderMissingShadowHosts } from "./rerenderMissingShadows.runtime.js";
+
+rerenderMissingShadowHosts();
diff --git a/packages/core/lib/v3/dom/rerenderMissingShadows.runtime.ts b/packages/core/lib/v3/dom/rerenderMissingShadows.runtime.ts
new file mode 100644
index 000000000..73b997a9b
--- /dev/null
+++ b/packages/core/lib/v3/dom/rerenderMissingShadows.runtime.ts
@@ -0,0 +1,35 @@
+export function rerenderMissingShadowHosts(): void {
+  try {
+    const piercer = window.__stagehandV3__;
+    if (!piercer || typeof piercer.getClosedRoot !== "function") return;
+
+    const needsReset: Element[] = [];
+    const walker = document.createTreeWalker(document, NodeFilter.SHOW_ELEMENT);
+    while (walker.nextNode()) {
+      const el = walker.currentNode as Element;
+      const tag = el.tagName?.toLowerCase() ?? "";
+      if (!tag.includes("-")) continue;
+      if (typeof customElements?.get !== "function") continue;
+      if (!customElements.get(tag)) continue;
+      const hasOpen = !!el.shadowRoot;
+      const hasClosed = !!piercer.getClosedRoot(el);
+      if (hasOpen || hasClosed) continue;
+      needsReset.push(el);
+    }
+
+    for (const host of needsReset) {
+      try {
+        const clone = host.cloneNode(true);
+        host.replaceWith(clone);
+      } catch {
+        // ignore individual failures
+      }
+    }
+
+    if (piercer.stats && needsReset.length) {
+      console.info("[v3-piercer] rerender", { count: needsReset.length });
+    }
+  } catch (err) {
+    console.info("[v3-piercer] rerender error", { message: String(err ?? "") });
+  }
+}
diff --git a/packages/core/lib/v3/dom/screenshotScripts/index.ts b/packages/core/lib/v3/dom/screenshotScripts/index.ts
new file mode 100644
index 000000000..9607ba56b
--- /dev/null
+++ b/packages/core/lib/v3/dom/screenshotScripts/index.ts
@@ -0,0 +1 @@
+export { resolveMaskRect } from "./resolveMaskRect.js";
diff --git a/packages/core/lib/v3/dom/screenshotScripts/resolveMaskRect.ts b/packages/core/lib/v3/dom/screenshotScripts/resolveMaskRect.ts
new file mode 100644
index 000000000..805074ffc
--- /dev/null
+++ b/packages/core/lib/v3/dom/screenshotScripts/resolveMaskRect.ts
@@ -0,0 +1,87 @@
+export type MaskRect = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  rootToken?: string | null;
+};
+
+export function resolveMaskRect(
+  this: Element | null,
+  maskToken?: string,
+): MaskRect | null {
+  function safeClosest(el: Element | null, selector: string): Element | null {
+    try {
+      return el && typeof el.closest === "function"
+        ? el.closest(selector)
+        : null;
+    } catch {
+      return null;
+    }
+  }
+
+  function safeMatches(el: Element | null, selector: string): boolean {
+    try {
+      return !!el && typeof el.matches === "function" && el.matches(selector);
+    } catch {
+      return false;
+    }
+  }
+
+  function findTopLayerRoot(el: Element | null): Element | null {
+    const dialog = safeClosest(el, "dialog[open]");
+    if (dialog) return dialog;
+    const popover = safeClosest(el, "[popover]");
+    if (popover && safeMatches(popover, ":popover-open")) return popover;
+    return null;
+  }
+
+  if (!this || typeof this.getBoundingClientRect !== "function") return null;
+  const rect = this.getBoundingClientRect();
+  if (!rect) return null;
+  const style = window.getComputedStyle(this);
+  if (!style) return null;
+  if (style.visibility === "hidden" || style.display === "none") return null;
+  if (rect.width <= 0 || rect.height <= 0) return null;
+
+  const root = findTopLayerRoot(this);
+  if (root) {
+    const rootRect = root.getBoundingClientRect();
+    if (!rootRect) return null;
+    let rootToken: string | null = null;
+    if (maskToken) {
+      try {
+        const existing = root.getAttribute("data-stagehand-mask-root");
+        if (existing && existing.startsWith(maskToken)) {
+          rootToken = existing;
+        } else {
+          rootToken =
+            maskToken + "_root_" + Math.random().toString(36).slice(2);
+          root.setAttribute("data-stagehand-mask-root", rootToken);
+        }
+      } catch {
+        rootToken = null;
+      }
+    }
+    return {
+      x:
+        rect.left -
+        rootRect.left -
+        (root.clientLeft || 0) +
+        (root.scrollLeft || 0),
+      y:
+        rect.top - rootRect.top - (root.clientTop || 0) + (root.scrollTop || 0),
+      width: rect.width,
+      height: rect.height,
+      rootToken,
+    };
+  }
+
+  return {
+    x: rect.left + window.scrollX,
+    y: rect.top + window.scrollY,
+    width: rect.width,
+    height: rect.height,
+    rootToken: null,
+  };
+}
diff --git a/packages/core/lib/v3/external_clients/aisdk.ts b/packages/core/lib/v3/external_clients/aisdk.ts
new file mode 100644
index 000000000..5a6eb4160
--- /dev/null
+++ b/packages/core/lib/v3/external_clients/aisdk.ts
@@ -0,0 +1,129 @@
+import {
+  CoreAssistantMessage,
+  ModelMessage,
+  CoreSystemMessage,
+  Tool,
+  CoreUserMessage,
+  generateObject,
+  generateText,
+  ImagePart,
+  TextPart,
+} from "ai";
+import type { LanguageModelV2 } from "@ai-sdk/provider";
+import { CreateChatCompletionOptions, LLMClient } from "../llm/LLMClient.js";
+import { AvailableModel } from "../types/public/index.js";
+import { ChatCompletion } from "openai/resources";
+
+export class AISdkClient extends LLMClient {
+  public type = "aisdk" as const;
+  private model: LanguageModelV2;
+
+  constructor({ model }: { model: LanguageModelV2 }) {
+    super(model.modelId as AvailableModel);
+    this.model = model;
+  }
+
+  async createChatCompletion<T = ChatCompletion>({
+    options,
+  }: CreateChatCompletionOptions): Promise<T> {
+    const formattedMessages: ModelMessage[] = options.messages.map(
+      (message) => {
+        if (Array.isArray(message.content)) {
+          if (message.role === "system") {
+            const systemMessage: CoreSystemMessage = {
+              role: "system",
+              content: message.content
+                .map((c) => ("text" in c ? c.text : ""))
+                .join("\n"),
+            };
+            return systemMessage;
+          }
+
+          const contentParts = message.content.map((content) => {
+            if ("image_url" in content) {
+              const imageContent: ImagePart = {
+                type: "image",
+                image: content.image_url.url,
+              };
+              return imageContent;
+            } else {
+              const textContent: TextPart = {
+                type: "text",
+                text: content.text,
+              };
+              return textContent;
+            }
+          });
+
+          if (message.role === "user") {
+            const userMessage: CoreUserMessage = {
+              role: "user",
+              content: contentParts,
+            };
+            return userMessage;
+          } else {
+            const textOnlyParts = contentParts.map((part) => ({
+              type: "text" as const,
+              text: part.type === "image" ? "[Image]" : part.text,
+            }));
+            const assistantMessage: CoreAssistantMessage = {
+              role: "assistant",
+              content: textOnlyParts,
+            };
+            return assistantMessage;
+          }
+        }
+
+        return {
+          role: message.role,
+          content: message.content,
+        };
+      },
+    );
+
+    if (options.response_model) {
+      const response = await generateObject({
+        model: this.model,
+        messages: formattedMessages,
+        schema: options.response_model.schema,
+      });
+
+      return {
+        data: response.object,
+        usage: {
+          prompt_tokens: response.usage.inputTokens ?? 0,
+          completion_tokens: response.usage.outputTokens ?? 0,
+          reasoning_tokens: response.usage.reasoningTokens ?? 0,
+          cached_input_tokens: response.usage.cachedInputTokens ?? 0,
+          total_tokens: response.usage.totalTokens ?? 0,
+        },
+      } as T;
+    }
+
+    const tools: Record<string, Tool> = {};
+
+    for (const rawTool of options.tools) {
+      tools[rawTool.name] = {
+        description: rawTool.description,
+        inputSchema: rawTool.parameters,
+      } as Tool;
+    }
+
+    const response = await generateText({
+      model: this.model,
+      messages: formattedMessages,
+      tools,
+    });
+
+    return {
+      data: response.text,
+      usage: {
+        prompt_tokens: response.usage.inputTokens ?? 0,
+        completion_tokens: response.usage.outputTokens ?? 0,
+        reasoning_tokens: response.usage.reasoningTokens ?? 0,
+        cached_input_tokens: response.usage.cachedInputTokens ?? 0,
+        total_tokens: response.usage.totalTokens ?? 0,
+      },
+    } as T;
+  }
+}
diff --git a/examples/external_clients/customOpenAI.ts b/packages/core/lib/v3/external_clients/customOpenAI.ts
similarity index 71%
rename from examples/external_clients/customOpenAI.ts
rename to packages/core/lib/v3/external_clients/customOpenAI.ts
index 6a6d70b3f..a7e926f01 100644
--- a/examples/external_clients/customOpenAI.ts
+++ b/packages/core/lib/v3/external_clients/customOpenAI.ts
@@ -5,9 +5,9 @@
  * You can just pass in an OpenAI instance to the client and it will work.
  */
 
-import { AvailableModel, CreateChatCompletionOptions, LLMClient } from "@/dist";
+import type { AvailableModel } from "../types/public/model.js";
+import { CreateChatCompletionOptions, LLMClient } from "../llm/LLMClient.js";
 import OpenAI from "openai";
-import { zodResponseFormat } from "openai/helpers/zod";
 import type {
   ChatCompletion,
   ChatCompletionAssistantMessageParam,
@@ -18,17 +18,12 @@ import type {
   ChatCompletionSystemMessageParam,
   ChatCompletionUserMessageParam,
 } from "openai/resources/chat/completions";
-import { z } from "zod";
-import { CreateChatCompletionResponseError } from "@/types/stagehandErrors";
-
-function validateZodSchema(schema: z.ZodTypeAny, data: unknown) {
-  try {
-    schema.parse(data);
-    return true;
-  } catch {
-    return false;
-  }
-}
+import { toJsonSchema } from "../zodCompat.js";
+import { validateZodSchema } from "../../utils.js";
+import {
+  CreateChatCompletionResponseError,
+  ZodSchemaValidationError,
+} from "../types/public/sdkErrors.js";
 
 export class CustomOpenAIClient extends LLMClient {
   public type = "openai" as const;
@@ -73,18 +68,13 @@ export class CustomOpenAIClient extends LLMClient {
       },
     });
 
-    if (options.image) {
-      console.warn(
-        "Image provided. Vision is not currently supported for openai",
-      );
-    }
-
-    let responseFormat = undefined;
+    let responseFormat:
+      | ChatCompletionCreateParamsNonStreaming["response_format"]
+      | undefined;
     if (options.response_model) {
-      responseFormat = zodResponseFormat(
-        options.response_model.schema,
-        options.response_model.name,
-      );
+      responseFormat = {
+        type: "json_object",
+      };
     }
 
     /* eslint-disable */
@@ -157,13 +147,23 @@ export class CustomOpenAIClient extends LLMClient {
           }
         }
 
-        const formattedMessage: ChatCompletionUserMessageParam = {
-          role: "user",
+        return {
+          ...message,
           content: message.content,
-        };
+        } as ChatCompletionMessageParam;
+      });
 
-        return formattedMessage;
+    if (options.response_model) {
+      const schemaJson = JSON.stringify(
+        toJsonSchema(options.response_model.schema),
+        null,
+        2,
+      );
+      formattedMessages.push({
+        role: "user",
+        content: `Respond with valid JSON matching this schema:\n${schemaJson}\n\nDo not include any other text, formatting or markdown in your output. Do not include \`\`\` or \`\`\`json in your response. Only the JSON object itself.`,
       });
+    }
 
     const body: ChatCompletionCreateParamsNonStreaming = {
       ...openaiOptions,
@@ -204,9 +204,20 @@ export class CustomOpenAIClient extends LLMClient {
       if (!extractedData) {
         throw new CreateChatCompletionResponseError("No content in response");
       }
-      const parsedData = JSON.parse(extractedData);
 
-      if (!validateZodSchema(options.response_model.schema, parsedData)) {
+      let parsedData: unknown;
+      try {
+        parsedData = JSON.parse(extractedData);
+        validateZodSchema(options.response_model.schema, parsedData);
+      } catch (e) {
+        const isParseError = e instanceof SyntaxError;
+        logger({
+          category: "openai",
+          message: isParseError
+            ? "Response is not valid JSON"
+            : "Response failed Zod schema validation",
+          level: 0,
+        });
         if (retries > 0) {
           return this.createChatCompletion({
             options,
@@ -215,7 +226,28 @@ export class CustomOpenAIClient extends LLMClient {
           });
         }
 
-        throw new CreateChatCompletionResponseError("Invalid response schema");
+        if (e instanceof ZodSchemaValidationError) {
+          logger({
+            category: "openai",
+            message: `Error during chat completion: ${e.message}`,
+            level: 0,
+            auxiliary: {
+              errorDetails: {
+                value: `Message: ${e.message}${e.stack ? "\nStack: " + e.stack : ""}`,
+                type: "string",
+              },
+              requestId: { value: requestId, type: "string" },
+            },
+          });
+          throw new CreateChatCompletionResponseError(e.message);
+        }
+        throw new CreateChatCompletionResponseError(
+          isParseError
+            ? "Failed to parse model response as JSON"
+            : e instanceof Error
+              ? e.message
+              : "Unknown error during response processing",
+        );
       }
 
       return {
diff --git a/packages/core/lib/v3/flowLogger.ts b/packages/core/lib/v3/flowLogger.ts
new file mode 100644
index 000000000..49375d5a2
--- /dev/null
+++ b/packages/core/lib/v3/flowLogger.ts
@@ -0,0 +1,1191 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import fs from "node:fs";
+import { Writable } from "node:stream";
+import { v7 as uuidv7 } from "uuid";
+import path from "node:path";
+import pino from "pino";
+import type { LanguageModelMiddleware } from "ai";
+import type { V3Options } from "./types/public/index.js";
+
+// =============================================================================
+// Constants
+// =============================================================================
+
+const MAX_LINE_LENGTH = 160;
+
+// Flow logging config dir - empty string disables logging entirely
+const CONFIG_DIR = process.env.BROWSERBASE_CONFIG_DIR || "";
+
+const NOISY_CDP_EVENTS = new Set([
+  "Target.targetInfoChanged",
+  "Runtime.executionContextCreated",
+  "Runtime.executionContextDestroyed",
+  "Runtime.executionContextsCleared",
+  "Page.lifecycleEvent",
+  "Network.dataReceived",
+  "Network.loadingFinished",
+  "Network.requestWillBeSentExtraInfo",
+  "Network.responseReceivedExtraInfo",
+  "Network.requestWillBeSent",
+  "Network.responseReceived",
+]);
+
+// =============================================================================
+// Types
+// =============================================================================
+
+type EventCategory =
+  | "AgentTask"
+  | "StagehandStep"
+  | "UnderstudyAction"
+  | "CDP"
+  | "LLM";
+
+interface FlowEvent {
+  // Core identifiers (set via mixin from child logger bindings)
+  eventId: string;
+  sessionId: string;
+  taskId?: string | null;
+  stepId?: string | null;
+  stepLabel?: string | null;
+  actionId?: string | null;
+  actionLabel?: string | null;
+
+  // Event classification
+  category: EventCategory;
+  event: "started" | "completed" | "call" | "message" | "request" | "response";
+  method?: string;
+  msg?: string;
+
+  // Event-specific payload (not truncated)
+  params?: unknown;
+  targetId?: string | null;
+
+  // LLM event fields (for individual LLM request/response events only)
+  requestId?: string; // Correlation ID linking LLM request to response
+  model?: string;
+  prompt?: unknown;
+  output?: unknown;
+  inputTokens?: number; // Tokens for THIS specific LLM call
+  outputTokens?: number; // Tokens for THIS specific LLM call
+
+  // Aggregate metrics (for completion events only - task/step/action)
+  metrics?: {
+    durationMs?: number;
+    llmRequests?: number; // Total LLM calls in this span
+    inputTokens?: number; // Total input tokens across all LLM calls
+    outputTokens?: number; // Total output tokens across all LLM calls
+    cdpEvents?: number; // Total CDP events in this span
+  };
+}
+
+interface FlowLoggerMetrics {
+  taskStartTime?: number;
+  stepStartTime?: number;
+  actionStartTime?: number;
+  llmRequests: number;
+  llmInputTokens: number;
+  llmOutputTokens: number;
+  cdpEvents: number;
+}
+
+export interface FlowLoggerContext {
+  logger: pino.Logger;
+  metrics: FlowLoggerMetrics;
+  sessionId: string;
+  sessionDir: string;
+  configDir: string;
+  initPromise: Promise<void>;
+  initialized: boolean;
+  // Current span context (mutable, injected via mixin)
+  taskId: string | null;
+  stepId: string | null;
+  stepLabel: string | null;
+  actionId: string | null;
+  actionLabel: string | null;
+  // File handles for pretty streams
+  fileStreams: {
+    agent: fs.WriteStream | null;
+    stagehand: fs.WriteStream | null;
+    understudy: fs.WriteStream | null;
+    cdp: fs.WriteStream | null;
+    llm: fs.WriteStream | null;
+    jsonl: fs.WriteStream | null;
+  };
+}
+
+const loggerContext = new AsyncLocalStorage<FlowLoggerContext>();
+
+// =============================================================================
+// Formatting Utilities (used by pretty streams)
+// =============================================================================
+
+/** Calculate base64 data size in KB */
+const dataToKb = (data: string): string =>
+  ((data.length * 0.75) / 1024).toFixed(1);
+
+/** Truncate CDP IDs: frameId:363F03EB...EF8 → frameId:363F…5EF8 */
+function truncateCdpIds(value: string): string {
+  return value.replace(
+    /([iI]d:?"?)([0-9A-F]{32})(?="?[,})\s]|$)/g,
+    (_, pre: string, id: string) => `${pre}${id.slice(0, 4)}…${id.slice(-4)}`,
+  );
+}
+
+/** Truncate line showing start...end */
+function truncateLine(value: string, maxLen: number): string {
+  const collapsed = value.replace(/\s+/g, " ");
+  if (collapsed.length <= maxLen) return collapsed;
+  const endLen = Math.floor(maxLen * 0.3);
+  const startLen = maxLen - endLen - 1;
+  return `${collapsed.slice(0, startLen)}…${collapsed.slice(-endLen)}`;
+}
+
+function formatValue(value: unknown): string {
+  if (typeof value === "string") return `'${value}'`;
+  if (value == null || typeof value !== "object") return String(value);
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "[unserializable]";
+  }
+}
+
+function formatArgs(args?: unknown | unknown[]): string {
+  if (args === undefined) return "";
+  return (Array.isArray(args) ? args : [args])
+    .filter((e) => e !== undefined)
+    .map(formatValue)
+    .filter((e) => e.length > 0)
+    .join(", ");
+}
+
+const shortId = (id: string | null | undefined): string =>
+  id ? id.slice(-4) : "-";
+
+function formatTag(
+  label: string | null | undefined,
+  id: string | null | undefined,
+  icon: string,
+): string {
+  return id ? `[${icon} #${shortId(id)}${label ? " " + label : ""}]` : "⤑";
+}
+
+let nonce = 0;
+function formatTimestamp(): string {
+  const d = new Date();
+  const pad = (n: number, w = 2) => String(n).padStart(w, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}${pad(nonce++ % 100)}`;
+}
+
+const SENSITIVE_KEYS =
+  /apikey|api_key|key|secret|token|password|passwd|pwd|credential|auth/i;
+
+function sanitizeOptions(options: V3Options): Record<string, unknown> {
+  const sanitize = (obj: unknown): unknown => {
+    if (typeof obj !== "object" || obj === null) return obj;
+    if (Array.isArray(obj)) return obj.map(sanitize);
+    const result: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = SENSITIVE_KEYS.test(key) ? "******" : sanitize(value);
+    }
+    return result;
+  };
+  return sanitize({ ...options }) as Record<string, unknown>;
+}
+
+/** Remove unescaped quotes for cleaner log output */
+function removeQuotes(str: string): string {
+  return str
+    .replace(/([^\\])["']/g, "$1")
+    .replace(/^["']|["']$/g, "")
+    .trim();
+}
+
+// =============================================================================
+// Pretty Formatting (converts FlowEvent to human-readable log line)
+// =============================================================================
+
+function prettifyEvent(event: FlowEvent): string | null {
+  const parts: string[] = [];
+
+  // Build context tags - always add parent span tags (formatTag returns ⤑ for null IDs)
+  if (event.category === "AgentTask") {
+    parts.push(formatTag("", event.taskId, "🅰"));
+  } else if (event.category === "StagehandStep") {
+    parts.push(formatTag("", event.taskId, "🅰"));
+    parts.push(formatTag(event.stepLabel, event.stepId, "🆂"));
+  } else if (event.category === "UnderstudyAction") {
+    parts.push(formatTag("", event.taskId, "🅰"));
+    parts.push(formatTag(event.stepLabel, event.stepId, "🆂"));
+    parts.push(formatTag(event.actionLabel, event.actionId, "🆄"));
+  } else if (event.category === "CDP") {
+    parts.push(formatTag("", event.taskId, "🅰"));
+    parts.push(formatTag(event.stepLabel, event.stepId, "🆂"));
+    parts.push(formatTag(event.actionLabel, event.actionId, "🆄"));
+    parts.push(formatTag("CDP", event.targetId, "🅲"));
+  } else if (event.category === "LLM") {
+    parts.push(formatTag("", event.taskId, "🅰"));
+    parts.push(formatTag(event.stepLabel, event.stepId, "🆂"));
+    parts.push(formatTag("LLM", event.requestId, "🧠"));
+  }
+
+  // Build details based on event type
+  let details = "";
+  const argsStr = event.params ? formatArgs(event.params) : "";
+
+  if (event.category === "AgentTask") {
+    if (event.event === "started") {
+      details = `▷ ${event.method}(${argsStr})`;
+    } else if (event.event === "completed") {
+      const m = event.metrics;
+      const durationSec = m?.durationMs
+        ? (m.durationMs / 1000).toFixed(1)
+        : "?";
+      const llmStats = `${m?.llmRequests ?? 0} LLM calls ꜛ${m?.inputTokens ?? 0} ꜜ${m?.outputTokens ?? 0} tokens`;
+      const cdpStats = `${m?.cdpEvents ?? 0} CDP msgs`;
+      details = `✓ Agent.execute() DONE in ${durationSec}s | ${llmStats} | ${cdpStats}`;
+    }
+  } else if (event.category === "StagehandStep") {
+    if (event.event === "started") {
+      details = `▷ ${event.method}(${argsStr})`;
+    } else if (event.event === "completed") {
+      const durationSec = event.metrics?.durationMs
+        ? (event.metrics.durationMs / 1000).toFixed(2)
+        : "?";
+      details = `✓ ${event.stepLabel || "STEP"} completed in ${durationSec}s`;
+    }
+  } else if (event.category === "UnderstudyAction") {
+    if (event.event === "started") {
+      details = `▷ ${event.method}(${argsStr})`;
+    } else if (event.event === "completed") {
+      const durationSec = event.metrics?.durationMs
+        ? (event.metrics.durationMs / 1000).toFixed(2)
+        : "?";
+      details = `✓ ${event.actionLabel || "ACTION"} completed in ${durationSec}s`;
+    }
+  } else if (event.category === "CDP") {
+    const icon = event.event === "call" ? "⏵" : "⏴";
+    details = `${icon} ${event.method}(${argsStr})`;
+  } else if (event.category === "LLM") {
+    if (event.event === "request") {
+      const promptStr = event.prompt ? " " + String(event.prompt) : "";
+      details = `${event.model} ⏴${promptStr}`;
+    } else if (event.event === "response") {
+      const hasTokens =
+        event.inputTokens !== undefined || event.outputTokens !== undefined;
+      const tokenStr = hasTokens
+        ? ` ꜛ${event.inputTokens ?? 0} ꜜ${event.outputTokens ?? 0} |`
+        : "";
+      const outputStr = event.output ? " " + String(event.output) : "";
+      details = `${event.model} ↳${tokenStr}${outputStr}`;
+    }
+  }
+
+  if (!details) return null;
+
+  // Assemble line and apply final truncation
+  const fullLine = `${formatTimestamp()} ${parts.join(" ")} ${details}`;
+  const cleaned = removeQuotes(fullLine);
+  const processed =
+    event.category === "CDP" ? truncateCdpIds(cleaned) : cleaned;
+  return truncateLine(processed, MAX_LINE_LENGTH);
+}
+
+/** Check if a CDP event should be filtered from pretty output */
+function shouldFilterCdpEvent(event: FlowEvent): boolean {
+  if (event.category !== "CDP") return false;
+  if (event.method?.endsWith(".enable") || event.method === "enable")
+    return true;
+  return event.event === "message" && NOISY_CDP_EVENTS.has(event.method!);
+}
+
+// =============================================================================
+// Stream Creation
+// =============================================================================
+
+const isWritable = (s: fs.WriteStream | null): s is fs.WriteStream =>
+  !!(s && !s.destroyed && s.writable);
+
+function createJsonlStream(ctx: FlowLoggerContext): Writable {
+  return new Writable({
+    objectMode: true,
+    write(chunk: string, _, cb) {
+      if (ctx.initialized && isWritable(ctx.fileStreams.jsonl)) {
+        ctx.fileStreams.jsonl.write(chunk, cb);
+      } else cb();
+    },
+  });
+}
+
+function createPrettyStream(
+  ctx: FlowLoggerContext,
+  category: EventCategory,
+  streamKey: keyof FlowLoggerContext["fileStreams"],
+): Writable {
+  return new Writable({
+    objectMode: true,
+    write(chunk: string, _, cb) {
+      const stream = ctx.fileStreams[streamKey];
+      if (!ctx.initialized || !isWritable(stream)) return cb();
+      try {
+        const event = JSON.parse(chunk) as FlowEvent;
+        if (event.category !== category || shouldFilterCdpEvent(event))
+          return cb();
+        const line = prettifyEvent(event);
+        if (line) stream.write(line + "\n", cb);
+        else cb();
+      } catch {
+        cb();
+      }
+    },
+  });
+}
+
+// =============================================================================
+// Public Helpers (used by external callers)
+// =============================================================================
+
+/**
+ * Get the config directory. Returns empty string if logging is disabled.
+ */
+export function getConfigDir(): string {
+  return CONFIG_DIR ? path.resolve(CONFIG_DIR) : "";
+}
+
+// =============================================================================
+// Prompt Preview Helpers
+// =============================================================================
+
+type ContentPart = {
+  type?: string;
+  text?: string;
+  content?: unknown[];
+  source?: { data?: string };
+  image_url?: { url?: string };
+  inlineData?: { data?: string };
+};
+
+/** Extract text and image info from a content array (handles nested tool_result) */
+function extractFromContent(
+  content: unknown[],
+  result: { text?: string; extras: string[] },
+): void {
+  for (const part of content) {
+    const p = part as ContentPart;
+    // Text
+    if (!result.text && p.text) {
+      result.text = p.type === "text" || !p.type ? p.text : undefined;
+    }
+    // Images - various formats
+    if (p.type === "image" || p.type === "image_url") {
+      const url = p.image_url?.url;
+      if (url?.startsWith("data:"))
+        result.extras.push(`${dataToKb(url)}kb image`);
+      else if (p.source?.data)
+        result.extras.push(`${dataToKb(p.source.data)}kb image`);
+      else result.extras.push("image");
+    } else if (p.source?.data) {
+      result.extras.push(`${dataToKb(p.source.data)}kb image`);
+    } else if (p.inlineData?.data) {
+      result.extras.push(`${dataToKb(p.inlineData.data)}kb image`);
+    }
+    // Recurse into tool_result content
+    if (p.type === "tool_result" && Array.isArray(p.content)) {
+      extractFromContent(p.content, result);
+    }
+  }
+}
+
+/** Build final preview string with extras */
+function buildPreview(
+  text: string | undefined,
+  extras: string[],
+  maxLen?: number,
+): string | undefined {
+  if (!text && extras.length === 0) return undefined;
+  let result = text || "";
+  if (maxLen && result.length > maxLen)
+    result = result.slice(0, maxLen) + "...";
+  if (extras.length > 0) {
+    const extrasStr = extras.map((e) => `+{${e}}`).join(" ");
+    result = result ? `${result} ${extrasStr}` : extrasStr;
+  }
+  return result || undefined;
+}
+
+/**
+ * Format a prompt preview from LLM messages for logging.
+ * Returns format like: "some text... +{5.8kb image} +{schema} +{12 tools}"
+ */
+export function formatLlmPromptPreview(
+  messages: Array<{ role: string; content: unknown }>,
+  options?: { toolCount?: number; hasSchema?: boolean },
+): string | undefined {
+  try {
+    const lastUserMsg = messages.filter((m) => m.role === "user").pop();
+    if (!lastUserMsg) return undefined;
+
+    const result = {
+      text: undefined as string | undefined,
+      extras: [] as string[],
+    };
+
+    if (typeof lastUserMsg.content === "string") {
+      result.text = lastUserMsg.content;
+    } else if (Array.isArray(lastUserMsg.content)) {
+      extractFromContent(lastUserMsg.content, result);
+    } else {
+      return undefined;
+    }
+
+    // Clean instruction prefix
+    if (result.text) {
+      result.text = result.text.replace(/^[Ii]nstruction: /, "");
+    }
+
+    if (options?.hasSchema) result.extras.push("schema");
+    if (options?.toolCount) result.extras.push(`${options.toolCount} tools`);
+
+    return buildPreview(result.text, result.extras);
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Extract a text preview from CUA-style messages.
+ * Accepts various message formats (Anthropic, OpenAI, Google).
+ */
+export function formatCuaPromptPreview(
+  messages: unknown[],
+  maxLen = 100,
+): string | undefined {
+  try {
+    const lastMsg = messages
+      .filter((m) => {
+        const msg = m as { role?: string; type?: string };
+        return msg.role === "user" || msg.type === "tool_result";
+      })
+      .pop() as
+      | { content?: unknown; parts?: unknown[]; text?: string }
+      | undefined;
+
+    if (!lastMsg) return undefined;
+
+    const result = {
+      text: undefined as string | undefined,
+      extras: [] as string[],
+    };
+
+    if (typeof lastMsg.content === "string") {
+      result.text = lastMsg.content;
+    } else if (typeof lastMsg.text === "string") {
+      result.text = lastMsg.text;
+    } else if (Array.isArray(lastMsg.parts)) {
+      extractFromContent(lastMsg.parts, result);
+    } else if (Array.isArray(lastMsg.content)) {
+      extractFromContent(lastMsg.content, result);
+    }
+
+    return buildPreview(result.text, result.extras, maxLen);
+  } catch {
+    return undefined;
+  }
+}
+
+/** Format CUA response output for logging */
+export function formatCuaResponsePreview(
+  output: unknown,
+  maxLen = 100,
+): string {
+  try {
+    // Handle Google format or array
+    const items: unknown[] =
+      (output as { candidates?: [{ content?: { parts?: unknown[] } }] })
+        ?.candidates?.[0]?.content?.parts ??
+      (Array.isArray(output) ? output : []);
+
+    const preview = items
+      .map((item) => {
+        const i = item as {
+          type?: string;
+          text?: string;
+          name?: string;
+          functionCall?: { name?: string };
+        };
+        if (i.text) return i.text.slice(0, 50);
+        if (i.functionCall?.name) return `fn:${i.functionCall.name}`;
+        if (i.type === "tool_use" && i.name) return `tool_use:${i.name}`;
+        return i.type ? `[${i.type}]` : "[item]";
+      })
+      .join(" ");
+
+    return preview.slice(0, maxLen);
+  } catch {
+    return "[error]";
+  }
+}
+
+// =============================================================================
+// SessionFileLogger - Main API
+// =============================================================================
+
+export class SessionFileLogger {
+  /**
+   * Initialize a new logging context. Call this at the start of a session.
+   * If BROWSERBASE_CONFIG_DIR is not set, logging is disabled.
+   */
+  static init(sessionId: string, v3Options?: V3Options): void {
+    const configDir = getConfigDir();
+    if (!configDir) return; // Logging disabled
+
+    const sessionDir = path.join(configDir, "sessions", sessionId);
+
+    // Create context with placeholder logger (will be replaced after streams init)
+    const ctx: FlowLoggerContext = {
+      logger: pino({ level: "silent" }), // Placeholder, replaced below
+      metrics: {
+        llmRequests: 0,
+        llmInputTokens: 0,
+        llmOutputTokens: 0,
+        cdpEvents: 0,
+      },
+      sessionId,
+      sessionDir,
+      configDir,
+      initPromise: Promise.resolve(),
+      initialized: false,
+      // Span context - mutable, injected into every log via mixin
+      taskId: null,
+      stepId: null,
+      stepLabel: null,
+      actionId: null,
+      actionLabel: null,
+      fileStreams: {
+        agent: null,
+        stagehand: null,
+        understudy: null,
+        cdp: null,
+        llm: null,
+        jsonl: null,
+      },
+    };
+
+    // Store init promise for awaiting in log methods
+    ctx.initPromise = SessionFileLogger.initAsync(ctx, v3Options);
+
+    loggerContext.enterWith(ctx);
+  }
+
+  private static async initAsync(
+    ctx: FlowLoggerContext,
+    v3Options?: V3Options,
+  ): Promise<void> {
+    try {
+      await fs.promises.mkdir(ctx.sessionDir, { recursive: true });
+
+      if (v3Options) {
+        const sanitizedOptions = sanitizeOptions(v3Options);
+        const sessionJsonPath = path.join(ctx.sessionDir, "session.json");
+        await fs.promises.writeFile(
+          sessionJsonPath,
+          JSON.stringify(sanitizedOptions, null, 2),
+          "utf-8",
+        );
+      }
+
+      // Create symlink to latest session
+      const latestLink = path.join(ctx.configDir, "sessions", "latest");
+      try {
+        try {
+          await fs.promises.unlink(latestLink);
+        } catch {
+          // Ignore if doesn't exist
+        }
+        await fs.promises.symlink(ctx.sessionId, latestLink, "dir");
+      } catch {
+        // Symlink creation can fail on Windows or due to permissions
+      }
+
+      // Create file streams
+      const dir = ctx.sessionDir;
+      ctx.fileStreams.agent = fs.createWriteStream(
+        path.join(dir, "agent_events.log"),
+        { flags: "a" },
+      );
+      ctx.fileStreams.stagehand = fs.createWriteStream(
+        path.join(dir, "stagehand_events.log"),
+        { flags: "a" },
+      );
+      ctx.fileStreams.understudy = fs.createWriteStream(
+        path.join(dir, "understudy_events.log"),
+        { flags: "a" },
+      );
+      ctx.fileStreams.cdp = fs.createWriteStream(
+        path.join(dir, "cdp_events.log"),
+        { flags: "a" },
+      );
+      ctx.fileStreams.llm = fs.createWriteStream(
+        path.join(dir, "llm_events.log"),
+        { flags: "a" },
+      );
+      ctx.fileStreams.jsonl = fs.createWriteStream(
+        path.join(dir, "session_events.jsonl"),
+        { flags: "a" },
+      );
+
+      ctx.initialized = true;
+
+      // Create pino multistream: JSONL + pretty streams per category
+      const streams: pino.StreamEntry[] = [
+        { stream: createJsonlStream(ctx) },
+        { stream: createPrettyStream(ctx, "AgentTask", "agent") },
+        { stream: createPrettyStream(ctx, "StagehandStep", "stagehand") },
+        { stream: createPrettyStream(ctx, "UnderstudyAction", "understudy") },
+        { stream: createPrettyStream(ctx, "CDP", "cdp") },
+        { stream: createPrettyStream(ctx, "LLM", "llm") },
+      ];
+
+      // Create logger with mixin that injects span context from AsyncLocalStorage
+      ctx.logger = pino(
+        {
+          level: "info",
+          // Mixin adds eventId and current span context to every log
+          mixin() {
+            const store = loggerContext.getStore();
+            return {
+              eventId: uuidv7(),
+              sessionId: store?.sessionId,
+              taskId: store?.taskId,
+              stepId: store?.stepId,
+              stepLabel: store?.stepLabel,
+              actionId: store?.actionId,
+              actionLabel: store?.actionLabel,
+            };
+          },
+        },
+        pino.multistream(streams),
+      );
+    } catch {
+      // Fail silently
+    }
+  }
+
+  static async close(): Promise<void> {
+    const ctx = loggerContext.getStore();
+    if (!ctx) return;
+    await ctx.initPromise;
+    SessionFileLogger.logAgentTaskCompleted();
+    await Promise.all(
+      Object.values(ctx.fileStreams)
+        .filter(Boolean)
+        .map((s) => new Promise<void>((r) => s!.end(r))),
+    ).catch(() => {});
+  }
+
+  static get sessionId(): string | null {
+    return loggerContext.getStore()?.sessionId ?? null;
+  }
+
+  static get sessionDir(): string | null {
+    return loggerContext.getStore()?.sessionDir ?? null;
+  }
+
+  /**
+   * Get the current logger context object.
+   */
+  static getContext(): FlowLoggerContext | null {
+    return loggerContext.getStore() ?? null;
+  }
+
+  // ===========================================================================
+  // Agent Task Events
+  // ===========================================================================
+
+  /**
+   * Start a new task and log it.
+   */
+  static logAgentTaskStarted({
+    invocation,
+    args,
+  }: {
+    invocation: string;
+    args?: unknown | unknown[];
+  }): void {
+    const ctx = loggerContext.getStore();
+    if (!ctx) return;
+
+    // Set up task context
+    ctx.taskId = uuidv7();
+    ctx.stepId = null;
+    ctx.stepLabel = null;
+    ctx.actionId = null;
+    ctx.actionLabel = null;
+
+    // Reset metrics for new task
+    ctx.metrics = {
+      taskStartTime: Date.now(),
+      llmRequests: 0,
+      llmInputTokens: 0,
+      llmOutputTokens: 0,
+      cdpEvents: 0,
+    };
+
+    ctx.logger.info({
+      category: "AgentTask",
+      event: "started",
+      method: invocation,
+      params: args,
+    } as FlowEvent);
+  }
+
+  /**
+   * Log task completion with metrics summary.
+   */
+  static logAgentTaskCompleted(options?: { cacheHit?: boolean }): void {
+    const ctx = loggerContext.getStore();
+    if (!ctx || !ctx.metrics.taskStartTime) return;
+
+    const durationMs = Date.now() - ctx.metrics.taskStartTime;
+
+    const event: Partial<FlowEvent> = {
+      category: "AgentTask",
+      event: "completed",
+      method: "Agent.execute",
+      metrics: {
+        durationMs,
+        llmRequests: ctx.metrics.llmRequests,
+        inputTokens: ctx.metrics.llmInputTokens,
+        outputTokens: ctx.metrics.llmOutputTokens,
+        cdpEvents: ctx.metrics.cdpEvents,
+      },
+    };
+
+    if (options?.cacheHit) {
+      event.msg = "CACHE HIT, NO LLM NEEDED";
+    }
+
+    ctx.logger.info(event);
+
+    // Clear task context
+    ctx.taskId = null;
+    ctx.stepId = null;
+    ctx.stepLabel = null;
+    ctx.actionId = null;
+    ctx.actionLabel = null;
+    ctx.metrics.taskStartTime = undefined;
+  }
+
+  // ===========================================================================
+  // Stagehand Step Events
+  // ===========================================================================
+
+  static logStagehandStepEvent({
+    invocation,
+    args,
+    label,
+  }: {
+    invocation: string;
+    args?: unknown | unknown[];
+    label: string;
+  }): string {
+    const ctx = loggerContext.getStore();
+    if (!ctx) return uuidv7();
+
+    // Set up step context
+    ctx.stepId = uuidv7();
+    ctx.stepLabel = label.toUpperCase();
+    ctx.actionId = null;
+    ctx.actionLabel = null;
+    ctx.metrics.stepStartTime = Date.now();
+
+    ctx.logger.info({
+      category: "StagehandStep",
+      event: "started",
+      method: invocation,
+      params: args,
+    } as FlowEvent);
+
+    return ctx.stepId;
+  }
+
+  static logStagehandStepCompleted(): void {
+    const ctx = loggerContext.getStore();
+    if (!ctx || !ctx.stepId) return;
+
+    const durationMs = ctx.metrics.stepStartTime
+      ? Date.now() - ctx.metrics.stepStartTime
+      : 0;
+
+    ctx.logger.info({
+      category: "StagehandStep",
+      event: "completed",
+      metrics: { durationMs },
+    } as FlowEvent);
+
+    // Clear step context
+    ctx.stepId = null;
+    ctx.stepLabel = null;
+    ctx.actionId = null;
+    ctx.actionLabel = null;
+    ctx.metrics.stepStartTime = undefined;
+  }
+
+  // ===========================================================================
+  // Understudy Action Events
+  // ===========================================================================
+
+  static logUnderstudyActionEvent({
+    actionType,
+    target,
+    args,
+  }: {
+    actionType: string;
+    target?: string;
+    args?: unknown | unknown[];
+  }): string {
+    const ctx = loggerContext.getStore();
+    if (!ctx) return uuidv7();
+
+    // Set up action context
+    ctx.actionId = uuidv7();
+    ctx.actionLabel = actionType
+      .toUpperCase()
+      .replace("UNDERSTUDY.", "")
+      .replace("PAGE.", "");
+    ctx.metrics.actionStartTime = Date.now();
+
+    const params: Record<string, unknown> = {};
+    if (target) params.target = target;
+    if (args) params.args = args;
+
+    ctx.logger.info({
+      category: "UnderstudyAction",
+      event: "started",
+      method: actionType,
+      params: Object.keys(params).length > 0 ? params : undefined,
+    } as FlowEvent);
+
+    return ctx.actionId;
+  }
+
+  static logUnderstudyActionCompleted(): void {
+    const ctx = loggerContext.getStore();
+    if (!ctx || !ctx.actionId) return;
+
+    const durationMs = ctx.metrics.actionStartTime
+      ? Date.now() - ctx.metrics.actionStartTime
+      : 0;
+
+    ctx.logger.info({
+      category: "UnderstudyAction",
+      event: "completed",
+      metrics: { durationMs },
+    } as FlowEvent);
+
+    // Clear action context
+    ctx.actionId = null;
+    ctx.actionLabel = null;
+    ctx.metrics.actionStartTime = undefined;
+  }
+
+  // ===========================================================================
+  // CDP Events
+  // ===========================================================================
+
+  private static logCdpEvent(
+    eventType: "call" | "message",
+    {
+      method,
+      params,
+      targetId,
+    }: { method: string; params?: unknown; targetId?: string | null },
+    explicitCtx?: FlowLoggerContext | null,
+  ): void {
+    const ctx = explicitCtx ?? loggerContext.getStore();
+    if (!ctx) return;
+    if (eventType === "call") ctx.metrics.cdpEvents++;
+    ctx.logger.info({
+      category: "CDP",
+      event: eventType,
+      method,
+      params,
+      targetId,
+    } as FlowEvent);
+  }
+
+  static logCdpCallEvent(
+    data: { method: string; params?: object; targetId?: string | null },
+    ctx?: FlowLoggerContext | null,
+  ): void {
+    SessionFileLogger.logCdpEvent("call", data, ctx);
+  }
+
+  static logCdpMessageEvent(
+    data: { method: string; params?: unknown; targetId?: string | null },
+    ctx?: FlowLoggerContext | null,
+  ): void {
+    SessionFileLogger.logCdpEvent("message", data, ctx);
+  }
+
+  // ===========================================================================
+  // LLM Events
+  // ===========================================================================
+
+  static logLlmRequest(
+    {
+      requestId,
+      model,
+      prompt,
+    }: {
+      requestId: string;
+      model: string;
+      operation: string;
+      prompt?: string;
+    },
+    explicitCtx?: FlowLoggerContext | null,
+  ): void {
+    const ctx = explicitCtx ?? loggerContext.getStore();
+    if (!ctx) return;
+
+    // Track LLM requests for task metrics
+    ctx.metrics.llmRequests++;
+
+    ctx.logger.info({
+      category: "LLM",
+      event: "request",
+      requestId,
+      method: "LLM.request",
+      model,
+      prompt,
+    });
+  }
+
+  static logLlmResponse(
+    {
+      requestId,
+      model,
+      output,
+      inputTokens,
+      outputTokens,
+    }: {
+      requestId: string;
+      model: string;
+      operation: string;
+      output?: string;
+      inputTokens?: number;
+      outputTokens?: number;
+    },
+    explicitCtx?: FlowLoggerContext | null,
+  ): void {
+    const ctx = explicitCtx ?? loggerContext.getStore();
+    if (!ctx) return;
+
+    // Track tokens for task metrics
+    ctx.metrics.llmInputTokens += inputTokens ?? 0;
+    ctx.metrics.llmOutputTokens += outputTokens ?? 0;
+
+    ctx.logger.info({
+      category: "LLM",
+      event: "response",
+      requestId,
+      method: "LLM.response",
+      model,
+      output,
+      inputTokens,
+      outputTokens,
+    });
+  }
+
+  // ===========================================================================
+  // LLM Logging Middleware
+  // ===========================================================================
+
+  /**
+   * Create middleware for wrapping language models with LLM call logging.
+   * Returns a no-op middleware when logging is disabled.
+   */
+  static createLlmLoggingMiddleware(
+    modelId: string,
+  ): Pick<LanguageModelMiddleware, "wrapGenerate"> {
+    // No-op middleware when logging is disabled
+    if (!CONFIG_DIR) {
+      return {
+        wrapGenerate: async ({ doGenerate }) => doGenerate(),
+      };
+    }
+
+    return {
+      wrapGenerate: async ({ doGenerate, params }) => {
+        const ctx = SessionFileLogger.getContext();
+        // Skip logging overhead if no context (shouldn't happen but be safe)
+        if (!ctx) {
+          return doGenerate();
+        }
+        const llmRequestId = uuidv7();
+        const toolCount = Array.isArray(params.tools) ? params.tools.length : 0;
+
+        // Extract prompt preview from last non-system message
+        const messages = (params.prompt ?? []) as Array<{
+          role?: string;
+          content?: unknown;
+        }>;
+        const lastMsg = messages.filter((m) => m.role !== "system").pop();
+        const extracted = {
+          text: undefined as string | undefined,
+          extras: [] as string[],
+        };
+
+        let rolePrefix = lastMsg?.role ?? "?";
+        if (lastMsg) {
+          if (typeof lastMsg.content === "string") {
+            extracted.text = lastMsg.content;
+          } else if (Array.isArray(lastMsg.content)) {
+            // Check for tool-result first
+            const toolResult = (
+              lastMsg.content as Array<{
+                type?: string;
+                toolName?: string;
+                output?: { type?: string; value?: unknown };
+              }>
+            ).find((p) => p.type === "tool-result");
+            if (toolResult) {
+              rolePrefix = `tool result: ${toolResult.toolName}()`;
+              const out = toolResult.output;
+              if (out?.type === "json" && out.value) {
+                extracted.text = JSON.stringify(out.value).slice(0, 150);
+              } else if (Array.isArray(out?.value)) {
+                extractFromContent(out.value as unknown[], extracted);
+              }
+            } else {
+              extractFromContent(lastMsg.content as unknown[], extracted);
+            }
+          }
+        }
+
+        const promptText = extracted.text || "(no text)";
+        const promptPreview = `${rolePrefix}: ${promptText} +{${toolCount} tools}`;
+
+        SessionFileLogger.logLlmRequest(
+          {
+            requestId: llmRequestId,
+            model: modelId,
+            operation: "generateText",
+            prompt: promptPreview,
+          },
+          ctx,
+        );
+
+        const result = await doGenerate();
+
+        // Extract output preview
+        const res = result as {
+          text?: string;
+          content?: unknown;
+          toolCalls?: unknown[];
+        };
+        let outputPreview = res.text || "";
+        if (!outputPreview && res.content) {
+          if (typeof res.content === "string") {
+            outputPreview = res.content;
+          } else if (Array.isArray(res.content)) {
+            outputPreview = (
+              res.content as Array<{
+                type?: string;
+                text?: string;
+                toolName?: string;
+              }>
+            )
+              .map(
+                (c) =>
+                  c.text ||
+                  (c.type === "tool-call"
+                    ? `tool call: ${c.toolName}()`
+                    : `[${c.type}]`),
+              )
+              .join(" ");
+          }
+        }
+        if (!outputPreview && res.toolCalls?.length) {
+          outputPreview = `[${res.toolCalls.length} tool calls]`;
+        }
+
+        SessionFileLogger.logLlmResponse(
+          {
+            requestId: llmRequestId,
+            model: modelId,
+            operation: "generateText",
+            output: outputPreview || "[empty]",
+            inputTokens: result.usage?.inputTokens,
+            outputTokens: result.usage?.outputTokens,
+          },
+          ctx,
+        );
+
+        return result;
+      },
+    };
+  }
+}
+
+/**
+ * Method decorator for logging understudy actions with automatic start/complete.
+ * Logs all arguments automatically. No-op when CONFIG_DIR is empty.
+ */
+export function logAction(actionType: string) {
+  return function <T extends (...args: never[]) => Promise<unknown>>(
+    originalMethod: T,
+  ): T {
+    // No-op when logging is disabled
+    if (!CONFIG_DIR) {
+      return originalMethod;
+    }
+
+    return async function (this: unknown, ...args: unknown[]) {
+      SessionFileLogger.logUnderstudyActionEvent({
+        actionType,
+        args: args.length > 0 ? args : undefined,
+      });
+
+      try {
+        return await originalMethod.apply(this, args as never[]);
+      } finally {
+        SessionFileLogger.logUnderstudyActionCompleted();
+      }
+    } as T;
+  };
+}
+
+/**
+ * Method decorator for logging Stagehand step events (act, extract, observe).
+ * Only adds logging - does NOT wrap with withInstanceLogContext (caller handles that).
+ * No-op when CONFIG_DIR is empty.
+ */
+export function logStagehandStep(invocation: string, label: string) {
+  return function <T extends (...args: never[]) => Promise<unknown>>(
+    originalMethod: T,
+  ): T {
+    // No-op when logging is disabled
+    if (!CONFIG_DIR) {
+      return originalMethod;
+    }
+
+    return async function (
+      this: unknown,
+      ...args: unknown[]
+    ): Promise<unknown> {
+      SessionFileLogger.logStagehandStepEvent({
+        invocation,
+        args: args.length > 0 ? args : undefined,
+        label,
+      });
+
+      try {
+        return await originalMethod.apply(this, args as never[]);
+      } finally {
+        SessionFileLogger.logStagehandStepCompleted();
+      }
+    } as T;
+  };
+}
diff --git a/packages/core/lib/v3/handlers/actHandler.ts b/packages/core/lib/v3/handlers/actHandler.ts
new file mode 100644
index 000000000..a965d9cc9
--- /dev/null
+++ b/packages/core/lib/v3/handlers/actHandler.ts
@@ -0,0 +1,534 @@
+// lib/v3/handlers/actHandler.ts
+import { act as actInference } from "../../inference.js";
+import { buildActPrompt, buildStepTwoPrompt } from "../../prompt.js";
+import { trimTrailingTextNode } from "../../utils.js";
+import { v3Logger } from "../logger.js";
+import { ActHandlerParams } from "../types/private/handlers.js";
+import { ActResult, Action, V3FunctionName } from "../types/public/methods.js";
+import { ActTimeoutError } from "../types/public/sdkErrors.js";
+import {
+  captureHybridSnapshot,
+  diffCombinedTrees,
+} from "../understudy/a11y/snapshot/index.js";
+import { LLMClient } from "../llm/LLMClient.js";
+import { SupportedUnderstudyAction } from "../types/private/index.js";
+import { EncodedId } from "../types/private/internal.js";
+import {
+  AvailableModel,
+  ClientOptions,
+  ModelConfiguration,
+} from "../types/public/model.js";
+import type { Variables } from "../types/public/agent.js";
+import type { Page } from "../understudy/page.js";
+import {
+  performUnderstudyMethod,
+  waitForDomNetworkQuiet,
+} from "./handlerUtils/actHandlerUtils.js";
+import { createTimeoutGuard } from "./handlerUtils/timeoutGuard.js";
+import { resolveVariableValue } from "../agent/utils/variables.js";
+
+type ActInferenceElement = {
+  elementId?: string;
+  description: string;
+  method?: string;
+  arguments?: string[];
+};
+
+type ActInferenceResponse = Awaited<ReturnType<typeof actInference>>;
+
+export class ActHandler {
+  private readonly llmClient: LLMClient;
+  private readonly defaultModelName: AvailableModel;
+  private readonly defaultClientOptions: ClientOptions;
+  private readonly resolveLlmClient: (model?: ModelConfiguration) => LLMClient;
+  private readonly systemPrompt: string;
+  private readonly logInferenceToFile: boolean;
+  private readonly selfHeal: boolean;
+  private readonly onMetrics?: (
+    functionName: V3FunctionName,
+    promptTokens: number,
+    completionTokens: number,
+    reasoningTokens: number,
+    cachedInputTokens: number,
+    inferenceTimeMs: number,
+  ) => void;
+  private readonly defaultDomSettleTimeoutMs?: number;
+
+  constructor(
+    llmClient: LLMClient,
+    defaultModelName: AvailableModel,
+    defaultClientOptions: ClientOptions,
+    resolveLlmClient: (model?: ModelConfiguration) => LLMClient,
+    systemPrompt?: string,
+    logInferenceToFile?: boolean,
+    selfHeal?: boolean,
+    onMetrics?: (
+      functionName: V3FunctionName,
+      promptTokens: number,
+      completionTokens: number,
+      reasoningTokens: number,
+      cachedInputTokens: number,
+      inferenceTimeMs: number,
+    ) => void,
+    defaultDomSettleTimeoutMs?: number,
+  ) {
+    this.llmClient = llmClient;
+    this.defaultModelName = defaultModelName;
+    this.defaultClientOptions = defaultClientOptions;
+    this.resolveLlmClient = resolveLlmClient;
+    this.systemPrompt = systemPrompt ?? "";
+    this.logInferenceToFile = logInferenceToFile ?? false;
+    this.selfHeal = !!selfHeal;
+    this.onMetrics = onMetrics;
+    this.defaultDomSettleTimeoutMs = defaultDomSettleTimeoutMs;
+  }
+
+  private recordActMetrics(response: ActInferenceResponse): void {
+    this.onMetrics?.(
+      V3FunctionName.ACT,
+      response.prompt_tokens ?? 0,
+      response.completion_tokens ?? 0,
+      response.reasoning_tokens ?? 0,
+      response.cached_input_tokens ?? 0,
+      response.inference_time_ms ?? 0,
+    );
+  }
+
+  private async getActionFromLLM({
+    instruction,
+    domElements,
+    xpathMap,
+    llmClient,
+    requireMethodAndArguments = true,
+  }: {
+    instruction: string;
+    domElements: string;
+    xpathMap: Record<string, string>;
+    llmClient: LLMClient;
+    requireMethodAndArguments?: boolean;
+  }): Promise<{ action?: Action; response: ActInferenceResponse }> {
+    const response = await actInference({
+      instruction,
+      domElements,
+      llmClient,
+      userProvidedInstructions: this.systemPrompt,
+      logger: v3Logger,
+      logInferenceToFile: this.logInferenceToFile,
+    });
+
+    this.recordActMetrics(response);
+
+    const normalized = normalizeActInferenceElement(
+      response.element as ActInferenceElement | undefined,
+      xpathMap,
+      requireMethodAndArguments,
+    );
+
+    if (!normalized) {
+      return { response };
+    }
+
+    return {
+      action: { ...normalized } as Action,
+      response,
+    };
+  }
+
+  async act(params: ActHandlerParams): Promise<ActResult> {
+    const { instruction, page, variables, timeout, model } = params;
+
+    const llmClient = this.resolveLlmClient(model);
+    const ensureTimeRemaining = createTimeoutGuard(
+      timeout,
+      (ms) => new ActTimeoutError(ms),
+    );
+
+    ensureTimeRemaining();
+    await waitForDomNetworkQuiet(
+      page.mainFrame(),
+      this.defaultDomSettleTimeoutMs,
+    );
+    ensureTimeRemaining();
+    const { combinedTree, combinedXpathMap } = await captureHybridSnapshot(
+      page,
+      { experimental: true },
+    );
+
+    const actInstruction = buildActPrompt(
+      instruction,
+      Object.values(SupportedUnderstudyAction),
+      variables,
+    );
+
+    ensureTimeRemaining();
+    const { action: firstAction, response: actInferenceResponse } =
+      await this.getActionFromLLM({
+        instruction: actInstruction,
+        domElements: combinedTree,
+        xpathMap: combinedXpathMap,
+        llmClient,
+      });
+
+    if (!firstAction) {
+      v3Logger({
+        category: "action",
+        message: "no actionable element returned by LLM",
+        level: 1,
+      });
+      return {
+        success: false,
+        message: "Failed to perform act: No action found",
+        actionDescription: instruction,
+        actions: [],
+      };
+    }
+
+    // First action (self-heal aware path)
+    ensureTimeRemaining();
+    const firstResult = await this.takeDeterministicAction(
+      firstAction,
+      page,
+      this.defaultDomSettleTimeoutMs,
+      llmClient,
+      ensureTimeRemaining,
+      variables,
+    );
+
+    // If not two-step, return the first action result
+    if (actInferenceResponse?.twoStep !== true) {
+      return firstResult;
+    }
+
+    // Take a new focused snapshot and observe again
+    ensureTimeRemaining();
+    const { combinedTree: combinedTree2, combinedXpathMap: combinedXpathMap2 } =
+      await captureHybridSnapshot(page, {
+        experimental: true,
+      });
+
+    let diffedTree = diffCombinedTrees(combinedTree, combinedTree2);
+    if (!diffedTree.trim()) {
+      // Fallback: if no diff detected, use the fresh tree to avoid empty context
+      diffedTree = combinedTree2;
+    }
+
+    const previousAction = `method: ${firstAction.method}, description: ${firstAction.description}, arguments: ${firstAction.arguments}`;
+
+    const stepTwoInstructions = buildStepTwoPrompt(
+      instruction,
+      previousAction,
+      Object.values(SupportedUnderstudyAction).filter(
+        (
+          action,
+        ): action is Exclude<
+          SupportedUnderstudyAction,
+          SupportedUnderstudyAction.SELECT_OPTION_FROM_DROPDOWN
+        > => action !== SupportedUnderstudyAction.SELECT_OPTION_FROM_DROPDOWN,
+      ),
+      variables,
+    );
+
+    ensureTimeRemaining();
+    const { action: secondAction } = await this.getActionFromLLM({
+      instruction: stepTwoInstructions,
+      domElements: diffedTree,
+      xpathMap: combinedXpathMap2,
+      llmClient,
+    });
+
+    if (!secondAction) {
+      // No second action found — return first result as-is
+      return firstResult;
+    }
+
+    ensureTimeRemaining();
+    const secondResult = await this.takeDeterministicAction(
+      secondAction,
+      page,
+      this.defaultDomSettleTimeoutMs,
+      llmClient,
+      ensureTimeRemaining,
+      variables,
+    );
+
+    // Combine results
+    return {
+      success: firstResult.success && secondResult.success,
+      message: secondResult.success
+        ? `${firstResult.message} → ${secondResult.message}`
+        : `${firstResult.message} → ${secondResult.message}`,
+      actionDescription: firstResult.actionDescription,
+      actions: [
+        ...(firstResult.actions || []),
+        ...(secondResult.actions || []),
+      ],
+    };
+  }
+
+  async takeDeterministicAction(
+    action: Action,
+    page: Page,
+    domSettleTimeoutMs?: number,
+    llmClientOverride?: LLMClient,
+    ensureTimeRemaining?: () => void,
+    variables?: Variables,
+  ): Promise<ActResult> {
+    ensureTimeRemaining?.();
+    const settleTimeout = domSettleTimeoutMs ?? this.defaultDomSettleTimeoutMs;
+    const effectiveClient = llmClientOverride ?? this.llmClient;
+    const method = action.method?.trim();
+    if (!method || method === "not-supported") {
+      v3Logger({
+        category: "action",
+        message: "action has no supported method",
+        level: 0,
+        auxiliary: {
+          act: { value: JSON.stringify(action), type: "object" },
+        },
+      });
+      return {
+        success: false,
+        message: `Unable to perform action: The method '${method ?? ""}' is not supported in Action. Please use a supported Playwright locator method.`,
+        actionDescription:
+          action.description || `Action (${method ?? "unknown"})`,
+        actions: [],
+      };
+    }
+
+    const placeholderArgs = Array.isArray(action.arguments)
+      ? [...action.arguments]
+      : [];
+    const resolvedArgs =
+      substituteVariablesInArguments(action.arguments, variables) ?? [];
+
+    try {
+      ensureTimeRemaining?.();
+      await performUnderstudyMethod(
+        page,
+        page.mainFrame(),
+        method,
+        action.selector,
+        resolvedArgs,
+        settleTimeout,
+      );
+      return {
+        success: true,
+        message: `Action [${method}] performed successfully on selector: ${action.selector}`,
+        actionDescription: action.description || `action (${method})`,
+        actions: [
+          {
+            selector: action.selector,
+            description: action.description || `action (${method})`,
+            method,
+            arguments: placeholderArgs,
+          },
+        ],
+      };
+    } catch (err) {
+      if (err instanceof ActTimeoutError) {
+        throw err;
+      }
+      const msg = err instanceof Error ? err.message : String(err);
+
+      // Attempt self-heal: rerun actInference and retry with updated selector
+      if (this.selfHeal) {
+        v3Logger({
+          category: "action",
+          message:
+            "Error performing action. Reprocessing the page and trying again",
+          level: 1,
+          auxiliary: {
+            error: { value: msg, type: "string" },
+            action: {
+              value: JSON.stringify(action),
+              type: "object",
+            },
+          },
+        });
+
+        try {
+          // Build an instruction combining method + description, avoiding duplication
+          const actCommand = action.description
+            ? action.description.toLowerCase().startsWith(method.toLowerCase())
+              ? action.description
+              : `${method} ${action.description}`
+            : method;
+
+          // Take a fresh snapshot and ask for a new actionable element
+          ensureTimeRemaining?.();
+          const { combinedTree, combinedXpathMap } =
+            await captureHybridSnapshot(page, {
+              experimental: true,
+            });
+
+          const instruction = buildActPrompt(
+            actCommand,
+            Object.values(SupportedUnderstudyAction),
+            {},
+          );
+
+          ensureTimeRemaining?.();
+          const { action: fallbackAction, response: fallbackResponse } =
+            await this.getActionFromLLM({
+              instruction,
+              domElements: combinedTree,
+              xpathMap: combinedXpathMap,
+              llmClient: effectiveClient,
+              requireMethodAndArguments: false,
+            });
+
+          const fallbackElement = fallbackResponse.element;
+          if (!fallbackElement) {
+            return {
+              success: false,
+              message:
+                "Failed to self-heal act: No observe results found for action",
+              actionDescription: actCommand,
+              actions: [],
+            };
+          }
+
+          // Retry with original method/args but new selector from fallback
+          let newSelector = action.selector;
+          if (fallbackAction?.selector) {
+            newSelector = fallbackAction.selector;
+          }
+
+          ensureTimeRemaining?.();
+          await performUnderstudyMethod(
+            page,
+            page.mainFrame(),
+            method,
+            newSelector,
+            resolvedArgs,
+            settleTimeout,
+          );
+
+          return {
+            success: true,
+            message: `Action [${method}] performed successfully on selector: ${newSelector}`,
+            actionDescription: action.description || `action (${method})`,
+            actions: [
+              {
+                selector: newSelector,
+                description: action.description || `action (${method})`,
+                method,
+                arguments: placeholderArgs,
+              },
+            ],
+          };
+        } catch (retryErr) {
+          if (retryErr instanceof ActTimeoutError) {
+            throw retryErr;
+          }
+          const retryMsg =
+            retryErr instanceof Error ? retryErr.message : String(retryErr);
+          return {
+            success: false,
+            message: `Failed to perform act after self-heal: ${retryMsg}`,
+            actionDescription: action.description || `action (${method})`,
+            actions: [],
+          };
+        }
+      }
+
+      return {
+        success: false,
+        message: `Failed to perform act: ${msg}`,
+        actionDescription: action.description || `action (${method})`,
+        actions: [],
+      };
+    }
+  }
+}
+
+function normalizeActInferenceElement(
+  element: ActInferenceElement | undefined,
+  xpathMap: Record<string, string>,
+  requireMethodAndArguments = true,
+): Action | undefined {
+  if (!element) {
+    return undefined;
+  }
+  const { elementId, description, method, arguments: args } = element;
+  const hasArgs = Array.isArray(args);
+
+  if (
+    requireMethodAndArguments &&
+    (!method || method === "not-supported" || !hasArgs)
+  ) {
+    return undefined;
+  }
+
+  if (typeof elementId !== "string" || !elementId.includes("-")) {
+    return undefined;
+  }
+
+  const xp = xpathMap[elementId as EncodedId];
+  const trimmed = trimTrailingTextNode(xp);
+  if (!trimmed) {
+    return undefined;
+  }
+
+  // For dragAndDrop, convert element ID in arguments to xpath (target element)
+  let resolvedArgs = hasArgs ? args : undefined;
+  if (method === "dragAndDrop" && hasArgs && args.length > 0) {
+    const targetArg = args[0];
+    // Check if argument looks like an element ID (e.g., "1-67")
+    if (typeof targetArg === "string" && /^\d+-\d+$/.test(targetArg)) {
+      const argXpath = xpathMap[targetArg as EncodedId];
+      const trimmedArgXpath = trimTrailingTextNode(argXpath);
+      if (trimmedArgXpath) {
+        resolvedArgs = [`xpath=${trimmedArgXpath}`, ...args.slice(1)];
+      } else {
+        // Target element lookup failed, filter out this action
+        v3Logger({
+          category: "action",
+          message: "dragAndDrop target element lookup failed",
+          level: 1,
+          auxiliary: {
+            targetElementId: { value: targetArg, type: "string" },
+            sourceElementId: { value: elementId, type: "string" },
+          },
+        });
+        return undefined;
+      }
+    } else {
+      v3Logger({
+        category: "action",
+        message: "dragAndDrop target element invalid ID format",
+        level: 0,
+        auxiliary: {
+          targetElementId: { value: String(targetArg), type: "string" },
+          sourceElementId: { value: elementId, type: "string" },
+        },
+      });
+      return undefined;
+    }
+  }
+
+  return {
+    description,
+    method,
+    arguments: resolvedArgs,
+    selector: `xpath=${trimmed}`,
+  } as Action;
+}
+
+function substituteVariablesInArguments(
+  args: string[] | undefined,
+  variables?: Variables,
+): string[] | undefined {
+  if (!variables || !Array.isArray(args)) {
+    return args;
+  }
+
+  return args.map((arg: string) => {
+    let out = arg;
+    for (const [key, v] of Object.entries(variables)) {
+      const token = `%${key}%`;
+      out = out.split(token).join(resolveVariableValue(v));
+    }
+    return out;
+  });
+}
diff --git a/packages/core/lib/v3/handlers/extractHandler.ts b/packages/core/lib/v3/handlers/extractHandler.ts
new file mode 100644
index 000000000..9fc53318b
--- /dev/null
+++ b/packages/core/lib/v3/handlers/extractHandler.ts
@@ -0,0 +1,253 @@
+// lib/v3/handlers/extractHandler.ts
+import { extract as runExtract } from "../../inference.js";
+import {
+  getZFactory,
+  getZodType,
+  injectUrls,
+  transformSchema,
+} from "../../utils.js";
+import { v3Logger } from "../logger.js";
+import { V3FunctionName } from "../types/public/methods.js";
+import { captureHybridSnapshot } from "../understudy/a11y/snapshot/index.js";
+import type { ZodTypeAny } from "zod";
+import { LLMClient } from "../llm/LLMClient.js";
+import { ExtractHandlerParams } from "../types/private/handlers.js";
+import { EncodedId, ZodPathSegments } from "../types/private/internal.js";
+import {
+  defaultExtractSchema,
+  pageTextSchema,
+} from "../types/public/methods.js";
+import {
+  AvailableModel,
+  ClientOptions,
+  ModelConfiguration,
+} from "../types/public/model.js";
+import {
+  StagehandInvalidArgumentError,
+  ExtractTimeoutError,
+} from "../types/public/sdkErrors.js";
+import { createTimeoutGuard } from "./handlerUtils/timeoutGuard.js";
+import type {
+  InferStagehandSchema,
+  StagehandZodObject,
+  StagehandZodSchema,
+} from "../zodCompat.js";
+
+/**
+ * Scans the provided Zod schema for any `z.string().url()` fields and
+ * replaces them with `z.number()`.
+ *
+ * @param schema - The Zod object schema to transform.
+ * @returns A tuple containing:
+ *   1. The transformed schema (or the original schema if no changes were needed).
+ *   2. An array of {@link ZodPathSegments} objects representing all the replaced URL fields,
+ *      with each path segment showing where in the schema the replacement occurred.
+ */
+export function transformUrlStringsToNumericIds<T extends StagehandZodSchema>(
+  schema: T,
+): [StagehandZodSchema, ZodPathSegments[]] {
+  const [finalSchema, urlPaths] = transformSchema(schema, []);
+  return [finalSchema, urlPaths];
+}
+
+interface ExtractionResponseBase {
+  metadata: { completed: boolean };
+  prompt_tokens: number;
+  completion_tokens: number;
+  reasoning_tokens: number;
+  cached_input_tokens?: number;
+  inference_time_ms: number;
+}
+
+type ExtractionResponse<T extends StagehandZodObject> = ExtractionResponseBase &
+  InferStagehandSchema<T>;
+
+export class ExtractHandler {
+  private readonly llmClient: LLMClient;
+  private readonly defaultModelName: AvailableModel;
+  private readonly defaultClientOptions: ClientOptions;
+  private readonly resolveLlmClient: (model?: ModelConfiguration) => LLMClient;
+  private readonly systemPrompt: string;
+  private readonly logInferenceToFile: boolean;
+  private readonly experimental: boolean;
+  private readonly onMetrics?: (
+    functionName: V3FunctionName,
+    promptTokens: number,
+    completionTokens: number,
+    reasoningTokens: number,
+    cachedInputTokens: number,
+    inferenceTimeMs: number,
+  ) => void;
+
+  constructor(
+    llmClient: LLMClient,
+    defaultModelName: AvailableModel,
+    defaultClientOptions: ClientOptions,
+    resolveLlmClient: (model?: ModelConfiguration) => LLMClient,
+    systemPrompt?: string,
+    logInferenceToFile?: boolean,
+    experimental?: boolean,
+    onMetrics?: (
+      functionName: V3FunctionName,
+      promptTokens: number,
+      completionTokens: number,
+      reasoningTokens: number,
+      cachedInputTokens: number,
+      inferenceTimeMs: number,
+    ) => void,
+  ) {
+    this.llmClient = llmClient;
+    this.defaultModelName = defaultModelName;
+    this.defaultClientOptions = defaultClientOptions;
+    this.resolveLlmClient = resolveLlmClient;
+    this.systemPrompt = systemPrompt ?? "";
+    this.logInferenceToFile = logInferenceToFile ?? false;
+    this.experimental = experimental ?? false;
+    this.onMetrics = onMetrics;
+  }
+
+  async extract<T extends StagehandZodSchema>(
+    params: ExtractHandlerParams<T>,
+  ): Promise<InferStagehandSchema<T> | { pageText: string }> {
+    const { instruction, schema, page, selector, timeout, model } = params;
+
+    const llmClient = this.resolveLlmClient(model);
+
+    const ensureTimeRemaining = createTimeoutGuard(
+      timeout,
+      (ms) => new ExtractTimeoutError(ms),
+    );
+
+    // No-args → page text (parity with v2)
+    const noArgs = !instruction && !schema;
+    if (noArgs) {
+      const focusSelector = selector?.replace(/^xpath=/i, "") ?? "";
+      ensureTimeRemaining();
+      const snap = await captureHybridSnapshot(page, {
+        experimental: this.experimental,
+        focusSelector: focusSelector || undefined,
+      });
+      ensureTimeRemaining();
+
+      const result = { pageText: snap.combinedTree };
+      // Validate via the same schema used in v2
+      return pageTextSchema.parse(result);
+    }
+
+    if (!instruction && schema) {
+      throw new StagehandInvalidArgumentError(
+        "extract() requires an instruction when a schema is provided.",
+      );
+    }
+
+    const focusSelector = selector?.replace(/^xpath=/, "") ?? "";
+
+    // Build the hybrid snapshot (includes combinedTree; combinedUrlMap optional)
+    ensureTimeRemaining();
+    const { combinedTree, combinedUrlMap } = await captureHybridSnapshot(page, {
+      experimental: this.experimental,
+      focusSelector: focusSelector,
+    });
+
+    v3Logger({
+      category: "extraction",
+      message: "Starting extraction using a11y snapshot",
+      level: 1,
+      auxiliary: instruction
+        ? { instruction: { value: instruction, type: "string" } }
+        : undefined,
+    });
+
+    // Normalize schema: if instruction provided without schema, use defaultExtractSchema
+    const baseSchema: StagehandZodSchema = (schema ??
+      defaultExtractSchema) as StagehandZodSchema;
+    // Ensure we pass an object schema into inference; wrap non-object schemas
+    const isObjectSchema = getZodType(baseSchema) === "object";
+    const WRAP_KEY = "value" as const;
+    const factory = getZFactory(baseSchema);
+    const objectSchema: StagehandZodObject = isObjectSchema
+      ? (baseSchema as StagehandZodObject)
+      : (factory.object({
+          [WRAP_KEY]: baseSchema as ZodTypeAny,
+        }) as StagehandZodObject);
+
+    const [transformedSchema, urlFieldPaths] =
+      transformUrlStringsToNumericIds(objectSchema);
+
+    ensureTimeRemaining();
+    const extractionResponse: ExtractionResponse<StagehandZodObject> =
+      await runExtract<StagehandZodObject>({
+        instruction,
+        domElements: combinedTree,
+        schema: transformedSchema as StagehandZodObject,
+        llmClient,
+        userProvidedInstructions: this.systemPrompt,
+        logger: v3Logger,
+        logInferenceToFile: this.logInferenceToFile,
+      });
+
+    const {
+      metadata: { completed },
+      prompt_tokens,
+      completion_tokens,
+      reasoning_tokens = 0,
+      cached_input_tokens = 0,
+      inference_time_ms,
+      ...rest
+    } = extractionResponse;
+    let output = rest as InferStagehandSchema<StagehandZodObject>;
+
+    // Update EXTRACT metrics from the LLM calls
+    this.onMetrics?.(
+      V3FunctionName.EXTRACT,
+      prompt_tokens,
+      completion_tokens,
+      reasoning_tokens,
+      cached_input_tokens,
+      inference_time_ms,
+    );
+
+    // Re-inject URLs for any url() fields we temporarily converted to number()
+    const idToUrl: Record<EncodedId, string> = (combinedUrlMap ?? {}) as Record<
+      EncodedId,
+      string
+    >;
+    for (const { segments } of urlFieldPaths) {
+      injectUrls(
+        output as Record<string, unknown>,
+        segments,
+        idToUrl as unknown as Record<string, string>,
+      );
+    }
+    // If we wrapped a non-object schema, unwrap the value
+    if (!isObjectSchema && output && typeof output === "object") {
+      output = (output as Record<string, unknown>)[WRAP_KEY];
+    }
+
+    const resultPreviewLength = 200;
+    const resultString = JSON.stringify(output) ?? "undefined";
+    const resultPreview =
+      resultString.length > resultPreviewLength
+        ? resultString.slice(0, resultPreviewLength) + "..."
+        : resultString;
+
+    v3Logger({
+      category: "extraction",
+      message: completed
+        ? "Extraction completed successfully"
+        : "Extraction incomplete after processing all data",
+      level: 1,
+      auxiliary: {
+        prompt_tokens: { value: String(prompt_tokens), type: "string" },
+        completion_tokens: { value: String(completion_tokens), type: "string" },
+        inference_time_ms: {
+          value: String(inference_time_ms),
+          type: "string",
+        },
+        result: { value: resultPreview, type: "string" },
+      },
+    });
+
+    return output as InferStagehandSchema<T>;
+  }
+}
diff --git a/packages/core/lib/v3/handlers/handlerUtils/actHandlerUtils.ts b/packages/core/lib/v3/handlers/handlerUtils/actHandlerUtils.ts
new file mode 100644
index 000000000..0b2ac3ce5
--- /dev/null
+++ b/packages/core/lib/v3/handlers/handlerUtils/actHandlerUtils.ts
@@ -0,0 +1,695 @@
+// lib/v3/handlers/handlerUtils/actHandlerUtils.ts
+import { Protocol } from "devtools-protocol";
+import { Frame } from "../../understudy/frame.js";
+import { Locator } from "../../understudy/locator.js";
+import { MouseButton } from "../../types/public/locator.js";
+import { resolveLocatorWithHops } from "../../understudy/deepLocator.js";
+import type { Page } from "../../understudy/page.js";
+import { v3Logger } from "../../logger.js";
+import { SessionFileLogger } from "../../flowLogger.js";
+import {
+  StagehandClickError,
+  UnderstudyCommandException,
+} from "../../types/public/sdkErrors.js";
+
+export interface UnderstudyMethodHandlerContext {
+  method: string;
+  locator: Locator;
+  xpath: string;
+  args: ReadonlyArray<string>;
+  frame: Frame;
+  page: Page;
+  initialUrl: string;
+  domSettleTimeoutMs?: number;
+}
+
+// Normalize cases where the XPath is the root "/" to point to the HTML element.
+function normalizeRootXPath(input: string): string {
+  const s = String(input ?? "").trim();
+  if (s === "/") return "/html";
+  if (/^xpath=\/$/i.test(s)) return "xpath=/html";
+  return s;
+}
+
+export async function performUnderstudyMethod(
+  page: Page,
+  frame: Frame,
+  method: string,
+  rawXPath: string,
+  args: ReadonlyArray<unknown>,
+  domSettleTimeoutMs?: number,
+): Promise<void> {
+  const selectorRaw = normalizeRootXPath(rawXPath);
+  // Unified resolver: supports '>>' hops and XPath across iframes
+  const locator: Locator = await resolveLocatorWithHops(
+    page,
+    frame,
+    selectorRaw,
+  );
+
+  const initialUrl = await getFrameUrl(frame);
+
+  v3Logger({
+    category: "action",
+    message: "performing understudy method",
+    level: 2,
+    auxiliary: {
+      xpath: { value: selectorRaw, type: "string" },
+      method: { value: method, type: "string" },
+      url: { value: initialUrl, type: "string" },
+    },
+  });
+
+  const ctx: UnderstudyMethodHandlerContext = {
+    method,
+    locator,
+    xpath: selectorRaw,
+    args: args.map((a) => (a == null ? "" : String(a))),
+    frame,
+    page,
+    initialUrl,
+    domSettleTimeoutMs,
+  };
+
+  SessionFileLogger.logUnderstudyActionEvent({
+    actionType: `Understudy.${method}`,
+    target: selectorRaw,
+    args: Array.from(args),
+  });
+
+  try {
+    const handler = METHOD_HANDLER_MAP[method] ?? null;
+
+    if (handler) {
+      await handler(ctx);
+    } else {
+      // Accept a few common locator method aliases
+      switch (method) {
+        case "click":
+          await clickElement(ctx);
+          break;
+        case "fill":
+          await fillOrType(ctx);
+          break;
+        case "type":
+          await typeText(ctx);
+          break;
+        default:
+          v3Logger({
+            category: "action",
+            message: "chosen method is invalid",
+            level: 1,
+            auxiliary: { method: { value: method, type: "string" } },
+          });
+          throw new UnderstudyCommandException(
+            `Method ${method} not supported`,
+          );
+      }
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    const stack = e instanceof Error ? e.stack : undefined;
+    v3Logger({
+      category: "action",
+      message: "error performing method",
+      level: 1,
+      auxiliary: {
+        error: { value: msg, type: "string" },
+        trace: { value: stack ?? "", type: "string" },
+        method: { value: method, type: "string" },
+        xpath: { value: selectorRaw, type: "string" },
+        args: { value: JSON.stringify(args), type: "object" },
+      },
+    });
+    if (e instanceof UnderstudyCommandException) {
+      throw e;
+    }
+    throw new UnderstudyCommandException(msg, e);
+  } finally {
+    SessionFileLogger.logUnderstudyActionCompleted();
+  }
+}
+
+/* ===================== Handlers & Map ===================== */
+
+const METHOD_HANDLER_MAP: Record<
+  string,
+  (ctx: UnderstudyMethodHandlerContext) => Promise<void>
+> = {
+  scrollIntoView,
+  scrollByPixelOffset,
+  scrollTo: scrollElementToPercentage,
+  scroll: scrollElementToPercentage,
+  "mouse.wheel": wheelScroll,
+  fill: fillOrType,
+  type: typeText,
+  press: pressKey,
+  click: clickElement,
+  doubleClick,
+  dragAndDrop,
+  nextChunk: scrollToNextChunk,
+  prevChunk: scrollToPreviousChunk,
+  selectOptionFromDropdown: selectOption,
+  selectOption: selectOption,
+  hover: hover,
+};
+
+export async function selectOption(ctx: UnderstudyMethodHandlerContext) {
+  const { locator, xpath, args } = ctx;
+  try {
+    const text = args[0]?.toString() || "";
+    await locator.selectOption(text);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    const stack = e instanceof Error ? e.stack : undefined;
+    v3Logger({
+      category: "action",
+      message: "error selecting option",
+      level: 0,
+      auxiliary: {
+        error: { value: msg, type: "string" },
+        trace: { value: stack ?? "", type: "string" },
+        xpath: { value: xpath, type: "string" },
+      },
+    });
+    throw new UnderstudyCommandException(msg, e);
+  }
+}
+
+async function scrollIntoView(
+  ctx: UnderstudyMethodHandlerContext,
+): Promise<void> {
+  const { locator, xpath } = ctx;
+  v3Logger({
+    category: "action",
+    message: "scrolling element into view",
+    level: 2,
+    auxiliary: { xpath: { value: xpath, type: "string" } },
+  });
+  const { objectId } = await locator.resolveNode();
+  const ownerSession = locator.getFrame().session;
+  await ownerSession.send("DOM.scrollIntoViewIfNeeded", { objectId });
+  await ownerSession
+    .send("Runtime.releaseObject", { objectId })
+    .catch(() => {});
+}
+
+async function scrollElementToPercentage(
+  ctx: UnderstudyMethodHandlerContext,
+): Promise<void> {
+  const { locator, xpath, args } = ctx;
+  v3Logger({
+    category: "action",
+    message: "scrolling element vertically to specified percentage",
+    level: 2,
+    auxiliary: {
+      xpath: { value: xpath, type: "string" },
+      coordinate: { value: JSON.stringify(args), type: "string" },
+    },
+  });
+
+  const [yArg = "0%"] = args;
+  await locator.scrollTo(yArg);
+}
+
+/** Scroll the page by pixel offset, starting from the element's center. */
+async function scrollByPixelOffset(
+  ctx: UnderstudyMethodHandlerContext,
+): Promise<void> {
+  const { locator, page, args } = ctx;
+  const dx = Number(args[0] ?? 0);
+  const dy = Number(args[1] ?? 0);
+
+  try {
+    const { x, y } = await locator.centroid();
+    await page.scroll(x, y, dx, dy);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new UnderstudyCommandException(msg, e);
+  }
+}
+
+async function wheelScroll(ctx: UnderstudyMethodHandlerContext): Promise<void> {
+  const { frame, args } = ctx;
+  const deltaY = Number(args[0] ?? 200);
+  v3Logger({
+    category: "action",
+    message: "dispatching mouse wheel",
+    level: 2,
+    auxiliary: { deltaY: { value: String(deltaY), type: "string" } },
+  });
+  await frame.session.send<never>("Input.dispatchMouseEvent", {
+    type: "mouseWheel",
+    x: 0,
+    y: 0,
+    deltaY,
+    deltaX: 0,
+  } as Protocol.Input.DispatchMouseEventRequest);
+}
+
+async function fillOrType(ctx: UnderstudyMethodHandlerContext): Promise<void> {
+  const { locator, xpath, args } = ctx;
+  try {
+    await locator.fill(""); // clear
+    await locator.fill(args[0] ?? "");
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    v3Logger({
+      category: "action",
+      message: "error filling element",
+      level: 1,
+      auxiliary: {
+        error: { value: msg, type: "string" },
+        xpath: { value: xpath, type: "string" },
+      },
+    });
+    throw new UnderstudyCommandException(msg, e);
+  }
+}
+
+async function typeText(ctx: UnderstudyMethodHandlerContext): Promise<void> {
+  const { locator, xpath, args } = ctx;
+  try {
+    await locator.type(args[0] ?? "");
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    v3Logger({
+      category: "action",
+      message: "error typing into element",
+      level: 1,
+      auxiliary: {
+        error: { value: msg, type: "string" },
+        xpath: { value: xpath, type: "string" },
+      },
+    });
+    throw new UnderstudyCommandException(msg, e);
+  }
+}
+
+async function pressKey(ctx: UnderstudyMethodHandlerContext): Promise<void> {
+  const { args, xpath, page } = ctx;
+  const key = args[0] ?? "";
+  try {
+    v3Logger({
+      category: "action",
+      message: "pressing key",
+      level: 1,
+      auxiliary: {
+        key: { value: key, type: "string" },
+        xpath: { value: xpath, type: "string" },
+      },
+    });
+    await page.keyPress(key);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    v3Logger({
+      category: "action",
+      message: "error pressing key",
+      level: 1,
+      auxiliary: {
+        error: { value: msg, type: "string" },
+        key: { value: key, type: "string" },
+        xpath: { value: xpath, type: "string" },
+      },
+    });
+    throw new UnderstudyCommandException(msg, e);
+  }
+}
+
+async function clickElement(
+  ctx: UnderstudyMethodHandlerContext,
+): Promise<void> {
+  const { locator, xpath, args } = ctx;
+  try {
+    await locator.click({ button: (args[0] as MouseButton) || undefined });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    v3Logger({
+      category: "action",
+      message: "error performing click",
+      level: 0,
+      auxiliary: {
+        error: { value: msg, type: "string" },
+        xpath: { value: xpath, type: "string" },
+      },
+    });
+    throw new StagehandClickError(ctx.xpath, msg);
+  }
+}
+
+async function doubleClick(ctx: UnderstudyMethodHandlerContext): Promise<void> {
+  const { locator, xpath } = ctx;
+  try {
+    await locator.click({ clickCount: 2 });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    v3Logger({
+      category: "action",
+      message: "error performing doubleClick",
+      level: 0,
+      auxiliary: {
+        error: { value: msg, type: "string" },
+        xpath: { value: xpath, type: "string" },
+      },
+    });
+    throw new UnderstudyCommandException(msg, e);
+  }
+}
+
+async function dragAndDrop(ctx: UnderstudyMethodHandlerContext): Promise<void> {
+  const { page, frame, locator, args, xpath } = ctx;
+  const toXPath = String(args[0] ?? "").trim();
+  if (!toXPath)
+    throw new UnderstudyCommandException(
+      "dragAndDrop requires a target XPath arg",
+    );
+
+  const targetLocator = await resolveLocatorWithHops(page, frame, toXPath);
+
+  try {
+    // 1) Centers in local (owning-frame) viewport
+    const { x: fromLocalX, y: fromLocalY } = await locator.centroid();
+    const { x: toLocalX, y: toLocalY } = await targetLocator.centroid();
+
+    // 2) Convert to main-viewport absolute coordinates
+    const fromAbs = await locator
+      .getFrame()
+      .evaluate<{ x: number; y: number }, { x: number; y: number }>(
+        ({ x, y }: { x: number; y: number }) => {
+          let X = x;
+          let Y = y;
+          let w: Window = window;
+          while (w !== w.top) {
+            const fe = w.frameElement as HTMLElement | null;
+            if (!fe) break;
+            const r = fe.getBoundingClientRect();
+            X += r.left;
+            Y += r.top;
+            w = w.parent as Window;
+          }
+          return { x: Math.round(X), y: Math.round(Y) };
+        },
+        { x: fromLocalX, y: fromLocalY },
+      );
+
+    const toAbs = await targetLocator
+      .getFrame()
+      .evaluate<{ x: number; y: number }, { x: number; y: number }>(
+        ({ x, y }: { x: number; y: number }) => {
+          let X = x;
+          let Y = y;
+          let w: Window = window;
+          while (w !== w.top) {
+            const fe = w.frameElement as HTMLElement | null;
+            if (!fe) break;
+            const r = fe.getBoundingClientRect();
+            X += r.left;
+            Y += r.top;
+            w = w.parent as Window;
+          }
+          return { x: Math.round(X), y: Math.round(Y) };
+        },
+        { x: toLocalX, y: toLocalY },
+      );
+
+    // 3) Perform drag in main session
+    await page.dragAndDrop(fromAbs.x, fromAbs.y, toAbs.x, toAbs.y, {
+      steps: 10,
+      delay: 5,
+    });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    v3Logger({
+      category: "action",
+      message: "error performing dragAndDrop",
+      level: 0,
+      auxiliary: {
+        error: { value: msg, type: "string" },
+        from: { value: xpath, type: "string" },
+        to: { value: toXPath, type: "string" },
+      },
+    });
+    throw new UnderstudyCommandException(msg, e);
+  }
+}
+
+async function scrollToNextChunk(
+  ctx: UnderstudyMethodHandlerContext,
+): Promise<void> {
+  await scrollByElementHeight(ctx, /*dir=*/ 1);
+}
+
+async function scrollToPreviousChunk(
+  ctx: UnderstudyMethodHandlerContext,
+): Promise<void> {
+  await scrollByElementHeight(ctx, /*dir=*/ -1);
+}
+
+async function scrollByElementHeight(
+  ctx: UnderstudyMethodHandlerContext,
+  direction: 1 | -1,
+): Promise<void> {
+  const { locator, xpath } = ctx;
+  v3Logger({
+    category: "action",
+    message:
+      direction > 0 ? "scrolling to next chunk" : "scrolling to previous chunk",
+    level: 2,
+    auxiliary: { xpath: { value: xpath, type: "string" } },
+  });
+
+  const { objectId } = await locator.resolveNode();
+  try {
+    const ownerSession = locator.getFrame().session;
+    await ownerSession.send<Protocol.Runtime.CallFunctionOnResponse>(
+      "Runtime.callFunctionOn",
+      {
+        objectId,
+        functionDeclaration: `
+          function(dir) {
+            const waitForScrollEnd = (el) => new Promise((resolve) => {
+              let last = el.scrollTop ?? 0;
+              const check = () => {
+                const cur = el.scrollTop ?? 0;
+                if (cur === last) return resolve();
+                last = cur;
+                requestAnimationFrame(check);
+              };
+              requestAnimationFrame(check);
+            });
+
+            const tag = this.tagName?.toLowerCase();
+            if (tag === "html" || tag === "body") {
+              const h = window.visualViewport?.height ?? window.innerHeight;
+              window.scrollBy({ top: h * dir, left: 0, behavior: "smooth" });
+              const root = document.scrollingElement ?? document.documentElement;
+              return waitForScrollEnd(root);
+            }
+            const h = this.getBoundingClientRect().height;
+            this.scrollBy({ top: h * dir, left: 0, behavior: "smooth" });
+            return waitForScrollEnd(this);
+          }
+        `,
+        arguments: [{ value: direction }],
+        awaitPromise: true,
+        returnByValue: true,
+      },
+    );
+  } finally {
+    const ownerSession = locator.getFrame().session;
+    await ownerSession
+      .send("Runtime.releaseObject", { objectId })
+      .catch(() => {});
+  }
+}
+
+export async function hover(ctx: UnderstudyMethodHandlerContext) {
+  const { locator, xpath } = ctx;
+  try {
+    await locator.hover();
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    const stack = e instanceof Error ? e.stack : undefined;
+    v3Logger({
+      category: "action",
+      message: "error attempting to hover",
+      level: 0,
+      auxiliary: {
+        error: { value: msg, type: "string" },
+        trace: { value: stack ?? "", type: "string" },
+        xpath: { value: xpath, type: "string" },
+      },
+    });
+    throw new UnderstudyCommandException(msg, e);
+  }
+}
+
+/* ===================== Helpers ===================== */
+
+async function getFrameUrl(frame: Frame): Promise<string> {
+  // Evaluate from within the frame's isolated world
+  const url = await frame.evaluate<string>("location.href");
+  return url;
+}
+
+/**
+ * More robust DOM settle using Network + Page events to detect network quiet.
+ * Closely modeled after the provided snippet, adapted to our Frame/session + logger.
+ */
+export async function waitForDomNetworkQuiet(
+  frame: Frame,
+  timeoutMs?: number,
+): Promise<void> {
+  const overallTimeout =
+    typeof timeoutMs === "number" && Number.isFinite(timeoutMs)
+      ? Math.max(0, timeoutMs)
+      : 5_000;
+  const client = frame.session;
+  const settleStart = Date.now();
+
+  // Ensure a document exists; if not, wait for DOMContentLoaded on this frame.
+  let hasDoc: boolean;
+  try {
+    const rs = await frame.evaluate<string>("document.readyState");
+    hasDoc = rs === "interactive" || rs === "complete";
+  } catch {
+    hasDoc = false;
+  }
+  if (!hasDoc && overallTimeout > 0) {
+    await frame
+      .waitForLoadState("domcontentloaded", overallTimeout)
+      .catch(() => {});
+  }
+
+  const elapsed = Date.now() - settleStart;
+  const remainingBudget = Math.max(0, overallTimeout - elapsed);
+  if (remainingBudget === 0) {
+    return;
+  }
+
+  await client.send("Network.enable").catch(() => {});
+  await client.send("Page.enable").catch(() => {});
+  // Best-effort; some sessions may not support Target.setAutoAttach here.
+  await client
+    .send("Target.setAutoAttach", {
+      autoAttach: true,
+      waitForDebuggerOnStart: false,
+      flatten: true,
+      filter: [
+        { type: "worker", exclude: true },
+        { type: "shared_worker", exclude: true },
+      ],
+    })
+    .catch(() => {});
+
+  return new Promise<void>((resolve) => {
+    const inflight = new Set<string>();
+    const meta = new Map<string, { url: string; start: number }>();
+    const docByFrame = new Map<string, string>();
+
+    let quietTimer: NodeJS.Timeout | null = null;
+    let stalledRequestSweepTimer: NodeJS.Timeout | null = null;
+
+    const clearQuiet = () => {
+      if (quietTimer) {
+        clearTimeout(quietTimer);
+        quietTimer = null;
+      }
+    };
+
+    const maybeQuiet = () => {
+      if (inflight.size === 0 && !quietTimer)
+        quietTimer = setTimeout(() => resolveDone(), 500);
+    };
+
+    const finishReq = (id: string) => {
+      if (!inflight.delete(id)) return;
+      meta.delete(id);
+      for (const [fid, rid] of docByFrame)
+        if (rid === id) docByFrame.delete(fid);
+      clearQuiet();
+      maybeQuiet();
+    };
+
+    const onRequest = (p: Protocol.Network.RequestWillBeSentEvent) => {
+      // Ignore long-lived streams
+      // ResourceType includes: Document, XHR, Fetch, WebSocket, EventSource, etc.
+      if (p.type === "WebSocket" || p.type === "EventSource") return;
+
+      inflight.add(p.requestId);
+      meta.set(p.requestId, { url: p.request.url, start: Date.now() });
+
+      if (p.type === "Document" && p.frameId)
+        docByFrame.set(p.frameId, p.requestId);
+
+      clearQuiet();
+    };
+
+    const onFinish = (p: { requestId: string }) => finishReq(p.requestId);
+    const onCached = (p: { requestId: string }) => finishReq(p.requestId);
+    const onDataUrl = (p: Protocol.Network.ResponseReceivedEvent) => {
+      if (p.response.url?.startsWith("data:")) finishReq(p.requestId);
+    };
+
+    const onFrameStop = (f: Protocol.Page.FrameStoppedLoadingEvent) => {
+      const id = docByFrame.get(f.frameId);
+      if (id) finishReq(id);
+    };
+
+    client.on("Network.requestWillBeSent", onRequest);
+    client.on("Network.loadingFinished", onFinish);
+    client.on("Network.loadingFailed", onFinish);
+    client.on("Network.requestServedFromCache", onCached);
+    client.on("Network.responseReceived", onDataUrl);
+    client.on("Page.frameStoppedLoading", onFrameStop);
+
+    stalledRequestSweepTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [id, m] of meta) {
+        if (now - m.start > 2_000) {
+          inflight.delete(id);
+          meta.delete(id);
+          v3Logger({
+            category: "dom",
+            message: "⏳ forcing completion of stalled iframe document",
+            level: 1,
+            auxiliary: {
+              url: { value: (m.url ?? "").slice(0, 120), type: "string" },
+            },
+          });
+        }
+      }
+      maybeQuiet();
+    }, 500);
+
+    maybeQuiet();
+
+    const guard = setTimeout(() => {
+      if (inflight.size) {
+        v3Logger({
+          category: "dom",
+          message:
+            "⚠️ DOM-settle timeout reached – network requests still pending",
+          level: 1,
+          auxiliary: {
+            count: { value: String(inflight.size), type: "integer" },
+          },
+        });
+      }
+      resolveDone();
+    }, remainingBudget);
+
+    const resolveDone = () => {
+      client.off("Network.requestWillBeSent", onRequest);
+      client.off("Network.loadingFinished", onFinish);
+      client.off("Network.loadingFailed", onFinish);
+      client.off("Network.requestServedFromCache", onCached);
+      client.off("Network.responseReceived", onDataUrl);
+      client.off("Page.frameStoppedLoading", onFrameStop);
+      if (quietTimer) clearTimeout(quietTimer);
+      if (stalledRequestSweepTimer) clearInterval(stalledRequestSweepTimer);
+      clearTimeout(guard);
+      resolve();
+    };
+  });
+}
diff --git a/packages/core/lib/v3/handlers/handlerUtils/timeoutGuard.ts b/packages/core/lib/v3/handlers/handlerUtils/timeoutGuard.ts
new file mode 100644
index 000000000..dd5196b3b
--- /dev/null
+++ b/packages/core/lib/v3/handlers/handlerUtils/timeoutGuard.ts
@@ -0,0 +1,21 @@
+import { TimeoutError } from "../../types/public/sdkErrors.js";
+
+export type TimeoutGuard = () => void;
+
+export function createTimeoutGuard(
+  timeoutMs?: number,
+  errorFactory?: (timeoutMs: number) => Error,
+): TimeoutGuard {
+  if (!timeoutMs || timeoutMs <= 0) {
+    return () => {};
+  }
+
+  const startTime = Date.now();
+  return () => {
+    if (Date.now() - startTime >= timeoutMs) {
+      const err =
+        errorFactory?.(timeoutMs) ?? new TimeoutError("operation", timeoutMs);
+      throw err;
+    }
+  };
+}
diff --git a/packages/core/lib/v3/handlers/observeHandler.ts b/packages/core/lib/v3/handlers/observeHandler.ts
new file mode 100644
index 000000000..d7a5c0c29
--- /dev/null
+++ b/packages/core/lib/v3/handlers/observeHandler.ts
@@ -0,0 +1,233 @@
+// lib/v3/handlers/observeHandler.ts
+import { observe as runObserve } from "../../inference.js";
+import { trimTrailingTextNode } from "../../utils.js";
+import { v3Logger } from "../logger.js";
+import { V3FunctionName } from "../types/public/methods.js";
+import { captureHybridSnapshot } from "../understudy/a11y/snapshot/index.js";
+import { LLMClient } from "../llm/LLMClient.js";
+import {
+  ObserveHandlerParams,
+  SupportedUnderstudyAction,
+} from "../types/private/handlers.js";
+import { EncodedId } from "../types/private/internal.js";
+import { Action } from "../types/public/methods.js";
+import {
+  AvailableModel,
+  ClientOptions,
+  ModelConfiguration,
+} from "../types/public/model.js";
+import { ObserveTimeoutError } from "../types/public/sdkErrors.js";
+import { createTimeoutGuard } from "./handlerUtils/timeoutGuard.js";
+
+export class ObserveHandler {
+  private readonly llmClient: LLMClient;
+  private readonly defaultModelName: AvailableModel;
+  private readonly defaultClientOptions: ClientOptions;
+  private readonly resolveLlmClient: (model?: ModelConfiguration) => LLMClient;
+  private readonly systemPrompt: string;
+  private readonly logInferenceToFile: boolean;
+  private readonly experimental: boolean;
+  private readonly onMetrics?: (
+    functionName: V3FunctionName,
+    promptTokens: number,
+    completionTokens: number,
+    reasoningTokens: number,
+    cachedInputTokens: number,
+    inferenceTimeMs: number,
+  ) => void;
+
+  constructor(
+    llmClient: LLMClient,
+    defaultModelName: AvailableModel,
+    defaultClientOptions: ClientOptions,
+    resolveLlmClient: (model?: ModelConfiguration) => LLMClient,
+    systemPrompt?: string,
+    logInferenceToFile?: boolean,
+    experimental?: boolean,
+    onMetrics?: (
+      functionName: V3FunctionName,
+      promptTokens: number,
+      completionTokens: number,
+      reasoningTokens: number,
+      cachedInputTokens: number,
+      inferenceTimeMs: number,
+    ) => void,
+  ) {
+    this.llmClient = llmClient;
+    this.defaultModelName = defaultModelName;
+    this.defaultClientOptions = defaultClientOptions;
+    this.resolveLlmClient = resolveLlmClient;
+    this.systemPrompt = systemPrompt ?? "";
+    this.logInferenceToFile = logInferenceToFile ?? false;
+    this.experimental = experimental ?? false;
+    this.onMetrics = onMetrics;
+  }
+
+  async observe(params: ObserveHandlerParams): Promise<Action[]> {
+    const { instruction, page, timeout, selector, model } = params;
+
+    const llmClient = this.resolveLlmClient(model);
+
+    const ensureTimeRemaining = createTimeoutGuard(
+      timeout,
+      (ms) => new ObserveTimeoutError(ms),
+    );
+
+    const effectiveInstruction =
+      instruction ??
+      "Find elements that can be used for any future actions in the page. These may be navigation links, related pages, section/subsection links, buttons, or other interactive elements. Be comprehensive: if there are multiple elements that may be relevant for future actions, return all of them.";
+
+    v3Logger({
+      category: "observation",
+      message: "starting observation",
+      level: 1,
+      auxiliary: {
+        instruction: {
+          value: effectiveInstruction,
+          type: "string",
+        },
+      },
+    });
+
+    // Build the hybrid snapshot (a11y-centric text tree + lookup maps)
+    const focusSelector = selector?.replace(/^xpath=/i, "") ?? "";
+    ensureTimeRemaining();
+    const snapshot = await captureHybridSnapshot(page, {
+      experimental: this.experimental,
+      focusSelector: focusSelector || undefined,
+    });
+
+    const combinedTree = snapshot.combinedTree;
+    const combinedXpathMap = snapshot.combinedXpathMap ?? {};
+
+    v3Logger({
+      category: "observation",
+      message: "Got accessibility tree data",
+      level: 1,
+    });
+
+    // Call the LLM to propose actionable elements
+    ensureTimeRemaining();
+    const observationResponse = await runObserve({
+      instruction: effectiveInstruction,
+      domElements: combinedTree,
+      llmClient,
+      userProvidedInstructions: this.systemPrompt,
+      logger: v3Logger,
+      logInferenceToFile: this.logInferenceToFile,
+      supportedActions: Object.values(SupportedUnderstudyAction),
+    });
+
+    const {
+      prompt_tokens = 0,
+      completion_tokens = 0,
+      reasoning_tokens = 0,
+      cached_input_tokens = 0,
+      inference_time_ms = 0,
+    } = observationResponse;
+
+    // Update OBSERVE metrics from the LLM observation call
+    this.onMetrics?.(
+      V3FunctionName.OBSERVE,
+      prompt_tokens,
+      completion_tokens,
+      reasoning_tokens,
+      cached_input_tokens,
+      inference_time_ms,
+    );
+
+    // Map elementIds -> selectors via combinedXpathMap
+    const elementsWithSelectors = (
+      await Promise.all(
+        observationResponse.elements.map(async (element) => {
+          const { elementId, ...rest } = element; // rest may or may not have method/arguments
+          if (typeof elementId === "string" && elementId.includes("-")) {
+            const lookUpIndex = elementId as EncodedId;
+            const xpath = combinedXpathMap[lookUpIndex];
+            const trimmedXpath = trimTrailingTextNode(xpath);
+            if (!trimmedXpath) return undefined;
+
+            // For dragAndDrop, convert element ID in arguments to xpath (target element)
+            let resolvedArgs = rest.arguments;
+            if (
+              rest.method === "dragAndDrop" &&
+              Array.isArray(rest.arguments) &&
+              rest.arguments.length > 0
+            ) {
+              const targetArg = rest.arguments[0];
+              // Check if argument looks like an element ID (e.g., "1-67")
+              if (
+                typeof targetArg === "string" &&
+                /^\d+-\d+$/.test(targetArg)
+              ) {
+                const argXpath = combinedXpathMap[targetArg as EncodedId];
+                const trimmedArgXpath = trimTrailingTextNode(argXpath);
+                if (trimmedArgXpath) {
+                  resolvedArgs = [
+                    `xpath=${trimmedArgXpath}`,
+                    ...rest.arguments.slice(1),
+                  ];
+                } else {
+                  // Target element lookup failed, filter out this action
+                  v3Logger({
+                    category: "observation",
+                    message: "dragAndDrop target element lookup failed",
+                    level: 0,
+                    auxiliary: {
+                      targetElementId: { value: targetArg, type: "string" },
+                      sourceElementId: { value: elementId, type: "string" },
+                    },
+                  });
+                  return undefined;
+                }
+              } else {
+                v3Logger({
+                  category: "observation",
+                  message: "dragAndDrop target element invalid ID format",
+                  level: 0,
+                  auxiliary: {
+                    targetElementId: { value: targetArg, type: "string" },
+                    sourceElementId: { value: elementId, type: "string" },
+                  },
+                });
+                return undefined;
+              }
+            }
+
+            return {
+              ...rest,
+              arguments: resolvedArgs,
+              selector: `xpath=${trimmedXpath}`,
+            } as {
+              description: string;
+              method?: string;
+              arguments?: string[];
+              selector: string;
+            };
+          }
+          // shadow-root fallback:
+          return {
+            description: "an element inside a shadow DOM",
+            method: "not-supported",
+            arguments: [],
+            selector: "not-supported",
+          };
+        }),
+      )
+    ).filter(<T>(e: T | undefined): e is T => e !== undefined);
+
+    v3Logger({
+      category: "observation",
+      message: "found elements",
+      level: 1,
+      auxiliary: {
+        elements: {
+          value: JSON.stringify(elementsWithSelectors),
+          type: "object",
+        },
+      },
+    });
+
+    return elementsWithSelectors;
+  }
+}
diff --git a/packages/core/lib/v3/handlers/v3AgentHandler.ts b/packages/core/lib/v3/handlers/v3AgentHandler.ts
new file mode 100644
index 000000000..6ccd2a9a3
--- /dev/null
+++ b/packages/core/lib/v3/handlers/v3AgentHandler.ts
@@ -0,0 +1,664 @@
+import { createAgentTools } from "../agent/tools/index.js";
+import { buildAgentSystemPrompt } from "../agent/prompts/agentSystemPrompt.js";
+import { LogLine } from "../types/public/logs.js";
+import { V3 } from "../v3.js";
+import {
+  ModelMessage,
+  ToolSet,
+  wrapLanguageModel,
+  stepCountIs,
+  LanguageModel,
+  type LanguageModelUsage,
+  type StepResult,
+  type GenerateTextOnStepFinishCallback,
+  type StreamTextOnStepFinishCallback,
+  type PrepareStepFunction,
+} from "ai";
+import { StagehandZodObject } from "../zodCompat.js";
+import { processMessages } from "../agent/utils/messageProcessing.js";
+import { LLMClient } from "../llm/LLMClient.js";
+import { SessionFileLogger } from "../flowLogger.js";
+import {
+  AgentExecuteOptions,
+  AgentStreamExecuteOptions,
+  AgentExecuteOptionsBase,
+  AgentResult,
+  AgentContext,
+  AgentState,
+  AgentStreamResult,
+  AgentStreamCallbacks,
+  AgentToolMode,
+  AgentModelConfig,
+  Variables,
+} from "../types/public/agent.js";
+import { V3FunctionName } from "../types/public/methods.js";
+import { mapToolResultToActions } from "../agent/utils/actionMapping.js";
+import {
+  MissingLLMConfigurationError,
+  StreamingCallbacksInNonStreamingModeError,
+  AgentAbortError,
+} from "../types/public/sdkErrors.js";
+import { handleDoneToolCall } from "../agent/utils/handleDoneToolCall.js";
+
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * Prepends a system message with cache control to the messages array.
+ * The cache control providerOptions are used by Anthropic and ignored by other providers.
+ */
+function prependSystemMessage(
+  systemPrompt: string,
+  messages: ModelMessage[],
+): ModelMessage[] {
+  return [
+    {
+      role: "system",
+      content: systemPrompt,
+      providerOptions: {
+        anthropic: {
+          cacheControl: { type: "ephemeral" },
+        },
+      },
+    },
+    ...messages,
+  ];
+}
+
+export class V3AgentHandler {
+  private v3: V3;
+  private logger: (message: LogLine) => void;
+  private llmClient: LLMClient;
+  private executionModel?: string | AgentModelConfig;
+  private systemInstructions?: string;
+  private mcpTools?: ToolSet;
+  private mode: AgentToolMode;
+
+  constructor(
+    v3: V3,
+    logger: (message: LogLine) => void,
+    llmClient: LLMClient,
+    executionModel?: string | AgentModelConfig,
+    systemInstructions?: string,
+    mcpTools?: ToolSet,
+    mode?: AgentToolMode,
+  ) {
+    this.v3 = v3;
+    this.logger = logger;
+    this.llmClient = llmClient;
+    this.executionModel = executionModel;
+    this.systemInstructions = systemInstructions;
+    this.mcpTools = mcpTools;
+    this.mode = mode ?? "dom";
+  }
+
+  private async prepareAgent(
+    instructionOrOptions: string | AgentExecuteOptionsBase,
+  ): Promise<AgentContext> {
+    try {
+      const options =
+        typeof instructionOrOptions === "string"
+          ? { instruction: instructionOrOptions }
+          : instructionOrOptions;
+
+      const maxSteps = options.maxSteps || 20;
+
+      // Get the initial page URL first (needed for the system prompt)
+      const initialPageUrl = (await this.v3.context.awaitActivePage()).url();
+
+      // Build the system prompt with mode-aware tool guidance
+      const systemPrompt = buildAgentSystemPrompt({
+        url: initialPageUrl,
+        executionInstruction: options.instruction,
+        mode: this.mode,
+        systemInstructions: this.systemInstructions,
+        isBrowserbase: this.v3.isBrowserbase,
+        excludeTools: options.excludeTools,
+        variables: options.variables,
+      });
+
+      const tools = this.createTools(
+        options.excludeTools,
+        options.variables,
+        options.toolTimeout,
+      );
+      const allTools: ToolSet = { ...tools, ...this.mcpTools };
+
+      // Use provided messages for continuation, or start fresh with the instruction
+      const messages: ModelMessage[] = options.messages?.length
+        ? [...options.messages, { role: "user", content: options.instruction }]
+        : [{ role: "user", content: options.instruction }];
+
+      if (!this.llmClient?.getLanguageModel) {
+        throw new MissingLLMConfigurationError();
+      }
+      const baseModel = this.llmClient.getLanguageModel();
+      //to do - we likely do not need middleware anymore
+      const wrappedModel = wrapLanguageModel({
+        model: baseModel,
+        middleware: {
+          ...SessionFileLogger.createLlmLoggingMiddleware(baseModel.modelId),
+        },
+      });
+
+      if (
+        this.mode === "hybrid" &&
+        !baseModel.modelId.includes("gemini-3-flash") &&
+        !baseModel.modelId.includes("claude")
+      ) {
+        this.logger({
+          category: "agent",
+          message: `Warning: "${baseModel.modelId}" may not perform well in hybrid mode. See recommended models: https://docs.stagehand.dev/v3/basics/agent#hybrid-mode`,
+          level: 0,
+        });
+      }
+
+      return {
+        options,
+        maxSteps,
+        systemPrompt,
+        allTools,
+        messages,
+        wrappedModel,
+        initialPageUrl,
+      };
+    } catch (error) {
+      this.logger({
+        category: "agent",
+        message: `failed to prepare agent: ${error}`,
+        level: 0,
+      });
+      throw error;
+    }
+  }
+  private createPrepareStep(
+    userCallback?: PrepareStepFunction<ToolSet>,
+  ): PrepareStepFunction<ToolSet> {
+    return async (options) => {
+      processMessages(options.messages);
+      if (userCallback) {
+        return userCallback(options);
+      }
+      return options;
+    };
+  }
+
+  private createStepHandler(
+    state: AgentState,
+    userCallback?:
+      | GenerateTextOnStepFinishCallback<ToolSet>
+      | StreamTextOnStepFinishCallback<ToolSet>,
+  ) {
+    return async (event: StepResult<ToolSet>) => {
+      this.logger({
+        category: "agent",
+        message: `Step finished: ${event.finishReason}`,
+        level: 2,
+      });
+
+      if (event.toolCalls && event.toolCalls.length > 0) {
+        for (let i = 0; i < event.toolCalls.length; i++) {
+          const toolCall = event.toolCalls[i];
+          const args = toolCall.input;
+          const toolResult = event.toolResults?.[i];
+
+          if (event.text && event.text.length > 0) {
+            state.collectedReasoning.push(event.text);
+            this.logger({
+              category: "agent",
+              message: `reasoning: ${event.text}`,
+              level: 1,
+            });
+          }
+
+          if (toolCall.toolName === "done") {
+            state.completed = true;
+            if (args?.taskComplete) {
+              const doneReasoning = args.reasoning;
+              const allReasoning = state.collectedReasoning.join(" ");
+              state.finalMessage = doneReasoning
+                ? `${allReasoning} ${doneReasoning}`.trim()
+                : allReasoning || "Task completed successfully";
+            }
+          }
+          const mappedActions = mapToolResultToActions({
+            toolCallName: toolCall.toolName,
+            toolResult,
+            args,
+            reasoning: event.text || undefined,
+          });
+
+          for (const action of mappedActions) {
+            action.pageUrl = state.currentPageUrl;
+            action.timestamp = Date.now();
+            state.actions.push(action);
+          }
+        }
+        state.currentPageUrl = (await this.v3.context.awaitActivePage()).url();
+
+        // Capture screenshot after tool execution (only for evals)
+        if (process.env.EVALS === "true") {
+          try {
+            await this.captureAndEmitScreenshot();
+          } catch (e) {
+            this.logger({
+              category: "agent",
+              message: `Warning: Failed to capture screenshot: ${getErrorMessage(e)}`,
+              level: 1,
+            });
+          }
+        }
+      }
+
+      if (userCallback) {
+        await userCallback(event);
+      }
+    };
+  }
+
+  public async execute(
+    instructionOrOptions: string | AgentExecuteOptions,
+  ): Promise<AgentResult> {
+    const startTime = Date.now();
+    const options =
+      typeof instructionOrOptions === "object" ? instructionOrOptions : null;
+    const signal = options?.signal;
+
+    // Highlight cursor defaults to true for hybrid mode, can be overridden
+    const shouldHighlightCursor =
+      options?.highlightCursor ?? this.mode === "hybrid";
+
+    const state: AgentState = {
+      collectedReasoning: [],
+      actions: [],
+      finalMessage: "",
+      completed: false,
+      currentPageUrl: "",
+    };
+
+    let messages: ModelMessage[] = [];
+
+    try {
+      const {
+        options: preparedOptions,
+        maxSteps,
+        systemPrompt,
+        allTools,
+        messages: preparedMessages,
+        wrappedModel,
+        initialPageUrl,
+      } = await this.prepareAgent(instructionOrOptions);
+
+      // Enable cursor overlay for hybrid mode (coordinate-based interactions)
+      if (shouldHighlightCursor && this.mode === "hybrid") {
+        const page = await this.v3.context.awaitActivePage();
+        await page.enableCursorOverlay().catch(() => {});
+      }
+
+      messages = preparedMessages;
+      state.currentPageUrl = initialPageUrl;
+
+      const callbacks = (instructionOrOptions as AgentExecuteOptions).callbacks;
+
+      if (callbacks) {
+        const streamingOnlyCallbacks = [
+          "onChunk",
+          "onFinish",
+          "onError",
+          "onAbort",
+        ];
+        const invalidCallbacks = streamingOnlyCallbacks.filter(
+          (name) => callbacks[name as keyof typeof callbacks] != null,
+        );
+        if (invalidCallbacks.length > 0) {
+          throw new StreamingCallbacksInNonStreamingModeError(invalidCallbacks);
+        }
+      }
+
+      const result = await this.llmClient.generateText({
+        model: wrappedModel,
+        messages: prependSystemMessage(systemPrompt, messages),
+        tools: allTools,
+        stopWhen: (result) => this.handleStop(result, maxSteps),
+        temperature: 1,
+        toolChoice: "auto",
+
+        prepareStep: this.createPrepareStep(callbacks?.prepareStep),
+        onStepFinish: this.createStepHandler(state, callbacks?.onStepFinish),
+        abortSignal: preparedOptions.signal,
+        providerOptions: wrappedModel.modelId.includes("gemini-3")
+          ? {
+              google: {
+                mediaResolution: "MEDIA_RESOLUTION_HIGH",
+              },
+            }
+          : undefined,
+      });
+
+      const allMessages = [...messages, ...(result.response?.messages || [])];
+      const doneResult = await this.ensureDone(
+        state,
+        wrappedModel,
+        allMessages,
+        preparedOptions.instruction,
+        preparedOptions.output,
+        this.logger,
+      );
+
+      return this.consolidateMetricsAndResult(
+        startTime,
+        state,
+        doneResult.messages,
+        result,
+        maxSteps,
+        doneResult.output,
+      );
+    } catch (error) {
+      // Re-throw validation errors that should propagate to the caller
+      if (error instanceof StreamingCallbacksInNonStreamingModeError) {
+        throw error;
+      }
+
+      // Re-throw abort errors wrapped in AgentAbortError for consistent error typing
+      if (signal?.aborted) {
+        const reason = signal.reason ? String(signal.reason) : "aborted";
+        throw new AgentAbortError(reason);
+      }
+
+      const errorMessage = getErrorMessage(error);
+      this.logger({
+        category: "agent",
+        message: `Error executing agent task: ${errorMessage}`,
+        level: 0,
+      });
+
+      // For non-abort errors, return a failure result instead of throwing
+      return {
+        success: false,
+        actions: state.actions,
+        message: `Failed to execute task: ${errorMessage}`,
+        completed: false,
+        messages,
+      };
+    }
+  }
+
+  public async stream(
+    instructionOrOptions: string | AgentStreamExecuteOptions,
+  ): Promise<AgentStreamResult> {
+    const streamOptions =
+      typeof instructionOrOptions === "object" ? instructionOrOptions : null;
+
+    // Highlight cursor defaults to true for hybrid mode, can be overridden
+    const shouldHighlightCursor =
+      streamOptions?.highlightCursor ?? this.mode === "hybrid";
+
+    const {
+      options,
+      maxSteps,
+      systemPrompt,
+      allTools,
+      messages,
+      wrappedModel,
+      initialPageUrl,
+    } = await this.prepareAgent(instructionOrOptions);
+
+    // Enable cursor overlay for hybrid mode (coordinate-based interactions)
+    if (shouldHighlightCursor && this.mode === "hybrid") {
+      const page = await this.v3.context.awaitActivePage();
+      await page.enableCursorOverlay().catch(() => {});
+    }
+
+    const callbacks = (instructionOrOptions as AgentStreamExecuteOptions)
+      .callbacks as AgentStreamCallbacks | undefined;
+
+    const state: AgentState = {
+      collectedReasoning: [],
+      actions: [],
+      finalMessage: "",
+      completed: false,
+      currentPageUrl: initialPageUrl,
+    };
+    const startTime = Date.now();
+
+    let resolveResult: (value: AgentResult | PromiseLike<AgentResult>) => void;
+    let rejectResult: (reason: unknown) => void;
+    const resultPromise = new Promise<AgentResult>((resolve, reject) => {
+      resolveResult = resolve;
+      rejectResult = reject;
+    });
+
+    const handleError = (error: unknown) => {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      this.logger({
+        category: "agent",
+        message: `Error during streaming: ${errorMessage}`,
+        level: 0,
+      });
+      rejectResult(error);
+    };
+
+    const streamResult = this.llmClient.streamText({
+      model: wrappedModel,
+      messages: prependSystemMessage(systemPrompt, messages),
+      tools: allTools,
+      stopWhen: (result) => this.handleStop(result, maxSteps),
+      temperature: 1,
+      toolChoice: "auto",
+      prepareStep: this.createPrepareStep(callbacks?.prepareStep),
+      onStepFinish: this.createStepHandler(state, callbacks?.onStepFinish),
+      onError: (event) => {
+        if (callbacks?.onError) {
+          callbacks.onError(event);
+        }
+        handleError(event.error);
+      },
+      onChunk: callbacks?.onChunk,
+      onFinish: (event) => {
+        if (callbacks?.onFinish) {
+          callbacks.onFinish(event);
+        }
+
+        const allMessages = [...messages, ...(event.response?.messages || [])];
+        this.ensureDone(
+          state,
+          wrappedModel,
+          allMessages,
+          options.instruction,
+          options.output,
+          this.logger,
+        ).then((doneResult) => {
+          const result = this.consolidateMetricsAndResult(
+            startTime,
+            state,
+            doneResult.messages,
+            event,
+            maxSteps,
+            doneResult.output,
+          );
+          resolveResult(result);
+        });
+      },
+      onAbort: (event) => {
+        if (callbacks?.onAbort) {
+          callbacks.onAbort(event);
+        }
+        // Reject the result promise with AgentAbortError when stream is aborted
+        const reason = options.signal?.reason
+          ? String(options.signal.reason)
+          : "Stream was aborted";
+        rejectResult(new AgentAbortError(reason));
+      },
+      abortSignal: options.signal,
+      providerOptions: wrappedModel.modelId.includes("gemini-3")
+        ? {
+            google: {
+              mediaResolution: "MEDIA_RESOLUTION_HIGH",
+            },
+          }
+        : undefined,
+    });
+
+    const agentStreamResult = streamResult as AgentStreamResult;
+    agentStreamResult.result = resultPromise;
+    return agentStreamResult;
+  }
+
+  private consolidateMetricsAndResult(
+    startTime: number,
+    state: AgentState,
+    inputMessages: ModelMessage[],
+    result: {
+      text?: string;
+      totalUsage?: LanguageModelUsage;
+      response?: { messages?: ModelMessage[] };
+      steps?: StepResult<ToolSet>[];
+    },
+    maxSteps?: number,
+    output?: Record<string, unknown>,
+  ): AgentResult {
+    if (!state.finalMessage) {
+      const allReasoning = state.collectedReasoning.join(" ").trim();
+
+      if (!state.completed && maxSteps && result.steps?.length >= maxSteps) {
+        this.logger({
+          category: "agent",
+          message: `Agent stopped: reached maximum steps (${maxSteps})`,
+          level: 1,
+        });
+        state.finalMessage = `Agent stopped: reached maximum steps (${maxSteps})`;
+      } else {
+        state.finalMessage = allReasoning || result.text || "";
+      }
+    }
+
+    const endTime = Date.now();
+    const inferenceTimeMs = endTime - startTime;
+    if (result.totalUsage) {
+      this.v3.updateMetrics(
+        V3FunctionName.AGENT,
+        result.totalUsage.inputTokens || 0,
+        result.totalUsage.outputTokens || 0,
+        result.totalUsage.reasoningTokens || 0,
+        result.totalUsage.cachedInputTokens || 0,
+        inferenceTimeMs,
+      );
+    }
+
+    return {
+      success: state.completed,
+      message: state.finalMessage || "Task execution completed",
+      actions: state.actions,
+      completed: state.completed,
+      output,
+      usage: result.totalUsage
+        ? {
+            input_tokens: result.totalUsage.inputTokens || 0,
+            output_tokens: result.totalUsage.outputTokens || 0,
+            reasoning_tokens: result.totalUsage.reasoningTokens || 0,
+            cached_input_tokens: result.totalUsage.cachedInputTokens || 0,
+            inference_time_ms: inferenceTimeMs,
+          }
+        : undefined,
+      messages: inputMessages,
+    };
+  }
+
+  private createTools(
+    excludeTools?: string[],
+    variables?: Variables,
+    toolTimeout?: number,
+  ) {
+    const provider = this.llmClient?.getLanguageModel?.()?.provider;
+    return createAgentTools(this.v3, {
+      executionModel: this.executionModel,
+      logger: this.logger,
+      mode: this.mode,
+      provider,
+      excludeTools,
+      variables,
+      toolTimeout,
+    });
+  }
+
+  private handleStop(
+    result: Parameters<ReturnType<typeof stepCountIs>>[0],
+    maxSteps: number,
+  ): boolean | PromiseLike<boolean> {
+    const lastStep = result.steps[result.steps.length - 1];
+    if (lastStep?.toolCalls?.some((tc) => tc.toolName === "done")) {
+      return true;
+    }
+    return stepCountIs(maxSteps)(result);
+  }
+
+  /**
+   * Ensures the done tool is called at the end of agent execution.
+   * Returns the messages and any extracted output from the done call.
+   */
+  private async ensureDone(
+    state: AgentState,
+    model: LanguageModel,
+    messages: ModelMessage[],
+    instruction: string,
+    outputSchema?: StagehandZodObject,
+    logger?: (message: LogLine) => void,
+  ): Promise<{ messages: ModelMessage[]; output?: Record<string, unknown> }> {
+    if (state.completed) return { messages };
+
+    const doneResult = await handleDoneToolCall({
+      model,
+      inputMessages: messages,
+      instruction,
+      outputSchema,
+      logger,
+    });
+
+    state.completed = doneResult.taskComplete;
+    state.finalMessage = doneResult.reasoning;
+
+    const doneAction = mapToolResultToActions({
+      toolCallName: "done",
+      toolResult: {
+        success: true,
+        reasoning: doneResult.reasoning,
+        taskComplete: doneResult.taskComplete,
+      },
+      args: {
+        reasoning: doneResult.reasoning,
+        taskComplete: doneResult.taskComplete,
+      },
+      reasoning: doneResult.reasoning,
+    });
+
+    for (const action of doneAction) {
+      action.pageUrl = state.currentPageUrl;
+      action.timestamp = Date.now();
+      state.actions.push(action);
+    }
+
+    return {
+      messages: [...messages, ...doneResult.messages],
+      output: doneResult.output,
+    };
+  }
+
+  /**
+   * Capture a screenshot and emit it via the event bus
+   */
+  private async captureAndEmitScreenshot(): Promise<void> {
+    try {
+      const page = await this.v3.context.awaitActivePage();
+      const screenshot = await page.screenshot({ fullPage: false });
+      this.v3.bus.emit("agent_screenshot_taken_event", screenshot);
+    } catch (error) {
+      this.logger({
+        category: "agent",
+        message: `Error capturing screenshot: ${getErrorMessage(error)}`,
+        level: 0,
+      });
+    }
+  }
+}
diff --git a/packages/core/lib/v3/handlers/v3CuaAgentHandler.ts b/packages/core/lib/v3/handlers/v3CuaAgentHandler.ts
new file mode 100644
index 000000000..e6c23dc4b
--- /dev/null
+++ b/packages/core/lib/v3/handlers/v3CuaAgentHandler.ts
@@ -0,0 +1,624 @@
+import { computeActiveElementXpath } from "../understudy/a11y/snapshot/index.js";
+import { V3 } from "../v3.js";
+import { ToolSet } from "ai";
+import { AgentClient } from "../agent/AgentClient.js";
+import { AgentProvider } from "../agent/AgentProvider.js";
+import { GoogleCUAClient } from "../agent/GoogleCUAClient.js";
+import { OpenAICUAClient } from "../agent/OpenAICUAClient.js";
+import { mapKeyToPlaywright } from "../agent/utils/cuaKeyMapping.js";
+import { ensureXPath } from "../agent/utils/xpath.js";
+import {
+  ActionExecutionResult,
+  AgentAction,
+  AgentExecuteOptions,
+  AgentHandlerOptions,
+  AgentResult,
+  SafetyConfirmationHandler,
+} from "../types/public/agent.js";
+import { LogLine } from "../types/public/logs.js";
+import { type Action, V3FunctionName } from "../types/public/methods.js";
+import { SessionFileLogger } from "../flowLogger.js";
+import { StagehandClosedError } from "../types/public/sdkErrors.js";
+
+export class V3CuaAgentHandler {
+  private v3: V3;
+  private agent: AgentClient;
+  private provider: AgentProvider;
+  private logger: (message: LogLine) => void;
+  private agentClient: AgentClient;
+  private options: AgentHandlerOptions;
+  private highlightCursor: boolean;
+
+  constructor(
+    v3: V3,
+    logger: (message: LogLine) => void,
+    options: AgentHandlerOptions,
+    tools?: ToolSet,
+  ) {
+    this.v3 = v3;
+    this.logger = logger;
+    this.options = options;
+
+    this.provider = new AgentProvider(logger);
+    const client = this.provider.getClient(
+      options.modelName,
+      options.clientOptions || {},
+      options.userProvidedInstructions,
+      tools,
+    );
+    this.agentClient = client;
+    this.setupAgentClient();
+    this.agent = client;
+  }
+
+  /**
+   * Ensures the V3 context is still available (not closed).
+   * Throws StagehandClosedError if stagehand.close() was called.
+   */
+  private ensureNotClosed(): void {
+    if (!this.v3.context) {
+      throw new StagehandClosedError();
+    }
+  }
+
+  private setupAgentClient(): void {
+    // Provide screenshots to the agent client
+    this.agentClient.setScreenshotProvider(async () => {
+      this.ensureNotClosed();
+      const page = await this.v3.context.awaitActivePage();
+      const screenshotBuffer = await page.screenshot({ fullPage: false });
+      return screenshotBuffer.toString("base64"); // base64 png
+    });
+
+    // Provide action executor
+    this.agentClient.setActionHandler(async (action) => {
+      this.ensureNotClosed();
+      action.pageUrl = (await this.v3.context.awaitActivePage()).url();
+
+      const defaultDelay = 500;
+      const waitBetween =
+        (this.options.clientOptions?.waitBetweenActions as number) ||
+        defaultDelay;
+      try {
+        // Try to inject cursor before each action if enabled
+        if (this.highlightCursor) {
+          try {
+            await this.injectCursor();
+          } catch {
+            // Ignore cursor injection failures
+          }
+        }
+        await new Promise((r) => setTimeout(r, 300));
+        // Skip logging for screenshot actions - they're no-ops, the actual
+        // Page.screenshot in captureAndSendScreenshot() is logged separately
+        const shouldLog = action.type !== "screenshot";
+        if (shouldLog) {
+          SessionFileLogger.logUnderstudyActionEvent({
+            actionType: `v3CUA.${action.type}`,
+            target: this.computePointerTarget(action),
+            args: [action],
+          });
+        }
+        try {
+          await this.executeAction(action);
+        } finally {
+          if (shouldLog) SessionFileLogger.logUnderstudyActionCompleted();
+        }
+
+        action.timestamp = Date.now();
+
+        await new Promise((r) => setTimeout(r, waitBetween));
+        try {
+          await this.captureAndSendScreenshot();
+        } catch (e) {
+          this.logger({
+            category: "agent",
+            message: `Warning: Failed to take screenshot after action: ${String(
+              (e as Error)?.message ?? e,
+            )}`,
+            level: 1,
+          });
+        }
+      } catch (error) {
+        const msg = (error as Error)?.message ?? String(error);
+        this.logger({
+          category: "agent",
+          message: `Error executing action ${action.type}: ${msg}`,
+          level: 0,
+        });
+        throw error;
+      }
+    });
+
+    void this.updateClientViewport();
+    void this.updateClientUrl();
+  }
+
+  setSafetyConfirmationHandler(handler?: SafetyConfirmationHandler): void {
+    if (
+      this.agentClient instanceof GoogleCUAClient ||
+      this.agentClient instanceof OpenAICUAClient
+    ) {
+      this.agentClient.setSafetyConfirmationHandler(handler);
+    }
+  }
+
+  async execute(
+    optionsOrInstruction: AgentExecuteOptions | string,
+  ): Promise<AgentResult> {
+    const options =
+      typeof optionsOrInstruction === "string"
+        ? { instruction: optionsOrInstruction }
+        : optionsOrInstruction;
+
+    this.setSafetyConfirmationHandler(options.callbacks?.onSafetyConfirmation);
+
+    this.highlightCursor = options.highlightCursor !== false;
+
+    // Redirect if blank
+    const page = await this.v3.context.awaitActivePage();
+    const currentUrl = page.url();
+    if (!currentUrl || currentUrl === "about:blank") {
+      this.logger({
+        category: "agent",
+        message: `Page URL is empty. Navigating to https://www.google.com ...`,
+        level: 1,
+      });
+      await page.goto("https://www.google.com", { waitUntil: "load" });
+    }
+
+    if (this.highlightCursor) {
+      try {
+        await this.injectCursor();
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        this.logger({
+          category: "agent",
+          message: `Warning: Failed to inject cursor: ${errorMessage}. Continuing with execution.`,
+          level: 1,
+        });
+        // Continue execution even if cursor injection fails
+      }
+    }
+
+    const start = Date.now();
+    const result = await this.agent.execute({ options, logger: this.logger });
+    const inferenceTimeMs = Date.now() - start;
+    if (result.usage) {
+      this.v3.updateMetrics(
+        V3FunctionName.AGENT,
+        result.usage.input_tokens,
+        result.usage.output_tokens,
+        result.usage.reasoning_tokens ?? 0,
+        result.usage.cached_input_tokens ?? 0,
+        inferenceTimeMs,
+      );
+    }
+    return result;
+  }
+
+  private async executeAction(
+    action: AgentAction,
+  ): Promise<ActionExecutionResult> {
+    const page = await this.v3.context.awaitActivePage();
+    const recording = this.v3.isAgentReplayActive();
+    switch (action.type) {
+      case "click": {
+        const { x, y, button = "left", clickCount } = action;
+        if (recording) {
+          const xpath = await page.click(x as number, y as number, {
+            button: (button as "left" | "right" | "middle") ?? "left",
+            clickCount: (clickCount as number) ?? 1,
+            returnXpath: true,
+          });
+          const normalized = ensureXPath(xpath);
+          if (normalized) {
+            const stagehandAction: Action = {
+              selector: normalized,
+              description: this.describePointerAction("click", x, y),
+              method: "click",
+              arguments: [],
+            };
+            this.recordCuaActStep(
+              action,
+              [stagehandAction],
+              stagehandAction.description,
+            );
+          }
+        } else {
+          await page.click(x as number, y as number, {
+            button: (button as "left" | "right" | "middle") ?? "left",
+            clickCount: (clickCount as number) ?? 1,
+          });
+        }
+        return { success: true };
+      }
+      case "double_click":
+      case "doubleClick": {
+        const { x, y } = action;
+        if (recording) {
+          const xpath = await page.click(x as number, y as number, {
+            button: "left",
+            clickCount: 2,
+            returnXpath: true,
+          });
+          const normalized = ensureXPath(xpath);
+          if (normalized) {
+            const stagehandAction: Action = {
+              selector: normalized,
+              description: this.describePointerAction("double click", x, y),
+              method: "doubleClick",
+              arguments: [],
+            };
+            this.recordCuaActStep(
+              action,
+              [stagehandAction],
+              stagehandAction.description,
+            );
+          }
+        } else {
+          await page.click(x as number, y as number, {
+            button: "left",
+            clickCount: 2,
+          });
+        }
+        return { success: true };
+      }
+      case "tripleClick": {
+        const { x, y } = action;
+        if (recording) {
+          const xpath = await page.click(x as number, y as number, {
+            button: "left",
+            clickCount: 3,
+            returnXpath: true,
+          });
+          const normalized = ensureXPath(xpath);
+          if (normalized) {
+            const stagehandAction: Action = {
+              selector: normalized,
+              description: this.describePointerAction("triple click", x, y),
+              method: "tripleClick",
+              arguments: [],
+            };
+            this.recordCuaActStep(
+              action,
+              [stagehandAction],
+              stagehandAction.description,
+            );
+          }
+        } else {
+          await page.click(x as number, y as number, {
+            clickCount: 3,
+          });
+        }
+        return { success: true };
+      }
+      case "type": {
+        const { text } = action;
+        await page.type(String(text ?? ""));
+        if (recording) {
+          const xpath = await computeActiveElementXpath(page);
+          const normalized = ensureXPath(xpath);
+          if (normalized) {
+            const stagehandAction: Action = {
+              selector: normalized,
+              description: this.describeTypeAction(String(text ?? "")),
+              method: "type",
+              arguments: [String(text ?? "")],
+            };
+            this.recordCuaActStep(
+              action,
+              [stagehandAction],
+              stagehandAction.description,
+            );
+          }
+        }
+        return { success: true };
+      }
+      case "keypress": {
+        const { keys } = action;
+        const keyList = Array.isArray(keys) ? keys : [keys];
+        const stagehandActions: Action[] = [];
+        for (const rawKey of keyList) {
+          const mapped = mapKeyToPlaywright(String(rawKey ?? ""));
+          await page.keyPress(mapped);
+          if (recording) {
+            stagehandActions.push({
+              selector: "xpath=/html",
+              description: `press ${mapped}`,
+              method: "press",
+              arguments: [mapped],
+            });
+          }
+        }
+        if (recording && stagehandActions.length > 0) {
+          this.recordCuaActStep(
+            action,
+            stagehandActions,
+            stagehandActions
+              .map((a) => a.description)
+              .filter(Boolean)
+              .join(", ") || "keypress",
+          );
+        }
+        return { success: true };
+      }
+      case "scroll": {
+        const { x, y, scroll_x = 0, scroll_y = 0 } = action;
+        await page.scroll(
+          (x as number) ?? 0,
+          (y as number) ?? 0,
+          (scroll_x as number) ?? 0,
+          (scroll_y as number) ?? 0,
+        );
+        this.v3.recordAgentReplayStep({
+          type: "scroll",
+          deltaX: Number(scroll_x ?? 0),
+          deltaY: Number(scroll_y ?? 0),
+          anchor:
+            typeof x === "number" && typeof y === "number"
+              ? { x: Math.round(x), y: Math.round(y) }
+              : undefined,
+        });
+        return { success: true };
+      }
+      case "drag": {
+        const { path } = action;
+        if (Array.isArray(path) && path.length >= 2) {
+          const start = path[0];
+          const end = path[path.length - 1];
+          if (recording) {
+            const xps = await page.dragAndDrop(start.x, start.y, end.x, end.y, {
+              steps: Math.min(20, Math.max(5, path.length)),
+              delay: 10,
+              returnXpath: true,
+            });
+            const [fromXpath, toXpath] = (xps as [string, string]) || ["", ""];
+            const from = ensureXPath(fromXpath);
+            const to = ensureXPath(toXpath);
+            if (from && to) {
+              const stagehandAction: Action = {
+                selector: from,
+                description: this.describeDragAction(),
+                method: "dragAndDrop",
+                arguments: [to],
+              };
+              this.recordCuaActStep(
+                action,
+                [stagehandAction],
+                stagehandAction.description,
+              );
+            }
+          } else {
+            await page.dragAndDrop(start.x, start.y, end.x, end.y, {
+              steps: Math.min(20, Math.max(5, path.length)),
+              delay: 10,
+            });
+          }
+        }
+        return { success: true };
+      }
+      case "move": {
+        const { x, y } = action;
+        if (typeof x === "number" && typeof y === "number") {
+          if (recording) {
+            const xpath = await page.hover(x, y, { returnXpath: true });
+            const normalized = ensureXPath(xpath);
+            if (normalized) {
+              const stagehandAction: Action = {
+                selector: normalized,
+                description: this.describePointerAction("hover", x, y),
+                method: "hover",
+                arguments: [],
+              };
+              this.recordCuaActStep(
+                action,
+                [stagehandAction],
+                stagehandAction.description,
+              );
+            }
+          } else {
+            await page.hover(x, y);
+          }
+        }
+        return { success: true };
+      }
+      case "wait": {
+        const time = action?.timeMs ?? 1000;
+        await new Promise((r) => setTimeout(r, time));
+        if (time > 0 && recording) {
+          this.v3.recordAgentReplayStep({ type: "wait", timeMs: Number(time) });
+        }
+        return { success: true };
+      }
+      case "screenshot": {
+        // No-op - screenshot is captured by captureAndSendScreenshot() after all actions
+        return { success: true };
+      }
+      case "goto": {
+        const { url } = action;
+        await page.goto(String(url ?? ""), { waitUntil: "load" });
+        if (recording) {
+          this.v3.recordAgentReplayStep({
+            type: "goto",
+            url: String(url ?? ""),
+          });
+        }
+        return { success: true };
+      }
+      case "back": {
+        await page.goBack();
+        if (recording) {
+          this.v3.recordAgentReplayStep({
+            type: "back",
+          });
+        }
+        return { success: true };
+      }
+      case "forward": {
+        await page.goForward();
+        if (recording) {
+          this.v3.recordAgentReplayStep({
+            type: "forward",
+          });
+        }
+        return { success: true };
+      }
+      case "open_web_browser": {
+        // Browser is already open, this is a no-op
+        return { success: true };
+      }
+      case "custom_tool": {
+        // Custom tools are handled by the agent client directly
+        return { success: true };
+      }
+      default:
+        this.logger({
+          category: "agent",
+          message: `Unknown action type: ${String(action.type)}`,
+          level: 1,
+        });
+        return {
+          success: false,
+          error: `Unknown action ${String(action.type)}`,
+        };
+    }
+  }
+
+  // helper to make pointer target human-readable for logging
+  private computePointerTarget(action: AgentAction): string | undefined {
+    return typeof action.x === "number" && typeof action.y === "number"
+      ? `(${action.x}, ${action.y})`
+      : typeof action.selector === "string"
+        ? action.selector
+        : typeof action.input === "string"
+          ? action.input
+          : typeof action.description === "string"
+            ? action.description
+            : undefined;
+  }
+
+  private describePointerAction(kind: string, x: unknown, y: unknown): string {
+    const nx = Number(x);
+    const ny = Number(y);
+    if (Number.isFinite(nx) && Number.isFinite(ny)) {
+      return `${kind} at (${Math.round(nx)}, ${Math.round(ny)})`;
+    }
+    return kind;
+  }
+
+  private describeTypeAction(text: string): string {
+    const snippet = text.length > 30 ? `${text.slice(0, 27)}...` : text;
+    return `type "${snippet}"`;
+  }
+
+  private describeDragAction(): string {
+    return "drag and drop";
+  }
+
+  private buildInstructionFallback(
+    agentAction: AgentAction,
+    fallback: string,
+  ): string {
+    const raw =
+      (typeof agentAction.action === "string" && agentAction.action.trim()) ||
+      (typeof agentAction.reasoning === "string" &&
+        agentAction.reasoning.trim());
+    return raw && raw.length > 0 ? raw : fallback;
+  }
+
+  private recordCuaActStep(
+    agentAction: AgentAction,
+    stagehandActions: Action[],
+    fallback: string,
+  ): void {
+    if (!stagehandActions.length) return;
+    const instruction = this.buildInstructionFallback(agentAction, fallback);
+    const description = stagehandActions[0]?.description || instruction;
+    const actions = stagehandActions.map((act) => ({
+      ...act,
+      description: act.description || description,
+    }));
+    this.v3.recordAgentReplayStep({
+      type: "act",
+      instruction,
+      actions,
+      actionDescription: description,
+      message:
+        typeof agentAction.reasoning === "string" &&
+        agentAction.reasoning.trim().length > 0
+          ? agentAction.reasoning.trim()
+          : undefined,
+    });
+  }
+
+  private async updateClientViewport(): Promise<void> {
+    try {
+      // For Google CUA, use configured viewport for coordinate normalization
+      // advancedStealth uses fixed 1288x711, otherwise use configured viewport
+      if (this.agentClient instanceof GoogleCUAClient) {
+        const dims = this.v3.isAdvancedStealth
+          ? { width: 1288, height: 711 }
+          : this.v3.configuredViewport;
+        this.agentClient.setViewport(dims.width, dims.height);
+      } else {
+        // For other clients, use actual window dimensions
+        const page = await this.v3.context.awaitActivePage();
+        const { w, h } = await page.mainFrame().evaluate<{
+          w: number;
+          h: number;
+        }>("({ w: window.innerWidth, h: window.innerHeight })");
+        if (w && h) this.agentClient.setViewport(w, h);
+      }
+    } catch {
+      //
+    }
+  }
+
+  private async updateClientUrl(): Promise<void> {
+    try {
+      const page = await this.v3.context.awaitActivePage();
+      const url = page.url();
+      this.agentClient.setCurrentUrl(url);
+    } catch {
+      //
+    }
+  }
+
+  async captureAndSendScreenshot(): Promise<unknown> {
+    this.logger({
+      category: "agent",
+      message: "Capturing screenshot",
+      level: 1,
+    });
+    try {
+      const page = await this.v3.context.awaitActivePage();
+      const screenshotBuffer = await page.screenshot({ fullPage: false });
+
+      // Emit screenshot event via the bus
+      this.v3.bus.emit("agent_screenshot_taken_event", screenshotBuffer);
+      const currentUrl = page.url();
+      return await this.agentClient.captureScreenshot({
+        base64Image: screenshotBuffer.toString("base64"),
+        currentUrl,
+      });
+    } catch (e) {
+      this.logger({
+        category: "agent",
+        message: `Error capturing screenshot: ${String((e as Error)?.message ?? e)}`,
+        level: 0,
+      });
+      return null;
+    }
+  }
+
+  private async injectCursor(): Promise<void> {
+    try {
+      const page = await this.v3.context.awaitActivePage();
+      await page.enableCursorOverlay();
+    } catch {
+      // Best-effort only
+    }
+  }
+}
diff --git a/packages/core/lib/v3/index.ts b/packages/core/lib/v3/index.ts
new file mode 100644
index 000000000..fdd42bdd5
--- /dev/null
+++ b/packages/core/lib/v3/index.ts
@@ -0,0 +1,119 @@
+import * as PublicApi from "./types/public/index.js";
+import { V3 } from "./v3.js";
+import { AnnotatedScreenshotText, LLMClient } from "./llm/LLMClient.js";
+import {
+  AgentProvider,
+  modelToAgentProviderMap,
+} from "./agent/AgentProvider.js";
+import {
+  validateZodSchema,
+  isRunningInBun,
+  toGeminiSchema,
+  getZodType,
+  transformSchema,
+  injectUrls,
+  providerEnvVarMap,
+  loadApiKeyFromEnv,
+  trimTrailingTextNode,
+  jsonSchemaToZod,
+} from "../utils.js";
+import { isZod4Schema, isZod3Schema, toJsonSchema } from "./zodCompat.js";
+import { connectToMCPServer } from "./mcp/connection.js";
+import { V3Evaluator } from "../v3Evaluator.js";
+import { tool } from "ai";
+import { getAISDKLanguageModel } from "./llm/LLMProvider.js";
+import { __internalCreateInMemoryAgentCacheHandle } from "./cache/serverAgentCache.js";
+import { maybeRunShutdownSupervisorFromArgv } from "./shutdown/supervisor.js";
+
+export { V3 } from "./v3.js";
+export { V3 as Stagehand } from "./v3.js";
+
+export * from "./types/public/index.js";
+export { AnnotatedScreenshotText, LLMClient } from "./llm/LLMClient.js";
+
+export {
+  AgentProvider,
+  modelToAgentProviderMap,
+} from "./agent/AgentProvider.js";
+export type {
+  AgentTools,
+  AgentToolTypesMap,
+  AgentUITools,
+  AgentToolCall,
+  AgentToolResult,
+} from "./agent/tools/index.js";
+
+export {
+  validateZodSchema,
+  isRunningInBun,
+  toGeminiSchema,
+  getZodType,
+  transformSchema,
+  injectUrls,
+  providerEnvVarMap,
+  loadApiKeyFromEnv,
+  trimTrailingTextNode,
+  jsonSchemaToZod,
+} from "../utils.js";
+export { isZod4Schema, isZod3Schema, toJsonSchema } from "./zodCompat.js";
+
+export { connectToMCPServer } from "./mcp/connection.js";
+export { V3Evaluator } from "../v3Evaluator.js";
+export { tool } from "ai";
+export { getAISDKLanguageModel } from "./llm/LLMProvider.js";
+export { __internalCreateInMemoryAgentCacheHandle } from "./cache/serverAgentCache.js";
+export { maybeRunShutdownSupervisorFromArgv as __internalMaybeRunShutdownSupervisorFromArgv } from "./shutdown/supervisor.js";
+export type { ServerAgentCacheHandle } from "./cache/serverAgentCache.js";
+
+export type {
+  ChatMessage,
+  ChatMessageContent,
+  ChatMessageImageContent,
+  ChatMessageTextContent,
+  ChatCompletionOptions,
+  LLMResponse,
+  CreateChatCompletionOptions,
+  LLMUsage,
+  LLMParsedResponse,
+} from "./llm/LLMClient.js";
+
+export type {
+  StagehandZodSchema,
+  StagehandZodObject,
+  InferStagehandSchema,
+  JsonSchemaDocument,
+} from "./zodCompat.js";
+
+export type { JsonSchema, JsonSchemaProperty } from "../utils.js";
+
+const StagehandDefault = {
+  ...PublicApi,
+  V3,
+  Stagehand: V3,
+  AnnotatedScreenshotText,
+  LLMClient,
+  AgentProvider,
+  modelToAgentProviderMap,
+  validateZodSchema,
+  isRunningInBun,
+  toGeminiSchema,
+  getZodType,
+  transformSchema,
+  injectUrls,
+  providerEnvVarMap,
+  loadApiKeyFromEnv,
+  trimTrailingTextNode,
+  jsonSchemaToZod,
+  isZod4Schema,
+  isZod3Schema,
+  toJsonSchema,
+  connectToMCPServer,
+  V3Evaluator,
+  tool,
+  getAISDKLanguageModel,
+  __internalCreateInMemoryAgentCacheHandle,
+  __internalMaybeRunShutdownSupervisorFromArgv:
+    maybeRunShutdownSupervisorFromArgv,
+};
+
+export default StagehandDefault;
diff --git a/packages/core/lib/v3/launch/browserbase.ts b/packages/core/lib/v3/launch/browserbase.ts
new file mode 100644
index 000000000..b4ecf1060
--- /dev/null
+++ b/packages/core/lib/v3/launch/browserbase.ts
@@ -0,0 +1,80 @@
+import Browserbase from "@browserbasehq/sdk";
+import {
+  BrowserbaseSessionNotFoundError,
+  StagehandInitError,
+} from "../types/public/sdkErrors.js";
+import type { BrowserbaseSessionCreateParams } from "../types/public/api.js";
+import { getEnvTimeoutMs, withTimeout } from "../timeoutConfig.js";
+
+export async function createBrowserbaseSession(
+  apiKey: string,
+  projectId?: string,
+  params?: BrowserbaseSessionCreateParams,
+  resumeSessionId?: string,
+): Promise<{ ws: string; sessionId: string; bb: Browserbase }> {
+  const bb = new Browserbase({ apiKey });
+  const sessionCreateTimeoutMs = getEnvTimeoutMs(
+    "BROWSERBASE_SESSION_CREATE_MAX_MS",
+  );
+
+  // Resume an existing session if provided
+  if (resumeSessionId) {
+    const existing = (await withTimeout(
+      bb.sessions.retrieve(resumeSessionId),
+      sessionCreateTimeoutMs,
+      "Browserbase session retrieve",
+    )) as unknown as {
+      id: string;
+      connectUrl?: string;
+      status?: string;
+    };
+    if (!existing?.id) {
+      throw new BrowserbaseSessionNotFoundError();
+    }
+
+    const ws = existing.connectUrl;
+    if (!ws) {
+      throw new StagehandInitError(
+        `Browserbase session resume missing connectUrl for ${resumeSessionId}`,
+      );
+    }
+    return { ws, sessionId: resumeSessionId, bb };
+  }
+
+  // Create a new session with optional overrides and a default viewport
+  const {
+    projectId: overrideProjectId,
+    browserSettings,
+    userMetadata,
+    ...rest
+  } = params ?? {};
+
+  // satisfies check ensures our BrowserbaseSessionCreateParamsSchema stays in sync with SDK
+  const resolvedProjectId = overrideProjectId ?? projectId;
+  const createPayload = {
+    ...(resolvedProjectId ? { projectId: resolvedProjectId } : {}),
+    ...rest,
+    browserSettings: {
+      ...(browserSettings ?? {}),
+      viewport: browserSettings?.viewport ?? { width: 1288, height: 711 },
+    },
+    userMetadata: {
+      ...(userMetadata ?? {}),
+      stagehand: "true",
+    },
+  } satisfies Browserbase.Sessions.SessionCreateParams;
+
+  const created = (await withTimeout(
+    bb.sessions.create(createPayload),
+    sessionCreateTimeoutMs,
+    "Browserbase session create",
+  )) as unknown as { id: string; connectUrl: string };
+
+  if (!created?.connectUrl || !created?.id) {
+    throw new StagehandInitError(
+      "Browserbase session creation returned an unexpected shape.",
+    );
+  }
+
+  return { ws: created.connectUrl, sessionId: created.id, bb };
+}
diff --git a/packages/core/lib/v3/launch/local.ts b/packages/core/lib/v3/launch/local.ts
new file mode 100644
index 000000000..92df6d467
--- /dev/null
+++ b/packages/core/lib/v3/launch/local.ts
@@ -0,0 +1,130 @@
+import { launch, LaunchedChrome } from "chrome-launcher";
+import WebSocket from "ws";
+import { ConnectionTimeoutError } from "../types/public/sdkErrors.js";
+
+interface LaunchLocalOptions {
+  chromePath?: string;
+  chromeFlags?: string[];
+  headless?: boolean;
+  userDataDir?: string;
+  port?: number;
+  connectTimeoutMs?: number;
+  handleSIGINT?: boolean;
+}
+
+export async function launchLocalChrome(
+  opts: LaunchLocalOptions,
+): Promise<{ ws: string; chrome: LaunchedChrome }> {
+  const connectTimeoutMs = opts.connectTimeoutMs ?? 15_000;
+  const deadlineMs = Date.now() + connectTimeoutMs;
+  const connectionPollInterval = 250;
+  const maxConnectionRetries = Math.max(
+    1,
+    Math.ceil(connectTimeoutMs / connectionPollInterval),
+  );
+  const headless = opts.headless ?? false;
+  const chromeFlags = [
+    headless ? "--headless=new" : undefined,
+    "--remote-allow-origins=*",
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--disable-dev-shm-usage",
+    "--site-per-process",
+    ...(opts.chromeFlags ?? []),
+  ].filter((f): f is string => typeof f === "string");
+
+  const chrome = await launch({
+    chromePath: opts.chromePath,
+    chromeFlags,
+    port: opts.port,
+    userDataDir: opts.userDataDir,
+    handleSIGINT: opts.handleSIGINT,
+    connectionPollInterval,
+    maxConnectionRetries,
+  });
+
+  const ws = await waitForWebSocketDebuggerUrl(chrome.port, deadlineMs);
+  await waitForWebSocketReady(ws, deadlineMs);
+
+  return { ws, chrome };
+}
+
+async function waitForWebSocketDebuggerUrl(
+  port: number,
+  deadlineMs: number,
+): Promise<string> {
+  let lastErrMsg = "";
+
+  while (Date.now() < deadlineMs) {
+    try {
+      const resp = await fetch(`http://127.0.0.1:${port}/json/version`);
+      if (resp.ok) {
+        const json = (await resp.json()) as unknown;
+        const url = (json as { webSocketDebuggerUrl?: string })
+          .webSocketDebuggerUrl;
+        if (typeof url === "string") return url;
+      } else {
+        lastErrMsg = `${resp.status} ${resp.statusText}`;
+      }
+    } catch (err) {
+      lastErrMsg = err instanceof Error ? err.message : String(err);
+    }
+    await new Promise((r) => setTimeout(r, 250));
+  }
+
+  throw new ConnectionTimeoutError(
+    `Timed out waiting for /json/version on port ${port} ${
+      lastErrMsg ? ` (last error: ${lastErrMsg})` : ""
+    }`,
+  );
+}
+
+async function waitForWebSocketReady(
+  wsUrl: string,
+  deadlineMs: number,
+): Promise<void> {
+  let lastErrMsg = "";
+  while (Date.now() < deadlineMs) {
+    const remainingMs = Math.max(200, deadlineMs - Date.now());
+    try {
+      await probeWebSocket(wsUrl, Math.min(2_000, remainingMs));
+      return;
+    } catch (error) {
+      lastErrMsg = error instanceof Error ? error.message : String(error);
+      await new Promise((r) => setTimeout(r, 100));
+    }
+  }
+  throw new ConnectionTimeoutError(
+    `Timed out waiting for CDP websocket to accept connections at ${wsUrl}${
+      lastErrMsg ? ` (last error: ${lastErrMsg})` : ""
+    }`,
+  );
+}
+
+function probeWebSocket(wsUrl: string, timeoutMs: number): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(wsUrl);
+    let settled = false;
+    const finish = (error?: unknown) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        ws.terminate();
+      } catch {
+        // best-effort cleanup
+      }
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      finish(new Error(`websocket probe timeout after ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    ws.once("open", () => finish());
+    ws.once("error", (error) => finish(error));
+  });
+}
diff --git a/lib/llm/AnthropicClient.ts b/packages/core/lib/v3/llm/AnthropicClient.ts
similarity index 72%
rename from lib/llm/AnthropicClient.ts
rename to packages/core/lib/v3/llm/AnthropicClient.ts
index 27d8f4c7c..2ba202686 100644
--- a/lib/llm/AnthropicClient.ts
+++ b/packages/core/lib/v3/llm/AnthropicClient.ts
@@ -5,42 +5,36 @@ import {
   TextBlockParam,
   Tool,
 } from "@anthropic-ai/sdk/resources";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { LogLine } from "../../types/log";
-import { AnthropicJsonSchemaObject, AvailableModel } from "../../types/model";
-import { LLMCache } from "../cache/LLMCache";
+import { LogLine } from "../types/public/logs.js";
+import {
+  AnthropicJsonSchemaObject,
+  AvailableModel,
+} from "../types/public/model.js";
 import {
   CreateChatCompletionOptions,
   LLMClient,
   LLMResponse,
-} from "./LLMClient";
-import { CreateChatCompletionResponseError } from "@/types/stagehandErrors";
+} from "./LLMClient.js";
+import { CreateChatCompletionResponseError } from "../types/public/sdkErrors.js";
+import { toJsonSchema } from "../zodCompat.js";
 
 export class AnthropicClient extends LLMClient {
   public type = "anthropic" as const;
   private client: Anthropic;
-  private cache: LLMCache | undefined;
-  private enableCaching: boolean;
-  public clientOptions: ClientOptions;
+  declare public clientOptions: ClientOptions;
 
   constructor({
-    enableCaching = false,
-    cache,
     modelName,
     clientOptions,
     userProvidedInstructions,
   }: {
     logger: (message: LogLine) => void;
-    enableCaching?: boolean;
-    cache?: LLMCache;
     modelName: AvailableModel;
     clientOptions?: ClientOptions;
     userProvidedInstructions?: string;
   }) {
     super(modelName);
     this.client = new Anthropic(clientOptions);
-    this.cache = cache;
-    this.enableCaching = enableCaching;
     this.modelName = modelName;
     this.clientOptions = clientOptions;
     this.userProvidedInstructions = userProvidedInstructions;
@@ -66,62 +60,6 @@ export class AnthropicClient extends LLMClient {
       },
     });
 
-    // Try to get cached response
-    const cacheOptions = {
-      model: this.modelName,
-      messages: options.messages,
-      temperature: options.temperature,
-      image: options.image,
-      response_model: options.response_model,
-      tools: options.tools,
-      retries: retries,
-    };
-
-    if (this.enableCaching) {
-      const cachedResponse = await this.cache.get<T>(
-        cacheOptions,
-        options.requestId,
-      );
-      if (cachedResponse) {
-        logger({
-          category: "llm_cache",
-          message: "LLM cache hit - returning cached response",
-          level: 1,
-          auxiliary: {
-            cachedResponse: {
-              value: JSON.stringify(cachedResponse),
-              type: "object",
-            },
-            requestId: {
-              value: options.requestId,
-              type: "string",
-            },
-            cacheOptions: {
-              value: JSON.stringify(cacheOptions),
-              type: "object",
-            },
-          },
-        });
-        return cachedResponse as T;
-      } else {
-        logger({
-          category: "llm_cache",
-          message: "LLM cache miss - no cached response found",
-          level: 1,
-          auxiliary: {
-            cacheOptions: {
-              value: JSON.stringify(cacheOptions),
-              type: "object",
-            },
-            requestId: {
-              value: options.requestId,
-              type: "string",
-            },
-          },
-        });
-      }
-    }
-
     const systemMessage = options.messages.find((msg) => {
       if (msg.role === "system") {
         if (typeof msg.content === "string") {
@@ -207,7 +145,7 @@ export class AnthropicClient extends LLMClient {
 
     let toolDefinition: Tool | undefined;
     if (options.response_model) {
-      const jsonSchema = zodToJsonSchema(options.response_model.schema);
+      const jsonSchema = toJsonSchema(options.response_model.schema);
       const { properties: schemaProperties, required: schemaRequired } =
         extractSchemaProperties(jsonSchema);
 
@@ -229,7 +167,7 @@ export class AnthropicClient extends LLMClient {
 
     const response = await this.client.messages.create({
       model: this.modelName,
-      max_tokens: options.maxTokens || 8192,
+      max_tokens: options.maxOutputTokens || 8192,
       messages: formattedMessages,
       tools: anthropicTools,
       system: systemMessage
@@ -316,10 +254,6 @@ export class AnthropicClient extends LLMClient {
           usage: usageData,
         } as unknown as T;
 
-        if (this.enableCaching) {
-          this.cache.set(cacheOptions, finalParsedResponse, options.requestId);
-        }
-
         return finalParsedResponse;
       } else {
         if (!retries || retries < 5) {
@@ -346,29 +280,6 @@ export class AnthropicClient extends LLMClient {
       }
     }
 
-    if (this.enableCaching) {
-      this.cache.set(cacheOptions, transformedResponse, options.requestId);
-      logger({
-        category: "anthropic",
-        message: "cached response",
-        level: 1,
-        auxiliary: {
-          requestId: {
-            value: options.requestId,
-            type: "string",
-          },
-          transformedResponse: {
-            value: JSON.stringify(transformedResponse),
-            type: "object",
-          },
-          cacheOptions: {
-            value: JSON.stringify(cacheOptions),
-            type: "object",
-          },
-        },
-      });
-    }
-
     // if the function was called with a response model, it would have returned earlier
     // so we can safely cast here to T, which defaults to AnthropicTransformedResponse
     return transformedResponse as T;
diff --git a/lib/llm/CerebrasClient.ts b/packages/core/lib/v3/llm/CerebrasClient.ts
similarity index 59%
rename from lib/llm/CerebrasClient.ts
rename to packages/core/lib/v3/llm/CerebrasClient.ts
index 4d5a0daca..f715882ae 100644
--- a/lib/llm/CerebrasClient.ts
+++ b/packages/core/lib/v3/llm/CerebrasClient.ts
@@ -1,35 +1,28 @@
 import OpenAI from "openai";
 import type { ClientOptions } from "openai";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { LogLine } from "../../types/log";
-import { AvailableModel } from "../../types/model";
-import { LLMCache } from "../cache/LLMCache";
+import { LogLine } from "../types/public/logs.js";
+import { AvailableModel } from "../types/public/model.js";
 import {
   ChatMessage,
   CreateChatCompletionOptions,
   LLMClient,
   LLMResponse,
-} from "./LLMClient";
-import { CreateChatCompletionResponseError } from "@/types/stagehandErrors";
+} from "./LLMClient.js";
+import { CreateChatCompletionResponseError } from "../types/public/sdkErrors.js";
+import { toJsonSchema } from "../zodCompat.js";
 
 export class CerebrasClient extends LLMClient {
   public type = "cerebras" as const;
   private client: OpenAI;
-  private cache: LLMCache | undefined;
-  private enableCaching: boolean;
-  public clientOptions: ClientOptions;
+  declare public clientOptions: ClientOptions;
   public hasVision = false;
 
   constructor({
-    enableCaching = false,
-    cache,
     modelName,
     clientOptions,
     userProvidedInstructions,
   }: {
     logger: (message: LogLine) => void;
-    enableCaching?: boolean;
-    cache?: LLMCache;
     modelName: AvailableModel;
     clientOptions?: ClientOptions;
     userProvidedInstructions?: string;
@@ -43,8 +36,6 @@ export class CerebrasClient extends LLMClient {
       ...clientOptions,
     });
 
-    this.cache = cache;
-    this.enableCaching = enableCaching;
     this.modelName = modelName;
     this.clientOptions = clientOptions;
   }
@@ -69,45 +60,6 @@ export class CerebrasClient extends LLMClient {
       },
     });
 
-    // Try to get cached response
-    const cacheOptions = {
-      model: this.modelName.split("cerebras-")[1],
-      messages: options.messages,
-      temperature: options.temperature,
-      response_model: options.response_model,
-      tools: options.tools,
-      retries: retries,
-    };
-
-    if (this.enableCaching) {
-      const cachedResponse = await this.cache.get<T>(
-        cacheOptions,
-        options.requestId,
-      );
-      if (cachedResponse) {
-        logger({
-          category: "llm_cache",
-          message: "LLM cache hit - returning cached response",
-          level: 1,
-          auxiliary: {
-            cachedResponse: {
-              value: JSON.stringify(cachedResponse),
-              type: "object",
-            },
-            requestId: {
-              value: options.requestId,
-              type: "string",
-            },
-            cacheOptions: {
-              value: JSON.stringify(cacheOptions),
-              type: "object",
-            },
-          },
-        });
-        return cachedResponse as T;
-      }
-    }
-
     // Format messages for Cerebras API (using OpenAI format)
     const formattedMessages = options.messages.map((msg: ChatMessage) => {
       const baseMessage = {
@@ -148,7 +100,7 @@ export class CerebrasClient extends LLMClient {
 
     // Add response model as a tool if provided
     if (options.response_model) {
-      const jsonSchema = zodToJsonSchema(options.response_model.schema) as {
+      const jsonSchema = toJsonSchema(options.response_model.schema) as {
         properties?: Record<string, unknown>;
         required?: string[];
       };
@@ -183,13 +135,15 @@ export class CerebrasClient extends LLMClient {
             ? [
                 {
                   role: "system" as const,
-                  content: `IMPORTANT: Your response must be valid JSON that matches this schema: ${JSON.stringify(options.response_model.schema)}`,
+                  content: `IMPORTANT: Your response must be valid JSON that matches this schema: ${JSON.stringify(
+                    options.response_model.schema,
+                  )}`,
                 },
               ]
             : []),
         ],
         temperature: options.temperature || 0.7,
-        max_tokens: options.maxTokens,
+        max_tokens: options.maxOutputTokens,
         tools: tools,
         tool_choice: options.tool_choice || "auto",
       });
@@ -234,77 +188,74 @@ export class CerebrasClient extends LLMClient {
         },
       });
 
-      if (options.response_model) {
-        // First try standard function calling format
-        const toolCall = response.choices[0]?.message?.tool_calls?.[0];
-        if (toolCall?.function?.arguments) {
-          try {
-            const result = JSON.parse(toolCall.function.arguments);
-            if (this.enableCaching) {
-              this.cache.set(cacheOptions, result, options.requestId);
-            }
-            return result as T;
-          } catch (e) {
-            // If JSON parse fails, the model might be returning a different format
-            logger({
-              category: "cerebras",
-              message: "failed to parse tool call arguments as JSON, retrying",
-              level: 0,
-              auxiliary: {
-                error: {
-                  value: e.message,
-                  type: "string",
-                },
-              },
-            });
-          }
-        }
+      // If we have no response model, just return the entire LLMResponse
+      if (!options.response_model) {
+        return response as T;
+      }
 
-        // If we have content but no tool calls, try to parse the content as JSON
-        const content = response.choices[0]?.message?.content;
-        if (content) {
-          try {
-            // Try to extract JSON from the content
-            const jsonMatch = content.match(/\{[\s\S]*\}/);
-            if (jsonMatch) {
-              const result = JSON.parse(jsonMatch[0]);
-              if (this.enableCaching) {
-                this.cache.set(cacheOptions, result, options.requestId);
-              }
-              return result as T;
-            }
-          } catch (e) {
-            logger({
-              category: "cerebras",
-              message: "failed to parse content as JSON",
-              level: 0,
-              auxiliary: {
-                error: {
-                  value: e.message,
-                  type: "string",
-                },
+      // If we have a response model, parse JSON from tool calls or content
+      const toolCall = response.choices[0]?.message?.tool_calls?.[0];
+      if (toolCall?.function?.arguments) {
+        try {
+          const result = JSON.parse(toolCall.function.arguments);
+          const finalResponse = {
+            data: result,
+            usage: response.usage,
+          };
+          return finalResponse as T;
+        } catch (e) {
+          logger({
+            category: "cerebras",
+            message: "failed to parse tool call arguments as JSON, retrying",
+            level: 0,
+            auxiliary: {
+              error: {
+                value: e.message,
+                type: "string",
               },
-            });
-          }
+            },
+          });
         }
+      }
 
-        // If we still haven't found valid JSON and have retries left, try again
-        if (!retries || retries < 5) {
-          return this.createChatCompletion({
-            options,
-            logger,
-            retries: (retries ?? 0) + 1,
+      // If we have content but no tool calls, try to parse the content as JSON
+      const content = response.choices[0]?.message?.content;
+      if (content) {
+        try {
+          const jsonMatch = content.match(/\{[\s\S]*\}/);
+          if (jsonMatch) {
+            const result = JSON.parse(jsonMatch[0]);
+            const finalResponse = {
+              data: result,
+              usage: response.usage,
+            };
+            return finalResponse as T;
+          }
+        } catch (e) {
+          logger({
+            category: "cerebras",
+            message: "failed to parse content as JSON",
+            level: 0,
+            auxiliary: {
+              error: {
+                value: e.message,
+                type: "string",
+              },
+            },
           });
         }
-
-        throw new CreateChatCompletionResponseError("Invalid response schema");
       }
 
-      if (this.enableCaching) {
-        this.cache.set(cacheOptions, response, options.requestId);
+      // If we still haven't found valid JSON and have retries left, try again
+      if (!retries || retries < 5) {
+        return this.createChatCompletion({
+          options,
+          logger,
+          retries: (retries ?? 0) + 1,
+        });
       }
 
-      return response as T;
+      throw new CreateChatCompletionResponseError("Invalid response schema");
     } catch (error) {
       logger({
         category: "cerebras",
diff --git a/lib/llm/GoogleClient.ts b/packages/core/lib/v3/llm/GoogleClient.ts
similarity index 79%
rename from lib/llm/GoogleClient.ts
rename to packages/core/lib/v3/llm/GoogleClient.ts
index 968ce9e22..90e0c0e8b 100644
--- a/lib/llm/GoogleClient.ts
+++ b/packages/core/lib/v3/llm/GoogleClient.ts
@@ -9,12 +9,14 @@ import {
   Schema,
   Type,
 } from "@google/genai";
-import zodToJsonSchema from "zod-to-json-schema";
 
-import { LogLine } from "../../types/log";
-import { AvailableModel, ClientOptions } from "../../types/model";
-import { LLMCache } from "../cache/LLMCache";
-import { validateZodSchema } from "../utils";
+import { LogLine } from "../types/public/logs.js";
+import { AvailableModel, ClientOptions } from "../types/public/model.js";
+import {
+  validateZodSchema,
+  toGeminiSchema,
+  loadApiKeyFromEnv,
+} from "../../utils.js";
 import {
   ChatCompletionOptions,
   ChatMessage,
@@ -22,11 +24,11 @@ import {
   LLMClient,
   LLMResponse,
   AnnotatedScreenshotText,
-} from "./LLMClient";
+} from "./LLMClient.js";
 import {
   CreateChatCompletionResponseError,
   StagehandError,
-} from "@/types/stagehandErrors";
+} from "../types/public/sdkErrors.js";
 
 // Mapping from generic roles to Gemini roles
 const roleMap: { [key in ChatMessage["role"]]: string } = {
@@ -58,39 +60,26 @@ const safetySettings = [
 export class GoogleClient extends LLMClient {
   public type = "google" as const;
   private client: GoogleGenAI;
-  private cache: LLMCache | undefined;
-  private enableCaching: boolean;
-  public clientOptions: ClientOptions;
-  public hasVision: boolean;
+  declare public clientOptions: ClientOptions;
+  declare public hasVision: boolean;
   private logger: (message: LogLine) => void;
 
   constructor({
     logger, // Added logger based on other clients
-    enableCaching = false,
-    cache,
     modelName,
     clientOptions,
   }: {
     logger: (message: LogLine) => void; // Added logger type
-    enableCaching?: boolean;
-    cache?: LLMCache;
     modelName: AvailableModel;
     clientOptions?: ClientOptions; // Expecting { apiKey: string } here
   }) {
     super(modelName);
     if (!clientOptions?.apiKey) {
-      // Ensure logger is passed if throwing an error
-      logger({
-        category: "google",
-        message: "Google API key is missing in clientOptions",
-        level: 0, // Error level
-      });
-      throw new StagehandError("Google API key is required.");
+      // Try to get the API key from the environment variable GOOGLE_API_KEY
+      clientOptions.apiKey = loadApiKeyFromEnv("google_legacy", logger);
     }
     this.clientOptions = clientOptions;
     this.client = new GoogleGenAI({ apiKey: clientOptions.apiKey });
-    this.cache = cache;
-    this.enableCaching = enableCaching;
     this.modelName = modelName;
     this.logger = logger;
     // Determine vision capability based on model name (adjust as needed)
@@ -237,78 +226,22 @@ export class GoogleClient extends LLMClient {
       tools,
       temperature,
       top_p,
-      maxTokens,
+      maxOutputTokens,
     } = options;
 
-    const cacheKeyOptions = {
-      model: this.modelName,
-      messages: options.messages,
-      temperature: temperature,
-      top_p: top_p,
-      // frequency_penalty and presence_penalty are not directly supported in Gemini API
-      image: image
-        ? { description: image.description, bufferLength: image.buffer.length }
-        : undefined, // Use buffer length for caching key stability
-      response_model: response_model
-        ? {
-            name: response_model.name,
-            schema: JSON.stringify(zodToJsonSchema(response_model.schema)),
-          }
-        : undefined,
-      tools: tools,
-      maxTokens: maxTokens,
-    };
-
-    if (this.enableCaching) {
-      const cachedResponse = await this.cache.get<T>(
-        cacheKeyOptions,
-        requestId,
-      );
-      if (cachedResponse) {
-        logger({
-          category: "llm_cache",
-          message: "LLM cache hit - returning cached response",
-          level: 1,
-          auxiliary: { requestId: { value: requestId, type: "string" } },
-        });
-        return cachedResponse;
-      } else {
-        logger({
-          category: "llm_cache",
-          message: "LLM cache miss - proceeding with API call",
-          level: 1,
-          auxiliary: { requestId: { value: requestId, type: "string" } },
-        });
-      }
-    }
-
     const formattedMessages = this.formatMessages(options.messages, image);
     const formattedTools = this.formatTools(tools);
 
     const generationConfig = {
-      maxOutputTokens: maxTokens,
+      maxOutputTokens: maxOutputTokens,
       temperature: temperature,
       topP: top_p,
       responseMimeType: response_model ? "application/json" : undefined,
+      responseSchema: response_model
+        ? toGeminiSchema(response_model.schema)
+        : undefined,
     };
 
-    // Handle JSON mode instructions
-    if (response_model) {
-      // Prepend instructions for JSON output if needed (similar to o1 handling)
-      const schemaString = JSON.stringify(
-        zodToJsonSchema(response_model.schema),
-      );
-      formattedMessages.push({
-        role: "user",
-        parts: [
-          {
-            text: `Please respond ONLY with a valid JSON object that strictly adheres to the following JSON schema. Do not include any other text, explanations, or markdown formatting like \`\`\`json ... \`\`\`. Just the JSON object.\n\nSchema:\n${schemaString}`,
-          },
-        ],
-      });
-      formattedMessages.push({ role: "model", parts: [{ text: "{" }] }); // Prime the model
-    }
-
     logger({
       category: "google",
       message: "creating chat completion",
@@ -454,7 +387,9 @@ export class GoogleClient extends LLMClient {
           );
         }
 
-        if (!validateZodSchema(response_model.schema, parsedData)) {
+        try {
+          validateZodSchema(response_model.schema, parsedData);
+        } catch (err) {
           logger({
             category: "google",
             message: "Response failed Zod schema validation",
@@ -467,9 +402,7 @@ export class GoogleClient extends LLMClient {
               retries: retries - 1,
             });
           }
-          throw new CreateChatCompletionResponseError(
-            "Invalid response schema",
-          );
+          throw err;
         }
 
         // If schema validation passes, structure the response for extraction use case
@@ -478,17 +411,9 @@ export class GoogleClient extends LLMClient {
           usage: llmResponse.usage,
         };
 
-        if (this.enableCaching) {
-          await this.cache.set(cacheKeyOptions, extractionResult, requestId);
-        }
         return extractionResult as T;
       }
 
-      // Cache the standard response if not using response_model
-      if (this.enableCaching) {
-        await this.cache.set(cacheKeyOptions, llmResponse, requestId);
-      }
-
       return llmResponse as T;
     } catch (error) {
       logger({
diff --git a/lib/llm/GroqClient.ts b/packages/core/lib/v3/llm/GroqClient.ts
similarity index 59%
rename from lib/llm/GroqClient.ts
rename to packages/core/lib/v3/llm/GroqClient.ts
index fe91d06ba..04aba8b3f 100644
--- a/lib/llm/GroqClient.ts
+++ b/packages/core/lib/v3/llm/GroqClient.ts
@@ -1,35 +1,28 @@
 import type { ClientOptions } from "openai";
 import OpenAI from "openai";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { LogLine } from "../../types/log";
-import { AvailableModel } from "../../types/model";
-import { LLMCache } from "../cache/LLMCache";
+import { LogLine } from "../types/public/logs.js";
+import { AvailableModel } from "../types/public/model.js";
 import {
   ChatMessage,
   CreateChatCompletionOptions,
   LLMClient,
   LLMResponse,
-} from "./LLMClient";
-import { CreateChatCompletionResponseError } from "@/types/stagehandErrors";
+} from "./LLMClient.js";
+import { CreateChatCompletionResponseError } from "../types/public/sdkErrors.js";
+import { toJsonSchema } from "../zodCompat.js";
 
 export class GroqClient extends LLMClient {
   public type = "groq" as const;
   private client: OpenAI;
-  private cache: LLMCache | undefined;
-  private enableCaching: boolean;
-  public clientOptions: ClientOptions;
+  declare public clientOptions: ClientOptions;
   public hasVision = false;
 
   constructor({
-    enableCaching = false,
-    cache,
     modelName,
     clientOptions,
     userProvidedInstructions,
   }: {
     logger: (message: LogLine) => void;
-    enableCaching?: boolean;
-    cache?: LLMCache;
     modelName: AvailableModel;
     clientOptions?: ClientOptions;
     userProvidedInstructions?: string;
@@ -43,8 +36,6 @@ export class GroqClient extends LLMClient {
       ...clientOptions,
     });
 
-    this.cache = cache;
-    this.enableCaching = enableCaching;
     this.modelName = modelName;
     this.clientOptions = clientOptions;
   }
@@ -69,45 +60,6 @@ export class GroqClient extends LLMClient {
       },
     });
 
-    // Try to get cached response
-    const cacheOptions = {
-      model: this.modelName.split("groq-")[1],
-      messages: options.messages,
-      temperature: options.temperature,
-      response_model: options.response_model,
-      tools: options.tools,
-      retries: retries,
-    };
-
-    if (this.enableCaching) {
-      const cachedResponse = await this.cache.get<T>(
-        cacheOptions,
-        options.requestId,
-      );
-      if (cachedResponse) {
-        logger({
-          category: "llm_cache",
-          message: "LLM cache hit - returning cached response",
-          level: 1,
-          auxiliary: {
-            cachedResponse: {
-              value: JSON.stringify(cachedResponse),
-              type: "object",
-            },
-            requestId: {
-              value: options.requestId,
-              type: "string",
-            },
-            cacheOptions: {
-              value: JSON.stringify(cacheOptions),
-              type: "object",
-            },
-          },
-        });
-        return cachedResponse as T;
-      }
-    }
-
     // Format messages for Groq API (using OpenAI format)
     const formattedMessages = options.messages.map((msg: ChatMessage) => {
       const baseMessage = {
@@ -148,7 +100,7 @@ export class GroqClient extends LLMClient {
 
     // Add response model as a tool if provided
     if (options.response_model) {
-      const jsonSchema = zodToJsonSchema(options.response_model.schema) as {
+      const jsonSchema = toJsonSchema(options.response_model.schema) as {
         properties?: Record<string, unknown>;
         required?: string[];
       };
@@ -183,13 +135,15 @@ export class GroqClient extends LLMClient {
             ? [
                 {
                   role: "system" as const,
-                  content: `IMPORTANT: Your response must be valid JSON that matches this schema: ${JSON.stringify(options.response_model.schema)}`,
+                  content: `IMPORTANT: Your response must be valid JSON that matches this schema: ${JSON.stringify(
+                    options.response_model.schema,
+                  )}`,
                 },
               ]
             : []),
         ],
         temperature: options.temperature || 0.7,
-        max_tokens: options.maxTokens,
+        max_tokens: options.maxOutputTokens,
         tools: tools,
         tool_choice: options.tool_choice || "auto",
       });
@@ -234,77 +188,75 @@ export class GroqClient extends LLMClient {
         },
       });
 
-      if (options.response_model) {
-        // First try standard function calling format
-        const toolCall = response.choices[0]?.message?.tool_calls?.[0];
-        if (toolCall?.function?.arguments) {
-          try {
-            const result = JSON.parse(toolCall.function.arguments);
-            if (this.enableCaching) {
-              this.cache.set(cacheOptions, result, options.requestId);
-            }
-            return result as T;
-          } catch (e) {
-            // If JSON parse fails, the model might be returning a different format
-            logger({
-              category: "groq",
-              message: "failed to parse tool call arguments as JSON, retrying",
-              level: 0,
-              auxiliary: {
-                error: {
-                  value: e.message,
-                  type: "string",
-                },
-              },
-            });
-          }
-        }
+      // If there's no response model, return the entire response object
+      if (!options.response_model) {
+        return response as T;
+      }
 
-        // If we have content but no tool calls, try to parse the content as JSON
-        const content = response.choices[0]?.message?.content;
-        if (content) {
-          try {
-            // Try to extract JSON from the content
-            const jsonMatch = content.match(/\{[\s\S]*\}/);
-            if (jsonMatch) {
-              const result = JSON.parse(jsonMatch[0]);
-              if (this.enableCaching) {
-                this.cache.set(cacheOptions, result, options.requestId);
-              }
-              return result as T;
-            }
-          } catch (e) {
-            logger({
-              category: "groq",
-              message: "failed to parse content as JSON",
-              level: 0,
-              auxiliary: {
-                error: {
-                  value: e.message,
-                  type: "string",
-                },
+      // Otherwise, try parsing the JSON from the tool call or content
+      const toolCall = response.choices[0]?.message?.tool_calls?.[0];
+      if (toolCall?.function?.arguments) {
+        try {
+          const result = JSON.parse(toolCall.function.arguments);
+          const finalResponse = {
+            data: result,
+            usage: response.usage,
+          };
+          return finalResponse as T;
+        } catch (e) {
+          logger({
+            category: "groq",
+            message: "failed to parse tool call arguments as JSON, retrying",
+            level: 0,
+            auxiliary: {
+              error: {
+                value: e.message,
+                type: "string",
               },
-            });
-          }
+            },
+          });
         }
+      }
 
-        // If we still haven't found valid JSON and have retries left, try again
-        if (!retries || retries < 5) {
-          return this.createChatCompletion({
-            options,
-            logger,
-            retries: (retries ?? 0) + 1,
+      // If we have content but no tool calls, try to parse the content as JSON
+      const content = response.choices[0]?.message?.content;
+      if (content) {
+        try {
+          // Try to extract JSON from the content
+          const jsonMatch = content.match(/\{[\s\S]*\}/);
+          if (jsonMatch) {
+            const result = JSON.parse(jsonMatch[0]);
+            const finalResponse = {
+              data: result,
+              usage: response.usage,
+            };
+            return finalResponse as T;
+          }
+        } catch (e) {
+          logger({
+            category: "groq",
+            message: "failed to parse content as JSON",
+            level: 0,
+            auxiliary: {
+              error: {
+                value: e.message,
+                type: "string",
+              },
+            },
           });
         }
-
-        throw new CreateChatCompletionResponseError("Invalid response schema");
       }
 
-      if (this.enableCaching) {
-        this.cache.set(cacheOptions, response, options.requestId);
+      // If we still haven't found valid JSON and have retries left, try again
+      if (!retries || retries < 5) {
+        return this.createChatCompletion({
+          options,
+          logger,
+          retries: (retries ?? 0) + 1,
+        });
       }
 
-      return response as T;
+      throw new CreateChatCompletionResponseError("Invalid response schema");
     } catch (error) {
       logger({
         category: "groq",
diff --git a/lib/llm/LLMClient.ts b/packages/core/lib/v3/llm/LLMClient.ts
similarity index 54%
rename from lib/llm/LLMClient.ts
rename to packages/core/lib/v3/llm/LLMClient.ts
index 71690c387..3a8c99949 100644
--- a/lib/llm/LLMClient.ts
+++ b/packages/core/lib/v3/llm/LLMClient.ts
@@ -1,7 +1,19 @@
-import { ZodType } from "zod";
-import { LLMTool } from "../../types/llm";
-import { LogLine } from "../../types/log";
-import { AvailableModel, ClientOptions } from "../../types/model";
+import { LLMTool } from "../types/public/model.js";
+import {
+  embed,
+  embedMany,
+  experimental_generateImage,
+  experimental_generateSpeech,
+  experimental_transcribe,
+  generateObject,
+  generateText,
+  streamObject,
+  streamText,
+} from "ai";
+import type { LanguageModelV2 } from "@ai-sdk/provider";
+import { LogLine } from "../types/public/logs.js";
+import { AvailableModel, ClientOptions } from "../types/public/model.js";
+import type { StagehandZodSchema } from "../zodCompat.js";
 
 export interface ChatMessage {
   role: "system" | "user" | "assistant";
@@ -43,12 +55,12 @@ export interface ChatCompletionOptions {
   };
   response_model?: {
     name: string;
-    schema: ZodType;
+    schema: StagehandZodSchema;
   };
   tools?: LLMTool[];
   tool_choice?: "auto" | "none" | "required";
-  maxTokens?: number;
-  requestId: string;
+  maxOutputTokens?: number;
+  requestId?: string;
 }
 
 export type LLMResponse = {
@@ -85,6 +97,23 @@ export interface CreateChatCompletionOptions {
   retries?: number;
 }
 
+/** Simple usage shape if your LLM returns usage tokens. */
+export interface LLMUsage {
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens: number;
+  reasoning_tokens?: number;
+  cached_input_tokens?: number;
+}
+
+/**
+ * For calls that use a schema: the LLMClient may return { data: T; usage?: LLMUsage }
+ */
+export interface LLMParsedResponse<T> {
+  data: T;
+  usage?: LLMUsage;
+}
+
 export abstract class LLMClient {
   public type: "openai" | "anthropic" | "cerebras" | "groq" | (string & {});
   public modelName: AvailableModel | (string & {});
@@ -97,9 +126,29 @@ export abstract class LLMClient {
     this.userProvidedInstructions = userProvidedInstructions;
   }
 
-  abstract createChatCompletion<
-    T = LLMResponse & {
-      usage?: LLMResponse["usage"];
+  // Overload 1: When response_model is provided, returns LLMParsedResponse<T>
+  abstract createChatCompletion<T>(
+    options: CreateChatCompletionOptions & {
+      options: {
+        response_model: { name: string; schema: StagehandZodSchema };
+      };
     },
-  >(options: CreateChatCompletionOptions): Promise<T>;
+  ): Promise<LLMParsedResponse<T>>;
+
+  // Overload 2: When response_model is not provided, returns T (defaults to LLMResponse)
+  abstract createChatCompletion<T = LLMResponse>(
+    options: CreateChatCompletionOptions,
+  ): Promise<T>;
+
+  public generateObject = generateObject;
+  public generateText = generateText;
+  public streamText = streamText;
+  public streamObject = streamObject;
+  public generateImage = experimental_generateImage;
+  public embed = embed;
+  public embedMany = embedMany;
+  public transcribe = experimental_transcribe;
+  public generateSpeech = experimental_generateSpeech;
+
+  getLanguageModel?(): LanguageModelV2;
 }
diff --git a/packages/core/lib/v3/llm/LLMProvider.ts b/packages/core/lib/v3/llm/LLMProvider.ts
new file mode 100644
index 000000000..11986d3cb
--- /dev/null
+++ b/packages/core/lib/v3/llm/LLMProvider.ts
@@ -0,0 +1,234 @@
+import {
+  ExperimentalNotConfiguredError,
+  UnsupportedAISDKModelProviderError,
+  UnsupportedModelError,
+  UnsupportedModelProviderError,
+} from "../types/public/sdkErrors.js";
+import { LogLine } from "../types/public/logs.js";
+import {
+  AvailableModel,
+  ClientOptions,
+  ModelProvider,
+} from "../types/public/model.js";
+import { AISdkClient } from "./aisdk.js";
+import { AnthropicClient } from "./AnthropicClient.js";
+import { CerebrasClient } from "./CerebrasClient.js";
+import { GoogleClient } from "./GoogleClient.js";
+import { GroqClient } from "./GroqClient.js";
+import { LLMClient } from "./LLMClient.js";
+import { OpenAIClient } from "./OpenAIClient.js";
+import { openai, createOpenAI } from "@ai-sdk/openai";
+import { bedrock, createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
+import { vertex, createVertex } from "@ai-sdk/google-vertex";
+import { anthropic, createAnthropic } from "@ai-sdk/anthropic";
+import { google, createGoogleGenerativeAI } from "@ai-sdk/google";
+import { xai, createXai } from "@ai-sdk/xai";
+import { azure, createAzure } from "@ai-sdk/azure";
+import { groq, createGroq } from "@ai-sdk/groq";
+import { cerebras, createCerebras } from "@ai-sdk/cerebras";
+import { togetherai, createTogetherAI } from "@ai-sdk/togetherai";
+import { mistral, createMistral } from "@ai-sdk/mistral";
+import { deepseek, createDeepSeek } from "@ai-sdk/deepseek";
+import { perplexity, createPerplexity } from "@ai-sdk/perplexity";
+import { ollama, createOllama } from "ollama-ai-provider-v2";
+import { gateway, createGateway } from "ai";
+import { AISDKProvider, AISDKCustomProvider } from "../types/public/model.js";
+
+const AISDKProviders: Record<string, AISDKProvider> = {
+  openai,
+  bedrock,
+  anthropic,
+  google,
+  xai,
+  azure,
+  groq,
+  cerebras,
+  togetherai,
+  mistral,
+  deepseek,
+  perplexity,
+  ollama,
+  vertex,
+  gateway,
+};
+const AISDKProvidersWithAPIKey: Record<string, AISDKCustomProvider> = {
+  openai: createOpenAI,
+  bedrock: createAmazonBedrock,
+  anthropic: createAnthropic,
+  google: createGoogleGenerativeAI,
+  vertex: createVertex,
+  xai: createXai,
+  azure: createAzure,
+  groq: createGroq,
+  cerebras: createCerebras,
+  togetherai: createTogetherAI,
+  mistral: createMistral,
+  deepseek: createDeepSeek,
+  perplexity: createPerplexity,
+  ollama: createOllama,
+  gateway: createGateway,
+};
+
+const modelToProviderMap: { [key in AvailableModel]: ModelProvider } = {
+  "gpt-4.1": "openai",
+  "gpt-4.1-mini": "openai",
+  "gpt-4.1-nano": "openai",
+  "o4-mini": "openai",
+  //prettier-ignore
+  "o3": "openai",
+  "o3-mini": "openai",
+  //prettier-ignore
+  "o1": "openai",
+  "o1-mini": "openai",
+  "gpt-4o": "openai",
+  "gpt-4o-mini": "openai",
+  "gpt-4o-2024-08-06": "openai",
+  "gpt-4.5-preview": "openai",
+  "o1-preview": "openai",
+  "cerebras-llama-3.3-70b": "cerebras",
+  "cerebras-llama-3.1-8b": "cerebras",
+  "groq-llama-3.3-70b-versatile": "groq",
+  "groq-llama-3.3-70b-specdec": "groq",
+  "moonshotai/kimi-k2-instruct": "groq",
+  "gemini-1.5-flash": "google",
+  "gemini-1.5-pro": "google",
+  "gemini-1.5-flash-8b": "google",
+  "gemini-2.0-flash-lite": "google",
+  "gemini-2.0-flash": "google",
+  "gemini-2.5-flash-preview-04-17": "google",
+  "gemini-2.5-pro-preview-03-25": "google",
+};
+
+export function getAISDKLanguageModel(
+  subProvider: string,
+  subModelName: string,
+  clientOptions?: ClientOptions,
+) {
+  const hasValidOptions =
+    clientOptions &&
+    Object.values(clientOptions).some((v) => v !== undefined && v !== null);
+
+  if (hasValidOptions) {
+    const creator = AISDKProvidersWithAPIKey[subProvider];
+    if (!creator) {
+      throw new UnsupportedAISDKModelProviderError(
+        subProvider,
+        Object.keys(AISDKProvidersWithAPIKey),
+      );
+    }
+    const provider = creator(clientOptions);
+    // Get the specific model from the provider
+    return provider(subModelName);
+  } else {
+    const provider = AISDKProviders[subProvider];
+    if (!provider) {
+      throw new UnsupportedAISDKModelProviderError(
+        subProvider,
+        Object.keys(AISDKProviders),
+      );
+    }
+    return provider(subModelName);
+  }
+}
+
+export class LLMProvider {
+  private logger: (message: LogLine) => void;
+
+  constructor(logger: (message: LogLine) => void) {
+    this.logger = logger;
+  }
+
+  getClient(
+    modelName: AvailableModel,
+    clientOptions?: ClientOptions,
+    options?: { experimental?: boolean; disableAPI?: boolean },
+  ): LLMClient {
+    if (modelName.includes("/")) {
+      const firstSlashIndex = modelName.indexOf("/");
+      const subProvider = modelName.substring(0, firstSlashIndex);
+      const subModelName = modelName.substring(firstSlashIndex + 1);
+      if (
+        subProvider === "vertex" &&
+        !options?.disableAPI &&
+        !options?.experimental
+      ) {
+        throw new ExperimentalNotConfiguredError("Vertex provider");
+      }
+
+      const languageModel = getAISDKLanguageModel(
+        subProvider,
+        subModelName,
+        clientOptions,
+      );
+
+      return new AISdkClient({
+        model: languageModel,
+        logger: this.logger,
+      });
+    }
+
+    // Model name doesn't include "/" - this format is deprecated
+    const provider = modelToProviderMap[modelName];
+    if (!provider) {
+      throw new UnsupportedModelError(Object.keys(modelToProviderMap));
+    }
+
+    this.logger({
+      category: "llm",
+      message: `Deprecation warning: Model format "${modelName}" is deprecated. Please use the provider/model format (e.g., "openai/gpt-5" or "anthropic/claude-sonnet-4").`,
+      level: 0,
+    });
+
+    const availableModel = modelName as AvailableModel;
+    switch (provider) {
+      case "openai":
+        return new OpenAIClient({
+          logger: this.logger,
+          modelName: availableModel,
+          clientOptions,
+        });
+      case "anthropic":
+        return new AnthropicClient({
+          logger: this.logger,
+          modelName: availableModel,
+          clientOptions,
+        });
+      case "cerebras":
+        return new CerebrasClient({
+          logger: this.logger,
+          modelName: availableModel,
+          clientOptions,
+        });
+      case "groq":
+        return new GroqClient({
+          logger: this.logger,
+          modelName: availableModel,
+          clientOptions,
+        });
+      case "google":
+        return new GoogleClient({
+          logger: this.logger,
+          modelName: availableModel,
+          clientOptions,
+        });
+      default:
+        // This default case handles unknown providers that exist in modelToProviderMap
+        // but aren't implemented in the switch. This is an internal consistency issue.
+        throw new UnsupportedModelProviderError([
+          ...new Set(Object.values(modelToProviderMap)),
+        ]);
+    }
+  }
+
+  static getModelProvider(modelName: AvailableModel): ModelProvider {
+    if (modelName.includes("/")) {
+      const firstSlashIndex = modelName.indexOf("/");
+      const subProvider = modelName.substring(0, firstSlashIndex);
+      if (AISDKProviders[subProvider]) {
+        return "aisdk";
+      }
+    }
+    const provider = modelToProviderMap[modelName];
+    return provider;
+  }
+}
diff --git a/lib/llm/OpenAIClient.ts b/packages/core/lib/v3/llm/OpenAIClient.ts
similarity index 76%
rename from lib/llm/OpenAIClient.ts
rename to packages/core/lib/v3/llm/OpenAIClient.ts
index 5086fa41d..d3391d8ca 100644
--- a/lib/llm/OpenAIClient.ts
+++ b/packages/core/lib/v3/llm/OpenAIClient.ts
@@ -1,5 +1,4 @@
 import OpenAI, { ClientOptions } from "openai";
-import { zodResponseFormat } from "openai/helpers/zod";
 import {
   ChatCompletionAssistantMessageParam,
   ChatCompletionContentPartImage,
@@ -9,47 +8,39 @@ import {
   ChatCompletionSystemMessageParam,
   ChatCompletionUserMessageParam,
 } from "openai/resources/chat";
-import zodToJsonSchema from "zod-to-json-schema";
-import { LogLine } from "../../types/log";
-import { AvailableModel } from "../../types/model";
-import { LLMCache } from "../cache/LLMCache";
-import { validateZodSchema } from "../utils";
+import { LogLine } from "../types/public/logs.js";
+import { AvailableModel } from "../types/public/model.js";
+import { validateZodSchema } from "../../utils.js";
 import {
   ChatCompletionOptions,
   ChatMessage,
   CreateChatCompletionOptions,
   LLMClient,
   LLMResponse,
-} from "./LLMClient";
+} from "./LLMClient.js";
 import {
   CreateChatCompletionResponseError,
   StagehandError,
-} from "@/types/stagehandErrors";
+  ZodSchemaValidationError,
+} from "../types/public/sdkErrors.js";
+import { toJsonSchema } from "../zodCompat.js";
 
 export class OpenAIClient extends LLMClient {
   public type = "openai" as const;
   private client: OpenAI;
-  private cache: LLMCache | undefined;
-  private enableCaching: boolean;
-  public clientOptions: ClientOptions;
+  declare public clientOptions: ClientOptions;
 
   constructor({
-    enableCaching = false,
-    cache,
     modelName,
     clientOptions,
   }: {
     logger: (message: LogLine) => void;
-    enableCaching?: boolean;
-    cache?: LLMCache;
     modelName: AvailableModel;
     clientOptions?: ClientOptions;
   }) {
     super(modelName);
     this.clientOptions = clientOptions;
     this.client = new OpenAI(clientOptions);
-    this.cache = cache;
-    this.enableCaching = enableCaching;
     this.modelName = modelName;
   }
 
@@ -95,8 +86,8 @@ export class OpenAIClient extends LLMClient {
 
       if (options.tools) {
         // Remove unsupported options
-        let { tools } = options;
-        ({ tools, ...options } = options);
+        const { tools, ...rest } = options;
+        options = rest;
         isToolsOverridedForO1 = true;
         options.messages.push({
           role: "user",
@@ -120,7 +111,7 @@ export class OpenAIClient extends LLMClient {
       throw new StagehandError("Temperature is not supported for o1 models");
     }
 
-    const { image, requestId, ...optionsWithoutImageAndRequestId } = options;
+    const { requestId, ...optionsWithoutImageAndRequestId } = options;
 
     logger({
       category: "openai",
@@ -141,54 +132,6 @@ export class OpenAIClient extends LLMClient {
       },
     });
 
-    const cacheOptions = {
-      model: this.modelName,
-      messages: options.messages,
-      temperature: options.temperature,
-      top_p: options.top_p,
-      frequency_penalty: options.frequency_penalty,
-      presence_penalty: options.presence_penalty,
-      image: image,
-      response_model: options.response_model,
-    };
-
-    if (this.enableCaching) {
-      const cachedResponse = await this.cache.get<T>(
-        cacheOptions,
-        options.requestId,
-      );
-      if (cachedResponse) {
-        logger({
-          category: "llm_cache",
-          message: "LLM cache hit - returning cached response",
-          level: 1,
-          auxiliary: {
-            requestId: {
-              value: options.requestId,
-              type: "string",
-            },
-            cachedResponse: {
-              value: JSON.stringify(cachedResponse),
-              type: "object",
-            },
-          },
-        });
-        return cachedResponse;
-      } else {
-        logger({
-          category: "llm_cache",
-          message: "LLM cache miss - no cached response found",
-          level: 1,
-          auxiliary: {
-            requestId: {
-              value: options.requestId,
-              type: "string",
-            },
-          },
-        });
-      }
-    }
-
     if (options.image) {
       const screenshotMessage: ChatMessage = {
         role: "user",
@@ -208,13 +151,15 @@ export class OpenAIClient extends LLMClient {
       options.messages.push(screenshotMessage);
     }
 
-    let responseFormat = undefined;
+    let responseFormat:
+      | ChatCompletionCreateParamsNonStreaming["response_format"]
+      | undefined;
     if (options.response_model) {
       // For O1 models, we need to add the schema as a user message.
       if (this.modelName.startsWith("o1") || this.modelName.startsWith("o3")) {
         try {
           const parsedSchema = JSON.stringify(
-            zodToJsonSchema(options.response_model.schema),
+            toJsonSchema(options.response_model.schema),
           );
           options.messages.push({
             role: "user",
@@ -241,10 +186,13 @@ export class OpenAIClient extends LLMClient {
           throw error;
         }
       } else {
-        responseFormat = zodResponseFormat(
-          options.response_model.schema,
-          options.response_model.name,
-        );
+        responseFormat = {
+          type: "json_schema",
+          json_schema: {
+            name: options.response_model.name,
+            schema: toJsonSchema(options.response_model.schema),
+          },
+        };
       }
     }
 
@@ -411,7 +359,14 @@ export class OpenAIClient extends LLMClient {
       const extractedData = response.choices[0].message.content;
       const parsedData = JSON.parse(extractedData);
 
-      if (!validateZodSchema(options.response_model.schema, parsedData)) {
+      try {
+        validateZodSchema(options.response_model.schema, parsedData);
+      } catch (e) {
+        logger({
+          category: "openai",
+          message: "Response failed Zod schema validation",
+          level: 0,
+        });
         if (retries > 0) {
           // as-casting to account for o1 models not supporting all options
           return this.createChatCompletion({
@@ -421,17 +376,22 @@ export class OpenAIClient extends LLMClient {
           });
         }
 
-        throw new CreateChatCompletionResponseError("Invalid response schema");
-      }
-
-      if (this.enableCaching) {
-        this.cache.set(
-          cacheOptions,
-          {
-            ...parsedData,
-          },
-          options.requestId,
-        );
+        if (e instanceof ZodSchemaValidationError) {
+          logger({
+            category: "openai",
+            message: `Error during OpenAI chat completion: ${e.message}`,
+            level: 0,
+            auxiliary: {
+              errorDetails: {
+                value: `Message: ${e.message}${e.stack ? "\nStack: " + e.stack : ""}`,
+                type: "string",
+              },
+              requestId: { value: requestId, type: "string" },
+            },
+          });
+          throw new CreateChatCompletionResponseError(e.message);
+        }
+        throw e;
       }
 
       return {
@@ -440,29 +400,6 @@ export class OpenAIClient extends LLMClient {
       } as T;
     }
 
-    if (this.enableCaching) {
-      logger({
-        category: "llm_cache",
-        message: "caching response",
-        level: 1,
-        auxiliary: {
-          requestId: {
-            value: options.requestId,
-            type: "string",
-          },
-          cacheOptions: {
-            value: JSON.stringify(cacheOptions),
-            type: "object",
-          },
-          response: {
-            value: JSON.stringify(response),
-            type: "object",
-          },
-        },
-      });
-      this.cache.set(cacheOptions, response, options.requestId);
-    }
-
     // if the function was called with a response model, it would have returned earlier
     // so we can safely cast here to T, which defaults to ChatCompletion
     return response as T;
diff --git a/packages/core/lib/v3/llm/aisdk.ts b/packages/core/lib/v3/llm/aisdk.ts
new file mode 100644
index 000000000..6db3058fc
--- /dev/null
+++ b/packages/core/lib/v3/llm/aisdk.ts
@@ -0,0 +1,412 @@
+import {
+  CoreAssistantMessage,
+  ModelMessage,
+  CoreSystemMessage,
+  CoreUserMessage,
+  generateObject,
+  generateText,
+  ImagePart,
+  NoObjectGeneratedError,
+  TextPart,
+  ToolSet,
+  Tool,
+} from "ai";
+import type { LanguageModelV2 } from "@ai-sdk/provider";
+import { ChatCompletion } from "openai/resources";
+import { v7 as uuidv7 } from "uuid";
+import { LogLine } from "../types/public/logs.js";
+import { AvailableModel } from "../types/public/model.js";
+import { CreateChatCompletionOptions, LLMClient } from "./LLMClient.js";
+import { SessionFileLogger, formatLlmPromptPreview } from "../flowLogger.js";
+import { toJsonSchema } from "../zodCompat.js";
+
+export class AISdkClient extends LLMClient {
+  public type = "aisdk" as const;
+  private model: LanguageModelV2;
+  private logger?: (message: LogLine) => void;
+
+  constructor({
+    model,
+    logger,
+  }: {
+    model: LanguageModelV2;
+    logger?: (message: LogLine) => void;
+  }) {
+    super(model.modelId as AvailableModel);
+    this.model = model;
+    this.logger = logger;
+  }
+
+  public getLanguageModel(): LanguageModelV2 {
+    return this.model;
+  }
+
+  async createChatCompletion<T = ChatCompletion>({
+    options,
+  }: CreateChatCompletionOptions): Promise<T> {
+    this.logger?.({
+      category: "aisdk",
+      message: "creating chat completion",
+      level: 2,
+      auxiliary: {
+        options: {
+          value: JSON.stringify({
+            ...options,
+            image: undefined,
+            messages: options.messages.map((msg) => ({
+              ...msg,
+              content: Array.isArray(msg.content)
+                ? msg.content.map((c) =>
+                    "image_url" in c
+                      ? { ...c, image_url: { url: "[IMAGE_REDACTED]" } }
+                      : c,
+                  )
+                : msg.content,
+            })),
+          }),
+          type: "object",
+        },
+        modelName: {
+          value: this.model.modelId,
+          type: "string",
+        },
+      },
+    });
+
+    const formattedMessages: ModelMessage[] = options.messages.map(
+      (message) => {
+        if (Array.isArray(message.content)) {
+          if (message.role === "system") {
+            const systemMessage: CoreSystemMessage = {
+              role: "system",
+              content: message.content
+                .map((c) => ("text" in c ? c.text : ""))
+                .join("\n"),
+            };
+            return systemMessage;
+          }
+
+          const contentParts = message.content.map((content) => {
+            if ("image_url" in content) {
+              const imageContent: ImagePart = {
+                type: "image",
+                image: content.image_url.url,
+              };
+              return imageContent;
+            } else {
+              const textContent: TextPart = {
+                type: "text",
+                text: content.text,
+              };
+              return textContent;
+            }
+          });
+
+          if (message.role === "user") {
+            const userMessage: CoreUserMessage = {
+              role: "user",
+              content: contentParts,
+            };
+            return userMessage;
+          } else {
+            const textOnlyParts = contentParts.map((part) => ({
+              type: "text" as const,
+              text: part.type === "image" ? "[Image]" : part.text,
+            }));
+            const assistantMessage: CoreAssistantMessage = {
+              role: "assistant",
+              content: textOnlyParts,
+            };
+            return assistantMessage;
+          }
+        }
+
+        return {
+          role: message.role,
+          content: message.content,
+        };
+      },
+    );
+
+    let objectResponse: Awaited<ReturnType<typeof generateObject>>;
+    const isGPT5 = this.model.modelId.includes("gpt-5");
+    const isCodex = this.model.modelId.includes("codex");
+    const usesLowReasoningEffort =
+      (this.model.modelId.includes("gpt-5.1") ||
+        this.model.modelId.includes("gpt-5.2")) &&
+      !isCodex;
+    // Kimi models only support temperature=1
+    const isKimi = this.model.modelId.includes("kimi");
+    const temperature = isKimi ? 1 : options.temperature;
+
+    // Models that lack native structured-output support need a prompt-based
+    // JSON fallback instead of response_format: { type: "json_schema" }.
+    const PROMPT_JSON_FALLBACK_PATTERNS = ["deepseek", "kimi", "glm"];
+    const needsPromptJsonFallback = PROMPT_JSON_FALLBACK_PATTERNS.some((p) =>
+      this.model.modelId.includes(p),
+    );
+
+    if (options.response_model) {
+      // Log LLM request for generateObject (extract)
+      const llmRequestId = uuidv7();
+      const promptPreview = formatLlmPromptPreview(options.messages, {
+        hasSchema: true,
+      });
+      SessionFileLogger.logLlmRequest({
+        requestId: llmRequestId,
+        model: this.model.modelId,
+        operation: "generateObject",
+        prompt: promptPreview,
+      });
+
+      // For models that don't support native structured outputs, add a prompt instruction
+      if (needsPromptJsonFallback) {
+        const parsedSchema = JSON.stringify(
+          toJsonSchema(options.response_model.schema),
+        );
+
+        formattedMessages.push({
+          role: "user",
+          content: `Respond in this zod schema format:\n${parsedSchema}\n
+You must respond in JSON format. respond WITH JSON. Do not include any other text, formatting or markdown in your output. Do not include \`\`\` or \`\`\`json in your response. Only the JSON object itself.`,
+        });
+      }
+
+      try {
+        objectResponse = await generateObject({
+          model: this.model,
+          messages: formattedMessages,
+          schema: options.response_model.schema,
+          temperature,
+          providerOptions: isGPT5
+            ? {
+                openai: {
+                  textVerbosity: isCodex ? "medium" : "low", // codex models only support 'medium'
+                  reasoningEffort: isCodex
+                    ? "medium"
+                    : usesLowReasoningEffort
+                      ? "low"
+                      : "minimal",
+                },
+              }
+            : undefined,
+        });
+      } catch (err) {
+        // Log error response to maintain request/response pairing
+        SessionFileLogger.logLlmResponse({
+          requestId: llmRequestId,
+          model: this.model.modelId,
+          operation: "generateObject",
+          output: `[error: ${err instanceof Error ? err.message : "unknown"}]`,
+        });
+
+        if (NoObjectGeneratedError.isInstance(err)) {
+          this.logger?.({
+            category: "AISDK error",
+            message: err.message,
+            level: 0,
+            auxiliary: {
+              cause: {
+                value: JSON.stringify(err.cause ?? {}),
+                type: "object",
+              },
+              text: {
+                value: err.text ?? "",
+                type: "string",
+              },
+              response: {
+                value: JSON.stringify(err.response ?? {}),
+                type: "object",
+              },
+              usage: {
+                value: JSON.stringify(err.usage ?? {}),
+                type: "object",
+              },
+              finishReason: {
+                value: err.finishReason ?? "unknown",
+                type: "string",
+              },
+              requestId: {
+                value: options.requestId,
+                type: "string",
+              },
+            },
+          });
+
+          throw err;
+        }
+        throw err;
+      }
+
+      const result = {
+        data: objectResponse.object,
+        usage: {
+          prompt_tokens: objectResponse.usage.inputTokens ?? 0,
+          completion_tokens: objectResponse.usage.outputTokens ?? 0,
+          reasoning_tokens: objectResponse.usage.reasoningTokens ?? 0,
+          cached_input_tokens: objectResponse.usage.cachedInputTokens ?? 0,
+          total_tokens: objectResponse.usage.totalTokens ?? 0,
+        },
+      } as T;
+
+      // Log LLM response for generateObject
+      SessionFileLogger.logLlmResponse({
+        requestId: llmRequestId,
+        model: this.model.modelId,
+        operation: "generateObject",
+        output: JSON.stringify(objectResponse.object),
+        inputTokens: objectResponse.usage.inputTokens,
+        outputTokens: objectResponse.usage.outputTokens,
+      });
+
+      this.logger?.({
+        category: "aisdk",
+        message: "response",
+        level: 1,
+        auxiliary: {
+          response: {
+            value: JSON.stringify({
+              object: objectResponse.object,
+              usage: objectResponse.usage,
+              finishReason: objectResponse.finishReason,
+              // Omit request and response properties that might contain images
+            }),
+            type: "object",
+          },
+          requestId: {
+            value: options.requestId,
+            type: "string",
+          },
+        },
+      });
+
+      return result;
+    }
+
+    const tools: ToolSet = {};
+    if (options.tools && options.tools.length > 0) {
+      for (const tool of options.tools) {
+        tools[tool.name] = {
+          description: tool.description,
+          inputSchema: tool.parameters,
+        } as Tool;
+      }
+    }
+
+    // Log LLM request for generateText (act/observe)
+    const llmRequestId = uuidv7();
+    const toolCount = Object.keys(tools).length;
+    const promptPreview = formatLlmPromptPreview(options.messages, {
+      toolCount,
+    });
+    SessionFileLogger.logLlmRequest({
+      requestId: llmRequestId,
+      model: this.model.modelId,
+      operation: "generateText",
+      prompt: promptPreview,
+    });
+
+    let textResponse: Awaited<ReturnType<typeof generateText>>;
+    try {
+      textResponse = await generateText({
+        model: this.model,
+        messages: formattedMessages,
+        tools: Object.keys(tools).length > 0 ? tools : undefined,
+        toolChoice:
+          Object.keys(tools).length > 0
+            ? options.tool_choice === "required"
+              ? "required"
+              : options.tool_choice === "none"
+                ? "none"
+                : "auto"
+            : undefined,
+        temperature,
+      });
+    } catch (err) {
+      // Log error response to maintain request/response pairing
+      SessionFileLogger.logLlmResponse({
+        requestId: llmRequestId,
+        model: this.model.modelId,
+        operation: "generateText",
+        output: `[error: ${err instanceof Error ? err.message : "unknown"}]`,
+      });
+      throw err;
+    }
+
+    // Transform AI SDK response to match LLMResponse format expected by operator handler
+    const transformedToolCalls = (textResponse.toolCalls || []).map(
+      (toolCall) => ({
+        id:
+          toolCall.toolCallId ||
+          `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+        type: "function",
+        function: {
+          name: toolCall.toolName,
+          arguments: JSON.stringify(toolCall.input),
+        },
+      }),
+    );
+
+    const result = {
+      id: `chatcmpl_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      object: "chat.completion",
+      created: Math.floor(Date.now() / 1000),
+      model: this.model.modelId,
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: "assistant",
+            content: textResponse.text || null,
+            tool_calls: transformedToolCalls,
+          },
+          finish_reason: textResponse.finishReason || "stop",
+        },
+      ],
+      usage: {
+        prompt_tokens: textResponse.usage.inputTokens ?? 0,
+        completion_tokens: textResponse.usage.outputTokens ?? 0,
+        reasoning_tokens: textResponse.usage.reasoningTokens ?? 0,
+        cached_input_tokens: textResponse.usage.cachedInputTokens ?? 0,
+        total_tokens: textResponse.usage.totalTokens ?? 0,
+      },
+    } as T;
+
+    // Log LLM response for generateText
+    SessionFileLogger.logLlmResponse({
+      requestId: llmRequestId,
+      model: this.model.modelId,
+      operation: "generateText",
+      output:
+        textResponse.text ||
+        (transformedToolCalls.length > 0
+          ? `[${transformedToolCalls.length} tool calls]`
+          : ""),
+      inputTokens: textResponse.usage.inputTokens,
+      outputTokens: textResponse.usage.outputTokens,
+    });
+
+    this.logger?.({
+      category: "aisdk",
+      message: "response",
+      level: 2,
+      auxiliary: {
+        response: {
+          value: JSON.stringify({
+            text: textResponse.text,
+            usage: textResponse.usage,
+            finishReason: textResponse.finishReason,
+            // Omit request and response properties that might contain images
+          }),
+          type: "object",
+        },
+        requestId: {
+          value: options.requestId,
+          type: "string",
+        },
+      },
+    });
+
+    return result;
+  }
+}
diff --git a/packages/core/lib/v3/logger.ts b/packages/core/lib/v3/logger.ts
new file mode 100644
index 000000000..76aa5e094
--- /dev/null
+++ b/packages/core/lib/v3/logger.ts
@@ -0,0 +1,104 @@
+import type { LogLine } from "./types/public/logs.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+/**
+ * Stagehand V3 Logging
+ *
+ * Design goals:
+ * - Support concurrent V3 instances with independent logger configuration
+ * - Each V3 instance has its own StagehandLogger (handles usePino, verbose, externalLogger)
+ * - Provide AsyncLocalStorage-based routing for backward compatibility with handler code
+ * - Prevent cross-talk between concurrent instances
+ *
+ * How it works:
+ * - Each V3 instance creates a StagehandLogger in its constructor (per-instance config)
+ * - bindInstanceLogger()/unbindInstanceLogger(): registers logger callback per instance ID
+ * - withInstanceLogContext(): establishes AsyncLocalStorage context for an async operation
+ * - v3Logger(): routes logs using AsyncLocalStorage with console fallback
+ *
+ * ⚠️ CONTEXT LOSS SCENARIOS:
+ * 1. setTimeout/setInterval callbacks lose context (runs outside AsyncLocalStorage scope)
+ * 2. Event emitters (EventEmitter.on) lose context (callback invoked outside scope)
+ * 3. Fire-and-forget promises (void promise) lose context if they don't complete synchronously
+ * 4. Third-party library callbacks may lose context depending on implementation
+ *
+ * WORKAROUND for context loss:
+ * - Use explicit logger parameter instead of v3Logger()
+ * - Wrap callback in withInstanceLogContext() manually
+ * - Or let logs fall back to console (acceptable for edge cases)
+ */
+
+// Per-instance routing using AsyncLocalStorage
+const logContext = new AsyncLocalStorage<string>();
+const instanceLoggers = new Map<string, (line: LogLine) => void>();
+
+export function bindInstanceLogger(
+  instanceId: string,
+  logger: (line: LogLine) => void,
+): void {
+  instanceLoggers.set(instanceId, logger);
+}
+
+export function unbindInstanceLogger(instanceId: string): void {
+  instanceLoggers.delete(instanceId);
+}
+
+export function withInstanceLogContext<T>(instanceId: string, fn: () => T): T {
+  return logContext.run(instanceId, fn);
+}
+
+/**
+ * Routes logs to the appropriate instance logger based on AsyncLocalStorage context.
+ * Falls back to console output if no instance context is available.
+ */
+export function v3Logger(line: LogLine): void {
+  const id = logContext.getStore();
+  if (id) {
+    const fn = instanceLoggers.get(id);
+    if (fn) {
+      const enriched: LogLine = {
+        ...line,
+        auxiliary: {
+          ...(line.auxiliary || {}),
+        },
+      };
+      try {
+        fn(enriched);
+        return;
+      } catch {
+        // fallback to console below
+      }
+    }
+  }
+
+  // Fallback: log to console when no instance context
+  const ts = line.timestamp ?? new Date().toISOString();
+  const lvl = line.level ?? 1;
+  const levelStr = lvl === 0 ? "ERROR" : lvl === 2 ? "DEBUG" : "INFO";
+  let output = `[${ts}] ${levelStr}: ${line.message}`;
+
+  if (line.auxiliary) {
+    for (const [key, { value, type }] of Object.entries(line.auxiliary)) {
+      let formattedValue = value;
+      if (type === "object") {
+        try {
+          formattedValue = JSON.stringify(JSON.parse(value), null, 2)
+            .split("\n")
+            .map((line, i) => (i === 0 ? line : `    ${line}`))
+            .join("\n");
+        } catch {
+          formattedValue = value;
+        }
+      }
+      output += `\n    ${key}: ${formattedValue}`;
+    }
+  }
+
+  if (lvl === 0) {
+    console.error(output);
+  } else if (lvl === 2) {
+    (console.debug ?? console.log)(output);
+  } else {
+    console.log(output);
+  }
+}
diff --git a/packages/core/lib/v3/mcp/connection.ts b/packages/core/lib/v3/mcp/connection.ts
new file mode 100644
index 000000000..00cb982de
--- /dev/null
+++ b/packages/core/lib/v3/mcp/connection.ts
@@ -0,0 +1,78 @@
+import {
+  Client,
+  ClientOptions,
+} from "@modelcontextprotocol/sdk/client/index.js";
+import {
+  StreamableHTTPClientTransport,
+  type StreamableHTTPClientTransportOptions,
+} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { MCPConnectionError } from "../types/public/sdkErrors.js";
+
+export interface ConnectToMCPServerOptions {
+  serverUrl: string | URL;
+  clientOptions?: ClientOptions;
+  requestOptions?: StreamableHTTPClientTransportOptions;
+}
+
+export interface StdioServerConfig {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export const connectToMCPServer = async (
+  serverConfig: string | URL | StdioServerConfig | ConnectToMCPServerOptions,
+): Promise<Client> => {
+  try {
+    let transport;
+    let clientOptions: ClientOptions | undefined;
+    let requestOptions: StreamableHTTPClientTransportOptions | undefined;
+
+    // Check if it's a stdio config (has 'command' property)
+    if (typeof serverConfig === "object" && "command" in serverConfig) {
+      transport = new StdioClientTransport(serverConfig);
+    } else {
+      // Handle URL-based connection
+      let serverUrl: string | URL;
+
+      if (typeof serverConfig === "string" || serverConfig instanceof URL) {
+        serverUrl = serverConfig;
+      } else {
+        serverUrl = (serverConfig as ConnectToMCPServerOptions).serverUrl;
+        clientOptions = (serverConfig as ConnectToMCPServerOptions)
+          .clientOptions;
+        requestOptions = (serverConfig as ConnectToMCPServerOptions)
+          .requestOptions;
+      }
+
+      transport = new StreamableHTTPClientTransport(
+        new URL(serverUrl),
+        requestOptions,
+      );
+    }
+
+    const client = new Client({
+      name: "Stagehand",
+      version: "1.0.0",
+      ...clientOptions,
+    });
+
+    await client.connect(transport);
+
+    try {
+      await client.ping();
+    } catch (pingError) {
+      await client.close();
+      throw new MCPConnectionError(serverConfig.toString(), pingError);
+    }
+
+    return client;
+  } catch (error) {
+    // Handle any errors during transport/client creation or connection
+    if (error instanceof MCPConnectionError) {
+      throw error; // Re-throw our custom error
+    }
+    throw new MCPConnectionError(serverConfig.toString(), error);
+  }
+};
diff --git a/packages/core/lib/v3/mcp/utils.ts b/packages/core/lib/v3/mcp/utils.ts
new file mode 100644
index 000000000..c861327a4
--- /dev/null
+++ b/packages/core/lib/v3/mcp/utils.ts
@@ -0,0 +1,45 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { ToolSet } from "ai";
+import { JsonSchema, jsonSchemaToZod } from "../../utils.js";
+import { connectToMCPServer } from "./connection.js";
+
+export const resolveTools = async (
+  clients: (Client | string)[],
+  userTools: ToolSet,
+): Promise<ToolSet> => {
+  const tools: ToolSet = { ...userTools };
+
+  for (const client of clients) {
+    let clientInstance: Client;
+    if (typeof client === "string") {
+      clientInstance = await connectToMCPServer(client);
+    } else {
+      clientInstance = client;
+    }
+
+    let nextCursor: string | undefined = undefined;
+
+    do {
+      const clientTools = await clientInstance.listTools({
+        cursor: nextCursor,
+      });
+
+      for (const tool of clientTools.tools) {
+        tools[tool.name] = {
+          description: tool.description,
+          inputSchema: jsonSchemaToZod(tool.inputSchema as JsonSchema),
+          execute: async (input) => {
+            const result = await clientInstance.callTool({
+              name: tool.name,
+              arguments: input,
+            });
+            return result;
+          },
+        };
+      }
+      nextCursor = clientTools.nextCursor;
+    } while (nextCursor);
+  }
+
+  return tools;
+};
diff --git a/packages/core/lib/v3/runtimePaths.ts b/packages/core/lib/v3/runtimePaths.ts
new file mode 100644
index 000000000..09e608024
--- /dev/null
+++ b/packages/core/lib/v3/runtimePaths.ts
@@ -0,0 +1,123 @@
+/**
+ * Keep this file in sync with:
+ * - /packages/core/lib/v3/runtimePaths.ts
+ * - /packages/server-v3/scripts/runtimePaths.ts
+ * - /packages/server-v4/scripts/runtimePaths.ts
+ * - /packages/evals/runtimePaths.ts
+ * - /packages/docs/scripts/runtimePaths.js
+ */
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+
+const PACKAGE_SEGMENT = "/packages/core/";
+const EVAL_FRAMES = new Set(["[eval]", "[eval]-wrapper"]);
+const INTERNAL_FRAME_NAMES = new Set([
+  "readCallsites",
+  "readCallsitePath",
+  "resolveCallerFilePath",
+  "getCurrentFilePath",
+  "getCurrentDirPath",
+  "getRepoRootDir",
+  "getPackageRootDir",
+  "createRequireFromCaller",
+  "isMainModule",
+]);
+
+const normalizePath = (value: string): string => {
+  const input = value.startsWith("file://") ? fileURLToPath(value) : value;
+  return path.resolve(input).replaceAll("\\", "/");
+};
+
+const readCallsites = (): NodeJS.CallSite[] => {
+  const previousPrepare = Error.prepareStackTrace;
+  try {
+    Error.prepareStackTrace = (_, stack) => stack;
+    return (
+      (new Error().stack as unknown as NodeJS.CallSite[] | undefined) ?? []
+    );
+  } finally {
+    Error.prepareStackTrace = previousPrepare;
+  }
+};
+
+type CallSiteWithScriptName = NodeJS.CallSite & {
+  getScriptNameOrSourceURL?: () => string | null;
+};
+
+const readCallsitePath = (callsite: NodeJS.CallSite): string | null => {
+  const callsiteWithScript = callsite as CallSiteWithScriptName;
+  const rawPath =
+    callsite.getFileName() ?? callsiteWithScript.getScriptNameOrSourceURL?.();
+  if (!rawPath) return null;
+  if (rawPath.startsWith("node:")) return null;
+  if (EVAL_FRAMES.has(rawPath)) return null;
+  return normalizePath(rawPath);
+};
+
+const isInternalCallsite = (callsite: NodeJS.CallSite): boolean => {
+  const functionName = callsite.getFunctionName();
+  if (functionName && INTERNAL_FRAME_NAMES.has(functionName)) return true;
+
+  const methodName = callsite.getMethodName();
+  if (methodName && INTERNAL_FRAME_NAMES.has(methodName)) return true;
+
+  const callsiteString = callsite.toString();
+  for (const frameName of INTERNAL_FRAME_NAMES) {
+    if (callsiteString.includes(`${frameName} (`)) return true;
+    if (callsiteString.includes(`.${frameName} (`)) return true;
+  }
+  return false;
+};
+
+const resolveCallerFilePath = (): string => {
+  const packageCandidates: string[] = [];
+  const fallbackCandidates: string[] = [];
+
+  for (const callsite of readCallsites()) {
+    const filePath = readCallsitePath(callsite);
+    if (!filePath) continue;
+    if (isInternalCallsite(callsite)) continue;
+    if (filePath.includes(PACKAGE_SEGMENT)) {
+      packageCandidates.push(filePath);
+      continue;
+    }
+    fallbackCandidates.push(filePath);
+  }
+
+  const packageCandidate = packageCandidates[0];
+  if (packageCandidate) return packageCandidate;
+
+  const fallbackCandidate = fallbackCandidates[0];
+  if (fallbackCandidate) return fallbackCandidate;
+
+  throw new Error("Unable to resolve caller file path.");
+};
+
+export const getCurrentFilePath = (): string => resolveCallerFilePath();
+
+export const getCurrentDirPath = (): string =>
+  path.dirname(getCurrentFilePath());
+
+export const getRepoRootDir = (): string => {
+  const currentFilePath = getCurrentFilePath();
+  const index = currentFilePath.lastIndexOf(PACKAGE_SEGMENT);
+  if (index === -1) {
+    throw new Error(
+      `Unable to determine repo root from ${currentFilePath} (missing ${PACKAGE_SEGMENT}).`,
+    );
+  }
+  return currentFilePath.slice(0, index);
+};
+
+export const getPackageRootDir = (): string =>
+  `${getRepoRootDir()}${PACKAGE_SEGMENT.slice(0, -1)}`;
+
+export const createRequireFromCaller = () =>
+  createRequire(getCurrentFilePath());
+
+export const isMainModule = (): boolean => {
+  const entryScript = process.argv.at(1);
+  if (!entryScript) return false;
+  return normalizePath(entryScript) === getCurrentFilePath();
+};
diff --git a/packages/core/lib/v3/shutdown/cleanupLocal.ts b/packages/core/lib/v3/shutdown/cleanupLocal.ts
new file mode 100644
index 000000000..8c4262cc1
--- /dev/null
+++ b/packages/core/lib/v3/shutdown/cleanupLocal.ts
@@ -0,0 +1,35 @@
+import fs from "node:fs";
+
+/**
+ * Shared cleanup logic for locally launched Chrome.
+ *
+ * Used by both `V3.close()` (normal shutdown) and the supervisor process
+ * (crash cleanup). The caller provides a `killChrome` callback since the
+ * kill mechanism differs: chrome-launcher's `chrome.kill()` in-process
+ * vs raw `process.kill(pid)` from the supervisor.
+ */
+export async function cleanupLocalBrowser(opts: {
+  killChrome?: () => Promise<void> | void;
+  userDataDir?: string;
+  createdTempProfile?: boolean;
+  preserveUserDataDir?: boolean;
+}): Promise<void> {
+  if (opts.killChrome) {
+    try {
+      await opts.killChrome();
+    } catch {
+      // best-effort
+    }
+  }
+  if (
+    opts.createdTempProfile &&
+    !opts.preserveUserDataDir &&
+    opts.userDataDir
+  ) {
+    try {
+      fs.rmSync(opts.userDataDir, { recursive: true, force: true });
+    } catch {
+      // ignore cleanup errors
+    }
+  }
+}
diff --git a/packages/core/lib/v3/shutdown/supervisor.ts b/packages/core/lib/v3/shutdown/supervisor.ts
new file mode 100644
index 000000000..6c914c73b
--- /dev/null
+++ b/packages/core/lib/v3/shutdown/supervisor.ts
@@ -0,0 +1,211 @@
+/**
+ * Shutdown supervisor process.
+ *
+ * This process watches a stdin lifeline. When the parent dies, stdin closes
+ * and the supervisor performs best-effort cleanup:
+ * - LOCAL: kill Chrome + remove temp profile
+ * - STAGEHAND_API: request session release
+ */
+
+import Browserbase from "@browserbasehq/sdk";
+import type { ShutdownSupervisorConfig } from "../types/private/shutdown.js";
+import { cleanupLocalBrowser } from "./cleanupLocal.js";
+
+const SIGKILL_POLL_MS = 250;
+const SIGKILL_TIMEOUT_MS = 7_000;
+const PID_POLL_INTERVAL_MS = 500;
+
+// `cleanupPromise` guarantees we execute cleanup at most once.
+let config: ShutdownSupervisorConfig | null = null;
+let cleanupPromise: Promise<void> | null = null;
+let started = false;
+let localPidKnownGone = false;
+
+const exit = (code = 0): void => {
+  try {
+    process.exit(code);
+  } catch {
+    // ignore
+  }
+};
+
+// Best-effort two-phase kill: SIGTERM first, then SIGKILL after timeout.
+// Treat only ESRCH as "already gone"; other errors should not imply dead.
+const politeKill = async (pid: number): Promise<void> => {
+  const isAlive = (): boolean => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      const err = error as NodeJS.ErrnoException;
+      // ESRCH = "No such process" (PID is already gone).
+      return err.code !== "ESRCH";
+    }
+  };
+
+  if (!isAlive()) return;
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch (error) {
+    const err = error as NodeJS.ErrnoException;
+    // ESRCH = process already exited; no further action needed.
+    if (err.code === "ESRCH") return;
+  }
+
+  const deadline = Date.now() + SIGKILL_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, SIGKILL_POLL_MS));
+    if (!isAlive()) return;
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+    // best-effort
+  }
+};
+
+let pidPollTimer: NodeJS.Timeout | null = null;
+
+// Local-only fallback: if Chrome dies while parent still lives, run cleanup and exit.
+const startPidPolling = (pid: number): void => {
+  if (pidPollTimer) return;
+  pidPollTimer = setInterval(() => {
+    try {
+      process.kill(pid, 0);
+      return;
+    } catch (error) {
+      const err = error as NodeJS.ErrnoException;
+      // Only ESRCH means the process is definitely gone.
+      if (err.code !== "ESRCH") return;
+    }
+
+    localPidKnownGone = true;
+    if (pidPollTimer) {
+      clearInterval(pidPollTimer);
+      pidPollTimer = null;
+    }
+    void runCleanup("Browser process exited").finally(() => exit(0));
+  }, PID_POLL_INTERVAL_MS);
+};
+
+const cleanupLocal = async (
+  cfg: Extract<ShutdownSupervisorConfig, { kind: "LOCAL" }>,
+  reason: string,
+) => {
+  const deletingUserDataDir = Boolean(
+    cfg.createdTempProfile && !cfg.preserveUserDataDir && cfg.userDataDir,
+  );
+  await cleanupLocalBrowser({
+    // If polling already observed ESRCH, avoid a follow-up PID kill.
+    // The PID could be reused by a different process before cleanup runs.
+    killChrome:
+      cfg.pid && !localPidKnownGone
+        ? () => {
+            console.error(
+              `[shutdown-supervisor] Shutting down Chrome pid=${cfg.pid} ` +
+                `(reason=${reason}, deletingUserDataDir=${deletingUserDataDir})`,
+            );
+            return politeKill(cfg.pid);
+          }
+        : undefined,
+    userDataDir: cfg.userDataDir,
+    createdTempProfile: cfg.createdTempProfile,
+    preserveUserDataDir: cfg.preserveUserDataDir,
+  });
+};
+
+const cleanupBrowserbase = async (
+  cfg: Extract<ShutdownSupervisorConfig, { kind: "STAGEHAND_API" }>,
+  reason: string,
+) => {
+  if (!cfg.apiKey || !cfg.sessionId) return;
+  try {
+    console.error(
+      `[shutdown-supervisor] Ending Browserbase session ${cfg.sessionId} ` +
+        `(reason=${reason})`,
+    );
+    const bb = new Browserbase({ apiKey: cfg.apiKey });
+    await bb.sessions.update(cfg.sessionId, {
+      status: "REQUEST_RELEASE",
+      ...(cfg.projectId ? { projectId: cfg.projectId } : {}),
+    } as Browserbase.Sessions.SessionUpdateParams);
+  } catch {
+    // best-effort cleanup
+  }
+};
+
+// Idempotent cleanup entrypoint used by all supervisor shutdown paths.
+const runCleanup = (reason: string): Promise<void> => {
+  if (!cleanupPromise) {
+    cleanupPromise = (async () => {
+      const cfg = config;
+      if (!cfg) return;
+      if (cfg.kind === "LOCAL") {
+        await cleanupLocal(cfg, reason);
+        return;
+      }
+      if (cfg.kind === "STAGEHAND_API") {
+        await cleanupBrowserbase(cfg, reason);
+      }
+    })();
+  }
+  return cleanupPromise;
+};
+
+const applyConfig = (nextConfig: ShutdownSupervisorConfig): void => {
+  config = nextConfig;
+  localPidKnownGone = false;
+  if (config.kind === "LOCAL" && config.pid) {
+    startPidPolling(config.pid);
+  }
+};
+
+const onLifelineClosed = (reason: string) => {
+  void runCleanup(reason).finally(() => exit(0));
+};
+
+const parseConfigFromArgv = (
+  argv: readonly string[] = process.argv.slice(2),
+): ShutdownSupervisorConfig | null => {
+  const prefix = "--supervisor-config=";
+  const raw = argv.find((arg) => arg.startsWith(prefix))?.slice(prefix.length);
+  if (!argv.includes("--supervisor") || !raw) return null;
+  try {
+    return JSON.parse(raw) as ShutdownSupervisorConfig;
+  } catch {
+    return null;
+  }
+};
+
+export const runShutdownSupervisor = (
+  initialConfig: ShutdownSupervisorConfig,
+): void => {
+  if (started) return;
+  started = true;
+  applyConfig(initialConfig);
+
+  // Stdin is the lifeline; losing it means parent is gone.
+  try {
+    process.stdin.resume();
+    process.stdin.on("end", () =>
+      onLifelineClosed("Stagehand process completed"),
+    );
+    process.stdin.on("close", () =>
+      onLifelineClosed("Stagehand process completed"),
+    );
+    process.stdin.on("error", () =>
+      onLifelineClosed("Stagehand process crashed or was killed"),
+    );
+  } catch {
+    // ignore
+  }
+};
+
+export const maybeRunShutdownSupervisorFromArgv = (
+  argv: readonly string[] = process.argv.slice(2),
+): boolean => {
+  const parsed = parseConfigFromArgv(argv);
+  if (!parsed) return false;
+  runShutdownSupervisor(parsed);
+  return true;
+};
diff --git a/packages/core/lib/v3/shutdown/supervisorClient.ts b/packages/core/lib/v3/shutdown/supervisorClient.ts
new file mode 100644
index 000000000..dabd4ad46
--- /dev/null
+++ b/packages/core/lib/v3/shutdown/supervisorClient.ts
@@ -0,0 +1,124 @@
+/**
+ * Parent-side helper for spawning the shutdown supervisor process.
+ *
+ * The supervisor runs out-of-process and watches a lifeline pipe. If the parent
+ * dies, the supervisor performs best-effort cleanup (Chrome kill or Browserbase
+ * session release) when keepAlive is false.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import type {
+  ShutdownSupervisorConfig,
+  ShutdownSupervisorHandle,
+} from "../types/private/shutdown.js";
+import {
+  ShutdownSupervisorResolveError,
+  ShutdownSupervisorSpawnError,
+} from "../types/private/shutdownErrors.js";
+import { getCurrentFilePath } from "../runtimePaths.js";
+
+const moduleFilename = getCurrentFilePath();
+const moduleDir = path.dirname(moduleFilename);
+const nodeRequire = createRequire(moduleFilename);
+
+const isSeaRuntime = (): boolean => {
+  try {
+    const sea = nodeRequire("node:sea") as { isSea?: () => boolean };
+    return Boolean(sea.isSea?.());
+  } catch {
+    return false;
+  }
+};
+
+// SEA: re-exec current binary with supervisor args.
+// Non-SEA: execute Stagehand CLI entrypoint with supervisor args.
+const resolveCliPath = (): string => `${moduleDir}/../cli.js`;
+
+const resolveSupervisorCommand = (
+  config: ShutdownSupervisorConfig,
+): {
+  command: string;
+  args: string[];
+} | null => {
+  const baseArgs = ["--supervisor", serializeConfigArg(config)];
+
+  if (isSeaRuntime()) {
+    return { command: process.execPath, args: baseArgs };
+  }
+
+  const cliPath = resolveCliPath();
+  if (!fs.existsSync(cliPath)) return null;
+  const needsTsxLoader =
+    fs.existsSync(`${moduleDir}/supervisor.ts`) &&
+    !fs.existsSync(`${moduleDir}/supervisor.js`);
+  return {
+    command: process.execPath,
+    args: needsTsxLoader
+      ? ["--import", "tsx", cliPath, ...baseArgs]
+      : [cliPath, ...baseArgs],
+  };
+};
+
+// Single JSON arg keeps supervisor bootstrap parsing tiny and versionable.
+const serializeConfigArg = (config: ShutdownSupervisorConfig): string =>
+  `--supervisor-config=${JSON.stringify({
+    ...config,
+    parentPid: process.pid,
+  })}`;
+
+/**
+ * Start a supervisor process for crash cleanup. Returns a handle that can
+ * stop the supervisor during a normal shutdown.
+ */
+export function startShutdownSupervisor(
+  config: ShutdownSupervisorConfig,
+  opts?: { onError?: (error: Error, context: string) => void },
+): ShutdownSupervisorHandle | null {
+  const resolved = resolveSupervisorCommand(config);
+  if (!resolved) {
+    opts?.onError?.(
+      new ShutdownSupervisorResolveError(
+        "Shutdown supervisor entry missing (expected Stagehand CLI entrypoint).",
+      ),
+      "resolve",
+    );
+    return null;
+  }
+
+  const child = spawn(resolved.command, resolved.args, {
+    // stdin is the parent lifeline.
+    // Preserve supervisor stderr so crash-cleanup debug lines are visible.
+    stdio: ["pipe", "ignore", "inherit"],
+    detached: true,
+  });
+  child.on("error", (error) => {
+    opts?.onError?.(
+      new ShutdownSupervisorSpawnError(
+        `Shutdown supervisor failed to start: ${error.message}`,
+      ),
+      "spawn",
+    );
+  });
+
+  try {
+    child.unref();
+    const stdin = child.stdin as unknown as { unref?: () => void } | null;
+    stdin?.unref?.();
+  } catch {
+    // best-effort: avoid keeping the event loop alive
+  }
+
+  const stop = () => {
+    // Normal close path: terminate supervisor directly.
+    try {
+      child.kill("SIGTERM");
+    } catch {
+      // ignore
+    }
+  };
+
+  return { stop };
+}
diff --git a/packages/core/lib/v3/timeoutConfig.ts b/packages/core/lib/v3/timeoutConfig.ts
new file mode 100644
index 000000000..02e914380
--- /dev/null
+++ b/packages/core/lib/v3/timeoutConfig.ts
@@ -0,0 +1,36 @@
+import { TimeoutError } from "./types/public/sdkErrors.js";
+
+export function getEnvTimeoutMs(name: string): number | undefined {
+  const raw = process.env[name];
+  if (!raw) return undefined;
+  const normalized = raw.trim().replace(/ms$/i, "");
+  const value = Number(normalized);
+  if (!Number.isFinite(value) || value <= 0) return undefined;
+  return value;
+}
+
+export async function withTimeout<T>(
+  promise: Promise<T>,
+  timeoutMs: number | null | undefined,
+  operation: string,
+): Promise<T> {
+  if (
+    typeof timeoutMs !== "number" ||
+    !Number.isFinite(timeoutMs) ||
+    timeoutMs <= 0
+  ) {
+    return await promise;
+  }
+
+  let timeoutId: NodeJS.Timeout | undefined;
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new TimeoutError(operation, timeoutMs));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
+  }
+}
diff --git a/packages/core/lib/v3/types/private/agent.ts b/packages/core/lib/v3/types/private/agent.ts
new file mode 100644
index 000000000..d4ad0a1a7
--- /dev/null
+++ b/packages/core/lib/v3/types/private/agent.ts
@@ -0,0 +1,6 @@
+export interface ActionMappingOptions {
+  toolCallName: string;
+  toolResult: unknown;
+  args: Record<string, unknown>;
+  reasoning?: string;
+}
diff --git a/packages/core/lib/v3/types/private/api.ts b/packages/core/lib/v3/types/private/api.ts
new file mode 100644
index 000000000..c486981ed
--- /dev/null
+++ b/packages/core/lib/v3/types/private/api.ts
@@ -0,0 +1,12 @@
+import type { Protocol } from "devtools-protocol";
+
+export interface SerializableResponse {
+  requestId: string;
+  frameId?: string;
+  loaderId?: string;
+  response: Protocol.Network.Response;
+  fromServiceWorkerFlag?: boolean;
+  finishedSettled?: boolean;
+  extraInfoHeaders?: Protocol.Network.Headers | null;
+  extraInfoHeadersText?: string;
+}
diff --git a/packages/core/lib/v3/types/private/cache.ts b/packages/core/lib/v3/types/private/cache.ts
new file mode 100644
index 000000000..385988cca
--- /dev/null
+++ b/packages/core/lib/v3/types/private/cache.ts
@@ -0,0 +1,160 @@
+import type {
+  ActOptions,
+  ActResult,
+  AvailableModel,
+  Logger,
+  AgentResult,
+  Action,
+  LoadState,
+} from "../public/index.js";
+import { CacheStorage } from "../../cache/CacheStorage.js";
+import type { ActHandler } from "../../handlers/actHandler.js";
+import type { V3Context } from "../../understudy/context.js";
+import type { LLMClient } from "../../llm/LLMClient.js";
+
+export type ActFn = (
+  instruction: string,
+  options?: ActOptions,
+) => Promise<ActResult>;
+
+export type AgentCacheContext = {
+  instruction: string;
+  startUrl: string;
+  options: SanitizedAgentExecuteOptions;
+  configSignature: string;
+  cacheKey: string;
+  variableKeys: string[] /** Variable keys used in this execution (for cache key) */;
+  /** Variable values to substitute during replay */
+  variables?: Record<string, string>;
+};
+
+export type AgentCacheTransferPayload = {
+  cacheKey: string;
+  entry: CachedAgentEntry;
+};
+
+export type AgentCacheDeps = {
+  storage: CacheStorage;
+  logger: Logger;
+  getActHandler: () => ActHandler | null;
+  getContext: () => V3Context | null;
+  getDefaultLlmClient: () => LLMClient;
+  getBaseModelName: () => AvailableModel;
+  getSystemPrompt: () => string | undefined;
+  domSettleTimeoutMs?: number;
+  act: ActFn;
+  bufferLatestEntry?: boolean;
+};
+
+export type ActCacheContext = {
+  instruction: string;
+  cacheKey: string;
+  pageUrl: string;
+  variableKeys: string[];
+  variables?: Record<string, string>;
+};
+
+export type ActCacheDeps = {
+  storage: CacheStorage;
+  logger: Logger;
+  getActHandler: () => ActHandler | null;
+  getDefaultLlmClient: () => LLMClient;
+  domSettleTimeoutMs?: number;
+};
+
+export type ReadJsonResult<T> = {
+  value: T | null;
+  path?: string;
+  error?: unknown;
+};
+
+export type WriteJsonResult = {
+  path?: string;
+  error?: unknown;
+};
+
+export interface CachedActEntry {
+  version: 1;
+  instruction: string;
+  url: string;
+  variableKeys: string[];
+  actions: Action[];
+  actionDescription?: string;
+  message?: string;
+}
+
+export type AgentReplayStep =
+  | AgentReplayActStep
+  | AgentReplayFillFormStep
+  | AgentReplayGotoStep
+  | AgentReplayScrollStep
+  | AgentReplayWaitStep
+  | AgentReplayNavBackStep
+  | AgentReplayKeysStep
+  | { type: string; [key: string]: unknown };
+
+export interface AgentReplayActStep {
+  type: "act";
+  instruction: string;
+  actions?: Action[];
+  actionDescription?: string;
+  message?: string;
+  timeout?: number;
+}
+
+export interface AgentReplayFillFormStep {
+  type: "fillForm";
+  fields?: Array<{ action: string; value: string }>;
+  observeResults?: Action[];
+  actions?: Action[];
+}
+
+export interface AgentReplayGotoStep {
+  type: "goto";
+  url: string;
+  waitUntil?: LoadState;
+}
+
+export interface AgentReplayScrollStep {
+  type: "scroll";
+  deltaX?: number;
+  deltaY?: number;
+  anchor?: { x: number; y: number };
+}
+
+export interface AgentReplayWaitStep {
+  type: "wait";
+  timeMs: number;
+}
+
+export interface AgentReplayNavBackStep {
+  type: "navback";
+  waitUntil?: LoadState;
+}
+
+export interface AgentReplayKeysStep {
+  type: "keys";
+  instruction?: string;
+  playwrightArguments: {
+    method: "type" | "press";
+    text?: string;
+    keys?: string;
+    times?: number;
+  };
+}
+
+export interface SanitizedAgentExecuteOptions {
+  maxSteps?: number;
+  highlightCursor?: boolean;
+}
+
+export interface CachedAgentEntry {
+  version: 1;
+  instruction: string;
+  startUrl: string;
+  options: SanitizedAgentExecuteOptions;
+  configSignature: string;
+  steps: AgentReplayStep[];
+  result: AgentResult;
+  timestamp: string;
+}
diff --git a/packages/core/lib/v3/types/private/evaluator.ts b/packages/core/lib/v3/types/private/evaluator.ts
new file mode 100644
index 000000000..00fc5ef6c
--- /dev/null
+++ b/packages/core/lib/v3/types/private/evaluator.ts
@@ -0,0 +1,42 @@
+export type EvaluateOptions = {
+  /** The question to ask about the task state */
+  question: string;
+  /** The answer to the question */
+  answer?: string;
+  /** Whether to take a screenshot of the task state, or array of screenshots to evaluate */
+  screenshot?: boolean | Buffer[];
+  /** Custom system prompt for the evaluator */
+  systemPrompt?: string;
+  /** Delay in milliseconds before taking the screenshot @default 250 */
+  screenshotDelayMs?: number;
+  /** The agent's reasoning/thought process for completing the task */
+  agentReasoning?: string;
+};
+
+export type BatchAskOptions = {
+  /** Array of questions with optional answers */
+  questions: Array<{
+    question: string;
+    answer?: string;
+  }>;
+  /** Whether to take a screenshot of the task state */
+  screenshot?: boolean;
+  /** Custom system prompt for the evaluator */
+  systemPrompt?: string;
+  /** Delay in milliseconds before taking the screenshot @default 1000 */
+  screenshotDelayMs?: number;
+};
+
+/**
+ * Result of an evaluation
+ */
+export interface EvaluationResult {
+  /**
+   * The evaluation result ('YES', 'NO', or 'INVALID' if parsing failed or value was unexpected)
+   */
+  evaluation: "YES" | "NO" | "INVALID";
+  /**
+   * The reasoning behind the evaluation
+   */
+  reasoning: string;
+}
diff --git a/packages/core/lib/v3/types/private/handlers.ts b/packages/core/lib/v3/types/private/handlers.ts
new file mode 100644
index 000000000..ab30ff6ac
--- /dev/null
+++ b/packages/core/lib/v3/types/private/handlers.ts
@@ -0,0 +1,44 @@
+import { Page } from "../../understudy/page.js";
+import { ModelConfiguration } from "../public/model.js";
+import type { StagehandZodSchema } from "../../zodCompat.js";
+import type { Variables } from "../public/agent.js";
+
+export interface ActHandlerParams {
+  instruction: string;
+  model?: ModelConfiguration;
+  variables?: Variables;
+  timeout?: number;
+  page: Page;
+}
+
+export interface ExtractHandlerParams<T extends StagehandZodSchema> {
+  instruction?: string;
+  schema?: T;
+  model?: ModelConfiguration;
+  timeout?: number;
+  selector?: string;
+  page: Page;
+}
+
+export interface ObserveHandlerParams {
+  instruction?: string;
+  model?: ModelConfiguration;
+  timeout?: number;
+  selector?: string;
+  page: Page;
+}
+
+// We can use this enum to list the actions supported in performUnderstudyMethod
+export enum SupportedUnderstudyAction {
+  CLICK = "click",
+  FILL = "fill",
+  TYPE = "type",
+  PRESS = "press",
+  SCROLL = "scrollTo",
+  NEXT_CHUNK = "nextChunk",
+  PREV_CHUNK = "prevChunk",
+  SELECT_OPTION_FROM_DROPDOWN = "selectOptionFromDropdown",
+  HOVER = "hover",
+  DOUBLE_CLICK = "doubleClick",
+  DRAG_AND_DROP = "dragAndDrop",
+}
diff --git a/packages/core/lib/v3/types/private/index.ts b/packages/core/lib/v3/types/private/index.ts
new file mode 100644
index 000000000..ee653b0ae
--- /dev/null
+++ b/packages/core/lib/v3/types/private/index.ts
@@ -0,0 +1,7 @@
+export * from "./api.js";
+export * from "./handlers.js";
+export * from "./internal.js";
+export * from "./evaluator.js";
+export * from "./cache.js";
+export * from "./agent.js";
+export * from "./snapshot.js";
diff --git a/packages/core/lib/v3/types/private/internal.ts b/packages/core/lib/v3/types/private/internal.ts
new file mode 100644
index 000000000..0ca54c9d6
--- /dev/null
+++ b/packages/core/lib/v3/types/private/internal.ts
@@ -0,0 +1,39 @@
+import Browserbase from "@browserbasehq/sdk";
+import { LaunchedChrome } from "chrome-launcher";
+
+export type InitState =
+  | { kind: "UNINITIALIZED" }
+  | {
+      kind: "LOCAL";
+      chrome: LaunchedChrome;
+      ws: string;
+      userDataDir?: string;
+      createdTempProfile?: boolean;
+      preserveUserDataDir?: boolean;
+    }
+  | { kind: "BROWSERBASE"; bb: Browserbase; sessionId: string; ws: string };
+
+export type EncodedId = `${number}-${number}`;
+
+/**
+ * Represents a path through a Zod schema from the root object down to a
+ * particular field. The `segments` array describes the chain of keys/indices.
+ *
+ * - **String** segments indicate object property names.
+ * - **Number** segments indicate array indices.
+ *
+ * For example, `["users", 0, "homepage"]` might describe reaching
+ * the `homepage` field in `schema.users[0].homepage`.
+ */
+export interface ZodPathSegments {
+  /**
+   * The ordered list of keys/indices leading from the schema root
+   * to the targeted field.
+   */
+  segments: Array<string | number>;
+}
+
+export type InitScriptSource<Arg> =
+  | string
+  | { path?: string; content?: string }
+  | ((arg: Arg) => unknown);
diff --git a/packages/core/lib/v3/types/private/locator.ts b/packages/core/lib/v3/types/private/locator.ts
new file mode 100644
index 000000000..105e61964
--- /dev/null
+++ b/packages/core/lib/v3/types/private/locator.ts
@@ -0,0 +1,10 @@
+import { Buffer } from "buffer";
+
+export interface NormalizedFilePayload {
+  name: string;
+  mimeType: string;
+  buffer: Buffer;
+  lastModified: number;
+  /** Absolute path to the source file when provided by the caller. */
+  absolutePath?: string;
+}
diff --git a/packages/core/lib/v3/types/private/network.ts b/packages/core/lib/v3/types/private/network.ts
new file mode 100644
index 000000000..b6abee0bd
--- /dev/null
+++ b/packages/core/lib/v3/types/private/network.ts
@@ -0,0 +1,41 @@
+import { Protocol } from "devtools-protocol";
+
+/** Metadata tracked for each network request currently in-flight. */
+export type NetworkRequestInfo = {
+  sessionId: string;
+  requestId: string;
+  requestKey: string;
+  frameId?: string;
+  loaderId?: string;
+  url?: string;
+  timestamp: number;
+  resourceType?: Protocol.Network.ResourceType;
+  documentRequest: boolean;
+};
+
+/** Callback hooks consumers can implement to observe network transitions. */
+export interface NetworkObserver {
+  onRequestStarted(info: NetworkRequestInfo): void;
+  onRequestFinished(info: NetworkRequestInfo): void;
+  onRequestFailed(info: NetworkRequestInfo): void;
+}
+
+/** Options for the idle waiter helper. */
+export type WaitForIdleOptions = {
+  startTime?: number;
+  timeoutMs: number;
+  idleTimeMs?: number;
+  filter?: (info: NetworkRequestInfo) => boolean;
+  totalBudgetMs?: number;
+};
+
+export const DEFAULT_IDLE_WAIT = 500;
+export const IGNORED_RESOURCE_TYPES = new Set<
+  Protocol.Network.ResourceType | undefined
+>(["EventSource", "WebSocket"]);
+
+/** The handle returned by the network manager idle helper. */
+export type WaitForIdleHandle = {
+  promise: Promise<void>;
+  dispose: () => void;
+};
diff --git a/packages/core/lib/v3/types/private/shutdown.ts b/packages/core/lib/v3/types/private/shutdown.ts
new file mode 100644
index 000000000..c99aca6b2
--- /dev/null
+++ b/packages/core/lib/v3/types/private/shutdown.ts
@@ -0,0 +1,23 @@
+/**
+ * Internal-only types for the shutdown supervisor process.
+ */
+
+export type ShutdownSupervisorConfig =
+  | {
+      kind: "LOCAL";
+      pid: number;
+      userDataDir?: string;
+      createdTempProfile?: boolean;
+      preserveUserDataDir?: boolean;
+    }
+  | {
+      kind: "STAGEHAND_API";
+      sessionId: string;
+      apiKey: string;
+      projectId?: string;
+    };
+
+export interface ShutdownSupervisorHandle {
+  /** Best-effort signal to stop the supervisor process. */
+  stop: () => void;
+}
diff --git a/packages/core/lib/v3/types/private/shutdownErrors.ts b/packages/core/lib/v3/types/private/shutdownErrors.ts
new file mode 100644
index 000000000..e7029de5e
--- /dev/null
+++ b/packages/core/lib/v3/types/private/shutdownErrors.ts
@@ -0,0 +1,24 @@
+/**
+ * Internal-only errors for the shutdown supervisor.
+ */
+
+export class ShutdownSupervisorError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ShutdownSupervisorError";
+  }
+}
+
+export class ShutdownSupervisorResolveError extends ShutdownSupervisorError {
+  constructor(message: string) {
+    super(message);
+    this.name = "ShutdownSupervisorResolveError";
+  }
+}
+
+export class ShutdownSupervisorSpawnError extends ShutdownSupervisorError {
+  constructor(message: string) {
+    super(message);
+    this.name = "ShutdownSupervisorSpawnError";
+  }
+}
diff --git a/packages/core/lib/v3/types/private/snapshot.ts b/packages/core/lib/v3/types/private/snapshot.ts
new file mode 100644
index 000000000..410d28284
--- /dev/null
+++ b/packages/core/lib/v3/types/private/snapshot.ts
@@ -0,0 +1,131 @@
+/**
+ * Options that control how hybrid snapshots and targeted scopes are captured.
+ */
+export type SnapshotOptions = {
+  /**
+   * Filter the snapshot to a specific element/subtree using a selector that can cross iframes.
+   * Supports XPath (prefixed with `xpath=` or starting with `/`) and CSS with iframe hops via `>>`.
+   */
+  focusSelector?: string;
+  /**
+   * Pierce shadow DOM when calling DOM.getDocument. Defaults to true to retain the
+   * existing behaviour.
+   */
+  pierceShadow?: boolean;
+  /**
+   * Toggle whether iframe subtrees are included in the merged snapshot. Defaults to true.
+   */
+  includeIframes?: boolean;
+  /**
+   * Optional feature flag that surfaces experimental traversal tweaks in the Accessibility layer.
+   */
+  experimental?: boolean;
+};
+
+/**
+ * Hybrid snapshot payload consumed by act/extract/observe handlers.
+ */
+export type HybridSnapshot = {
+  /** Merged outline across every frame. */
+  combinedTree: string;
+  /** EncodedId (frameOrdinal-backendNodeId) -> absolute XPath. */
+  combinedXpathMap: Record<string, string>;
+  /** EncodedId -> URL extracted from AX properties. */
+  combinedUrlMap: Record<string, string>;
+  /** Per-frame payloads expose the original relative data for debugging. */
+  perFrame?: PerFrameSnapshot[];
+};
+
+export type PerFrameSnapshot = {
+  frameId: string;
+  outline: string;
+  xpathMap: Record<string, string>;
+  urlMap: Record<string, string>;
+};
+
+/**
+ * Compact encoding of DOM data for an entire session. Shared between capture
+ * and focus helpers so DOM traversal can be unit tested in isolation.
+ */
+export type SessionDomIndex = {
+  rootBackend: number;
+  absByBe: Map<number, string>;
+  tagByBe: Map<number, string>;
+  scrollByBe: Map<number, boolean>;
+  docRootOf: Map<number, number>;
+  contentDocRootByIframe: Map<number, number>;
+};
+
+export type FrameDomMaps = {
+  tagNameMap: Record<string, string>;
+  xpathMap: Record<string, string>;
+  scrollableMap: Record<string, boolean>;
+  urlMap: Record<string, string>;
+};
+
+export type ResolvedLocation = {
+  frameId: string;
+  backendNodeId: number;
+  absoluteXPath: string;
+};
+
+export type ResolvedFocusFrame = {
+  targetFrameId: string;
+  tailXPath: string;
+  absPrefix: string;
+};
+
+export type ResolvedCssFocus = {
+  targetFrameId: string;
+  tailSelector: string;
+  absPrefix: string;
+};
+
+export type Axis = "child" | "desc";
+
+export type Step = {
+  axis: Axis;
+  raw: string;
+  name: string;
+};
+
+export type A11yNode = {
+  role: string;
+  name?: string;
+  description?: string;
+  value?: string | number | boolean;
+  nodeId: string;
+  backendDOMNodeId?: number;
+  parentId?: string;
+  childIds?: string[];
+  children?: A11yNode[];
+  encodedId?: string;
+};
+
+export type A11yOptions = {
+  focusSelector?: string;
+  experimental: boolean;
+  tagNameMap: Record<string, string>;
+  scrollableMap: Record<string, boolean>;
+  encode: (backendNodeId: number) => string;
+};
+
+export type AccessibilityTreeResult = {
+  outline: string;
+  urlMap: Record<string, string>;
+  scopeApplied: boolean;
+};
+
+export type FrameParentIndex = Map<string, string | null>;
+
+/**
+ * Shared frame metadata that every snapshot step needs.
+ * - `rootId`: stable identifier for the main frame so we can detect root prefixes.
+ * - `parentByFrame`: lookup table for iframe parentage (used by focus scoping and prefixing).
+ * - `frames`: DFS-ordered frame ids so merging walks parents before children.
+ */
+export type FrameContext = {
+  rootId: string;
+  parentByFrame: FrameParentIndex;
+  frames: string[];
+};
diff --git a/packages/core/lib/v3/types/public/agent.ts b/packages/core/lib/v3/types/public/agent.ts
new file mode 100644
index 000000000..3e9cf258a
--- /dev/null
+++ b/packages/core/lib/v3/types/public/agent.ts
@@ -0,0 +1,760 @@
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import {
+  ToolSet,
+  ModelMessage,
+  wrapLanguageModel,
+  StreamTextResult,
+  StepResult,
+  PrepareStepFunction,
+  GenerateTextOnStepFinishCallback,
+  StreamTextOnStepFinishCallback,
+  StreamTextOnErrorCallback,
+  StreamTextOnChunkCallback,
+  StreamTextOnFinishCallback,
+} from "ai";
+import { LogLine } from "./logs.js";
+import { ClientOptions } from "./model.js";
+import { StagehandZodObject } from "../../zodCompat.js";
+
+// Re-export ModelMessage for consumers who want to use it for conversation continuation
+export type { ModelMessage } from "ai";
+
+// Re-export Tool type for consumers who want to define custom tools
+export type { Tool } from "ai";
+import { Page as PlaywrightPage } from "playwright-core";
+import { Page as PuppeteerPage } from "puppeteer-core";
+import { Page as PatchrightPage } from "patchright-core";
+import { Page } from "../../understudy/page.js";
+
+// =============================================================================
+// Variable Types
+// =============================================================================
+
+/**
+ * A variable value can be a simple primitive or a rich object with an optional description.
+ * This unified type is shared across `act`, `agent.execute`, and other methods.
+ *
+ * @example Simple (backward-compatible):
+ * ```typescript
+ * variables: { username: "john@example.com" }
+ * ```
+ *
+ * @example Rich with description (useful for agents):
+ * ```typescript
+ * variables: {
+ *   username: { value: "john@example.com", description: "The login email" }
+ * }
+ * ```
+ */
+export type VariableValue =
+  | string
+  | number
+  | boolean
+  | { value: string | number | boolean; description?: string };
+
+/**
+ * A collection of named variables for use in act, agent, and other methods.
+ */
+export type Variables = Record<string, VariableValue>;
+
+export interface AgentContext {
+  options: AgentExecuteOptionsBase;
+  maxSteps: number;
+  systemPrompt: string;
+  allTools: ToolSet;
+  messages: ModelMessage[];
+  wrappedModel: ReturnType<typeof wrapLanguageModel>;
+  initialPageUrl: string;
+}
+
+export interface AgentState {
+  collectedReasoning: string[];
+  actions: AgentAction[];
+  finalMessage: string;
+  completed: boolean;
+  currentPageUrl: string;
+}
+
+export interface AgentAction {
+  type: string;
+  reasoning?: string;
+  taskCompleted?: boolean;
+  action?: string;
+  // Tool-specific fields
+  timeMs?: number; // wait tool
+  pageText?: string; // ariaTree tool
+  pageUrl?: string; // ariaTree tool
+  instruction?: string; // various tools
+  [key: string]: unknown;
+}
+
+export interface AgentResult {
+  success: boolean;
+  message: string;
+  actions: AgentAction[];
+  completed: boolean;
+  metadata?: Record<string, unknown>;
+  usage?: {
+    input_tokens: number;
+    output_tokens: number;
+    reasoning_tokens?: number;
+    cached_input_tokens?: number;
+    inference_time_ms: number;
+  };
+  /**
+   * The conversation messages from this execution.
+   * Pass these to a subsequent execute() call via the `messages` option to continue the conversation.
+   * @experimental
+   */
+  messages?: ModelMessage[];
+  /**
+   * Custom output data extracted based on the `output` schema provided in execute options.
+   * Only populated if an `output` schema was provided.
+   * @experimental
+   */
+  output?: Record<string, unknown>;
+}
+
+export type AgentStreamResult = StreamTextResult<ToolSet, never> & {
+  result: Promise<AgentResult>;
+};
+
+/**
+ * Base callbacks shared between execute (non-streaming) and streaming modes.
+ */
+export interface AgentCallbacks {
+  /**
+   * Optional function called before each step to modify settings.
+   * You can change the model, tool choices, active tools, system prompt,
+   * and input messages for each step.
+   */
+  prepareStep?: PrepareStepFunction<ToolSet>;
+  /**
+   * Callback called when each step (LLM call) is finished.
+   * This is called for intermediate steps as well as the final step.
+   */
+  onStepFinish?:
+    | GenerateTextOnStepFinishCallback<ToolSet>
+    | StreamTextOnStepFinishCallback<ToolSet>;
+}
+
+/**
+ * Error message type for streaming-only callbacks used in non-streaming mode.
+ * This provides a clear error message when users try to use streaming callbacks without stream: true.
+ */
+type StreamingCallbackNotAvailable =
+  "This callback requires 'stream: true' in AgentConfig. Set stream: true to use streaming callbacks like onChunk, onFinish, onError, and onAbort.";
+
+/**
+ * Error message for safety confirmation callback misuse.
+ * Safety confirmations are only available for non-streaming CUA agent executions.
+ */
+type SafetyConfirmationCallbackNotAvailable =
+  "Safety confirmation callbacks are only available via non-streaming AgentExecuteOptions.callbacks when using mode: 'cua'.";
+
+/**
+ * Callbacks specific to the non-streaming execute method.
+ */
+export interface AgentExecuteCallbacks extends AgentCallbacks {
+  /**
+   * Callback called when each step (LLM call) is finished.
+   */
+  onStepFinish?: GenerateTextOnStepFinishCallback<ToolSet>;
+  /**
+   * Callback for handling safety confirmation requests from CUA providers.
+   * Only available when running an agent configured with mode: "cua".
+   */
+  onSafetyConfirmation?: SafetyConfirmationHandler;
+
+  /**
+   * NOT AVAILABLE in non-streaming mode.
+   * This callback requires `stream: true` in AgentConfig.
+   *
+   * @example
+   * ```typescript
+   * // Enable streaming to use onChunk:
+   * const agent = stagehand.agent({ stream: true });
+   * await agent.execute({
+   *   instruction: "...",
+   *   callbacks: { onChunk: async (chunk) => console.log(chunk) }
+   * });
+   * ```
+   */
+  onChunk?: StreamingCallbackNotAvailable;
+
+  /**
+   * NOT AVAILABLE in non-streaming mode.
+   * This callback requires `stream: true` in AgentConfig.
+   *
+   * @example
+   * ```typescript
+   * // Enable streaming to use onFinish:
+   * const agent = stagehand.agent({ stream: true });
+   * await agent.execute({
+   *   instruction: "...",
+   *   callbacks: { onFinish: (event) => console.log("Done!", event) }
+   * });
+   * ```
+   */
+  onFinish?: StreamingCallbackNotAvailable;
+
+  /**
+   * NOT AVAILABLE in non-streaming mode.
+   * This callback requires `stream: true` in AgentConfig.
+   *
+   * @example
+   * ```typescript
+   * // Enable streaming to use onError:
+   * const agent = stagehand.agent({ stream: true });
+   * await agent.execute({
+   *   instruction: "...",
+   *   callbacks: { onError: ({ error }) => console.error(error) }
+   * });
+   * ```
+   */
+  onError?: StreamingCallbackNotAvailable;
+
+  /**
+   * NOT AVAILABLE in non-streaming mode.
+   * This callback requires `stream: true` in AgentConfig.
+   *
+   * @example
+   * ```typescript
+   * // Enable streaming to use onAbort:
+   * const agent = stagehand.agent({ stream: true });
+   * await agent.execute({
+   *   instruction: "...",
+   *   callbacks: { onAbort: (event) => console.log("Aborted", event.steps) }
+   * });
+   * ```
+   */
+  onAbort?: StreamingCallbackNotAvailable;
+}
+
+/**
+ * Callbacks specific to the streaming mode.
+ */
+export interface AgentStreamCallbacks extends AgentCallbacks {
+  /**
+   * Callback called when each step (LLM call) is finished during streaming.
+   */
+  onStepFinish?: StreamTextOnStepFinishCallback<ToolSet>;
+  /**
+   * Callback called when an error occurs during streaming.
+   * Use this to log errors or handle error states.
+   */
+  onError?: StreamTextOnErrorCallback;
+  /**
+   * Callback called for each chunk of the stream.
+   * Stream processing will pause until the callback promise resolves.
+   */
+  onChunk?: StreamTextOnChunkCallback<ToolSet>;
+  /**
+   * Callback called when the stream finishes.
+   */
+  onFinish?: StreamTextOnFinishCallback<ToolSet>;
+  /**
+   * Callback called when the stream is aborted.
+   */
+  onAbort?: (event: {
+    steps: Array<StepResult<ToolSet>>;
+  }) => PromiseLike<void> | void;
+  /**
+   * NOT AVAILABLE in streaming mode.
+   * Safety confirmations currently require non-streaming execute() on CUA agents.
+   */
+  onSafetyConfirmation?: SafetyConfirmationCallbackNotAvailable;
+}
+
+/**
+ * Base options for agent execution (without callbacks).
+ */
+export interface AgentExecuteOptionsBase {
+  instruction: string;
+  maxSteps?: number;
+  page?: PlaywrightPage | PuppeteerPage | PatchrightPage | Page;
+  highlightCursor?: boolean;
+  /**
+   * Previous conversation messages to continue from.
+   * Pass the `messages` from a previous AgentResult to continue that conversation.
+   * @experimental
+   */
+  messages?: ModelMessage[];
+  /**
+   * An AbortSignal that can be used to cancel the agent execution.
+   * When aborted, the agent will stop and return a partial result.
+   * @experimental
+   *
+   * @example
+   * ```typescript
+   * const controller = new AbortController();
+   * setTimeout(() => controller.abort(), 30000); // 30 second timeout
+   *
+   * const result = await agent.execute({
+   *   instruction: "...",
+   *   signal: controller.signal
+   * });
+   * ```
+   */
+  signal?: AbortSignal;
+  /**
+   * Tools to exclude from this execution.
+   * Pass an array of tool names to prevent the agent from using those tools.
+   *
+   * **Note:** Not supported in CUA mode (`mode: "cua"`).
+   *
+   * **Available tools by mode:**
+   *
+   * **DOM mode (default):**
+   * - `act` - Perform semantic actions (click, type, etc.)
+   * - `fillForm` - Fill form fields using DOM selectors
+   * - `ariaTree` - Get accessibility tree of the page
+   * - `extract` - Extract structured data from page
+   * - `goto` - Navigate to a URL
+   * - `scroll` - Scroll using semantic directions (up/down/left/right)
+   * - `keys` - Press keyboard keys
+   * - `navback` - Navigate back in history
+   * - `screenshot` - Take a screenshot
+   * - `think` - Agent reasoning/planning step
+   * - `wait` - Wait for time or condition
+   * - `done` - Mark task as complete
+   * - `search` - Web search (requires BRAVE_API_KEY)
+   *
+   * **Hybrid mode:**
+   * - `click` - Click at specific coordinates
+   * - `type` - Type text at coordinates
+   * - `dragAndDrop` - Drag from one point to another
+   * - `clickAndHold` - Click and hold at coordinates
+   * - `fillFormVision` - Fill forms using vision/coordinates
+   * - `act` - Perform semantic actions
+   * - `ariaTree` - Get accessibility tree
+   * - `extract` - Extract data from page
+   * - `goto` - Navigate to URL
+   * - `scroll` - Scroll using coordinates
+   * - `keys` - Press keyboard keys
+   * - `navback` - Navigate back
+   * - `screenshot` - Take screenshot
+   * - `think` - Agent reasoning step
+   * - `wait` - Wait for time/condition
+   * - `done` - Mark task complete
+   * - `search` - Web search (requires BRAVE_API_KEY)
+   *
+   * @experimental
+   * @example
+   * ```typescript
+   * // Exclude screenshot and extract tools
+   * const result = await agent.execute({
+   *   instruction: "Click the submit button",
+   *   excludeTools: ["screenshot", "extract"]
+   * });
+   * ```
+   */
+  excludeTools?: string[];
+  /**
+   * A Zod schema defining custom output data to return when the task completes.
+   * The agent will populate this data in the final done tool call.
+   *
+   * @experimental
+   * @example
+   * ```typescript
+   * const result = await agent.execute({
+   *   instruction: "Find the cheapest flight from NYC to LA",
+   *   output: z.object({
+   *     price: z.string().describe("The price of the flight"),
+   *     airline: z.string().describe("The airline name"),
+   *     departureTime: z.string().describe("Departure time"),
+   *   }),
+   * });
+   *
+   * console.log(result.output); // { price: "$199", airline: "Delta", departureTime: "8:00 AM" }
+   * ```
+   */
+  output?: StagehandZodObject;
+  /**
+   * Variables that the agent can use when filling forms or typing text.
+   * The agent will see variable names and descriptions in the system prompt,
+   * and can use them via `%variableName%` syntax in act/type/fillForm tool calls.
+   *
+   * Accepts both simple values and rich objects with descriptions (same type as `act`).
+   *
+   * **Note:** Not supported in CUA mode (`mode: "cua"`). Requires `experimental: true`.
+   *
+   * @experimental
+   * @example
+   * ```typescript
+   * // Simple values
+   * variables: { username: "john@example.com", password: "secret123" }
+   *
+   * // Rich values with descriptions (helps the agent understand context)
+   * variables: {
+   *   username: { value: "john@example.com", description: "The login email" },
+   *   password: { value: "secret123", description: "The login password" },
+   * }
+   * ```
+   */
+  variables?: Variables;
+  /**
+   * Timeout in milliseconds for each agent tool call.
+   * If a tool call exceeds this duration, it will be aborted and
+   * reported back to the LLM as a timeout error so it can retry or adjust.
+   * For tools that call v3 methods (act, extract, fillForm, ariaTree), the
+   * timeout is also forwarded to the underlying v3 call for true cancellation.
+   * @default 45000 (45 seconds)
+   */
+  toolTimeout?: number;
+}
+
+/**
+ * Options for non-streaming agent execution.
+ * Only accepts AgentExecuteCallbacks (no streaming-specific callbacks like onChunk, onFinish).
+ */
+export interface AgentExecuteOptions extends AgentExecuteOptionsBase {
+  /**
+   * Callbacks for non-streaming agent execution.
+   * For streaming callbacks (onChunk, onFinish, onError, onAbort), use stream: true in AgentConfig.
+   */
+  callbacks?: AgentExecuteCallbacks;
+}
+
+/**
+ * Options for streaming agent execution.
+ * Accepts AgentStreamCallbacks including onChunk, onFinish, onError, and onAbort.
+ */
+export interface AgentStreamExecuteOptions extends AgentExecuteOptionsBase {
+  /**
+   * Callbacks for streaming agent execution.
+   * Includes streaming-specific callbacks: onChunk, onFinish, onError, onAbort.
+   */
+  callbacks?: AgentStreamCallbacks;
+}
+export type AgentType =
+  | "openai"
+  | "anthropic"
+  | "google"
+  | "microsoft"
+  | "bedrock";
+
+export const AVAILABLE_CUA_MODELS = [
+  "openai/computer-use-preview",
+  "openai/computer-use-preview-2025-03-11",
+  "anthropic/claude-opus-4-5-20251101",
+  "anthropic/claude-opus-4-6",
+  "anthropic/claude-sonnet-4-6",
+  "anthropic/claude-haiku-4-5-20251001",
+  "anthropic/claude-sonnet-4-20250514",
+  "anthropic/claude-sonnet-4-5-20250929",
+  "google/gemini-2.5-computer-use-preview-10-2025",
+  "google/gemini-3-flash-preview",
+  "google/gemini-3-pro-preview",
+  "microsoft/fara-7b",
+] as const;
+export type AvailableCuaModel = (typeof AVAILABLE_CUA_MODELS)[number];
+
+export interface AgentExecutionOptions<
+  TOptions extends AgentExecuteOptions = AgentExecuteOptions,
+> {
+  options: TOptions;
+  logger: (message: LogLine) => void;
+  retries?: number;
+}
+
+export interface AgentHandlerOptions {
+  modelName: string;
+  clientOptions?: ClientOptions;
+  userProvidedInstructions?: string;
+  experimental?: boolean;
+}
+
+export interface ActionExecutionResult {
+  success: boolean;
+  error?: string;
+  data?: unknown;
+}
+
+/**
+ * Represents a safety check that requires user confirmation before proceeding.
+ * These are issued by CUA providers (OpenAI, Google) when the agent attempts
+ * potentially risky actions.
+ */
+export interface SafetyCheck {
+  /** Unique identifier for this safety check */
+  id: string;
+  /** Code identifying the type of safety concern */
+  code: string;
+  /** Human-readable description of the safety concern */
+  message: string;
+}
+
+/**
+ * Response from the user for a safety confirmation request.
+ */
+export interface SafetyConfirmationResponse {
+  /** Whether the user acknowledged/approved the safety checks */
+  acknowledged: boolean;
+}
+
+/**
+ * Callback for handling safety confirmation requests.
+ * Called when the CUA provider issues safety checks that require user confirmation.
+ * The callback should return a promise that resolves when the user has made a decision.
+ *
+ * @param safetyChecks - Array of safety checks requiring confirmation
+ * @returns Promise resolving to the user's response
+ *
+ * @example
+ * ```typescript
+ * const agent = stagehand.agent({
+ *   mode: "cua",
+ * });
+ * await agent.execute({
+ *   instruction: "...",
+ *   callbacks: {
+ *     onSafetyConfirmation: async (checks) => {
+ *       console.log("Safety checks:", checks);
+ *       const userApproved = await showConfirmationDialog(checks);
+ *       return { acknowledged: userApproved };
+ *     },
+ *   },
+ * });
+ * ```
+ */
+export type SafetyConfirmationHandler = (
+  safetyChecks: SafetyCheck[],
+) => Promise<SafetyConfirmationResponse>;
+
+// Anthropic types:
+
+export interface ToolUseItem extends ResponseItem {
+  type: "tool_use";
+  id: string; // This is the correct property name from Anthropic's API
+  name: string; // Name of the tool being used
+  input: Record<string, unknown>;
+}
+
+export interface AnthropicMessage {
+  role: string;
+  content: string | Array<AnthropicContentBlock>;
+}
+
+export interface AnthropicContentBlock {
+  type: string;
+  [key: string]: unknown;
+}
+
+export interface AnthropicTextBlock extends AnthropicContentBlock {
+  type: "text";
+  text: string;
+}
+
+export interface AnthropicToolResult {
+  type: "tool_result";
+  tool_use_id: string;
+  content: string | Array<AnthropicContentBlock>;
+}
+
+// OpenAI types:
+
+export interface ResponseItem {
+  type: string;
+  id: string;
+  [key: string]: unknown;
+}
+
+export interface ComputerCallItem extends ResponseItem {
+  type: "computer_call";
+  call_id: string;
+  action: {
+    type: string;
+    [key: string]: unknown;
+  };
+  pending_safety_checks?: Array<{
+    id: string;
+    code: string;
+    message: string;
+  }>;
+}
+
+export interface FunctionCallItem extends ResponseItem {
+  type: "function_call";
+  call_id: string;
+  name: string;
+  arguments: string;
+}
+
+export type ResponseInputItem =
+  | { role: string; content: string }
+  | {
+      type: "computer_call_output";
+      call_id: string;
+      output:
+        | {
+            type: "input_image";
+            image_url: string;
+            current_url?: string;
+            error?: string;
+            [key: string]: unknown;
+          }
+        | string;
+      acknowledged_safety_checks?: Array<{
+        id: string;
+        code: string;
+        message: string;
+      }>;
+    }
+  | {
+      type: "function_call_output";
+      call_id: string;
+      output: string;
+    };
+
+export interface AgentInstance {
+  execute: (
+    instructionOrOptions: string | AgentExecuteOptions,
+  ) => Promise<AgentResult>;
+}
+
+export type AgentProviderType = AgentType;
+
+export type AgentModelConfig<TModelName extends string = string> = {
+  modelName: TModelName;
+} & Record<string, unknown>;
+
+/**
+ * Agent tool mode determines which set of tools are available to the agent.
+ * - 'dom': Uses DOM-based tools (act, fillForm) - better for structured page interactions
+ * - 'hybrid': Uses coordinate-based tools (click, type, dragAndDrop, etc.) - better for visual/screenshot-based interactions
+ * - 'cua': Uses Computer Use Agent (CUA) providers like Anthropic Claude or Google Gemini for screenshot-based automation
+ */
+export type AgentToolMode = "dom" | "hybrid" | "cua";
+
+export type AgentConfig = {
+  /**
+   * Custom system prompt to provide to the agent. Overrides the default system prompt.
+   */
+  systemPrompt?: string;
+  /**
+   * MCP integrations - Array of Client objects
+   */
+  integrations?: (Client | string)[];
+  /**
+   * Tools passed to the agent client
+   */
+  tools?: ToolSet;
+  /**
+   * @deprecated Use `mode: "cua"` instead. This option will be removed in a future version.
+   * Enables Computer Use Agent (CUA) mode.
+   */
+  cua?: boolean;
+  /**
+   * The model to use for agent functionality
+   */
+  model?: string | AgentModelConfig<string>;
+  /**
+   * The model to use for tool execution (observe/act calls within agent tools).
+   * If not specified, inherits from the main model configuration.
+   * Format: "provider/model" (e.g., "openai/gpt-4o-mini", "google/gemini-2.0-flash-exp")
+   */
+  executionModel?: string | AgentModelConfig<string>;
+  /**
+   * Enable streaming mode for the agent.
+   * When true, execute() returns AgentStreamResult with textStream for incremental output.
+   * When false (default), execute() returns AgentResult after completion.
+   */
+  stream?: boolean;
+  /**
+   * Tool mode for the agent. Determines which set of tools are available.
+   * - 'dom' (default): Uses DOM-based tools (act, fillForm) for structured interactions
+   * - 'hybrid': Uses coordinate-based tools (click, type, dragAndDrop, clickAndHold, fillFormVision)
+   *             for visual/screenshot-based interactions
+   * - 'cua': Uses Computer Use Agent (CUA) providers for screenshot-based automation
+   */
+  mode?: AgentToolMode;
+};
+
+/**
+ * Agent instance returned when stream: true is set in AgentConfig.
+ * execute() returns a streaming result that can be consumed incrementally.
+ * Accepts AgentStreamExecuteOptions with streaming-specific callbacks.
+ */
+export interface StreamingAgentInstance {
+  execute: (
+    instructionOrOptions: string | AgentStreamExecuteOptions,
+  ) => Promise<AgentStreamResult>;
+}
+
+/**
+ * Agent instance returned when stream is false or not set in AgentConfig.
+ * execute() returns a result after the agent completes.
+ * Accepts AgentExecuteOptions with non-streaming callbacks only.
+ */
+export interface NonStreamingAgentInstance {
+  execute: (
+    instructionOrOptions: string | AgentExecuteOptions,
+  ) => Promise<AgentResult>;
+}
+
+// =============================================================================
+// Vision Action Tool Result Types
+// =============================================================================
+
+/**
+ * Content item type for toModelOutput return values.
+ * Used in tool definitions to return text and/or media to the model.
+ */
+export type ModelOutputContentItem =
+  | { type: "text"; text: string }
+  | { type: "media"; mediaType: string; data: string };
+
+export interface ClickToolResult {
+  success: boolean;
+  describe?: string;
+  coordinates?: number[];
+  error?: string;
+  screenshotBase64?: string;
+}
+
+export interface TypeToolResult {
+  success: boolean;
+  describe?: string;
+  text?: string;
+  error?: string;
+  screenshotBase64?: string;
+}
+
+export interface DragAndDropToolResult {
+  success: boolean;
+  describe?: string;
+  error?: string;
+  screenshotBase64?: string;
+}
+
+export interface FillFormField {
+  action: string;
+  value: string;
+  coordinates: { x: number; y: number };
+}
+
+export interface FillFormVisionToolResult {
+  success: boolean;
+  playwrightArguments?: FillFormField[];
+  error?: string;
+  screenshotBase64?: string;
+}
+
+export interface ScrollToolResult {
+  success: boolean;
+  message: string;
+  scrolledPixels: number;
+  error?: string;
+}
+
+export interface ScrollVisionToolResult extends ScrollToolResult {
+  screenshotBase64?: string;
+}
+
+export interface WaitToolResult {
+  success: boolean;
+  waited: number;
+  screenshotBase64?: string;
+  error?: string;
+}
diff --git a/packages/core/lib/v3/types/public/api.ts b/packages/core/lib/v3/types/public/api.ts
new file mode 100644
index 000000000..33ac3f73a
--- /dev/null
+++ b/packages/core/lib/v3/types/public/api.ts
@@ -0,0 +1,1136 @@
+/**
+ * Centralized Zod schemas for Stagehand Server API
+ *
+ * Naming conventions:
+ * - `*RequestSchema` - Request body schemas (zod4), `*Request` is the inferred type
+ * - `*ResultSchema` - Inner response data (unwrapped), `*Result` is the inferred type
+ * - `*ResponseSchema` - Full response with success wrapper: { success: true, data: *Result }, `*Response` is the inferred type
+ *
+ * All TypeScript types are inferred from the Zod4 *Schemas using z.infer<>
+ */
+import { z } from "zod/v4";
+import type Browserbase from "@browserbasehq/sdk";
+
+// =============================================================================
+// Shared Components
+// =============================================================================
+
+/** Browser launch options for local browsers */
+export const LocalBrowserLaunchOptionsSchema = z
+  .object({
+    args: z.array(z.string()).optional(),
+    executablePath: z.string().optional(),
+    port: z.number().optional(),
+    userDataDir: z.string().optional(),
+    preserveUserDataDir: z.boolean().optional(),
+    headless: z.boolean().optional(),
+    devtools: z.boolean().optional(),
+    chromiumSandbox: z.boolean().optional(),
+    ignoreDefaultArgs: z.union([z.boolean(), z.array(z.string())]).optional(),
+    proxy: z
+      .object({
+        server: z.string(),
+        bypass: z.string().optional(),
+        username: z.string().optional(),
+        password: z.string().optional(),
+      })
+      .optional(),
+    locale: z.string().optional(),
+    viewport: z.object({ width: z.number(), height: z.number() }).optional(),
+    deviceScaleFactor: z.number().optional(),
+    hasTouch: z.boolean().optional(),
+    ignoreHTTPSErrors: z.boolean().optional(),
+    cdpUrl: z.string().optional(),
+    cdpHeaders: z.record(z.string(), z.string()).optional(),
+    connectTimeoutMs: z.number().optional(),
+    downloadsPath: z.string().optional(),
+    acceptDownloads: z.boolean().optional(),
+  })
+  .strict()
+  .meta({ id: "LocalBrowserLaunchOptions" });
+
+/** Detailed model configuration object */
+export const ModelConfigObjectSchema = z
+  .object({
+    provider: z
+      .enum(["openai", "anthropic", "google", "microsoft", "bedrock"])
+      .optional()
+      .meta({
+        description:
+          "AI provider for the model (or provide a baseURL endpoint instead)",
+        example: "openai",
+      }),
+    modelName: z.string().meta({
+      description:
+        "Model name string with provider prefix (e.g., 'openai/gpt-5-nano')",
+      example: "openai/gpt-5-nano",
+    }),
+    apiKey: z.string().optional().meta({
+      description: "API key for the model provider",
+      example: "sk-some-openai-api-key",
+    }),
+    baseURL: z.string().url().optional().meta({
+      description: "Base URL for the model provider",
+      example: "https://api.openai.com/v1",
+    }),
+  })
+  .meta({ id: "ModelConfigObject" });
+
+/** Model configuration */
+export const ModelConfigSchema = ModelConfigObjectSchema.meta({
+  id: "ModelConfig",
+});
+
+/** Action object returned by observe and used by act */
+export const ActionSchema = z
+  .object({
+    selector: z.string().meta({
+      description: "CSS selector or XPath for the element",
+      example: "[data-testid='submit-button']",
+    }),
+    description: z.string().meta({
+      description: "Human-readable description of the action",
+      example: "Click the submit button",
+    }),
+    backendNodeId: z.number().optional().meta({
+      description: "Backend node ID for the element",
+    }),
+    method: z.string().optional().meta({
+      description: "The method to execute (click, fill, etc.)",
+      example: "click",
+    }),
+    arguments: z
+      .array(z.string())
+      .optional()
+      .meta({
+        description: "Arguments to pass to the method",
+        example: ["Hello World"],
+      }),
+  })
+  .meta({
+    id: "Action",
+    description: "Action object returned by observe and used by act",
+  });
+
+/** Session ID path parameter */
+export const SessionIdParamsSchema = z
+  .object({
+    id: z.string().meta({
+      description: "Unique session identifier",
+      example: "c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123",
+    }),
+  })
+  .strict()
+  .meta({ id: "SessionIdParams" });
+
+/** Browser configuration for session start */
+export const BrowserConfigSchema = z
+  .object({
+    type: z.enum(["local", "browserbase"]).optional().meta({
+      description: "Browser type to use",
+      example: "local",
+    }),
+    cdpUrl: z.string().optional().meta({
+      description:
+        "Chrome DevTools Protocol URL for connecting to existing browser",
+      example: "ws://localhost:9222",
+    }),
+    launchOptions: LocalBrowserLaunchOptionsSchema.optional(),
+  })
+  .meta({ id: "BrowserConfig" });
+
+// =============================================================================
+// Request Headers (operational only - auth headers are in security schemes)
+// =============================================================================
+
+/** Operational headers for all session requests (auth handled via security schemes) */
+export const SessionHeadersSchema = z
+  .object({
+    "x-stream-response": z.enum(["true", "false"]).optional().meta({
+      description: "Whether to stream the response via SSE",
+      example: "true",
+    }),
+  })
+  .meta({ id: "SessionHeaders" });
+
+// =============================================================================
+// Response Wrapper Helper
+// =============================================================================
+
+/** Wraps a result schema in standard success response format */
+const wrapResponse = <T extends z.ZodTypeAny>(resultSchema: T, name: string) =>
+  z
+    .object({
+      success: z.boolean().meta({
+        description: "Indicates whether the request was successful",
+      }),
+      data: resultSchema,
+    })
+    .meta({ id: name });
+
+/** Standard error response */
+export const ErrorResponseSchema = z
+  .object({
+    success: z.literal(false),
+    error: z.string(),
+    code: z.string().optional(),
+  })
+  .strict()
+  .meta({ id: "ErrorResponse" });
+
+// =============================================================================
+// Browserbase Session Create Params  (zod+hints duplicated version of Browserbase.Sessions.SessionCreateParams)
+// =============================================================================
+
+/** Browserbase viewport configuration */
+export const BrowserbaseViewportSchema = z
+  .object({
+    width: z.number().optional(),
+    height: z.number().optional(),
+  })
+  .meta({ id: "BrowserbaseViewport" });
+
+/** Browserbase fingerprint screen configuration */
+export const BrowserbaseFingerprintScreenSchema = z
+  .object({
+    maxHeight: z.number().optional(),
+    maxWidth: z.number().optional(),
+    minHeight: z.number().optional(),
+    minWidth: z.number().optional(),
+  })
+  .meta({ id: "BrowserbaseFingerprintScreen" });
+
+/** Browserbase fingerprint configuration for stealth mode */
+export const BrowserbaseFingerprintSchema = z
+  .object({
+    browsers: z
+      .array(z.enum(["chrome", "edge", "firefox", "safari"]))
+      .optional(),
+    devices: z.array(z.enum(["desktop", "mobile"])).optional(),
+    httpVersion: z.enum(["1", "2"]).optional(),
+    locales: z.array(z.string()).optional(),
+    operatingSystems: z
+      .array(z.enum(["android", "ios", "linux", "macos", "windows"]))
+      .optional(),
+    screen: BrowserbaseFingerprintScreenSchema.optional(),
+  })
+  .meta({ id: "BrowserbaseFingerprint" });
+
+/** Browserbase context configuration for session persistence */
+export const BrowserbaseContextSchema = z
+  .object({
+    id: z.string(),
+    persist: z.boolean().optional(),
+  })
+  .meta({ id: "BrowserbaseContext" });
+
+/** Browserbase browser settings for session creation */
+export const BrowserbaseBrowserSettingsSchema = z
+  .object({
+    advancedStealth: z.boolean().optional(),
+    blockAds: z.boolean().optional(),
+    context: BrowserbaseContextSchema.optional(),
+    extensionId: z.string().optional(),
+    fingerprint: BrowserbaseFingerprintSchema.optional(),
+    logSession: z.boolean().optional(),
+    recordSession: z.boolean().optional(),
+    solveCaptchas: z.boolean().optional(),
+    viewport: BrowserbaseViewportSchema.optional(),
+  })
+  .meta({ id: "BrowserbaseBrowserSettings" });
+
+/** Browserbase managed proxy geolocation configuration */
+export const BrowserbaseProxyGeolocationSchema = z
+  .object({
+    country: z.string(),
+    city: z.string().optional(),
+    state: z.string().optional(),
+  })
+  .meta({ id: "BrowserbaseProxyGeolocation" });
+
+/** Browserbase managed proxy configuration */
+export const BrowserbaseProxyConfigSchema = z
+  .object({
+    type: z.literal("browserbase"),
+    domainPattern: z.string().optional(),
+    geolocation: BrowserbaseProxyGeolocationSchema.optional(),
+  })
+  .meta({ id: "BrowserbaseProxyConfig" });
+
+/** External proxy configuration */
+export const ExternalProxyConfigSchema = z
+  .object({
+    type: z.literal("external"),
+    server: z.string(),
+    domainPattern: z.string().optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+  })
+  .meta({ id: "ExternalProxyConfig" });
+
+/** Union of proxy configuration types */
+export const ProxyConfigSchema = z
+  .discriminatedUnion("type", [
+    BrowserbaseProxyConfigSchema,
+    ExternalProxyConfigSchema,
+  ])
+  .meta({ id: "ProxyConfig" });
+
+/** Browserbase region identifier for multi-region support */
+export const BrowserbaseRegionSchema = z
+  .enum(["us-west-2", "us-east-1", "eu-central-1", "ap-southeast-1"])
+  .meta({ id: "BrowserbaseRegion" });
+
+/** Browserbase session creation parameters */
+export const BrowserbaseSessionCreateParamsSchema = z
+  .object({
+    projectId: z.string().optional(),
+    browserSettings: BrowserbaseBrowserSettingsSchema.optional(),
+    extensionId: z.string().optional(),
+    keepAlive: z.boolean().optional(),
+    proxies: z.union([z.boolean(), z.array(ProxyConfigSchema)]).optional(),
+    region: BrowserbaseRegionSchema.optional(),
+    timeout: z.number().optional(),
+    userMetadata: z.record(z.string(), z.unknown()).optional(),
+  })
+  .meta({ id: "BrowserbaseSessionCreateParams" });
+
+// =============================================================================
+// Session Start
+// =============================================================================
+
+export const SessionStartRequestSchema = z
+  .object({
+    modelName: z.string().meta({
+      description: "Model name to use for AI operations",
+      example: "openai/gpt-4o",
+    }),
+    domSettleTimeoutMs: z.number().optional().meta({
+      description: "Timeout in ms to wait for DOM to settle",
+      example: 5000,
+    }),
+    verbose: z
+      .union([z.literal(0), z.literal(1), z.literal(2)])
+      .optional()
+      .meta({
+        description: "Logging verbosity level (0=quiet, 1=normal, 2=debug)",
+        example: 1,
+        override: ({ jsonSchema }: { jsonSchema: Record<string, unknown> }) => {
+          delete jsonSchema.anyOf;
+          delete jsonSchema.allOf;
+          delete jsonSchema.oneOf;
+          jsonSchema.type = "number";
+          jsonSchema.enum = [0, 1, 2];
+        },
+      }),
+    systemPrompt: z.string().optional().meta({
+      description: "Custom system prompt for AI operations",
+    }),
+    browserbaseSessionCreateParams:
+      BrowserbaseSessionCreateParamsSchema.optional(),
+    browser: BrowserConfigSchema.optional(),
+    selfHeal: z.boolean().optional().meta({
+      description: "Enable self-healing for failed actions",
+      example: true,
+    }),
+    browserbaseSessionID: z.string().optional().meta({
+      description: "Existing Browserbase session ID to resume",
+    }),
+    // experimental is a V3 field but doesn't need to go over the wire - included because wire type imports options type
+    experimental: z.boolean().optional(),
+    // V2 compatibility fields - only included because the server imports this type and supports V2
+    // should never be used in v3 clients or v3-only server implementations
+    waitForCaptchaSolves: z.boolean().optional().meta({
+      description: "Wait for captcha solves (deprecated, v2 only)",
+    }),
+    actTimeoutMs: z.number().optional().meta({
+      description: "Timeout in ms for act operations (deprecated, v2 only)",
+    }),
+  })
+  .meta({ id: "SessionStartRequest" });
+
+export const SessionStartResultSchema = z
+  .object({
+    sessionId: z.string().meta({
+      description: "Unique Browserbase session identifier",
+      example: "c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123",
+    }),
+    cdpUrl: z.string().nullish().meta({
+      description:
+        "CDP WebSocket URL for connecting to the Browserbase cloud browser (present when available)",
+      example: "wss://connect.browserbase.com/?signingKey=abc123",
+    }),
+    available: z.boolean(),
+  })
+  .meta({ id: "SessionStartResult" });
+
+export const SessionStartResponseSchema = wrapResponse(
+  SessionStartResultSchema,
+  "SessionStartResponse",
+);
+
+// =============================================================================
+// Session End
+// =============================================================================
+
+/** Session end request - no request body. */
+export const SessionEndRequestSchema = z
+  .object({})
+  .strict()
+  .optional()
+  .meta({ id: "SessionEndRequest" });
+
+export const SessionEndResultSchema = z
+  .object({})
+  .strict()
+  .meta({ id: "SessionEndResult" });
+
+/** Session end response - just success flag, no data wrapper */
+export const SessionEndResponseSchema = z
+  .object({
+    success: z.boolean().meta({
+      description: "Indicates whether the request was successful",
+    }),
+  })
+  .strict()
+  .meta({ id: "SessionEndResponse" });
+
+// =============================================================================
+// Act
+// =============================================================================
+
+export const ActOptionsSchema = z
+  .object({
+    model: z.union([ModelConfigSchema, z.string()]).optional().meta({
+      description:
+        "Model configuration object or model name string (e.g., 'openai/gpt-5-nano')",
+    }),
+    variables: z
+      .record(z.string(), z.string())
+      .optional()
+      .meta({
+        description: "Variables to substitute in the action instruction",
+        example: { username: "john_doe" },
+      }),
+    timeout: z.number().optional().meta({
+      description: "Timeout in ms for the action",
+      example: 30000,
+    }),
+  })
+  .optional()
+  .meta({ id: "ActOptions" });
+
+export const ActRequestSchema = z
+  .object({
+    input: z.string().or(ActionSchema).meta({
+      description: "Natural language instruction or Action object",
+      example: "Click the login button",
+    }),
+    options: ActOptionsSchema,
+    frameId: z.string().nullish().meta({
+      description: "Target frame ID for the action",
+    }),
+    streamResponse: z.boolean().optional().meta({
+      description: "Whether to stream the response via SSE",
+      example: true,
+    }),
+  })
+  .meta({ id: "ActRequest" });
+
+/** Inner act result data */
+export const ActResultDataSchema = z
+  .object({
+    success: z.boolean().meta({
+      description: "Whether the action completed successfully",
+      example: true,
+    }),
+    message: z.string().meta({
+      description: "Human-readable result message",
+      example: "Successfully clicked the login button",
+    }),
+    actionDescription: z.string().meta({
+      description: "Description of the action that was performed",
+      example: "Clicked button with text 'Login'",
+    }),
+    actions: z.array(ActionSchema).meta({
+      description: "List of actions that were executed",
+    }),
+  })
+  .meta({ id: "ActResultData" });
+
+export const ActResultSchema = z
+  .object({
+    result: ActResultDataSchema,
+    actionId: z.string().optional().meta({
+      description: "Action ID for tracking",
+    }),
+  })
+  .meta({ id: "ActResult" });
+
+export const ActResponseSchema = wrapResponse(ActResultSchema, "ActResponse");
+
+// =============================================================================
+// Extract
+// =============================================================================
+
+export const ExtractOptionsSchema = z
+  .object({
+    model: z.union([ModelConfigSchema, z.string()]).optional().meta({
+      description:
+        "Model configuration object or model name string (e.g., 'openai/gpt-5-nano')",
+    }),
+    timeout: z.number().optional().meta({
+      description: "Timeout in ms for the extraction",
+      example: 30000,
+    }),
+    selector: z.string().optional().meta({
+      description: "CSS selector to scope extraction to a specific element",
+      example: "#main-content",
+    }),
+  })
+  .optional()
+  .meta({ id: "ExtractOptions" });
+
+export const ExtractRequestSchema = z
+  .object({
+    instruction: z.string().optional().meta({
+      description: "Natural language instruction for what to extract",
+      example: "Extract all product names and prices from the page",
+    }),
+    schema: z.record(z.string(), z.unknown()).optional().meta({
+      description: "JSON Schema defining the structure of data to extract",
+    }),
+    options: ExtractOptionsSchema,
+    frameId: z.string().nullish().meta({
+      description: "Target frame ID for the extraction",
+    }),
+    streamResponse: z.boolean().optional().meta({
+      description: "Whether to stream the response via SSE",
+      example: true,
+    }),
+  })
+  .meta({ id: "ExtractRequest" });
+
+export const ExtractResultSchema = z
+  .object({
+    result: z.unknown().meta({
+      description: "Extracted data matching the requested schema",
+      override: ({ jsonSchema }: { jsonSchema: Record<string, unknown> }) => {
+        jsonSchema["x-stainless-any"] = true;
+      },
+    }),
+    actionId: z.string().optional().meta({
+      description: "Action ID for tracking",
+    }),
+  })
+  .meta({ id: "ExtractResult" });
+
+export const ExtractResponseSchema = wrapResponse(
+  ExtractResultSchema,
+  "ExtractResponse",
+);
+
+// =============================================================================
+// Observe
+// =============================================================================
+
+export const ObserveOptionsSchema = z
+  .object({
+    model: z.union([ModelConfigSchema, z.string()]).optional().meta({
+      description:
+        "Model configuration object or model name string (e.g., 'openai/gpt-5-nano')",
+    }),
+    timeout: z.number().optional().meta({
+      description: "Timeout in ms for the observation",
+      example: 30000,
+    }),
+    selector: z.string().optional().meta({
+      description: "CSS selector to scope observation to a specific element",
+      example: "nav",
+    }),
+  })
+  .optional()
+  .meta({ id: "ObserveOptions" });
+
+export const ObserveRequestSchema = z
+  .object({
+    instruction: z.string().optional().meta({
+      description: "Natural language instruction for what actions to find",
+      example: "Find all clickable navigation links",
+    }),
+    options: ObserveOptionsSchema,
+    frameId: z.string().nullish().meta({
+      description: "Target frame ID for the observation",
+    }),
+    streamResponse: z.boolean().optional().meta({
+      description: "Whether to stream the response via SSE",
+      example: true,
+    }),
+  })
+  .meta({ id: "ObserveRequest" });
+
+export const ObserveResultSchema = z
+  .object({
+    result: z.array(ActionSchema),
+    actionId: z.string().optional().meta({
+      description: "Action ID for tracking",
+    }),
+  })
+  .meta({ id: "ObserveResult" });
+
+export const ObserveResponseSchema = wrapResponse(
+  ObserveResultSchema,
+  "ObserveResponse",
+);
+
+// =============================================================================
+// Agent Execute
+// =============================================================================
+
+export const AgentConfigSchema = z
+  .object({
+    provider: z // cloud accepts provider: at the top level for legacy reasons, in the future we should remove it
+      .enum(["openai", "anthropic", "google", "microsoft", "bedrock"])
+      .optional()
+      .meta({
+        description:
+          "AI provider for the agent (legacy, use model: openai/gpt-5-nano instead)",
+        example: "openai",
+      }),
+    model: z.union([ModelConfigSchema, z.string()]).optional().meta({
+      description:
+        "Model configuration object or model name string (e.g., 'openai/gpt-5-nano')",
+    }),
+    systemPrompt: z.string().optional().meta({
+      description: "Custom system prompt for the agent",
+    }),
+    cua: z.boolean().optional().meta({
+      description:
+        "Deprecated. Use mode: 'cua' instead. If both are provided, mode takes precedence.",
+      example: true,
+    }),
+    mode: z.enum(["dom", "hybrid", "cua"]).optional().meta({
+      description:
+        "Tool mode for the agent (dom, hybrid, cua). If set, overrides cua.",
+      example: "cua",
+    }),
+    executionModel: z.union([ModelConfigSchema, z.string()]).optional().meta({
+      description:
+        "Model configuration object or model name string (e.g., 'openai/gpt-5-nano') for tool execution (observe/act calls within agent tools). If not specified, inherits from the main model configuration.",
+    }),
+  })
+  .meta({ id: "AgentConfig" });
+
+/** Action taken by the agent during execution */
+export const AgentActionSchema = z
+  .object({
+    type: z.string().meta({
+      description: "Type of action taken",
+      example: "click",
+    }),
+    reasoning: z.string().optional().meta({
+      description: "Agent's reasoning for taking this action",
+    }),
+    taskCompleted: z.boolean().optional(),
+    action: z.string().optional(),
+    timeMs: z.number().optional().meta({
+      description: "Time taken for this action in ms",
+    }),
+    pageText: z.string().optional(),
+    pageUrl: z.string().optional(),
+    instruction: z.string().optional(),
+  })
+  .passthrough()
+  .meta({ id: "AgentAction" });
+
+/** Token usage statistics for agent execution */
+export const AgentUsageSchema = z
+  .object({
+    input_tokens: z.number().meta({ example: 1500 }),
+    output_tokens: z.number().meta({ example: 250 }),
+    reasoning_tokens: z.number().optional(),
+    cached_input_tokens: z.number().optional(),
+    inference_time_ms: z.number().meta({ example: 2500 }),
+  })
+  .meta({ id: "AgentUsage" });
+
+/** Result data from agent execution */
+export const AgentResultDataSchema = z
+  .object({
+    success: z.boolean().meta({
+      description: "Whether the agent completed successfully",
+      example: true,
+    }),
+    message: z.string().meta({
+      description: "Summary of what the agent accomplished",
+      example: "Successfully logged in and navigated to dashboard",
+    }),
+    actions: z.array(AgentActionSchema),
+    completed: z.boolean().meta({
+      description: "Whether the agent finished its task",
+      example: true,
+    }),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    usage: AgentUsageSchema.optional(),
+  })
+  .meta({ id: "AgentResultData" });
+
+export const AgentCacheEntrySchema = z
+  .object({
+    cacheKey: z.string().meta({
+      description:
+        "Opaque cache identifier computed from instruction, URL, options, and config",
+    }),
+    entry: z.unknown().meta({
+      description: "Serialized cache entry that can be written to disk",
+    }),
+  })
+  .meta({ id: "AgentCacheEntry" });
+
+export const AgentExecuteOptionsSchema = z
+  .object({
+    instruction: z.string().meta({
+      description: "Natural language instruction for the agent",
+      example:
+        "Log in with username 'demo' and password 'test123', then navigate to settings",
+    }),
+    maxSteps: z.number().optional().meta({
+      description: "Maximum number of steps the agent can take",
+      example: 20,
+    }),
+    highlightCursor: z.boolean().optional().meta({
+      description: "Whether to visually highlight the cursor during execution",
+      example: true,
+    }),
+  })
+  .meta({ id: "AgentExecuteOptions" });
+
+export const AgentExecuteRequestSchema = z
+  .object({
+    agentConfig: AgentConfigSchema,
+    executeOptions: AgentExecuteOptionsSchema,
+    frameId: z.string().nullish().meta({
+      description: "Target frame ID for the agent",
+    }),
+    streamResponse: z.boolean().optional().meta({
+      description: "Whether to stream the response via SSE",
+      example: true,
+    }),
+    shouldCache: z.boolean().optional().meta({
+      description:
+        "If true, the server captures a cache entry and returns it to the client",
+    }),
+  })
+  .meta({ id: "AgentExecuteRequest" });
+
+export const AgentExecuteResultSchema = z
+  .object({
+    result: AgentResultDataSchema,
+    cacheEntry: AgentCacheEntrySchema.optional(),
+  })
+  .meta({ id: "AgentExecuteResult" });
+
+export const AgentExecuteResponseSchema = wrapResponse(
+  AgentExecuteResultSchema,
+  "AgentExecuteResponse",
+);
+
+// =============================================================================
+// Navigate
+// =============================================================================
+
+export const NavigateOptionsSchema = z
+  .object({
+    referer: z.string().optional().meta({
+      description: "Referer header to send with the request",
+    }),
+    timeout: z.number().optional().meta({
+      description: "Timeout in ms for the navigation",
+      example: 30000,
+    }),
+    waitUntil: z
+      .enum(["load", "domcontentloaded", "networkidle"])
+      .optional()
+      .meta({
+        description: "When to consider navigation complete",
+        example: "networkidle",
+      }),
+  })
+  .optional()
+  .meta({ id: "NavigateOptions" });
+
+export const NavigateRequestSchema = z
+  .object({
+    url: z.string().meta({
+      description: "URL to navigate to",
+      example: "https://example.com",
+    }),
+    options: NavigateOptionsSchema,
+    frameId: z.string().nullish().meta({
+      description: "Target frame ID for the navigation",
+    }),
+    streamResponse: z.boolean().optional().meta({
+      description: "Whether to stream the response via SSE",
+      example: true,
+    }),
+  })
+  .meta({ id: "NavigateRequest" });
+
+export const NavigateResultSchema = z
+  .object({
+    // SerializableResponse from types/private/api.ts - no Zod schema available
+    // as it wraps complex devtools-protocol types (Protocol.Network.Response)
+    result: z
+      .unknown()
+      .nullable()
+      .meta({
+        description: "Navigation response (Playwright Response object or null)",
+        override: ({ jsonSchema }: { jsonSchema: Record<string, unknown> }) => {
+          jsonSchema["x-stainless-any"] = true;
+        },
+      }),
+    actionId: z.string().optional().meta({
+      description: "Action ID for tracking",
+    }),
+  })
+  .meta({ id: "NavigateResult" });
+
+export const NavigateResponseSchema = wrapResponse(
+  NavigateResultSchema,
+  "NavigateResponse",
+);
+
+// =============================================================================
+// Replay Metrics
+// =============================================================================
+
+/** Token usage for a single action */
+export const TokenUsageSchema = z
+  .object({
+    inputTokens: z.number().optional(),
+    outputTokens: z.number().optional(),
+    timeMs: z.number().optional(),
+    cost: z.number().optional(),
+  })
+  .meta({ id: "TokenUsage" });
+
+/** Action entry in replay metrics */
+export const ReplayActionSchema = z
+  .object({
+    method: z.string(),
+    parameters: z.record(z.string(), z.unknown()),
+    result: z.record(z.string(), z.unknown()),
+    timestamp: z.number(),
+    endTime: z.number().optional(),
+    tokenUsage: TokenUsageSchema.optional(),
+  })
+  .meta({ id: "ReplayAction" });
+
+/** Page entry in replay metrics */
+export const ReplayPageSchema = z
+  .object({
+    url: z.string(),
+    timestamp: z.number(),
+    duration: z.number(),
+    actions: z.array(ReplayActionSchema),
+  })
+  .meta({ id: "ReplayPage" });
+
+/** Inner result data for replay */
+export const ReplayResultSchema = z
+  .object({
+    pages: z.array(ReplayPageSchema),
+    clientLanguage: z.string().optional(),
+  })
+  .meta({ id: "ReplayResult" });
+
+export const ReplayResponseSchema = wrapResponse(
+  ReplayResultSchema,
+  "ReplayResponse",
+);
+
+// =============================================================================
+// SSE Stream Events
+// =============================================================================
+// These schemas define the Server-Sent Events format for streaming responses.
+// Streaming is enabled by setting the `x-stream-response: true` header.
+
+/** Status values for SSE stream events */
+export const StreamEventStatusSchema = z
+  .enum(["starting", "connected", "running", "finished", "error"])
+  .meta({
+    id: "StreamEventStatus",
+    description: "Current status of the streaming operation",
+  });
+
+/** Type discriminator for SSE stream events */
+export const StreamEventTypeSchema = z.enum(["system", "log"]).meta({
+  id: "StreamEventType",
+  description: "Type of stream event - system events or log messages",
+});
+
+/** Data payload for system stream events */
+export const StreamEventSystemDataSchema = z
+  .object({
+    status: StreamEventStatusSchema,
+    result: z
+      .unknown()
+      .optional()
+      .meta({
+        description: "Operation result (present when status is 'finished')",
+        override: ({ jsonSchema }: { jsonSchema: Record<string, unknown> }) => {
+          jsonSchema["x-stainless-any"] = true;
+        },
+      }),
+    error: z.string().optional().meta({
+      description: "Error message (present when status is 'error')",
+    }),
+  })
+  .meta({ id: "StreamEventSystemData" });
+
+/** Data payload for log stream events */
+export const StreamEventLogDataSchema = z
+  .object({
+    status: z.literal("running"),
+    message: z.string().meta({
+      description: "Log message from the operation",
+    }),
+  })
+  .meta({ id: "StreamEventLogData" });
+
+/**
+ * SSE stream event sent during streaming responses.
+ *
+ * IMPORTANT: Key ordering matters for Stainless SDK generation.
+ * The `data` field MUST be serialized first, with `status` as the first key within it.
+ * This allows Stainless to use `data_starts_with: '{"data":{"status":"finished"'` for event handling.
+ *
+ * Expected serialization order: {"data":{"status":...},"type":...,"id":...}
+ */
+export const StreamEventSchema = z
+  .object({
+    data: z.union([StreamEventSystemDataSchema, StreamEventLogDataSchema]),
+    type: StreamEventTypeSchema,
+    id: z.string().uuid().meta({
+      description: "Unique identifier for this event",
+      example: "c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123",
+    }),
+  })
+  .meta({
+    id: "StreamEvent",
+    description:
+      "Server-Sent Event emitted during streaming responses. Events are sent as `data: <JSON>\\n\\n`. Key order: data (with status first), type, id.",
+  });
+
+// =============================================================================
+// OpenAPI Components
+// =============================================================================
+// These objects are exported for use in gen-openapi.ts to configure the spec.
+
+/** OpenAPI security schemes for authentication */
+export const openApiSecuritySchemes = {
+  BrowserbaseApiKey: {
+    type: "apiKey",
+    in: "header",
+    name: "x-bb-api-key",
+    description: "Browserbase API key for authentication",
+  },
+  BrowserbaseProjectId: {
+    type: "apiKey",
+    in: "header",
+    name: "x-bb-project-id",
+    description: "Browserbase project ID",
+  },
+  ModelApiKey: {
+    type: "apiKey",
+    in: "header",
+    name: "x-model-api-key",
+    description: "API key for the AI model provider (OpenAI, Anthropic, etc.)",
+  },
+} as const;
+
+/** OpenAPI links for session operations (used in SessionStart response) */
+export const openApiLinks = {
+  SessionAct: {
+    operationId: "SessionAct",
+    parameters: { id: "$response.body#/data/sessionId" },
+    description: "Perform an action on the session",
+  },
+  SessionExtract: {
+    operationId: "SessionExtract",
+    parameters: { id: "$response.body#/data/sessionId" },
+    description: "Extract data from the session",
+  },
+  SessionObserve: {
+    operationId: "SessionObserve",
+    parameters: { id: "$response.body#/data/sessionId" },
+    description: "Observe available actions on the session",
+  },
+  SessionNavigate: {
+    operationId: "SessionNavigate",
+    parameters: { id: "$response.body#/data/sessionId" },
+    description: "Navigate to a URL in the session",
+  },
+  SessionAgentExecute: {
+    operationId: "SessionAgentExecute",
+    parameters: { id: "$response.body#/data/sessionId" },
+    description: "Execute an agent on the session",
+  },
+  SessionReplay: {
+    operationId: "SessionReplay",
+    parameters: { id: "$response.body#/data/sessionId" },
+    description: "Replay session metrics",
+  },
+  SessionEnd: {
+    operationId: "SessionEnd",
+    parameters: { id: "$response.body#/data/sessionId" },
+    description: "End the session and release resources",
+  },
+} as const;
+
+/** OpenAPI operation metadata for each endpoint */
+export const Operations = {
+  SessionStart: {
+    operationId: "SessionStart",
+    summary: "Start a new browser session",
+    description:
+      "Creates a new browser session with the specified configuration. Returns a session ID used for all subsequent operations.",
+  },
+  SessionEnd: {
+    operationId: "SessionEnd",
+    summary: "End a browser session",
+    description:
+      "Terminates the browser session and releases all associated resources.",
+  },
+  SessionAct: {
+    operationId: "SessionAct",
+    summary: "Perform an action",
+    description:
+      "Executes a browser action using natural language instructions or a predefined Action object.",
+  },
+  SessionExtract: {
+    operationId: "SessionExtract",
+    summary: "Extract data from the page",
+    description:
+      "Extracts structured data from the current page using AI-powered analysis.",
+  },
+  SessionObserve: {
+    operationId: "SessionObserve",
+    summary: "Observe available actions",
+    description:
+      "Identifies and returns available actions on the current page that match the given instruction.",
+  },
+  SessionNavigate: {
+    operationId: "SessionNavigate",
+    summary: "Navigate to a URL",
+    description: "Navigates the browser to the specified URL.",
+  },
+  SessionAgentExecute: {
+    operationId: "SessionAgentExecute",
+    summary: "Execute an AI agent",
+    description:
+      "Runs an autonomous AI agent that can perform complex multi-step browser tasks.",
+  },
+  SessionReplay: {
+    operationId: "SessionReplay",
+    summary: "Replay session metrics",
+    description: "Retrieves replay metrics for a session.",
+  },
+} as const;
+
+// =============================================================================
+// Type Exports (inferred from schemas)
+// =============================================================================
+
+// Shared types
+export type Action = z.infer<typeof ActionSchema>;
+export type ModelConfig = z.infer<typeof ModelConfigSchema>;
+export type BrowserConfig = z.infer<typeof BrowserConfigSchema>;
+export type SessionIdParams = z.infer<typeof SessionIdParamsSchema>;
+
+// Header types
+export type SessionHeaders = z.infer<typeof SessionHeadersSchema>;
+
+// Browserbase types
+export type BrowserbaseViewport = z.infer<typeof BrowserbaseViewportSchema>;
+export type BrowserbaseFingerprintScreen = z.infer<
+  typeof BrowserbaseFingerprintScreenSchema
+>;
+export type BrowserbaseFingerprint = z.infer<
+  typeof BrowserbaseFingerprintSchema
+>;
+export type BrowserbaseContext = z.infer<typeof BrowserbaseContextSchema>;
+export type BrowserbaseBrowserSettings = z.infer<
+  typeof BrowserbaseBrowserSettingsSchema
+>;
+export type BrowserbaseProxyGeolocation = z.infer<
+  typeof BrowserbaseProxyGeolocationSchema
+>;
+export type BrowserbaseProxyConfig = z.infer<
+  typeof BrowserbaseProxyConfigSchema
+>;
+export type ExternalProxyConfig = z.infer<typeof ExternalProxyConfigSchema>;
+export type BrowserbaseRegion = z.infer<typeof BrowserbaseRegionSchema>;
+export type BrowserbaseSessionCreateParams = z.infer<
+  typeof BrowserbaseSessionCreateParamsSchema
+>;
+
+// Type check: ensure our schema-derived type is assignable to the SDK type
+// This will cause a compile error if our schema drifts from the SDK
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+type _BrowserbaseSessionCreateParamsCheck =
+  BrowserbaseSessionCreateParams extends Browserbase.Sessions.SessionCreateParams
+    ? true
+    : never;
+
+// /sessions/start
+export type SessionStartRequest = z.infer<typeof SessionStartRequestSchema>;
+export type SessionStartResult = z.infer<typeof SessionStartResultSchema>;
+export type SessionStartResponse = z.infer<typeof SessionStartResponseSchema>;
+
+// /sessions/{id}/end
+export type SessionEndResult = z.infer<typeof SessionEndResultSchema>;
+export type SessionEndResponse = z.infer<typeof SessionEndResponseSchema>;
+
+// /sessions/{id}/act
+export type ActRequest = z.infer<typeof ActRequestSchema>;
+export type ActResultData = z.infer<typeof ActResultDataSchema>;
+export type ActResult = z.infer<typeof ActResultSchema>;
+export type ActResponse = z.infer<typeof ActResponseSchema>;
+
+// /sessions/{id}/extract
+export type ExtractRequest = z.infer<typeof ExtractRequestSchema>;
+export type ExtractResult = z.infer<typeof ExtractResultSchema>;
+export type ExtractResponse = z.infer<typeof ExtractResponseSchema>;
+
+// /sessions/{id}/observe
+export type ObserveRequest = z.infer<typeof ObserveRequestSchema>;
+export type ObserveResult = z.infer<typeof ObserveResultSchema>;
+export type ObserveResponse = z.infer<typeof ObserveResponseSchema>;
+
+// /sessions/{id}/agentExecute
+export type AgentAction = z.infer<typeof AgentActionSchema>;
+export type AgentUsage = z.infer<typeof AgentUsageSchema>;
+export type AgentResultData = z.infer<typeof AgentResultDataSchema>;
+export type AgentExecuteRequest = z.infer<typeof AgentExecuteRequestSchema>;
+export type AgentExecuteResult = z.infer<typeof AgentExecuteResultSchema>;
+export type AgentExecuteResponse = z.infer<typeof AgentExecuteResponseSchema>;
+
+// /sessions/{id}/navigate
+export type NavigateRequest = z.infer<typeof NavigateRequestSchema>;
+export type NavigateResult = z.infer<typeof NavigateResultSchema>;
+export type NavigateResponse = z.infer<typeof NavigateResponseSchema>;
+
+// /sessions/{id}/replay
+export type TokenUsage = z.infer<typeof TokenUsageSchema>;
+export type ReplayAction = z.infer<typeof ReplayActionSchema>;
+export type ReplayPage = z.infer<typeof ReplayPageSchema>;
+export type ReplayResult = z.infer<typeof ReplayResultSchema>;
+export type ReplayResponse = z.infer<typeof ReplayResponseSchema>;
+
+// SSE Stream Events
+export type StreamEventStatus = z.infer<typeof StreamEventStatusSchema>;
+export type StreamEventType = z.infer<typeof StreamEventTypeSchema>;
+export type StreamEventSystemData = z.infer<typeof StreamEventSystemDataSchema>;
+export type StreamEventLogData = z.infer<typeof StreamEventLogDataSchema>;
+export type StreamEvent = z.infer<typeof StreamEventSchema>;
diff --git a/types/stagehandApiErrors.ts b/packages/core/lib/v3/types/public/apiErrors.ts
similarity index 100%
rename from types/stagehandApiErrors.ts
rename to packages/core/lib/v3/types/public/apiErrors.ts
diff --git a/packages/core/lib/v3/types/public/context.ts b/packages/core/lib/v3/types/public/context.ts
new file mode 100644
index 000000000..f5a173436
--- /dev/null
+++ b/packages/core/lib/v3/types/public/context.ts
@@ -0,0 +1,34 @@
+/** A cookie as returned by the browser. */
+export interface Cookie {
+  name: string;
+  value: string;
+  domain: string;
+  path: string;
+  /** Unix time in seconds. -1 means session cookie. */
+  expires: number;
+  httpOnly: boolean;
+  secure: boolean;
+  sameSite: "Strict" | "Lax" | "None";
+}
+
+/** Parameters for setting a cookie. Provide `url` OR `domain`+`path`, not both. */
+export interface CookieParam {
+  name: string;
+  value: string;
+  /** Convenience: if provided, domain/path/secure are derived from this URL. */
+  url?: string;
+  domain?: string;
+  path?: string;
+  /** Unix timestamp in seconds. -1 or omitted = session cookie. */
+  expires?: number;
+  httpOnly?: boolean;
+  secure?: boolean;
+  sameSite?: "Strict" | "Lax" | "None";
+}
+
+/** Filter options for clearing cookies selectively. */
+export interface ClearCookieOptions {
+  name?: string | RegExp;
+  domain?: string | RegExp;
+  path?: string | RegExp;
+}
diff --git a/packages/core/lib/v3/types/public/index.ts b/packages/core/lib/v3/types/public/index.ts
new file mode 100644
index 000000000..9c5df08d0
--- /dev/null
+++ b/packages/core/lib/v3/types/public/index.ts
@@ -0,0 +1,16 @@
+export * from "./agent.js";
+// Export api.ts under namespace to avoid conflicts with methods.ts types
+export * as Api from "./api.js";
+// Also export BrowserbaseRegion directly for convenience
+export type { BrowserbaseRegion } from "./api.js";
+export * from "./apiErrors.js";
+export * from "./logs.js";
+export * from "./methods.js";
+export * from "./metrics.js";
+export * from "./model.js";
+export * from "./options.js";
+export * from "./page.js";
+export * from "./sdkErrors.js";
+export * from "./context.js";
+export { AISdkClient } from "../../external_clients/aisdk.js";
+export { CustomOpenAIClient } from "../../external_clients/customOpenAI.js";
diff --git a/packages/core/lib/v3/types/public/locator.ts b/packages/core/lib/v3/types/public/locator.ts
new file mode 100644
index 000000000..e2e188c44
--- /dev/null
+++ b/packages/core/lib/v3/types/public/locator.ts
@@ -0,0 +1,16 @@
+import { Buffer } from "buffer";
+
+export type MouseButton = "left" | "right" | "middle";
+
+export interface SetInputFilePayload {
+  name: string;
+  mimeType?: string;
+  buffer: ArrayBuffer | Uint8Array | Buffer | string;
+  lastModified?: number;
+}
+
+export type SetInputFilesArgument =
+  | string
+  | string[]
+  | SetInputFilePayload
+  | SetInputFilePayload[];
diff --git a/types/log.ts b/packages/core/lib/v3/types/public/logs.ts
similarity index 100%
rename from types/log.ts
rename to packages/core/lib/v3/types/public/logs.ts
diff --git a/packages/core/lib/v3/types/public/methods.ts b/packages/core/lib/v3/types/public/methods.ts
new file mode 100644
index 000000000..ded9c0267
--- /dev/null
+++ b/packages/core/lib/v3/types/public/methods.ts
@@ -0,0 +1,100 @@
+import { Page as PatchrightPage } from "patchright-core";
+import { Page as PlaywrightPage } from "playwright-core";
+import { Page as PuppeteerPage } from "puppeteer-core";
+import { z } from "zod";
+import type {
+  InferStagehandSchema,
+  StagehandZodSchema,
+} from "../../zodCompat.js";
+import { Page } from "../../understudy/page.js";
+import { ModelConfiguration } from "../public/model.js";
+import type { Variables } from "./agent.js";
+
+export interface ActOptions {
+  model?: ModelConfiguration;
+  variables?: Variables;
+  timeout?: number;
+  page?: PlaywrightPage | PuppeteerPage | PatchrightPage | Page;
+  /**
+   * Override the instance-level serverCache setting for this request.
+   * When true, enables server-side caching.
+   * When false, disables server-side caching.
+   */
+  serverCache?: boolean;
+}
+
+export interface ActResult {
+  success: boolean;
+  message: string;
+  actionDescription: string;
+  actions: Action[];
+  cacheStatus?: "HIT" | "MISS";
+}
+
+export type ExtractResult<T extends StagehandZodSchema> =
+  InferStagehandSchema<T> & {
+    cacheStatus?: "HIT" | "MISS";
+  };
+
+export interface Action {
+  selector: string;
+  description: string;
+  method?: string;
+  arguments?: string[];
+}
+
+export interface HistoryEntry {
+  method: "act" | "extract" | "observe" | "navigate" | "agent";
+  parameters: unknown;
+  result: unknown;
+  timestamp: string;
+}
+
+export interface ExtractOptions {
+  model?: ModelConfiguration;
+  timeout?: number;
+  selector?: string;
+  page?: PlaywrightPage | PuppeteerPage | PatchrightPage | Page;
+  /**
+   * Override the instance-level serverCache setting for this request.
+   * When true, enables server-side caching.
+   * When false, disables server-side caching.
+   */
+  serverCache?: boolean;
+}
+
+export const defaultExtractSchema = z.object({
+  extraction: z.string(),
+});
+
+export const pageTextSchema = z.object({
+  pageText: z.string(),
+});
+
+export interface ObserveOptions {
+  model?: ModelConfiguration;
+  timeout?: number;
+  selector?: string;
+  page?: PlaywrightPage | PuppeteerPage | PatchrightPage | Page;
+  /**
+   * Override the instance-level serverCache setting for this request.
+   * When true, enables server-side caching.
+   * When false, disables server-side caching.
+   */
+  serverCache?: boolean;
+}
+
+/**
+ * Observe returns an array of candidate actions. The optional `cacheStatus`
+ * property is attached when the server responds with a
+ * `browserbase-cache-status` header so callers can tell whether the result
+ * was served from the server-side cache.
+ */
+export type ObserveResult = Action[] & { cacheStatus?: "HIT" | "MISS" };
+
+export enum V3FunctionName {
+  ACT = "ACT",
+  EXTRACT = "EXTRACT",
+  OBSERVE = "OBSERVE",
+  AGENT = "AGENT",
+}
diff --git a/packages/core/lib/v3/types/public/metrics.ts b/packages/core/lib/v3/types/public/metrics.ts
new file mode 100644
index 000000000..45728e01e
--- /dev/null
+++ b/packages/core/lib/v3/types/public/metrics.ts
@@ -0,0 +1,27 @@
+export interface StagehandMetrics {
+  actPromptTokens: number;
+  actCompletionTokens: number;
+  actReasoningTokens: number;
+  actCachedInputTokens: number;
+  actInferenceTimeMs: number;
+  extractPromptTokens: number;
+  extractCompletionTokens: number;
+  extractReasoningTokens: number;
+  extractCachedInputTokens: number;
+  extractInferenceTimeMs: number;
+  observePromptTokens: number;
+  observeCompletionTokens: number;
+  observeReasoningTokens: number;
+  observeCachedInputTokens: number;
+  observeInferenceTimeMs: number;
+  agentPromptTokens: number;
+  agentCompletionTokens: number;
+  agentReasoningTokens: number;
+  agentCachedInputTokens: number;
+  agentInferenceTimeMs: number;
+  totalPromptTokens: number;
+  totalCompletionTokens: number;
+  totalReasoningTokens: number;
+  totalCachedInputTokens: number;
+  totalInferenceTimeMs: number;
+}
diff --git a/packages/core/lib/v3/types/public/model.ts b/packages/core/lib/v3/types/public/model.ts
new file mode 100644
index 000000000..983516d63
--- /dev/null
+++ b/packages/core/lib/v3/types/public/model.ts
@@ -0,0 +1,121 @@
+import type { ClientOptions as AnthropicClientOptionsBase } from "@anthropic-ai/sdk";
+import type { GoogleVertexProviderSettings as GoogleVertexProviderSettingsBase } from "@ai-sdk/google-vertex";
+import type { LanguageModelV2 } from "@ai-sdk/provider";
+import type { ClientOptions as OpenAIClientOptionsBase } from "openai";
+import type { AgentProviderType } from "./agent.js";
+
+export type OpenAIClientOptions = Pick<
+  OpenAIClientOptionsBase,
+  "baseURL" | "apiKey"
+>;
+
+export type AnthropicClientOptions = Pick<
+  AnthropicClientOptionsBase,
+  "baseURL" | "apiKey"
+>;
+
+export interface GoogleServiceAccountCredentials {
+  type?: string;
+  project_id?: string;
+  private_key_id?: string;
+  private_key?: string;
+  client_email?: string;
+  client_id?: string;
+  auth_uri?: string;
+  token_uri?: string;
+  auth_provider_x509_cert_url?: string;
+  client_x509_cert_url?: string;
+  universe_domain?: string;
+}
+
+export type GoogleVertexProviderSettings = Pick<
+  GoogleVertexProviderSettingsBase,
+  "project" | "location" | "headers"
+> & {
+  googleAuthOptions?: {
+    credentials?: GoogleServiceAccountCredentials;
+  };
+};
+
+export type AnthropicJsonSchemaObject = {
+  definitions?: {
+    MySchema?: {
+      properties?: Record<string, unknown>;
+      required?: string[];
+    };
+  };
+  properties?: Record<string, unknown>;
+  required?: string[];
+} & Record<string, unknown>;
+
+export interface LLMTool {
+  type: "function";
+  name: string;
+  description: string;
+  parameters: Record<string, unknown>;
+}
+
+export type AISDKProvider = (modelName: string) => LanguageModelV2;
+// Represents a function that takes options (like apiKey) and returns an AISDKProvider
+export type AISDKCustomProvider = (options: ClientOptions) => AISDKProvider;
+
+export type AvailableModel =
+  | "gpt-4.1"
+  | "gpt-4.1-mini"
+  | "gpt-4.1-nano"
+  | "o4-mini"
+  | "o3"
+  | "o3-mini"
+  | "o1"
+  | "o1-mini"
+  | "gpt-4o"
+  | "gpt-4o-mini"
+  | "gpt-4o-2024-08-06"
+  | "gpt-4.5-preview"
+  | "o1-preview"
+  | "cerebras-llama-3.3-70b"
+  | "cerebras-llama-3.1-8b"
+  | "groq-llama-3.3-70b-versatile"
+  | "groq-llama-3.3-70b-specdec"
+  | "gemini-1.5-flash"
+  | "gemini-1.5-pro"
+  | "gemini-1.5-flash-8b"
+  | "gemini-2.0-flash-lite"
+  | "gemini-2.0-flash"
+  | "gemini-2.5-flash-preview-04-17"
+  | "gemini-2.5-pro-preview-03-25"
+  | string;
+
+export type ModelProvider =
+  | "openai"
+  | "anthropic"
+  | "cerebras"
+  | "groq"
+  | "google"
+  | "aisdk";
+
+export type ClientOptions = (
+  | OpenAIClientOptions
+  | AnthropicClientOptions
+  | GoogleVertexProviderSettings
+) & {
+  apiKey?: string;
+  provider?: AgentProviderType;
+  baseURL?: string;
+  /** OpenAI organization ID */
+  organization?: string;
+  /** Delay between agent actions in ms */
+  waitBetweenActions?: number;
+  /** Anthropic thinking budget for extended thinking */
+  thinkingBudget?: number;
+  /** Environment type for CUA agents (browser, mac, windows, ubuntu) */
+  environment?: string;
+  /** Max images for Microsoft FARA agent */
+  maxImages?: number;
+  /** Temperature for model inference */
+  temperature?: number;
+};
+
+export type ModelConfiguration =
+  | AvailableModel
+  | (ClientOptions & { modelName: AvailableModel });
diff --git a/packages/core/lib/v3/types/public/options.ts b/packages/core/lib/v3/types/public/options.ts
new file mode 100644
index 000000000..7fb66edb8
--- /dev/null
+++ b/packages/core/lib/v3/types/public/options.ts
@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { LLMClient } from "../../llm/LLMClient.js";
+import { ModelConfiguration } from "./model.js";
+import { LogLine } from "./logs.js";
+import {
+  type BrowserbaseSessionCreateParams,
+  LocalBrowserLaunchOptionsSchema,
+} from "./api.js";
+
+export type V3Env = "LOCAL" | "BROWSERBASE";
+
+// Re-export for backwards compatibility (camelCase alias)
+export const localBrowserLaunchOptionsSchema = LocalBrowserLaunchOptionsSchema;
+
+export type LocalBrowserLaunchOptions = z.infer<
+  typeof LocalBrowserLaunchOptionsSchema
+>;
+
+/** Constructor options for V3 */
+export interface V3Options {
+  env: V3Env;
+  // Browserbase (required when env = "BROWSERBASE")
+  apiKey?: string;
+  projectId?: string;
+  /**
+   * Optional: fine-tune Browserbase session creation or resume an existing session.
+   */
+  browserbaseSessionCreateParams?: BrowserbaseSessionCreateParams;
+  browserbaseSessionID?: string;
+  /**
+   * Controls browser keepalive behavior. When set, it overrides any value in
+   * browserbaseSessionCreateParams.keepAlive.
+   */
+  keepAlive?: boolean;
+
+  // Local Chromium (optional)
+  localBrowserLaunchOptions?: LocalBrowserLaunchOptions;
+
+  model?: ModelConfiguration;
+  llmClient?: LLMClient; // allow user to pass their own
+  systemPrompt?: string;
+  logInferenceToFile?: boolean;
+  experimental?: boolean;
+  verbose?: 0 | 1 | 2;
+  selfHeal?: boolean;
+  // V2 compatibility fields - only included because the server imports this type and supports V2
+  waitForCaptchaSolves?: boolean;
+  actTimeoutMs?: number;
+  /** Disable pino logging backend (useful for tests or minimal environments). */
+  disablePino?: boolean;
+  /** Optional external logger hook for integrating with host apps. */
+  logger?: (line: LogLine) => void;
+  /** Directory used to persist cached actions for act(). */
+  cacheDir?: string;
+  domSettleTimeout?: number;
+  disableAPI?: boolean;
+  /**
+   * When true, enables server-side caching for API requests.
+   * When false, disables server-side caching.
+   * Defaults to true (caching enabled).
+   * Can be overridden per-method in act(), extract(), and observe() options.
+   */
+  serverCache?: boolean;
+}
diff --git a/packages/core/lib/v3/types/public/page.ts b/packages/core/lib/v3/types/public/page.ts
new file mode 100644
index 000000000..656f03a1b
--- /dev/null
+++ b/packages/core/lib/v3/types/public/page.ts
@@ -0,0 +1,23 @@
+import { Page } from "../../understudy/page.js";
+import { Page as PlaywrightPage } from "playwright-core";
+import { Page as PatchrightPage } from "patchright-core";
+import { Page as PuppeteerPage } from "puppeteer-core";
+
+export type { PlaywrightPage, PatchrightPage, PuppeteerPage, Page };
+export type AnyPage = PlaywrightPage | PuppeteerPage | PatchrightPage | Page;
+
+export { ConsoleMessage } from "../../understudy/consoleMessage.js";
+export type { ConsoleListener } from "../../understudy/consoleMessage.js";
+
+export type LoadState = "load" | "domcontentloaded" | "networkidle";
+export { Response } from "../../understudy/response.js";
+
+export type SnapshotResult = {
+  formattedTree: string;
+  xpathMap: Record<string, string>;
+  urlMap: Record<string, string>;
+};
+
+export type PageSnapshotOptions = {
+  includeIframes?: boolean;
+};
diff --git a/packages/core/lib/v3/types/public/screenshotTypes.ts b/packages/core/lib/v3/types/public/screenshotTypes.ts
new file mode 100644
index 000000000..aa40a8e1a
--- /dev/null
+++ b/packages/core/lib/v3/types/public/screenshotTypes.ts
@@ -0,0 +1,28 @@
+import type { Locator } from "../../understudy/locator.js";
+
+export type ScreenshotAnimationsOption = "disabled" | "allow";
+export type ScreenshotCaretOption = "hide" | "initial";
+export type ScreenshotScaleOption = "css" | "device";
+
+export interface ScreenshotClip {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface ScreenshotOptions {
+  animations?: ScreenshotAnimationsOption;
+  caret?: ScreenshotCaretOption;
+  clip?: ScreenshotClip;
+  fullPage?: boolean;
+  mask?: Locator[];
+  maskColor?: string;
+  omitBackground?: boolean;
+  path?: string;
+  quality?: number;
+  scale?: ScreenshotScaleOption;
+  style?: string;
+  timeout?: number;
+  type?: "png" | "jpeg";
+}
diff --git a/packages/core/lib/v3/types/public/sdkErrors.ts b/packages/core/lib/v3/types/public/sdkErrors.ts
new file mode 100644
index 000000000..066220be4
--- /dev/null
+++ b/packages/core/lib/v3/types/public/sdkErrors.ts
@@ -0,0 +1,437 @@
+import { ZodError } from "zod";
+// Avoid .js extension so bundlers resolve TS source
+import { STAGEHAND_VERSION } from "../../../version.js";
+
+export class StagehandError extends Error {
+  public readonly cause?: unknown;
+
+  constructor(message: string, cause?: unknown) {
+    super(message);
+    this.name = this.constructor.name;
+    if (cause !== undefined) {
+      this.cause = cause;
+    }
+  }
+}
+
+export class StagehandDefaultError extends StagehandError {
+  constructor(error?: unknown) {
+    if (error instanceof Error || error instanceof StagehandError) {
+      super(
+        `\nHey! We're sorry you ran into an error. \nStagehand version: ${STAGEHAND_VERSION} \nIf you need help, please open a Github issue or reach out to us on Discord: https://stagehand.dev/discord\n\nFull error:\n${error.message}`,
+      );
+    }
+  }
+}
+
+export class StagehandEnvironmentError extends StagehandError {
+  constructor(
+    currentEnvironment: string,
+    requiredEnvironment: string,
+    feature: string,
+  ) {
+    super(
+      `You seem to be setting the current environment to ${currentEnvironment}.` +
+        `Ensure the environment is set to ${requiredEnvironment} if you want to use ${feature}.`,
+    );
+  }
+}
+
+export class MissingEnvironmentVariableError extends StagehandError {
+  constructor(missingEnvironmentVariable: string, feature: string) {
+    super(
+      `${missingEnvironmentVariable} is required to use ${feature}.` +
+        `Please set ${missingEnvironmentVariable} in your environment.`,
+    );
+  }
+}
+
+export class UnsupportedModelError extends StagehandError {
+  constructor(supportedModels: string[], feature?: string) {
+    const message = feature
+      ? `${feature} requires a valid model.`
+      : `Unsupported model.`;
+
+    const guidance =
+      `\n\nPlease use the provider/model format (e.g., "openai/gpt-4o", "anthropic/claude-sonnet-4-5", "google/gemini-3-flash-preview").` +
+      `\n\nFor a complete list of supported models and providers, see: https://docs.stagehand.dev/v3/configuration/models#configuration-setup`;
+
+    super(`${message}${guidance}`);
+  }
+}
+
+export class UnsupportedModelProviderError extends StagehandError {
+  constructor(supportedProviders: string[], feature?: string) {
+    super(
+      feature
+        ? `${feature} requires one of the following model providers: ${supportedProviders}`
+        : `please use one of the supported model providers: ${supportedProviders}`,
+    );
+  }
+}
+
+export class UnsupportedAISDKModelProviderError extends StagehandError {
+  constructor(provider: string, supportedProviders: string[]) {
+    super(
+      `${provider} is not currently supported for aiSDK. please use one of the supported model providers: ${supportedProviders}`,
+    );
+  }
+}
+
+export class InvalidAISDKModelFormatError extends StagehandError {
+  constructor(modelName: string) {
+    super(
+      `${modelName} does not follow correct format for specifying aiSDK models. Please define your model as 'provider/model-name'. For example: \`model: 'openai/gpt-4o-mini'\``,
+    );
+  }
+}
+
+export class StagehandNotInitializedError extends StagehandError {
+  constructor(prop: string) {
+    super(
+      `You seem to be calling \`${prop}\` on a page in an uninitialized \`Stagehand\` object. ` +
+        `Ensure you are running \`await stagehand.init()\` on the Stagehand object before ` +
+        `referencing the \`page\` object.`,
+    );
+  }
+}
+
+export class BrowserbaseSessionNotFoundError extends StagehandError {
+  constructor() {
+    super("No Browserbase session ID found");
+  }
+}
+
+export class CaptchaTimeoutError extends StagehandError {
+  constructor() {
+    super("Captcha timeout");
+  }
+}
+
+export class MissingLLMConfigurationError extends StagehandError {
+  constructor() {
+    super(
+      "No LLM API key or LLM Client configured. An LLM API key or a custom LLM Client " +
+        "is required to use act, extract, or observe.",
+    );
+  }
+}
+
+export class HandlerNotInitializedError extends StagehandError {
+  constructor(handlerType: string) {
+    super(`${handlerType} handler not initialized`);
+  }
+}
+
+export class StagehandInvalidArgumentError extends StagehandError {
+  constructor(message: string) {
+    super(`InvalidArgumentError: ${message}`);
+  }
+}
+
+export class CookieValidationError extends StagehandError {
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+export class CookieSetError extends StagehandError {
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+export class StagehandElementNotFoundError extends StagehandError {
+  constructor(xpaths: string[]) {
+    super(`Could not find an element for the given xPath(s): ${xpaths}`);
+  }
+}
+
+export class AgentScreenshotProviderError extends StagehandError {
+  constructor(message: string) {
+    super(`ScreenshotProviderError: ${message}`);
+  }
+}
+
+export class StagehandMissingArgumentError extends StagehandError {
+  constructor(message: string) {
+    super(`MissingArgumentError: ${message}`);
+  }
+}
+
+export class CreateChatCompletionResponseError extends StagehandError {
+  constructor(message: string) {
+    super(`CreateChatCompletionResponseError: ${message}`);
+  }
+}
+
+export class StagehandEvalError extends StagehandError {
+  constructor(message: string) {
+    super(`StagehandEvalError: ${message}`);
+  }
+}
+
+export class StagehandDomProcessError extends StagehandError {
+  constructor(message: string) {
+    super(`Error Processing Dom: ${message}`);
+  }
+}
+
+export class StagehandLocatorError extends StagehandError {
+  constructor(action: string, selector: string, message: string) {
+    super(
+      `Error ${action} Element with selector: ${selector} Reason: ${message}`,
+    );
+  }
+}
+
+export class StagehandClickError extends StagehandError {
+  constructor(message: string, selector: string) {
+    super(
+      `Error Clicking Element with selector: ${selector} Reason: ${message}`,
+    );
+  }
+}
+
+export class LLMResponseError extends StagehandError {
+  constructor(primitive: string, message: string) {
+    super(`${primitive} LLM response error: ${message}`);
+  }
+}
+
+export class StagehandIframeError extends StagehandError {
+  constructor(frameUrl: string, message: string) {
+    super(
+      `Unable to resolve frameId for iframe with URL: ${frameUrl} Full error: ${message}`,
+    );
+  }
+}
+
+export class ContentFrameNotFoundError extends StagehandError {
+  constructor(selector: string) {
+    super(`Unable to obtain a content frame for selector: ${selector}`);
+  }
+}
+
+export class XPathResolutionError extends StagehandError {
+  constructor(xpath: string) {
+    super(`XPath "${xpath}" does not resolve in the current page or frames`);
+  }
+}
+
+export class ExperimentalApiConflictError extends StagehandError {
+  constructor() {
+    super(
+      "`experimental` mode cannot be used together with the Stagehand API. " +
+        "To use experimental features, set experimental: true and disableAPI: true in the stagehand constructor. " +
+        "To use the Stagehand API, set experimental: false and disableAPI: false (or omit it) in the stagehand constructor.",
+    );
+  }
+}
+
+export class ExperimentalNotConfiguredError extends StagehandError {
+  constructor(featureName: string) {
+    super(`Feature "${featureName}" is an experimental feature, and cannot be configured when disableAPI: false.
+    Please set experimental: true and disableAPI: true in the stagehand constructor to use this feature.
+    If you wish to use the Stagehand API, please ensure ${featureName} is not defined in your function call,
+    and set experimental: false, disableAPI: false (or omit it) in the Stagehand constructor.`);
+  }
+}
+
+export class CuaModelRequiredError extends StagehandError {
+  constructor(availableModels: readonly string[]) {
+    super(
+      `To use the computer use agent (CUA), please provide a CUA model in the agent constructor or stagehand config. ` +
+        `Try one of our supported CUA models: ${availableModels.join(", ")}`,
+    );
+  }
+}
+
+export class ZodSchemaValidationError extends Error {
+  constructor(
+    public readonly received: unknown,
+    public readonly issues: ReturnType<ZodError["format"]>,
+  ) {
+    super(`Zod schema validation failed
+
+— Received —
+${JSON.stringify(received, null, 2)}
+
+— Issues —
+${JSON.stringify(issues, null, 2)}`);
+    this.name = "ZodSchemaValidationError";
+  }
+}
+
+export class StagehandInitError extends StagehandError {
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+export class MCPConnectionError extends StagehandError {
+  public readonly serverUrl: string;
+  public readonly originalError: unknown;
+
+  constructor(serverUrl: string, originalError: unknown) {
+    const errorMessage =
+      originalError instanceof Error
+        ? originalError.message
+        : String(originalError);
+
+    super(
+      `Failed to connect to MCP server at "${serverUrl}". ${errorMessage}. ` +
+        `Please verify the server URL is correct and the server is running.`,
+    );
+
+    this.serverUrl = serverUrl;
+    this.originalError = originalError;
+  }
+}
+
+export class StagehandShadowRootMissingError extends StagehandError {
+  constructor(detail?: string) {
+    super(
+      `No shadow root present on the resolved host` +
+        (detail ? `: ${detail}` : ""),
+    );
+  }
+}
+
+export class StagehandShadowSegmentEmptyError extends StagehandError {
+  constructor() {
+    super(`Empty selector segment after shadow-DOM hop ("//")`);
+  }
+}
+
+export class StagehandShadowSegmentNotFoundError extends StagehandError {
+  constructor(segment: string, hint?: string) {
+    super(
+      `Shadow segment '${segment}' matched no element inside shadow root` +
+        (hint ? ` ${hint}` : ""),
+    );
+  }
+}
+
+export class ElementNotVisibleError extends StagehandError {
+  constructor(selector: string) {
+    super(`Element not visible (no box model): ${selector}`);
+  }
+}
+
+export class ResponseBodyError extends StagehandError {
+  constructor(message: string) {
+    super(`Failed to retrieve response body: ${message}`);
+  }
+}
+
+export class ResponseParseError extends StagehandError {
+  constructor(message: string) {
+    super(`Failed to parse response: ${message}`);
+  }
+}
+
+export class TimeoutError extends StagehandError {
+  constructor(operation: string, timeoutMs: number) {
+    super(`${operation} timed out after ${timeoutMs}ms`);
+  }
+}
+
+export class ActTimeoutError extends TimeoutError {
+  constructor(timeoutMs: number) {
+    super("act()", timeoutMs);
+    this.name = "ActTimeoutError";
+  }
+}
+
+export class ExtractTimeoutError extends TimeoutError {
+  constructor(timeoutMs: number) {
+    super("extract()", timeoutMs);
+    this.name = "ExtractTimeoutError";
+  }
+}
+
+export class ObserveTimeoutError extends TimeoutError {
+  constructor(timeoutMs: number) {
+    super("observe()", timeoutMs);
+    this.name = "ObserveTimeoutError";
+  }
+}
+
+export class PageNotFoundError extends StagehandError {
+  constructor(identifier: string) {
+    super(`No Page found for ${identifier}`);
+  }
+}
+
+export class ConnectionTimeoutError extends StagehandError {
+  constructor(message: string) {
+    super(`Connection timeout: ${message}`);
+  }
+}
+
+export class StreamingCallbacksInNonStreamingModeError extends StagehandError {
+  public readonly invalidCallbacks: string[];
+
+  constructor(invalidCallbacks: string[]) {
+    super(
+      `Streaming-only callback(s) "${invalidCallbacks.join('", "')}" cannot be used in non-streaming mode. ` +
+        `Set 'stream: true' in AgentConfig to use these callbacks.`,
+    );
+    this.invalidCallbacks = invalidCallbacks;
+  }
+}
+
+export class AgentAbortError extends StagehandError {
+  public readonly reason: string;
+
+  constructor(reason?: string) {
+    const message = reason
+      ? `Agent execution was aborted: ${reason}`
+      : "Agent execution was aborted";
+    super(message);
+    this.reason = reason || "aborted";
+  }
+}
+
+export class StagehandClosedError extends StagehandError {
+  constructor() {
+    super("Stagehand session was closed");
+  }
+}
+
+export class CdpConnectionClosedError extends StagehandError {
+  constructor(reason: string) {
+    super(`CDP connection closed: ${reason}`);
+  }
+}
+
+export class StagehandSetExtraHTTPHeadersError extends StagehandError {
+  public readonly failures: string[];
+
+  constructor(failures: string[]) {
+    super(
+      `setExtraHTTPHeaders failed for ${failures.length} session(s): ${failures.join(", ")}`,
+    );
+    this.failures = failures;
+  }
+}
+
+export class StagehandSnapshotError extends StagehandError {
+  constructor(cause?: unknown) {
+    const suffix =
+      cause instanceof Error
+        ? `: ${cause.message}`
+        : cause
+          ? `: ${String(cause)}`
+          : "";
+    super(`error taking snapshot${suffix}`, cause);
+  }
+}
+
+export class UnderstudyCommandException extends StagehandError {
+  constructor(message: string, cause?: unknown) {
+    super(message, cause);
+    this.name = "UnderstudyCommandException";
+  }
+}
diff --git a/packages/core/lib/v3/understudy/a11y/snapshot/a11yTree.ts b/packages/core/lib/v3/understudy/a11y/snapshot/a11yTree.ts
new file mode 100644
index 000000000..d702053b2
--- /dev/null
+++ b/packages/core/lib/v3/understudy/a11y/snapshot/a11yTree.ts
@@ -0,0 +1,243 @@
+import type { Protocol } from "devtools-protocol";
+import type { CDPSessionLike } from "../../cdp.js";
+import type {
+  A11yNode,
+  A11yOptions,
+  AccessibilityTreeResult,
+} from "../../../types/private/snapshot.js";
+import {
+  resolveObjectIdForCss,
+  resolveObjectIdForXPath,
+} from "./focusSelectors.js";
+import { formatTreeLine, normaliseSpaces } from "./treeFormatUtils.js";
+
+/**
+ * Fetch and prune the accessibility tree for a frame, optionally scoping the
+ * output to a selector root for faster targeted snapshots.
+ */
+export async function a11yForFrame(
+  session: CDPSessionLike,
+  frameId: string | undefined,
+  opts: A11yOptions,
+): Promise<AccessibilityTreeResult> {
+  await session.send("Accessibility.enable").catch(() => {});
+  await session.send("Runtime.enable").catch(() => {});
+  await session.send("DOM.enable").catch(() => {});
+
+  let nodes: Protocol.Accessibility.AXNode[] = [];
+  try {
+    const params = frameId ? ({ frameId } as Record<string, unknown>) : {};
+    ({ nodes } = await session.send<{
+      nodes: Protocol.Accessibility.AXNode[];
+    }>("Accessibility.getFullAXTree", params));
+  } catch (e) {
+    const msg = String((e as Error)?.message ?? e ?? "");
+    const isFrameScopeError =
+      msg.includes("Frame with the given") ||
+      msg.includes("does not belong to the target") ||
+      msg.includes("is not found");
+    if (!isFrameScopeError || !frameId) throw e;
+    ({ nodes } = await session.send<{
+      nodes: Protocol.Accessibility.AXNode[];
+    }>("Accessibility.getFullAXTree"));
+  }
+
+  const urlMap: Record<string, string> = {};
+  for (const n of nodes) {
+    const be = n.backendDOMNodeId;
+    if (typeof be !== "number") continue;
+    const url = extractUrlFromAXNode(n);
+    if (!url) continue;
+    const enc = opts.encode(be);
+    urlMap[enc] = url;
+  }
+
+  let scopeApplied = false;
+  const nodesForOutline = await (async () => {
+    const sel = opts.focusSelector?.trim();
+    if (!sel) return nodes;
+    try {
+      const looksLikeXPath = /^xpath=/i.test(sel) || sel.startsWith("/");
+      const objectId = looksLikeXPath
+        ? await resolveObjectIdForXPath(session, sel, frameId)
+        : await resolveObjectIdForCss(session, sel, frameId);
+      if (!objectId) return nodes;
+      const desc = await session.send<{ node?: { backendNodeId?: number } }>(
+        "DOM.describeNode",
+        { objectId },
+      );
+      const be = desc.node?.backendNodeId;
+      if (typeof be !== "number") return nodes;
+      const target = nodes.find((n) => n.backendDOMNodeId === be);
+      if (!target) return nodes;
+      scopeApplied = true;
+      const keep = new Set<string>([target.nodeId]);
+      const queue: Protocol.Accessibility.AXNode[] = [target];
+      while (queue.length) {
+        const cur = queue.shift()!;
+        for (const id of cur.childIds ?? []) {
+          if (keep.has(id)) continue;
+          keep.add(id);
+          const child = nodes.find((n) => n.nodeId === id);
+          if (child) queue.push(child);
+        }
+      }
+      return nodes
+        .filter((n) => keep.has(n.nodeId))
+        .map((n) =>
+          n.nodeId === target.nodeId ? { ...n, parentId: undefined } : n,
+        );
+    } catch {
+      return nodes;
+    }
+  })();
+
+  const decorated = decorateRoles(nodesForOutline, opts);
+  const { tree } = await buildHierarchicalTree(decorated, opts);
+
+  const simplified = tree.map((n) => formatTreeLine(n)).join("\n");
+  return { outline: simplified.trimEnd(), urlMap, scopeApplied };
+}
+
+export function decorateRoles(
+  nodes: Protocol.Accessibility.AXNode[],
+  opts: A11yOptions,
+): A11yNode[] {
+  const asRole = (n: Protocol.Accessibility.AXNode) =>
+    String(n.role?.value ?? "");
+
+  return nodes.map((n) => {
+    let encodedId: string | undefined;
+    if (typeof n.backendDOMNodeId === "number") {
+      try {
+        encodedId = opts.encode(n.backendDOMNodeId);
+      } catch {
+        //
+      }
+    }
+
+    let role = asRole(n);
+
+    const domIsScrollable = encodedId
+      ? opts.scrollableMap[encodedId] === true
+      : false;
+    const tag = encodedId ? opts.tagNameMap[encodedId] : undefined;
+    const isHtmlElement = tag === "html";
+    if ((domIsScrollable || isHtmlElement) && tag !== "#document") {
+      const tagLabel = tag && tag.startsWith("#") ? tag.slice(1) : tag;
+      role = tagLabel
+        ? `scrollable, ${tagLabel}`
+        : `scrollable${role ? `, ${role}` : ""}`;
+    }
+
+    return {
+      role,
+      name: n.name?.value,
+      description: n.description?.value,
+      value: n.value?.value,
+      nodeId: n.nodeId,
+      backendDOMNodeId: n.backendDOMNodeId,
+      parentId: n.parentId,
+      childIds: n.childIds,
+      encodedId,
+    };
+  });
+}
+
+export async function buildHierarchicalTree(
+  nodes: A11yNode[],
+  opts: A11yOptions,
+): Promise<{ tree: A11yNode[] }> {
+  const nodeMap = new Map<string, A11yNode>();
+
+  for (const n of nodes) {
+    const keep =
+      !!(n.name && n.name.trim()) ||
+      !!(n.childIds && n.childIds.length) ||
+      !isStructural(n.role);
+    if (!keep) continue;
+    nodeMap.set(n.nodeId, { ...n });
+  }
+
+  for (const n of nodes) {
+    if (!n.parentId) continue;
+    const parent = nodeMap.get(n.parentId);
+    const cur = nodeMap.get(n.nodeId);
+    if (parent && cur) (parent.children ??= []).push(cur);
+  }
+
+  const roots = nodes
+    .filter((n) => !n.parentId && nodeMap.has(n.nodeId))
+    .map((n) => nodeMap.get(n.nodeId)!) as A11yNode[];
+
+  const cleaned = (await Promise.all(roots.map(pruneStructuralSafe))).filter(
+    Boolean,
+  ) as A11yNode[];
+
+  return { tree: cleaned };
+
+  async function pruneStructuralSafe(node: A11yNode): Promise<A11yNode | null> {
+    if (+node.nodeId < 0) return null;
+
+    const children = node.children ?? [];
+    if (!children.length) {
+      return isStructural(node.role) ? null : node;
+    }
+
+    const cleanedKids = (
+      await Promise.all(children.map(pruneStructuralSafe))
+    ).filter(Boolean) as A11yNode[];
+
+    const prunedStatic = removeRedundantStaticTextChildren(node, cleanedKids);
+
+    if (isStructural(node.role)) {
+      if (prunedStatic.length === 1) return prunedStatic[0]!;
+      if (prunedStatic.length === 0) return null;
+    }
+
+    let newRole = node.role;
+    if ((newRole === "generic" || newRole === "none") && node.encodedId) {
+      const tagName = opts.tagNameMap[node.encodedId];
+      if (tagName) newRole = tagName;
+    }
+
+    if (newRole === "combobox" && node.encodedId) {
+      const tagName = opts.tagNameMap[node.encodedId];
+      if (tagName === "select") newRole = "select";
+    }
+
+    return { ...node, role: newRole, children: prunedStatic };
+  }
+}
+
+export function isStructural(role: string): boolean {
+  const r = role?.toLowerCase();
+  return r === "generic" || r === "none" || r === "inlinetextbox";
+}
+
+export function extractUrlFromAXNode(
+  ax: Protocol.Accessibility.AXNode,
+): string | undefined {
+  const props = ax.properties ?? [];
+  const urlProp = props.find((p) => p.name === "url");
+  const value = urlProp?.value?.value;
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+export function removeRedundantStaticTextChildren(
+  parent: A11yNode,
+  children: A11yNode[],
+): A11yNode[] {
+  if (!parent.name) return children;
+  const parentNorm = normaliseSpaces(parent.name).trim();
+  let combined = "";
+  for (const c of children) {
+    if (c.role === "StaticText" && c.name) {
+      combined += normaliseSpaces(c.name).trim();
+    }
+  }
+  if (combined === parentNorm) {
+    return children.filter((c) => c.role !== "StaticText");
+  }
+  return children;
+}
diff --git a/packages/core/lib/v3/understudy/a11y/snapshot/activeElement.ts b/packages/core/lib/v3/understudy/a11y/snapshot/activeElement.ts
new file mode 100644
index 000000000..4d4df8ef7
--- /dev/null
+++ b/packages/core/lib/v3/understudy/a11y/snapshot/activeElement.ts
@@ -0,0 +1,134 @@
+import type { Protocol } from "devtools-protocol";
+import { Page } from "../../page.js";
+import { executionContexts } from "../../executionContextRegistry.js";
+import { buildA11yInvocation } from "../../a11yInvocation.js";
+import { a11yScriptSources } from "../../../dom/build/a11yScripts.generated.js";
+import {
+  absoluteXPathForBackendNode,
+  normalizeXPath,
+  prefixXPath,
+} from "./xpathUtils.js";
+
+/**
+ * Compute the absolute XPath for the currently focused element.
+ * - Detects which frame has focus via document.hasFocus().
+ * - Finds the deepest activeElement (dives into shadow DOM).
+ * - Builds an absolute, cross-frame XPath by prefixing iframe hosts.
+ */
+export async function computeActiveElementXpath(
+  page: Page,
+): Promise<string | null> {
+  const tree = page.getFullFrameTree();
+  const parentByFrame = new Map<string, string | null>();
+  (function index(n: Protocol.Page.FrameTree, parent: string | null) {
+    parentByFrame.set(n.frame.id, parent);
+    for (const c of n.childFrames ?? []) index(c, n.frame.id);
+  })(tree, null);
+
+  const frames = page.listAllFrameIds();
+  let focusedFrameId: string | null = null;
+  for (const fid of frames) {
+    const sess = page.getSessionForFrame(fid);
+    try {
+      await sess.send("Runtime.enable").catch(() => {});
+      const ctxId = await executionContexts
+        .waitForMainWorld(sess, fid, 1000)
+        .catch(() => {});
+      const hasFocusExpr = buildA11yInvocation("documentHasFocusStrict", []);
+      const evalParams = ctxId
+        ? {
+            contextId: ctxId,
+            expression: hasFocusExpr,
+            returnByValue: true,
+          }
+        : { expression: hasFocusExpr, returnByValue: true };
+      const { result } = await sess.send<Protocol.Runtime.EvaluateResponse>(
+        "Runtime.evaluate",
+        evalParams,
+      );
+      if (result?.value === true) {
+        focusedFrameId = fid;
+        break;
+      }
+    } catch {
+      //
+    }
+  }
+  if (!focusedFrameId) focusedFrameId = page.mainFrameId();
+  const focusedSession = page.getSessionForFrame(focusedFrameId);
+
+  let objectId: string | undefined;
+  try {
+    await focusedSession.send("Runtime.enable").catch(() => {});
+    const ctxId = await executionContexts
+      .waitForMainWorld(focusedSession, focusedFrameId, 1000)
+      .catch(() => {});
+    const activeExpr = buildA11yInvocation("resolveDeepActiveElement", []);
+    const evalParams = ctxId
+      ? {
+          contextId: ctxId,
+          expression: activeExpr,
+          returnByValue: false,
+        }
+      : { expression: activeExpr, returnByValue: false };
+    const { result } =
+      await focusedSession.send<Protocol.Runtime.EvaluateResponse>(
+        "Runtime.evaluate",
+        evalParams,
+      );
+    objectId = result?.objectId as string | undefined;
+  } catch {
+    objectId = undefined;
+  }
+  if (!objectId) return null;
+
+  const leafXPath = await (async () => {
+    try {
+      const { result } = await focusedSession.send<{
+        result: { value?: string };
+      }>("Runtime.callFunctionOn", {
+        objectId,
+        functionDeclaration: a11yScriptSources.nodeToAbsoluteXPath,
+        returnByValue: true,
+      });
+      try {
+        await focusedSession.send("Runtime.releaseObject", { objectId });
+      } catch {
+        //
+      }
+      const xp = result?.value || "";
+      return typeof xp === "string" && xp ? xp : null;
+    } catch {
+      try {
+        await focusedSession.send("Runtime.releaseObject", { objectId });
+      } catch {
+        //
+      }
+      return null;
+    }
+  })();
+
+  if (!leafXPath) return null;
+
+  let prefix = "";
+  let cur: string | null | undefined = focusedFrameId;
+  while (cur) {
+    const parent = parentByFrame.get(cur) ?? null;
+    if (!parent) break;
+    const parentSess = page.getSessionForFrame(parent);
+    try {
+      const { backendNodeId } = await parentSess.send<{
+        backendNodeId?: number;
+      }>("DOM.getFrameOwner", { frameId: cur });
+      if (typeof backendNodeId === "number") {
+        const xp = await absoluteXPathForBackendNode(parentSess, backendNodeId);
+        if (xp) prefix = prefix ? prefixXPath(prefix, xp) : normalizeXPath(xp);
+      }
+    } catch {
+      //
+    }
+    cur = parent;
+  }
+
+  return prefix ? prefixXPath(prefix, leafXPath) : normalizeXPath(leafXPath);
+}
diff --git a/packages/core/lib/v3/understudy/a11y/snapshot/capture.ts b/packages/core/lib/v3/understudy/a11y/snapshot/capture.ts
new file mode 100644
index 000000000..87ff845d3
--- /dev/null
+++ b/packages/core/lib/v3/understudy/a11y/snapshot/capture.ts
@@ -0,0 +1,474 @@
+import type { Protocol } from "devtools-protocol";
+import type { CDPSessionLike } from "../../cdp.js";
+import { Page } from "../../page.js";
+import { v3Logger } from "../../../logger.js";
+import type {
+  FrameContext,
+  FrameDomMaps,
+  FrameParentIndex,
+  HybridSnapshot,
+  SnapshotOptions,
+  SessionDomIndex,
+} from "../../../types/private/index.js";
+import { a11yForFrame } from "./a11yTree.js";
+import {
+  resolveCssFocusFrameAndTail,
+  resolveFocusFrameAndTail,
+} from "./focusSelectors.js";
+import {
+  buildSessionDomIndex,
+  domMapsForSession,
+  relativizeXPath,
+} from "./domTree.js";
+import { injectSubtrees } from "./treeFormatUtils.js";
+import { ownerSession, parentSession } from "./sessions.js";
+import { normalizeXPath, prefixXPath } from "./xpathUtils.js";
+
+/**
+ * Capture a hybrid DOM + Accessibility snapshot for the provided page.
+ *
+ * Flow overview:
+ * 1. (Optional) Scope directly to a requested selector. We walk iframe hops to
+ *    find the owning frame, build just that frame’s DOM + AX tree, and bail out
+ *    early when the subtree satisfies the caller.
+ * 2. Build DOM indexes for every unique CDP session. DOM.getDocument is called
+ *    once per session and hydrated so per-frame slices can share the result.
+ * 3. Slice each frame’s DOM data from its session index and fetch its AX tree.
+ *    This yields relative XPath/tag/url maps for the document rooted at that frame.
+ * 4. Walk the frame tree to compute absolute iframe prefixes. Every child frame
+ *    needs the XPath of the iframe element that hosts it so we can prefix maps.
+ * 5. Merge all per-frame results into global combined maps and stitch the text
+ *    outline. The final payload mirrors the legacy shape but is built in layers.
+ *
+ * Each numbered block below references the step above for easier debugging.
+ */
+export async function captureHybridSnapshot(
+  page: Page,
+  options?: SnapshotOptions,
+): Promise<HybridSnapshot> {
+  const pierce = options?.pierceShadow ?? true;
+  const includeIframes = options?.includeIframes !== false;
+
+  const context = buildFrameContext(page);
+
+  const scopedSnapshot = await tryScopedSnapshot(
+    page,
+    options,
+    context,
+    pierce,
+  );
+  if (scopedSnapshot) return scopedSnapshot;
+
+  const framesInScope = includeIframes ? [...context.frames] : [context.rootId];
+  if (!framesInScope.includes(context.rootId)) {
+    framesInScope.unshift(context.rootId);
+  }
+
+  const sessionToIndex = await buildSessionIndexes(page, framesInScope, pierce);
+  const { perFrameMaps, perFrameOutlines } = await collectPerFrameMaps(
+    page,
+    context,
+    sessionToIndex,
+    options,
+    pierce,
+    framesInScope,
+  );
+  const { absPrefix, iframeHostEncByChild } = await computeFramePrefixes(
+    page,
+    context,
+    perFrameMaps,
+    framesInScope,
+  );
+
+  return mergeFramesIntoSnapshot(
+    context,
+    perFrameMaps,
+    perFrameOutlines,
+    absPrefix,
+    iframeHostEncByChild,
+    framesInScope,
+  );
+}
+
+/**
+ * Snapshot the current frame tree so downstream helpers have consistent topology
+ * without re-querying CDP. The map is intentionally shallow (frameId → parentId)
+ * so it is serializable/testable without holding on to CDP handles.
+ */
+export function buildFrameContext(page: Page): FrameContext {
+  const rootId = page.mainFrameId();
+  const frameTree = page.asProtocolFrameTree(rootId);
+  const parentByFrame: FrameParentIndex = new Map();
+  (function index(n: Protocol.Page.FrameTree, parent: string | null) {
+    parentByFrame.set(n.frame.id, parent);
+    for (const c of n.childFrames ?? []) index(c, n.frame.id);
+  })(frameTree, null);
+  const frames = page.listAllFrameIds();
+  return { rootId, parentByFrame, frames };
+}
+
+/**
+ * Step 1 – scoped snapshot fast-path. If a selector is provided we try to:
+ *  1) Resolve the selector (XPath or CSS) across iframes.
+ *  2) Build DOM + AX data only for the owning frame.
+ *  3) Bail out early when the selector's subtree satisfies the request.
+ *
+ * Returns `null` when scoping fails (e.g., selector miss) so the caller can
+ * fall back to the full multi-frame snapshot.
+ */
+export async function tryScopedSnapshot(
+  page: Page,
+  options: SnapshotOptions | undefined,
+  context: FrameContext,
+  pierce: boolean,
+): Promise<HybridSnapshot | null> {
+  const requestedFocus = options?.focusSelector?.trim();
+  if (!requestedFocus) return null;
+
+  const logScopeFallback = () => {
+    v3Logger({
+      message: `Unable to narrow scope with selector. Falling back to using full DOM`,
+      level: 1,
+      auxiliary: {
+        arguments: {
+          value: `selector: ${options?.focusSelector?.trim()}`,
+          type: "string",
+        },
+      },
+    });
+  };
+
+  try {
+    let targetFrameId: string;
+    let tailSelector: string | undefined;
+    let absPrefix: string | undefined;
+
+    const looksLikeXPath =
+      /^xpath=/i.test(requestedFocus) || requestedFocus.startsWith("/");
+    if (looksLikeXPath) {
+      const focus = normalizeXPath(requestedFocus);
+      const hit = await resolveFocusFrameAndTail(
+        page,
+        focus,
+        context.parentByFrame,
+        context.rootId,
+      );
+      targetFrameId = hit.targetFrameId;
+      tailSelector = hit.tailXPath || undefined;
+      absPrefix = hit.absPrefix;
+    } else {
+      const cssHit = await resolveCssFocusFrameAndTail(
+        page,
+        requestedFocus,
+        context.parentByFrame,
+        context.rootId,
+      );
+      targetFrameId = cssHit.targetFrameId;
+      tailSelector = cssHit.tailSelector || undefined;
+      absPrefix = cssHit.absPrefix;
+    }
+
+    const owningSess = ownerSession(page, targetFrameId);
+    const parentId = context.parentByFrame.get(targetFrameId);
+    const sameSessionAsParent =
+      !!parentId &&
+      ownerSession(page, parentId) === ownerSession(page, targetFrameId);
+    const { tagNameMap, xpathMap, scrollableMap } = await domMapsForSession(
+      owningSess,
+      targetFrameId,
+      pierce,
+      (fid, be) => `${page.getOrdinal(fid)}-${be}`,
+      sameSessionAsParent,
+    );
+
+    const { outline, urlMap, scopeApplied } = await a11yForFrame(
+      owningSess,
+      targetFrameId,
+      {
+        focusSelector: tailSelector || undefined,
+        tagNameMap,
+        experimental: options?.experimental ?? false,
+        scrollableMap,
+        encode: (backendNodeId) =>
+          `${page.getOrdinal(targetFrameId)}-${backendNodeId}`,
+      },
+    );
+
+    const scopedXpathMap: Record<string, string> = {};
+    const abs = absPrefix ?? "";
+    const isRoot = !abs || abs === "/";
+    if (isRoot) {
+      Object.assign(scopedXpathMap, xpathMap);
+    } else {
+      // Prefix relative XPaths so the scoped result matches the global encoding.
+      for (const [encId, xp] of Object.entries(xpathMap)) {
+        scopedXpathMap[encId] = prefixXPath(abs, xp);
+      }
+    }
+
+    const scopedUrlMap: Record<string, string> = { ...urlMap };
+
+    const snapshot: HybridSnapshot = {
+      combinedTree: outline,
+      combinedXpathMap: scopedXpathMap,
+      combinedUrlMap: scopedUrlMap,
+      perFrame: [
+        {
+          frameId: targetFrameId,
+          outline,
+          xpathMap,
+          urlMap,
+        },
+      ],
+    };
+
+    if (scopeApplied) {
+      return snapshot;
+    }
+
+    logScopeFallback();
+  } catch {
+    logScopeFallback();
+  }
+  return null;
+}
+
+/**
+ * Step 2 – call DOM.getDocument once per unique CDP session and hydrate the
+ * result so per-frame slices can share the structure. We key by session id
+ * because same process iframes live inside the same session.
+ */
+export async function buildSessionIndexes(
+  page: Page,
+  frames: string[],
+  pierce: boolean,
+): Promise<Map<string, SessionDomIndex>> {
+  const sessionToIndex = new Map<string, SessionDomIndex>();
+  const sessionById = new Map<string, CDPSessionLike>();
+  for (const frameId of frames) {
+    const sess = ownerSession(page, frameId);
+    const sid = sess.id ?? "root";
+    if (!sessionById.has(sid)) sessionById.set(sid, sess);
+  }
+  for (const [sid, sess] of sessionById.entries()) {
+    const idx = await buildSessionDomIndex(sess, pierce);
+    sessionToIndex.set(sid, idx);
+  }
+  return sessionToIndex;
+}
+
+/**
+ * Step 3 – derive per-frame DOM maps and accessibility outlines.
+ * Each frame:
+ *  - slices the shared session index down to its document root
+ *  - builds frame-aware encoded ids (ordinal-backendNodeId)
+ *  - collects tag/xpath/scrollability maps for DOM-based lookups
+ *  - fetches its AX tree to produce outlines and URL maps
+ */
+export async function collectPerFrameMaps(
+  page: Page,
+  context: FrameContext,
+  sessionToIndex: Map<string, SessionDomIndex>,
+  options: SnapshotOptions | undefined,
+  pierce: boolean,
+  frameIds: string[],
+): Promise<{
+  perFrameMaps: Map<string, FrameDomMaps>;
+  perFrameOutlines: Array<{ frameId: string; outline: string }>;
+}> {
+  const perFrameMaps = new Map<string, FrameDomMaps>();
+  const perFrameOutlines: Array<{ frameId: string; outline: string }> = [];
+
+  for (const frameId of frameIds) {
+    const sess = ownerSession(page, frameId);
+    const sid = sess.id ?? "root";
+    let idx = sessionToIndex.get(sid);
+    if (!idx) {
+      idx = await buildSessionDomIndex(sess, pierce);
+      sessionToIndex.set(sid, idx);
+    }
+
+    const parentId = context.parentByFrame.get(frameId);
+    const sameSessionAsParent =
+      !!parentId && ownerSession(page, parentId) === sess;
+    let docRootBe = idx.rootBackend;
+    if (sameSessionAsParent) {
+      try {
+        const { backendNodeId } = await sess.send<{ backendNodeId?: number }>(
+          "DOM.getFrameOwner",
+          { frameId },
+        );
+        if (typeof backendNodeId === "number") {
+          const cdBe = idx.contentDocRootByIframe.get(backendNodeId);
+          if (typeof cdBe === "number") docRootBe = cdBe;
+        }
+      } catch {
+        //
+      }
+    }
+
+    const tagNameMap: Record<string, string> = {};
+    const xpathMap: Record<string, string> = {};
+    const scrollableMap: Record<string, boolean> = {};
+    const enc = (be: number) => `${page.getOrdinal(frameId)}-${be}`;
+    const baseAbs = idx.absByBe.get(docRootBe) ?? "/";
+
+    for (const [be, nodeAbs] of idx.absByBe.entries()) {
+      const nodeDocRoot = idx.docRootOf.get(be);
+      if (nodeDocRoot !== docRootBe) continue;
+
+      // Translate absolute XPaths into document-relative ones for this frame.
+      const rel = relativizeXPath(baseAbs, nodeAbs);
+      const key = enc(be);
+      xpathMap[key] = rel;
+      const tag = idx.tagByBe.get(be);
+      if (tag) tagNameMap[key] = tag;
+      if (idx.scrollByBe.get(be)) scrollableMap[key] = true;
+    }
+
+    const { outline, urlMap } = await a11yForFrame(sess, frameId, {
+      experimental: options?.experimental ?? false,
+      tagNameMap,
+      scrollableMap,
+      encode: (backendNodeId) => `${page.getOrdinal(frameId)}-${backendNodeId}`,
+    });
+
+    perFrameOutlines.push({ frameId, outline });
+    perFrameMaps.set(frameId, { tagNameMap, xpathMap, scrollableMap, urlMap });
+  }
+
+  return { perFrameMaps, perFrameOutlines };
+}
+
+/**
+ * Step 4 – walk the frame tree (parent-first) to compute absolute prefixes for
+ * every frame. The prefix is the absolute XPath of the iframe element hosting
+ * the frame, so we can later convert relative XPaths into cross-frame ones.
+ */
+export async function computeFramePrefixes(
+  page: Page,
+  context: FrameContext,
+  perFrameMaps: Map<string, FrameDomMaps>,
+  frameIds: string[],
+): Promise<{
+  absPrefix: Map<string, string>;
+  iframeHostEncByChild: Map<string, string>;
+}> {
+  const absPrefix = new Map<string, string>();
+  const iframeHostEncByChild = new Map<string, string>();
+  absPrefix.set(context.rootId, "");
+  const included = new Set(frameIds);
+
+  const queue: string[] = [];
+  if (included.has(context.rootId)) {
+    queue.push(context.rootId);
+  }
+
+  while (queue.length) {
+    const parent = queue.shift()!;
+    const parentAbs = absPrefix.get(parent)!;
+
+    for (const child of context.frames) {
+      if (!included.has(child)) continue;
+      if (context.parentByFrame.get(child) !== parent) continue;
+      queue.push(child);
+
+      const parentSess = parentSession(page, context.parentByFrame, child);
+
+      const ownerBackendNodeId = await (async () => {
+        try {
+          const { backendNodeId } = await parentSess.send<{
+            backendNodeId?: number;
+          }>("DOM.getFrameOwner", { frameId: child });
+          return backendNodeId;
+        } catch {
+          return undefined;
+        }
+      })();
+
+      if (!ownerBackendNodeId) {
+        // OOPIFs resolved via a different session inherit the parent prefix.
+        absPrefix.set(child, parentAbs);
+        continue;
+      }
+
+      const parentDom = perFrameMaps.get(parent);
+      const iframeEnc = `${page.getOrdinal(parent)}-${ownerBackendNodeId}`;
+      const iframeXPath = parentDom?.xpathMap[iframeEnc];
+
+      const childAbs = iframeXPath
+        ? prefixXPath(parentAbs || "/", iframeXPath)
+        : parentAbs;
+
+      absPrefix.set(child, childAbs);
+      iframeHostEncByChild.set(child, iframeEnc);
+    }
+  }
+
+  return { absPrefix, iframeHostEncByChild };
+}
+
+/**
+ * Step 5 – merge per-frame maps into the combined snapshot payload. We prefix
+ * each frame's relative XPaths with the absolute path collected in step 4,
+ * merge URL maps, and stitch text outlines by nesting child trees under the
+ * encoded id of their parent iframe host.
+ */
+export function mergeFramesIntoSnapshot(
+  context: FrameContext,
+  perFrameMaps: Map<string, FrameDomMaps>,
+  perFrameOutlines: Array<{ frameId: string; outline: string }>,
+  absPrefix: Map<string, string>,
+  iframeHostEncByChild: Map<string, string>,
+  frameIds: string[],
+): HybridSnapshot {
+  const combinedXpathMap: Record<string, string> = {};
+  const combinedUrlMap: Record<string, string> = {};
+
+  for (const frameId of frameIds) {
+    const maps = perFrameMaps.get(frameId);
+    if (!maps) continue;
+
+    const abs = absPrefix.get(frameId) ?? "";
+    const isRoot = abs === "" || abs === "/";
+
+    if (isRoot) {
+      Object.assign(combinedXpathMap, maps.xpathMap);
+      Object.assign(combinedUrlMap, maps.urlMap);
+      continue;
+    }
+
+    for (const [encId, xp] of Object.entries(maps.xpathMap)) {
+      combinedXpathMap[encId] = prefixXPath(abs, xp);
+    }
+    Object.assign(combinedUrlMap, maps.urlMap);
+  }
+
+  const idToTree = new Map<string, string>();
+  for (const { frameId, outline } of perFrameOutlines) {
+    const parentEnc = iframeHostEncByChild.get(frameId);
+    // The key is the parent iframe's encoded id so injectSubtrees can nest lines.
+    if (parentEnc) idToTree.set(parentEnc, outline);
+  }
+
+  const rootOutline =
+    perFrameOutlines.find((o) => o.frameId === context.rootId)?.outline ??
+    perFrameOutlines[0]?.outline ??
+    "";
+  const combinedTree = injectSubtrees(rootOutline, idToTree);
+
+  return {
+    combinedTree,
+    combinedXpathMap,
+    combinedUrlMap,
+    perFrame: perFrameOutlines.map(({ frameId, outline }) => {
+      const maps = perFrameMaps.get(frameId);
+      return {
+        frameId,
+        outline,
+        xpathMap: maps?.xpathMap ?? {},
+        urlMap: maps?.urlMap ?? {},
+      };
+    }),
+  };
+}
diff --git a/packages/core/lib/v3/understudy/a11y/snapshot/coordinateResolver.ts b/packages/core/lib/v3/understudy/a11y/snapshot/coordinateResolver.ts
new file mode 100644
index 000000000..b6fa4bbe7
--- /dev/null
+++ b/packages/core/lib/v3/understudy/a11y/snapshot/coordinateResolver.ts
@@ -0,0 +1,165 @@
+import type { Protocol } from "devtools-protocol";
+import type { CDPSessionLike } from "../../cdp.js";
+import { Page } from "../../page.js";
+import { executionContexts } from "../../executionContextRegistry.js";
+import { a11yScriptSources } from "../../../dom/build/a11yScripts.generated.js";
+import { buildA11yInvocation } from "../../a11yInvocation.js";
+import type { ResolvedLocation } from "../../../types/private/snapshot.js";
+import { listChildrenOf } from "./focusSelectors.js";
+import { buildAbsoluteXPathFromChain } from "./xpathUtils.js";
+
+/**
+ * Resolve deepest node for a page coordinate and compute its absolute XPath across frames.
+ * More efficient than building a full hybrid snapshot when only a single node’s XPath is needed.
+ */
+export async function resolveXpathForLocation(
+  page: Page,
+  x: number,
+  y: number,
+): Promise<ResolvedLocation | null> {
+  const tree = page.getFullFrameTree();
+  const parentByFrame = new Map<string, string | null>();
+  (function index(n: Protocol.Page.FrameTree, parent: string | null) {
+    parentByFrame.set(n.frame.id, parent);
+    for (const c of n.childFrames ?? []) index(c, n.frame.id);
+  })(tree, null);
+
+  const iframeChain: Array<{
+    parentSession: CDPSessionLike;
+    iframeBackendNodeId: number;
+  }> = [];
+
+  let curFrameId = page.mainFrameId();
+  let curSession = page.getSessionForFrame(curFrameId);
+  let curX = x;
+  let curY = y;
+
+  for (let depth = 0; depth < 8; depth++) {
+    try {
+      await curSession.send("DOM.enable").catch(() => {});
+
+      let sx = 0;
+      let sy = 0;
+      try {
+        await curSession.send("Runtime.enable").catch(() => {});
+        const ctxId = await executionContexts
+          .waitForMainWorld(curSession, curFrameId)
+          .catch(() => {});
+        const scrollExpr = buildA11yInvocation("getScrollOffsets", []);
+        const evalParams = ctxId
+          ? {
+              contextId: ctxId,
+              expression: scrollExpr,
+              returnByValue: true,
+            }
+          : { expression: scrollExpr, returnByValue: true };
+        const { result } = await curSession.send<{
+          result: { value?: { sx?: number; sy?: number } };
+        }>("Runtime.evaluate", evalParams);
+        sx = Number(result?.value?.sx ?? 0);
+        sy = Number(result?.value?.sy ?? 0);
+      } catch {
+        //
+      }
+      const xi = Math.max(0, Math.floor(curX + sx));
+      const yi = Math.max(0, Math.floor(curY + sy));
+
+      let res: { backendNodeId?: number; frameId?: string } | undefined;
+      try {
+        res = await curSession.send<{
+          backendNodeId?: number;
+          frameId?: string;
+        }>("DOM.getNodeForLocation", {
+          x: xi,
+          y: yi,
+          includeUserAgentShadowDOM: false,
+          ignorePointerEventsNone: false,
+        });
+      } catch {
+        return null;
+      }
+
+      const be = res?.backendNodeId;
+      const reportedFrameId = res?.frameId;
+      if (
+        typeof be === "number" &&
+        reportedFrameId &&
+        reportedFrameId !== curFrameId
+      ) {
+        const abs = await buildAbsoluteXPathFromChain(
+          iframeChain,
+          curSession,
+          be,
+        );
+        return abs
+          ? { frameId: reportedFrameId, backendNodeId: be, absoluteXPath: abs }
+          : null;
+      }
+
+      if (typeof be !== "number") return null;
+
+      let matchedChild: string | undefined;
+      for (const fid of listChildrenOf(parentByFrame, curFrameId)) {
+        try {
+          const { backendNodeId } = await curSession.send<{
+            backendNodeId?: number;
+          }>("DOM.getFrameOwner", { frameId: fid });
+          if (backendNodeId === be) {
+            matchedChild = fid;
+            break;
+          }
+        } catch {
+          continue;
+        }
+      }
+
+      if (!matchedChild) {
+        const abs = await buildAbsoluteXPathFromChain(
+          iframeChain,
+          curSession,
+          be,
+        );
+        return abs
+          ? { frameId: curFrameId, backendNodeId: be, absoluteXPath: abs }
+          : null;
+      }
+
+      iframeChain.push({
+        parentSession: curSession,
+        iframeBackendNodeId: be,
+      });
+
+      let left = 0;
+      let top = 0;
+      try {
+        const { object } = await curSession.send<{
+          object: { objectId?: string };
+        }>("DOM.resolveNode", { backendNodeId: be });
+        const objectId = object?.objectId;
+        if (objectId) {
+          const { result } = await curSession.send<{
+            result: { value?: { left: number; top: number } };
+          }>("Runtime.callFunctionOn", {
+            objectId,
+            functionDeclaration: a11yScriptSources.getBoundingRectLite,
+            returnByValue: true,
+          });
+          left = Number(result?.value?.left ?? 0);
+          top = Number(result?.value?.top ?? 0);
+          await curSession
+            .send("Runtime.releaseObject", { objectId })
+            .catch(() => {});
+        }
+      } catch {
+        //
+      }
+      curX = Math.max(0, curX - left);
+      curY = Math.max(0, curY - top);
+      curFrameId = matchedChild;
+      curSession = page.getSessionForFrame(curFrameId);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
diff --git a/packages/core/lib/v3/understudy/a11y/snapshot/domTree.ts b/packages/core/lib/v3/understudy/a11y/snapshot/domTree.ts
new file mode 100644
index 000000000..cc23a9542
--- /dev/null
+++ b/packages/core/lib/v3/understudy/a11y/snapshot/domTree.ts
@@ -0,0 +1,344 @@
+import type { Protocol } from "devtools-protocol";
+import type { CDPSessionLike } from "../../cdp.js";
+import { StagehandDomProcessError } from "../../../types/public/sdkErrors.js";
+import type { SessionDomIndex } from "../../../types/private/snapshot.js";
+import {
+  buildChildXPathSegments,
+  joinXPath,
+  normalizeXPath,
+} from "./xpathUtils.js";
+
+// starting from infinite depth (-1), exponentially shrink down to 1
+const DOM_DEPTH_ATTEMPTS = [-1, 256, 128, 64, 32, 16, 8, 4, 2, 1];
+const DESCRIBE_DEPTH_ATTEMPTS = [-1, 64, 32, 16, 8, 4, 2, 1];
+
+/** Identify CDP failures caused by deep DOM trees blowing the CBOR encoder stack. */
+function isCborStackError(message: string): boolean {
+  return message.includes("CBOR: stack limit exceeded");
+}
+
+/**
+ * Determine if CDP truncated a node's children when streaming the DOM tree.
+ * childNodeCount stays accurate even when `children` are omitted; we use this to
+ * decide whether DOM.describeNode must be re-run for that node.
+ */
+export function shouldExpandNode(node: Protocol.DOM.Node): boolean {
+  const declaredChildren = node.childNodeCount ?? 0;
+  const realizedChildren = node.children?.length ?? 0;
+  return declaredChildren > realizedChildren;
+}
+
+/** Merge an expanded DescribeNode payload back into the original shallow node. */
+export function mergeDomNodes(
+  target: Protocol.DOM.Node,
+  source: Protocol.DOM.Node,
+): void {
+  target.childNodeCount = source.childNodeCount ?? target.childNodeCount;
+  target.children = source.children ?? target.children;
+  target.shadowRoots = source.shadowRoots ?? target.shadowRoots;
+  target.contentDocument = source.contentDocument ?? target.contentDocument;
+}
+
+/** Helper that returns every nested collection we recurse through uniformly. */
+export function collectDomTraversalTargets(
+  node: Protocol.DOM.Node,
+): Protocol.DOM.Node[] {
+  const targets: Protocol.DOM.Node[] = [];
+  if (node.children) targets.push(...node.children);
+  if (node.shadowRoots) targets.push(...node.shadowRoots);
+  if (node.contentDocument) targets.push(node.contentDocument);
+  return targets;
+}
+
+/**
+ * Rehydrate a truncated DOM tree by repeatedly calling DOM.describeNode with
+ * decreasing depths. Any non-CBOR failure is surfaced as a StagehandDomProcessError.
+ */
+export async function hydrateDomTree(
+  session: CDPSessionLike,
+  root: Protocol.DOM.Node,
+  pierce: boolean,
+): Promise<void> {
+  const stack: Protocol.DOM.Node[] = [root];
+  const expandedNodeIds = new Set<number>();
+  const expandedBackendIds = new Set<number>();
+
+  while (stack.length) {
+    const node = stack.pop()!;
+    const nodeId =
+      typeof node.nodeId === "number" && node.nodeId > 0
+        ? node.nodeId
+        : undefined;
+    const backendId =
+      typeof node.backendNodeId === "number" && node.backendNodeId > 0
+        ? node.backendNodeId
+        : undefined;
+
+    const seenByNode = nodeId ? expandedNodeIds.has(nodeId) : false;
+    const seenByBackend =
+      !nodeId && backendId ? expandedBackendIds.has(backendId) : false;
+    if (seenByNode || seenByBackend) continue;
+    if (nodeId) expandedNodeIds.add(nodeId);
+    else if (backendId) expandedBackendIds.add(backendId);
+
+    const needsExpansion = shouldExpandNode(node);
+    if (needsExpansion && (nodeId || backendId)) {
+      const describeParamsBase = nodeId
+        ? { nodeId }
+        : { backendNodeId: backendId! };
+      let expanded = false;
+      for (const depth of DESCRIBE_DEPTH_ATTEMPTS) {
+        try {
+          const described =
+            await session.send<Protocol.DOM.DescribeNodeResponse>(
+              "DOM.describeNode",
+              {
+                ...describeParamsBase,
+                depth,
+                pierce,
+              },
+            );
+          mergeDomNodes(node, described.node);
+          if (!nodeId && described.node.nodeId && described.node.nodeId > 0) {
+            node.nodeId = described.node.nodeId;
+            expandedNodeIds.add(described.node.nodeId);
+          }
+          expanded = true;
+          break;
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          if (isCborStackError(message)) {
+            continue;
+          }
+          const identifier = nodeId ?? backendId ?? "unknown";
+          throw new StagehandDomProcessError(
+            `Failed to expand DOM node ${identifier}: ${String(err)}`,
+          );
+        }
+      }
+      if (!expanded) {
+        const identifier = nodeId ?? backendId ?? "unknown";
+        throw new StagehandDomProcessError(
+          `Unable to expand DOM node ${identifier} after describeNode depth retries`,
+        );
+      }
+    }
+
+    for (const child of collectDomTraversalTargets(node)) {
+      stack.push(child);
+    }
+  }
+}
+
+/**
+ * Attempt DOM.getDocument with progressively shallower depths until CBOR stops
+ * complaining. When a shallower snapshot is returned we hydrate the missing
+ * branches so downstream DOM traversals see the full tree shape.
+ */
+export async function getDomTreeWithFallback(
+  session: CDPSessionLike,
+  pierce: boolean,
+): Promise<Protocol.DOM.Node> {
+  let lastCborMessage = "";
+
+  for (const depth of DOM_DEPTH_ATTEMPTS) {
+    try {
+      const { root } = await session.send<{ root: Protocol.DOM.Node }>(
+        "DOM.getDocument",
+        { depth, pierce },
+      );
+
+      if (depth !== -1) {
+        await hydrateDomTree(session, root, pierce);
+      }
+
+      return root;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (isCborStackError(message)) {
+        lastCborMessage = message;
+        continue;
+      }
+      throw err;
+    }
+  }
+
+  throw new StagehandDomProcessError(
+    lastCborMessage
+      ? `CDP DOM.getDocument failed after adaptive depth retries: ${lastCborMessage}`
+      : "CDP DOM.getDocument failed after adaptive depth retries.",
+  );
+}
+
+/**
+ * Build tag name and XPath maps for a single frame session.
+ * EncodedId is produced by a frame-aware encoder provided by the caller.
+ */
+export async function domMapsForSession(
+  session: CDPSessionLike,
+  frameId: string,
+  pierce: boolean,
+  encode: (fid: string, backendNodeId: number) => string,
+  attemptOwnerLookup = true,
+): Promise<{
+  tagNameMap: Record<string, string>;
+  xpathMap: Record<string, string>;
+  scrollableMap: Record<string, boolean>;
+}> {
+  await session.send("DOM.enable").catch(() => {});
+  const root = await getDomTreeWithFallback(session, pierce);
+
+  let startNode: Protocol.DOM.Node = root;
+  if (attemptOwnerLookup) {
+    try {
+      const owner = await session.send<{ backendNodeId?: number }>(
+        "DOM.getFrameOwner",
+        { frameId },
+      );
+      const ownerBackendId = owner.backendNodeId;
+      if (typeof ownerBackendId === "number") {
+        const ownerEl = findNodeByBackendId(root, ownerBackendId);
+        if (ownerEl?.contentDocument) {
+          startNode = ownerEl.contentDocument;
+        }
+      }
+    } catch {
+      // OOPIF or race → keep startNode = root
+    }
+  }
+
+  const tagNameMap: Record<string, string> = {};
+  const xpathMap: Record<string, string> = {};
+  const scrollableMap: Record<string, boolean> = {};
+
+  type StackEntry = { node: Protocol.DOM.Node; xpath: string };
+  const stack: StackEntry[] = [{ node: startNode, xpath: "" }];
+
+  while (stack.length) {
+    const { node, xpath } = stack.pop()!;
+
+    if (node.backendNodeId) {
+      const encId = encode(frameId, node.backendNodeId);
+      tagNameMap[encId] = String(node.nodeName).toLowerCase();
+      xpathMap[encId] = xpath || "/";
+      const isScrollable = node?.isScrollable === true;
+      if (isScrollable) scrollableMap[encId] = true;
+    }
+
+    const kids = node.children ?? [];
+    if (kids.length) {
+      const segs = buildChildXPathSegments(kids);
+      for (let i = kids.length - 1; i >= 0; i--) {
+        const child = kids[i]!;
+        const step = segs[i]!;
+        stack.push({
+          node: child,
+          xpath: joinXPath(xpath, step),
+        });
+      }
+    }
+
+    for (const sr of node.shadowRoots ?? []) {
+      stack.push({
+        node: sr,
+        xpath: joinXPath(xpath, "//"),
+      });
+    }
+  }
+
+  return { tagNameMap, xpathMap, scrollableMap };
+}
+
+/**
+ * Build an index of absolute XPath/tag metadata for an entire CDP session.
+ * Once the index is cached, per-frame slices are derived without extra DOM
+ * calls, which keeps snapshot capture linear in the number of frames.
+ */
+export async function buildSessionDomIndex(
+  session: CDPSessionLike,
+  pierce: boolean,
+): Promise<SessionDomIndex> {
+  await session.send("DOM.enable").catch(() => {});
+  const root = await getDomTreeWithFallback(session, pierce);
+
+  const absByBe = new Map<number, string>();
+  const tagByBe = new Map<number, string>();
+  const scrollByBe = new Map<number, boolean>();
+  const docRootOf = new Map<number, number>();
+  const contentDocRootByIframe = new Map<number, number>();
+
+  type Entry = { node: Protocol.DOM.Node; xp: string; docRootBe: number };
+  const rootBe = root.backendNodeId!;
+  const stack: Entry[] = [{ node: root, xp: "/", docRootBe: rootBe }];
+
+  while (stack.length) {
+    const { node, xp, docRootBe } = stack.pop()!;
+    if (node.backendNodeId) {
+      absByBe.set(node.backendNodeId, xp || "/");
+      tagByBe.set(node.backendNodeId, String(node.nodeName).toLowerCase());
+      if (node?.isScrollable === true) scrollByBe.set(node.backendNodeId, true);
+      docRootOf.set(node.backendNodeId, docRootBe);
+    }
+
+    const kids = node.children ?? [];
+    if (kids.length) {
+      const segs = buildChildXPathSegments(kids);
+      for (let i = kids.length - 1; i >= 0; i--) {
+        const child = kids[i]!;
+        const step = segs[i]!;
+        stack.push({ node: child, xp: joinXPath(xp, step), docRootBe });
+      }
+    }
+
+    for (const sr of node.shadowRoots ?? []) {
+      stack.push({ node: sr, xp: joinXPath(xp, "//"), docRootBe });
+    }
+
+    const cd = node.contentDocument as Protocol.DOM.Node | undefined;
+    if (cd && typeof cd.backendNodeId === "number") {
+      contentDocRootByIframe.set(node.backendNodeId!, cd.backendNodeId);
+      stack.push({ node: cd, xp, docRootBe: cd.backendNodeId });
+    }
+  }
+
+  return {
+    rootBackend: rootBe,
+    absByBe,
+    tagByBe,
+    scrollByBe,
+    docRootOf,
+    contentDocRootByIframe,
+  };
+}
+
+/**
+ * Relativize an absolute XPath against a document root's absolute path.
+ * When the node lives outside the document we return the absolute path as-is.
+ */
+export function relativizeXPath(baseAbs: string, nodeAbs: string): string {
+  const base = normalizeXPath(baseAbs);
+  const abs = normalizeXPath(nodeAbs);
+  if (abs === base) return "/";
+  if (abs.startsWith(base)) {
+    const tail = abs.slice(base.length);
+    if (!tail) return "/";
+    return tail.startsWith("/") || tail.startsWith("//") ? tail : `/${tail}`;
+  }
+  if (base === "/") return abs;
+  return abs;
+}
+
+/** Find a node by backendNodeId inside a DOM.getDocument tree. */
+export function findNodeByBackendId(
+  root: Protocol.DOM.Node,
+  backendNodeId: number,
+): Protocol.DOM.Node | undefined {
+  const stack: Protocol.DOM.Node[] = [root];
+  while (stack.length) {
+    const n = stack.pop()!;
+    if (n.backendNodeId === backendNodeId) return n;
+    if (n.children) for (const c of n.children) stack.push(c);
+    if (n.shadowRoots) for (const s of n.shadowRoots) stack.push(s);
+  }
+  return undefined;
+}
diff --git a/packages/core/lib/v3/understudy/a11y/snapshot/focusSelectors.ts b/packages/core/lib/v3/understudy/a11y/snapshot/focusSelectors.ts
new file mode 100644
index 000000000..257ce8cb2
--- /dev/null
+++ b/packages/core/lib/v3/understudy/a11y/snapshot/focusSelectors.ts
@@ -0,0 +1,292 @@
+import type { Protocol } from "devtools-protocol";
+import type { CDPSessionLike } from "../../cdp.js";
+import { Page } from "../../page.js";
+import { executionContexts } from "../../executionContextRegistry.js";
+import { buildLocatorInvocation } from "../../locatorInvocation.js";
+import { StagehandIframeError } from "../../../types/public/sdkErrors.js";
+import type {
+  Axis,
+  FrameParentIndex,
+  ResolvedCssFocus,
+  ResolvedFocusFrame,
+  Step,
+} from "../../../types/private/snapshot.js";
+import { prefixXPath } from "./xpathUtils.js";
+
+/**
+ * Parse a cross-frame XPath into discrete steps. Each step tracks whether it
+ * represents a descendant hop (“//”) or a single-child hop (“/”).
+ */
+export function parseXPathToSteps(path: string): Step[] {
+  const s = path.trim();
+  let i = 0;
+  const steps: Step[] = [];
+  while (i < s.length) {
+    let axis: Axis = "child";
+    if (s.startsWith("//", i)) {
+      axis = "desc";
+      i += 2;
+    } else if (s[i] === "/") {
+      axis = "child";
+      i += 1;
+    }
+
+    const start = i;
+    while (i < s.length && s[i] !== "/") i++;
+    const raw = s.slice(start, i).trim();
+    if (!raw) continue;
+    const name = raw.replace(/\[\d+\]\s*$/u, "").toLowerCase();
+    steps.push({ axis, raw, name });
+  }
+  return steps;
+}
+
+/** Rebuild an XPath string from parsed steps. */
+export function buildXPathFromSteps(steps: ReadonlyArray<Step>): string {
+  let out = "";
+  for (const st of steps) {
+    out += st.axis === "desc" ? "//" : "/";
+    out += st.raw;
+  }
+  return out || "/";
+}
+
+export const IFRAME_STEP_RE = /^i?frame(?:\[\d+])?$/i;
+
+/**
+ * Given a cross-frame XPath, walk iframe steps to resolve:
+ * - the target frameId (last iframe hop)
+ * - the tail XPath (within the target frame)
+ * - the absolute XPath prefix up to the iframe element hosting that frame
+ */
+export async function resolveFocusFrameAndTail(
+  page: Page,
+  absoluteXPath: string,
+  parentByFrame: FrameParentIndex,
+  rootId: string,
+): Promise<ResolvedFocusFrame> {
+  const steps = parseXPathToSteps(absoluteXPath);
+  let ctxFrameId = rootId;
+  let buf: Step[] = [];
+  let absPrefix = "";
+
+  const flushIntoChild = async (): Promise<void> => {
+    if (!buf.length) return;
+    const selectorForIframe = buildXPathFromSteps(buf);
+    const parentSess = page.getSessionForFrame(ctxFrameId);
+    const objectId = await resolveObjectIdForXPath(
+      parentSess,
+      selectorForIframe,
+      ctxFrameId,
+    );
+    if (!objectId)
+      throw new StagehandIframeError(
+        selectorForIframe,
+        "Failed to resolve iframe element by XPath",
+      );
+
+    try {
+      await parentSess.send("DOM.enable").catch(() => {});
+      const desc = await parentSess.send<Protocol.DOM.DescribeNodeResponse>(
+        "DOM.describeNode",
+        { objectId },
+      );
+      const iframeBackendNodeId = desc.node.backendNodeId;
+
+      let childFrameId: string | undefined;
+      for (const fid of listChildrenOf(parentByFrame, ctxFrameId)) {
+        try {
+          const { backendNodeId } = await parentSess.send<{
+            backendNodeId: number;
+          }>("DOM.getFrameOwner", { frameId: fid });
+          if (backendNodeId === iframeBackendNodeId) {
+            childFrameId = fid;
+            break;
+          }
+        } catch {
+          continue;
+        }
+      }
+      if (!childFrameId)
+        throw new StagehandIframeError(
+          selectorForIframe,
+          "Could not map iframe to child frameId",
+        );
+
+      absPrefix = prefixXPath(absPrefix || "/", selectorForIframe);
+      ctxFrameId = childFrameId;
+    } finally {
+      await parentSess
+        .send("Runtime.releaseObject", { objectId })
+        .catch(() => {});
+    }
+
+    buf = [];
+  };
+
+  for (const st of steps) {
+    buf.push(st);
+    if (IFRAME_STEP_RE.test(st.name)) {
+      await flushIntoChild();
+    }
+  }
+
+  const tailXPath = buildXPathFromSteps(buf);
+  return { targetFrameId: ctxFrameId, tailXPath, absPrefix };
+}
+
+/** Resolve focus frame and tail CSS selector using '>>' to hop iframes. */
+export async function resolveCssFocusFrameAndTail(
+  page: Page,
+  rawSelector: string,
+  parentByFrame: FrameParentIndex,
+  rootId: string,
+): Promise<ResolvedCssFocus> {
+  const parts = rawSelector
+    .split(">>")
+    .map((s) => s.trim())
+    .filter(Boolean);
+  let ctxFrameId = rootId;
+  const absPrefix = "";
+
+  for (let i = 0; i < Math.max(0, parts.length - 1); i++) {
+    const parentSess = page.getSessionForFrame(ctxFrameId);
+    const objectId = await resolveObjectIdForCss(
+      parentSess,
+      parts[i]!,
+      ctxFrameId,
+    );
+    if (!objectId)
+      throw new StagehandIframeError(
+        parts[i]!,
+        "Failed to resolve iframe via CSS hop",
+      );
+    try {
+      await parentSess.send("DOM.enable").catch(() => {});
+      const desc = await parentSess.send<Protocol.DOM.DescribeNodeResponse>(
+        "DOM.describeNode",
+        { objectId },
+      );
+      const iframeBackendNodeId = desc.node.backendNodeId;
+      let childFrameId: string | undefined;
+      for (const fid of listChildrenOf(parentByFrame, ctxFrameId)) {
+        try {
+          const { backendNodeId } = await parentSess.send<{
+            backendNodeId: number;
+          }>("DOM.getFrameOwner", { frameId: fid });
+          if (backendNodeId === iframeBackendNodeId) {
+            childFrameId = fid;
+            break;
+          }
+        } catch {
+          continue;
+        }
+      }
+      if (!childFrameId)
+        throw new StagehandIframeError(
+          parts[i]!,
+          "Could not map CSS iframe hop to child frameId",
+        );
+      ctxFrameId = childFrameId;
+    } finally {
+      await parentSess
+        .send("Runtime.releaseObject", { objectId })
+        .catch(() => {});
+    }
+  }
+
+  const tailSelector = parts[parts.length - 1] ?? "*";
+  return { targetFrameId: ctxFrameId, tailSelector, absPrefix };
+}
+
+/** Resolve an XPath to a Runtime remoteObjectId in the given CDP session. */
+export async function resolveObjectIdForXPath(
+  session: CDPSessionLike,
+  xpath: string,
+  frameId?: string,
+): Promise<string | null> {
+  let contextId: number | undefined;
+  try {
+    if (frameId) {
+      contextId = await executionContexts
+        .waitForMainWorld(session, frameId, 800)
+        .catch(
+          () => executionContexts.getMainWorld(session, frameId) ?? undefined,
+        );
+    }
+  } catch {
+    contextId = undefined;
+  }
+  const expr = buildLocatorInvocation("resolveXPathMainWorld", [
+    JSON.stringify(xpath),
+    "0",
+  ]);
+  const { result, exceptionDetails } = await session.send<{
+    result: { objectId?: string | undefined };
+    exceptionDetails?: Protocol.Runtime.ExceptionDetails;
+  }>("Runtime.evaluate", {
+    expression: expr,
+    returnByValue: false,
+    contextId,
+    awaitPromise: true,
+  });
+  if (exceptionDetails) return null;
+  return result?.objectId ?? null;
+}
+
+/** Resolve a CSS selector (supports '>>' within the same frame only) to a Runtime objectId. */
+export async function resolveObjectIdForCss(
+  session: CDPSessionLike,
+  selector: string,
+  frameId?: string,
+): Promise<string | null> {
+  let contextId: number | undefined;
+  try {
+    if (frameId) {
+      contextId = await executionContexts
+        .waitForMainWorld(session, frameId, 800)
+        .catch(
+          () => executionContexts.getMainWorld(session, frameId) ?? undefined,
+        );
+    }
+  } catch {
+    contextId = undefined;
+  }
+  const primaryExpr = buildLocatorInvocation("resolveCssSelector", [
+    JSON.stringify(selector),
+    "0",
+  ]);
+  const fallbackExpr = buildLocatorInvocation("resolveCssSelectorPierce", [
+    JSON.stringify(selector),
+    "0",
+  ]);
+
+  const evaluate = async (expression: string): Promise<string | null> => {
+    const { result, exceptionDetails } = await session.send<{
+      result: { objectId?: string | undefined };
+      exceptionDetails?: Protocol.Runtime.ExceptionDetails;
+    }>("Runtime.evaluate", {
+      expression,
+      returnByValue: false,
+      contextId,
+      awaitPromise: true,
+    });
+    if (exceptionDetails) return null;
+    return result?.objectId ?? null;
+  };
+
+  const primary = await evaluate(primaryExpr);
+  if (primary) return primary;
+  return evaluate(fallbackExpr);
+}
+
+export function listChildrenOf(
+  parentByFrame: FrameParentIndex,
+  parentId: string,
+): string[] {
+  const out: string[] = [];
+  for (const [fid, p] of parentByFrame.entries()) {
+    if (p === parentId) out.push(fid);
+  }
+  return out;
+}
diff --git a/packages/core/lib/v3/understudy/a11y/snapshot/index.ts b/packages/core/lib/v3/understudy/a11y/snapshot/index.ts
new file mode 100644
index 000000000..b484476dc
--- /dev/null
+++ b/packages/core/lib/v3/understudy/a11y/snapshot/index.ts
@@ -0,0 +1,4 @@
+export { captureHybridSnapshot } from "./capture.js";
+export { computeActiveElementXpath } from "./activeElement.js";
+export { diffCombinedTrees } from "./treeFormatUtils.js";
+export { resolveXpathForLocation } from "./coordinateResolver.js";
diff --git a/packages/core/lib/v3/understudy/a11y/snapshot/sessions.ts b/packages/core/lib/v3/understudy/a11y/snapshot/sessions.ts
new file mode 100644
index 000000000..0f9c43a3f
--- /dev/null
+++ b/packages/core/lib/v3/understudy/a11y/snapshot/sessions.ts
@@ -0,0 +1,31 @@
+import type { CDPSessionLike } from "../../cdp.js";
+import { Page } from "../../page.js";
+import type { FrameParentIndex } from "../../../types/private/snapshot.js";
+
+/**
+ * Session helpers ensure DOM lookups are always executed against the session
+ * that actually owns a frame. Keeping this logic centralized prevents subtle
+ * bugs when OOPIF adoption changes session ownership mid-capture.
+ */
+
+/** Return the owning session for a frame as registered on the Page. */
+export function ownerSession(page: Page, frameId: string): CDPSessionLike {
+  return page.getSessionForFrame(frameId);
+}
+
+/**
+ * DOM.getFrameOwner must be called against the parent frame's session.
+ * This helper hides the lookup (including main-frame fallback) so callers
+ * always reach for the correct connection.
+ */
+export function parentSession(
+  page: Page,
+  parentByFrame: FrameParentIndex,
+  frameId: string,
+): CDPSessionLike {
+  const parentId = parentByFrame.get(frameId) ?? null;
+  if (!parentId) {
+    return page.getSessionForFrame(frameId);
+  }
+  return page.getSessionForFrame(parentId);
+}
diff --git a/packages/core/lib/v3/understudy/a11y/snapshot/treeFormatUtils.ts b/packages/core/lib/v3/understudy/a11y/snapshot/treeFormatUtils.ts
new file mode 100644
index 000000000..fd90e1529
--- /dev/null
+++ b/packages/core/lib/v3/understudy/a11y/snapshot/treeFormatUtils.ts
@@ -0,0 +1,152 @@
+import type { A11yNode } from "../../../types/private/snapshot.js";
+
+/**
+ * Render a formatted outline (with encoded ids) for the accessibility tree.
+ * Keeps indentation logic shared between modules so unit tests can cover these
+ * pure formatting helpers without a full snapshot pipeline.
+ */
+export function formatTreeLine(node: A11yNode, level = 0): string {
+  const indent = "  ".repeat(level);
+  const labelId = node.encodedId ?? node.nodeId;
+  const label = `[${labelId}] ${node.role}${node.name ? `: ${cleanText(node.name)}` : ""}`;
+  const kids =
+    node.children?.map((c) => formatTreeLine(c, level + 1)).join("\n") ?? "";
+  return kids ? `${indent}${label}\n${kids}` : `${indent}${label}`;
+}
+
+/**
+ * Inject each child frame outline under the parent's iframe node line.
+ * Keys in `idToTree` are the parent's iframe encoded ids.
+ */
+export function injectSubtrees(
+  rootOutline: string,
+  idToTree: Map<string, string>,
+): string {
+  type Frame = { lines: string[]; i: number };
+  const out: string[] = [];
+  const visited = new Set<string>();
+  const stack: Frame[] = [{ lines: rootOutline.split("\n"), i: 0 }];
+
+  while (stack.length) {
+    const top = stack[stack.length - 1];
+    if (top.i >= top.lines.length) {
+      stack.pop();
+      continue;
+    }
+
+    const raw = top.lines[top.i++];
+    out.push(raw);
+
+    const indent = raw.match(/^(\s*)/)?.[1] ?? "";
+    const content = raw.slice(indent.length);
+
+    const m = content.match(/^\[([^\]]+)]/);
+    if (!m) continue;
+
+    const encId = m[1]!;
+    const childOutline = idToTree.get(encId);
+    if (!childOutline || visited.has(encId)) continue;
+
+    visited.add(encId);
+
+    const fullyInjectedChild = injectSubtrees(childOutline, idToTree);
+    out.push(indentBlock(fullyInjectedChild.trimEnd(), indent + "  "));
+  }
+
+  return out.join("\n");
+}
+
+export function indentBlock(block: string, indent: string): string {
+  if (!block) return "";
+  return block
+    .split("\n")
+    .map((line) => (line.length ? indent + line : indent + line))
+    .join("\n");
+}
+
+/**
+ * Return the lines that appear in `nextTree` but not in `prevTree`.
+ * Comparison is done line-by-line, ignoring leading whitespace in both trees.
+ * The returned block is re-indented so the minimal indent becomes column 0.
+ */
+export function diffCombinedTrees(prevTree: string, nextTree: string): string {
+  const prevSet = new Set(
+    (prevTree || "")
+      .split("\n")
+      .map((l) => l.trim())
+      .filter((l) => l.length > 0),
+  );
+
+  const nextLines = (nextTree || "").split("\n");
+  const added: string[] = [];
+  for (const line of nextLines) {
+    const core = line.trim();
+    if (!core) continue;
+    if (!prevSet.has(core)) added.push(line);
+  }
+
+  if (added.length === 0) return "";
+
+  let minIndent = Infinity;
+  for (const l of added) {
+    if (!l.trim()) continue;
+    const m = l.match(/^\s*/);
+    const indentLen = m ? m[0]!.length : 0;
+    if (indentLen < minIndent) minIndent = indentLen;
+  }
+  if (!isFinite(minIndent)) minIndent = 0;
+
+  const out = added.map((l) =>
+    l.length >= minIndent ? l.slice(minIndent) : l,
+  );
+  return out.join("\n");
+}
+
+/**
+ * Remove whitespace noise and invisible code points before rendering names.
+ */
+export function cleanText(input: string): string {
+  const PUA_START = 0xe000;
+  const PUA_END = 0xf8ff;
+  const NBSP = new Set<number>([0x00a0, 0x202f, 0x2007, 0xfeff]);
+
+  let out = "";
+  let prevSpace = false;
+  for (let i = 0; i < input.length; i++) {
+    const code = input.charCodeAt(i);
+    if (code >= PUA_START && code <= PUA_END) continue;
+    if (NBSP.has(code)) {
+      if (!prevSpace) {
+        out += " ";
+        prevSpace = true;
+      }
+      continue;
+    }
+    out += input[i];
+    prevSpace = input[i] === " ";
+  }
+  return out.trim();
+}
+
+/**
+ * Collapse all whitespace runs in a string to a single space without trimming.
+ * Exported for pruning routines that need the same normalization.
+ */
+export function normaliseSpaces(s: string): string {
+  let out = "";
+  let inWs = false;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i]!;
+    const isWs = /\s/.test(ch);
+    if (isWs) {
+      if (!inWs) {
+        out += " ";
+        inWs = true;
+      }
+    } else {
+      out += ch;
+      inWs = false;
+    }
+  }
+  return out;
+}
diff --git a/packages/core/lib/v3/understudy/a11y/snapshot/xpathUtils.ts b/packages/core/lib/v3/understudy/a11y/snapshot/xpathUtils.ts
new file mode 100644
index 000000000..d4edf84db
--- /dev/null
+++ b/packages/core/lib/v3/understudy/a11y/snapshot/xpathUtils.ts
@@ -0,0 +1,120 @@
+import type { Protocol } from "devtools-protocol";
+import type { CDPSessionLike } from "../../cdp.js";
+import { a11yScriptSources } from "../../../dom/build/a11yScripts.generated.js";
+
+/**
+ * Build the absolute XPath for a node by walking through every iframe host
+ * we've traversed so far followed by the leaf backend node.
+ */
+export async function buildAbsoluteXPathFromChain(
+  chain: Array<{
+    parentSession: CDPSessionLike;
+    iframeBackendNodeId: number;
+  }>,
+  leafSession: CDPSessionLike,
+  leafBackendNodeId: number,
+): Promise<string | null> {
+  let prefix = "";
+  for (const step of chain) {
+    const xp = await absoluteXPathForBackendNode(
+      step.parentSession,
+      step.iframeBackendNodeId,
+    );
+    if (!xp) continue;
+    prefix = prefix ? prefixXPath(prefix, xp) : normalizeXPath(xp);
+  }
+  const leaf = await absoluteXPathForBackendNode(
+    leafSession,
+    leafBackendNodeId,
+  );
+  if (!leaf) return prefix || "/";
+  return prefix ? prefixXPath(prefix, leaf) : normalizeXPath(leaf);
+}
+
+/**
+ * Resolve a backend node to an absolute XPath within the provided session.
+ * The CDP Runtime is used so we can invoke a small helper that walks the DOM.
+ */
+export async function absoluteXPathForBackendNode(
+  session: CDPSessionLike,
+  backendNodeId: number,
+): Promise<string | null> {
+  try {
+    const { object } = await session.send<{ object: { objectId?: string } }>(
+      "DOM.resolveNode",
+      { backendNodeId },
+    );
+    const objectId = object?.objectId;
+    if (!objectId) return null;
+
+    const { result } = await session.send<{ result: { value?: string } }>(
+      "Runtime.callFunctionOn",
+      {
+        objectId,
+        functionDeclaration: a11yScriptSources.nodeToAbsoluteXPath,
+        returnByValue: true,
+      },
+    );
+    await session.send("Runtime.releaseObject", { objectId }).catch(() => {});
+    return typeof result?.value === "string" && result.value
+      ? result.value
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Prefix `child` XPath with an absolute iframe path `parentAbs`.
+ * Handles root slashes and shadow hops (“//”) cleanly.
+ */
+export function prefixXPath(parentAbs: string, child: string): string {
+  const p = parentAbs === "/" ? "" : parentAbs.replace(/\/$/, "");
+  if (!child || child === "/") return p || "/";
+  if (child.startsWith("//"))
+    return p ? `${p}//${child.slice(2)}` : `//${child.slice(2)}`;
+  const c = child.replace(/^\//, "");
+  return p ? `${p}/${c}` : `/${c}`;
+}
+
+/** Normalize an XPath: strip `xpath=`, ensure leading '/', remove trailing '/'. */
+export function normalizeXPath(x?: string): string {
+  if (!x) return "";
+  let s = x.trim().replace(/^xpath=/i, "");
+  if (!s.startsWith("/")) s = "/" + s;
+  if (s.length > 1 && s.endsWith("/")) s = s.slice(0, -1);
+  return s;
+}
+
+/** Build per-sibling XPath steps for DOM traversal. */
+export function buildChildXPathSegments(kids: Protocol.DOM.Node[]): string[] {
+  const segs: string[] = [];
+  const ctr: Record<string, number> = {};
+  for (const child of kids) {
+    const tag = String(child.nodeName).toLowerCase();
+    const key = `${child.nodeType}:${tag}`;
+    const idx = (ctr[key] = (ctr[key] ?? 0) + 1);
+    if (child.nodeType === 3) {
+      segs.push(`text()[${idx}]`);
+    } else if (child.nodeType === 8) {
+      segs.push(`comment()[${idx}]`);
+    } else {
+      segs.push(
+        tag.includes(":") ? `*[name()='${tag}'][${idx}]` : `${tag}[${idx}]`,
+      );
+    }
+  }
+  return segs;
+}
+
+/** Join two XPath fragments while preserving special shadow-root hops. */
+export function joinXPath(base: string, step: string): string {
+  if (step === "//") {
+    if (!base || base === "/") return "//";
+    return base.endsWith("/") ? `${base}/` : `${base}//`;
+  }
+  if (!base || base === "/") return step ? `/${step}` : "/";
+  if (base.endsWith("//")) return `${base}${step}`;
+  if (!step) return base;
+  return `${base}/${step}`;
+}
diff --git a/packages/core/lib/v3/understudy/a11yInvocation.ts b/packages/core/lib/v3/understudy/a11yInvocation.ts
new file mode 100644
index 000000000..0d63a720f
--- /dev/null
+++ b/packages/core/lib/v3/understudy/a11yInvocation.ts
@@ -0,0 +1,19 @@
+import {
+  a11yScriptBootstrap,
+  a11yScriptGlobalRefs,
+  type A11yScriptName,
+} from "../dom/build/a11yScripts.generated.js";
+
+/**
+ * Wrap a generated a11y script in a self-invoking expression that first ensures
+ * the bootstrap has run, then calls the requested helper via its global ref.
+ * This mirrors the locator resolver’s injection path so any CDP Runtime.evaluate
+ * can reuse the shared bundle without inlining JS strings.
+ */
+export function buildA11yInvocation(
+  name: A11yScriptName,
+  args: string[],
+): string {
+  const invocation = `${a11yScriptGlobalRefs[name]}(${args.join(", ")})`;
+  return `(() => { ${a11yScriptBootstrap}; return ${invocation}; })()`;
+}
diff --git a/packages/core/lib/v3/understudy/cdp.ts b/packages/core/lib/v3/understudy/cdp.ts
new file mode 100644
index 000000000..fe22f5eb1
--- /dev/null
+++ b/packages/core/lib/v3/understudy/cdp.ts
@@ -0,0 +1,415 @@
+// lib/v3/understudy/cdp.ts
+import WebSocket from "ws";
+import type { Protocol } from "devtools-protocol";
+import { STAGEHAND_VERSION } from "../../version.js";
+import {
+  CdpConnectionClosedError,
+  PageNotFoundError,
+} from "../types/public/sdkErrors.js";
+
+/**
+ * CDP transport & session multiplexer
+ *
+ * Owns the browser WebSocket and multiplexes flattened Target sessions.
+ * Tracks inflight CDP calls, routes responses to the right session, and forwards events.
+ *
+ * This does not interpret Page/DOM/Runtime semantics — callers own that logic.
+ */
+export interface CDPSessionLike {
+  send<R = unknown>(method: string, params?: object): Promise<R>;
+  on<P = unknown>(event: string, handler: (params: P) => void): void;
+  off<P = unknown>(event: string, handler: (params: P) => void): void;
+  close(): Promise<void>;
+  readonly id: string | null;
+}
+
+type Inflight = {
+  resolve: (v: unknown) => void;
+  reject: (e: Error) => void;
+  sessionId?: string | null;
+  method: string;
+  params?: object;
+  stack?: string;
+  ts: number;
+};
+
+type EventHandler = (params: unknown) => void;
+type SessionDispatchWaiter = {
+  sessionId: string;
+  method: string;
+  match?: (params?: object) => boolean;
+  resolve: () => void;
+  reject: (error: Error) => void;
+};
+
+type RawMessage =
+  | {
+      id: number;
+      result?: unknown;
+      error?: { code: number; message: string; data?: unknown };
+      sessionId?: string;
+    }
+  | { method: string; params?: unknown; sessionId?: string };
+
+export class CdpConnection implements CDPSessionLike {
+  private ws: WebSocket;
+  private nextId = 1;
+  private inflight = new Map<number, Inflight>();
+  private eventHandlers = new Map<string, Set<EventHandler>>();
+  private sessions = new Map<string, CdpSession>();
+  /** Maps sessionId -> targetId (1:1 mapping) */
+  private sessionToTarget = new Map<string, string>();
+  private sessionDispatchWaiters = new Set<SessionDispatchWaiter>();
+  public readonly id: string | null = null; // root
+  private transportCloseHandlers = new Set<(why: string) => void>();
+
+  /** Optional CDP logger - set this to receive all outgoing CDP method calls */
+  public cdpLogger?: (info: {
+    method: string;
+    params?: object;
+    targetId?: string | null;
+  }) => void;
+
+  /** Optional CDP event logger - set this to receive all incoming CDP events */
+  public cdpEventLogger?: (info: {
+    method: string;
+    params?: unknown;
+    targetId?: string | null;
+  }) => void;
+
+  public onTransportClosed(handler: (why: string) => void): void {
+    this.transportCloseHandlers.add(handler);
+  }
+  public offTransportClosed(handler: (why: string) => void): void {
+    this.transportCloseHandlers.delete(handler);
+  }
+
+  private emitTransportClosed(why: string) {
+    for (const h of this.transportCloseHandlers) {
+      try {
+        h(why);
+      } catch {
+        //
+      }
+    }
+  }
+
+  private constructor(ws: WebSocket) {
+    this.ws = ws;
+    this.ws.on("close", (code, reason) => {
+      // Reason is a Buffer in ws; stringify defensively
+      const why = `socket-close code=${code} reason=${String(reason || "")}`;
+      this.rejectAllInflight(why);
+      this.emitTransportClosed(why);
+    });
+
+    this.ws.on("error", (err) => {
+      const why = `socket-error ${err?.message ?? String(err)}`;
+      this.rejectAllInflight(why);
+      this.emitTransportClosed(why);
+    });
+    this.ws.on("message", (data) => this.onMessage(data.toString()));
+  }
+
+  static async connect(
+    wsUrl: string,
+    options?: { headers?: Record<string, string> },
+  ): Promise<CdpConnection> {
+    // Include User-Agent header for server-side observability and version tracking
+    // Merge user-provided headers, letting them override defaults
+    const headers = {
+      "User-Agent": `Stagehand/${STAGEHAND_VERSION}`,
+      ...options?.headers,
+    };
+    const ws = new WebSocket(wsUrl, { headers });
+    await new Promise<void>((resolve, reject) => {
+      ws.once("open", () => resolve());
+      ws.once("error", (e) => reject(e));
+    });
+    return new CdpConnection(ws);
+  }
+
+  async enableAutoAttach(): Promise<void> {
+    await this.send("Target.setAutoAttach", {
+      autoAttach: true,
+      flatten: true,
+      waitForDebuggerOnStart: true,
+    });
+    await this.send("Target.setDiscoverTargets", { discover: true });
+  }
+
+  async send<R = unknown>(method: string, params?: object): Promise<R> {
+    const id = this.nextId++;
+    const payload = { id, method, params };
+    const stack = new Error().stack?.split("\n").slice(1, 4).join("\n");
+    const p = new Promise<R>((resolve, reject) => {
+      this.inflight.set(id, {
+        resolve,
+        reject,
+        sessionId: null,
+        method,
+        params,
+        stack,
+        ts: Date.now(),
+      });
+    });
+    // Prevent unhandledRejection if a session detaches before the caller awaits.
+    void p.catch(() => {});
+    this.cdpLogger?.({ method, params, targetId: null });
+    this.ws.send(JSON.stringify(payload));
+    return p;
+  }
+
+  on<P = unknown>(event: string, handler: (params: P) => void): void {
+    const set = this.eventHandlers.get(event) ?? new Set<EventHandler>();
+    set.add(handler as EventHandler);
+    this.eventHandlers.set(event, set);
+  }
+
+  off<P = unknown>(event: string, handler: (params: P) => void): void {
+    const set = this.eventHandlers.get(event);
+    if (set) set.delete(handler as EventHandler);
+  }
+
+  async close(): Promise<void> {
+    if (this.ws.readyState === WebSocket.CLOSED) return;
+    await new Promise<void>((resolve) => {
+      this.ws.once("close", () => resolve());
+      this.ws.close();
+    });
+  }
+
+  private rejectAllInflight(why: string): void {
+    for (const [id, entry] of this.inflight.entries()) {
+      entry.reject(new CdpConnectionClosedError(why));
+      this.inflight.delete(id);
+    }
+    for (const waiter of Array.from(this.sessionDispatchWaiters)) {
+      waiter.reject(new CdpConnectionClosedError(why));
+    }
+  }
+
+  getSession(sessionId: string): CdpSession | undefined {
+    return this.sessions.get(sessionId);
+  }
+
+  waitForSessionDispatch(
+    sessionId: string,
+    method: string,
+    match?: (params?: object) => boolean,
+  ): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      const waiter: SessionDispatchWaiter = {
+        sessionId,
+        method,
+        match,
+        resolve: () => {
+          this.sessionDispatchWaiters.delete(waiter);
+          resolve();
+        },
+        reject: (error: Error) => {
+          this.sessionDispatchWaiters.delete(waiter);
+          reject(error);
+        },
+      };
+      this.sessionDispatchWaiters.add(waiter);
+    });
+  }
+
+  async attachToTarget(targetId: string): Promise<CdpSession> {
+    const { sessionId } = (await this.send<{ sessionId: string }>(
+      "Target.attachToTarget",
+      { targetId, flatten: true },
+    )) as { sessionId: string };
+
+    let session = this.sessions.get(sessionId);
+    if (!session) {
+      session = new CdpSession(this, sessionId);
+      this.sessions.set(sessionId, session);
+    }
+    this.sessionToTarget.set(sessionId, targetId);
+    return session;
+  }
+
+  async getTargets(): Promise<Protocol.Target.TargetInfo[]> {
+    const res = await this.send<{
+      targetInfos: Protocol.Target.TargetInfo[];
+    }>("Target.getTargets");
+    return res.targetInfos;
+  }
+
+  private onMessage(json: string): void {
+    const msg = JSON.parse(json) as RawMessage;
+
+    if ("id" in msg) {
+      const rec = this.inflight.get(msg.id);
+      if (!rec) return;
+
+      this.inflight.delete(msg.id);
+
+      if ("error" in msg && msg.error) {
+        rec.reject(new Error(`${msg.error.code} ${msg.error.message}`));
+      } else {
+        rec.resolve((msg as { result?: unknown }).result);
+      }
+      return;
+    }
+
+    if ("method" in msg) {
+      if (msg.method === "Target.attachedToTarget") {
+        const p = (msg as { params: Protocol.Target.AttachedToTargetEvent })
+          .params;
+        if (!this.sessions.has(p.sessionId)) {
+          this.sessions.set(p.sessionId, new CdpSession(this, p.sessionId));
+        }
+        this.sessionToTarget.set(p.sessionId, p.targetInfo.targetId);
+      } else if (msg.method === "Target.detachedFromTarget") {
+        const p = (msg as { params: Protocol.Target.DetachedFromTargetEvent })
+          .params;
+        for (const [id, entry] of this.inflight.entries()) {
+          if (entry.sessionId === p.sessionId) {
+            entry.reject(
+              new PageNotFoundError(
+                `target closed before CDP response (sessionId=${p.sessionId}, targetId=${p.targetId})`,
+              ),
+            );
+            this.inflight.delete(id);
+          }
+        }
+        for (const waiter of Array.from(this.sessionDispatchWaiters)) {
+          if (waiter.sessionId === p.sessionId) {
+            waiter.reject(
+              new PageNotFoundError(
+                `target closed before CDP send (sessionId=${p.sessionId}, targetId=${p.targetId})`,
+              ),
+            );
+          }
+        }
+        this.sessions.delete(p.sessionId);
+        this.sessionToTarget.delete(p.sessionId);
+      } else if (msg.method === "Target.targetDestroyed") {
+        const p = (msg as { params: { targetId: string } }).params;
+        // Remove any session mapping for this target
+        for (const [sessionId, targetId] of this.sessionToTarget.entries()) {
+          if (targetId === p.targetId) {
+            this.sessionToTarget.delete(sessionId);
+            break;
+          }
+        }
+      }
+
+      const { method, params, sessionId } = msg;
+
+      // Log incoming CDP events
+      const targetId = this.sessionToTarget.get(sessionId) || sessionId;
+      this.cdpEventLogger?.({ method, params, targetId });
+
+      if (sessionId) {
+        const session = this.sessions.get(sessionId);
+        session?.dispatch(method, params);
+
+        // Forward target lifecycle events to root listeners as well.
+        // Some browsers emit these via a parent session rather than the root
+        // connection; fan-out keeps target tracking consistent.
+        if (method.startsWith("Target.")) {
+          const handlers = this.eventHandlers.get(method);
+          if (handlers) for (const h of handlers) h(params);
+        }
+      } else {
+        const handlers = this.eventHandlers.get(method);
+        if (handlers) for (const h of handlers) h(params);
+      }
+    }
+  }
+
+  _sendViaSession<R = unknown>(
+    sessionId: string,
+    method: string,
+    params?: object,
+  ): Promise<R> {
+    const id = this.nextId++;
+    const payload = { id, method, params, sessionId };
+    const stack = new Error().stack?.split("\n").slice(1, 4).join("\n");
+
+    const p = new Promise<R>((resolve, reject) => {
+      this.inflight.set(id, {
+        resolve,
+        reject,
+        sessionId,
+        method,
+        params,
+        stack,
+        ts: Date.now(),
+      });
+    });
+    // Prevent unhandledRejection if a session detaches before the caller awaits.
+    void p.catch(() => {});
+    const targetId = this.sessionToTarget.get(sessionId) ?? null;
+    this.cdpLogger?.({ method, params, targetId });
+    for (const waiter of Array.from(this.sessionDispatchWaiters)) {
+      if (waiter.sessionId !== sessionId) continue;
+      if (waiter.method !== method) continue;
+      if (waiter.match && !waiter.match(params)) continue;
+      waiter.resolve();
+      break;
+    }
+    this.ws.send(JSON.stringify(payload));
+    return p;
+  }
+
+  _onSessionEvent(
+    sessionId: string,
+    event: string,
+    handler: EventHandler,
+  ): void {
+    const key = `${sessionId}:${event}`;
+    const set = this.eventHandlers.get(key) ?? new Set<EventHandler>();
+    set.add(handler);
+    this.eventHandlers.set(key, set);
+  }
+
+  _offSessionEvent(
+    sessionId: string,
+    event: string,
+    handler: EventHandler,
+  ): void {
+    const key = `${sessionId}:${event}`;
+    const set = this.eventHandlers.get(key);
+    if (set) set.delete(handler);
+  }
+
+  _dispatchToSession(sessionId: string, event: string, params: unknown): void {
+    const key = `${sessionId}:${event}`;
+    const handlers = this.eventHandlers.get(key);
+    if (handlers) for (const h of handlers) h(params);
+  }
+}
+
+export class CdpSession implements CDPSessionLike {
+  constructor(
+    private readonly root: CdpConnection,
+    public readonly id: string,
+  ) {}
+
+  send<R = unknown>(method: string, params?: object): Promise<R> {
+    return this.root._sendViaSession<R>(this.id, method, params);
+  }
+
+  on<P = unknown>(event: string, handler: (params: P) => void): void {
+    this.root._onSessionEvent(this.id, event, handler as EventHandler);
+  }
+
+  off<P = unknown>(event: string, handler: (params: P) => void): void {
+    this.root._offSessionEvent(this.id, event, handler as EventHandler);
+  }
+
+  async close(): Promise<void> {
+    await this.root.send<void>("Target.detachFromTarget", {
+      sessionId: this.id,
+    });
+  }
+
+  dispatch(event: string, params: unknown): void {
+    this.root._dispatchToSession(this.id, event, params);
+  }
+}
diff --git a/packages/core/lib/v3/understudy/consoleMessage.ts b/packages/core/lib/v3/understudy/consoleMessage.ts
new file mode 100644
index 000000000..d72449a4b
--- /dev/null
+++ b/packages/core/lib/v3/understudy/consoleMessage.ts
@@ -0,0 +1,75 @@
+import type { Protocol } from "devtools-protocol";
+import type { Page } from "./page.js";
+
+type RemoteObject = Protocol.Runtime.RemoteObject;
+
+export type ConsoleListener = (message: ConsoleMessage) => void;
+
+function formatRemoteObject(obj: RemoteObject | undefined): string {
+  if (!obj) return "";
+
+  if ("value" in obj) {
+    const value = obj.value;
+    if (value === undefined) return "";
+    if (typeof value === "string") return value;
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+
+  if (obj.unserializableValue) return obj.unserializableValue;
+  if (obj.description) return obj.description;
+
+  return obj.type ?? "";
+}
+
+export class ConsoleMessage {
+  constructor(
+    private readonly event: Protocol.Runtime.ConsoleAPICalledEvent,
+    private readonly pageRef?: Page,
+  ) {}
+
+  type(): Protocol.Runtime.ConsoleAPICalledEvent["type"] {
+    return this.event.type;
+  }
+
+  text(): string {
+    const args = this.args();
+    if (!args.length) return "";
+    return args
+      .map((arg) => formatRemoteObject(arg))
+      .filter((chunk) => chunk.length > 0)
+      .join(" ");
+  }
+
+  args(): RemoteObject[] {
+    return this.event.args ? [...this.event.args] : [];
+  }
+
+  location(): { url?: string; lineNumber?: number; columnNumber?: number } {
+    const frame = this.event.stackTrace?.callFrames?.[0];
+    return {
+      url: frame?.url,
+      lineNumber: frame?.lineNumber,
+      columnNumber: frame?.columnNumber,
+    };
+  }
+
+  page(): Page | undefined {
+    return this.pageRef;
+  }
+
+  timestamp(): number | undefined {
+    return this.event.timestamp;
+  }
+
+  raw(): Protocol.Runtime.ConsoleAPICalledEvent {
+    return this.event;
+  }
+
+  toString(): string {
+    return this.text();
+  }
+}
diff --git a/packages/core/lib/v3/understudy/context.ts b/packages/core/lib/v3/understudy/context.ts
new file mode 100644
index 000000000..7c318caf7
--- /dev/null
+++ b/packages/core/lib/v3/understudy/context.ts
@@ -0,0 +1,1177 @@
+// lib/v3/understudy/context.ts
+import type { Protocol } from "devtools-protocol";
+import { v3Logger } from "../logger.js";
+import { CdpConnection, CDPSessionLike } from "./cdp.js";
+import { Page } from "./page.js";
+import { installV3PiercerIntoSession } from "./piercer.js";
+import { v3ScriptContent } from "../dom/build/scriptV3Content.js";
+import { executionContexts } from "./executionContextRegistry.js";
+import type { StagehandAPIClient } from "../api.js";
+import { LocalBrowserLaunchOptions } from "../types/public/index.js";
+import { InitScriptSource } from "../types/private/index.js";
+import { normalizeInitScriptSource } from "./initScripts.js";
+import {
+  TimeoutError,
+  CookieSetError,
+  PageNotFoundError,
+  StagehandSetExtraHTTPHeadersError,
+} from "../types/public/sdkErrors.js";
+import { getEnvTimeoutMs, withTimeout } from "../timeoutConfig.js";
+import {
+  filterCookies,
+  normalizeCookieParams,
+  cookieMatchesFilter,
+  toCdpCookieParam,
+} from "./cookies.js";
+import {
+  Cookie,
+  ClearCookieOptions,
+  CookieParam,
+} from "../types/public/context.js";
+
+type TargetId = string;
+type SessionId = string;
+
+type TargetType = "page" | "iframe" | string;
+
+/**
+ * Returns true when the target's URL points to a document with a real,
+ * pierceable HTML DOM.  We allowlist the small set of schemes that carry
+ * web content rather than trying to blacklist every internal browser scheme
+ * (chrome://, chrome-extension://, devtools://, brave://, edge://, …).
+ */
+function hasInjectableDOM(url: string | undefined): boolean {
+  if (!url || url === "") return true;
+  if (
+    url === "about:blank" ||
+    url === "about:srcdoc" ||
+    url.startsWith("about:blank#")
+  )
+    return true;
+  if (url.startsWith("http://") || url.startsWith("https://")) return true;
+  if (
+    url.startsWith("data:") ||
+    url.startsWith("blob:") ||
+    url.startsWith("file://") ||
+    url.startsWith("filesystem:")
+  )
+    return true;
+  return false;
+}
+
+function isNonWebTarget(info: Protocol.Target.TargetInfo): boolean {
+  return (
+    (info.type !== "page" && info.type !== "iframe") ||
+    !hasInjectableDOM(info.url)
+  );
+}
+
+function isTopLevelPage(info: Protocol.Target.TargetInfo): boolean {
+  const ti = info as unknown as { subtype?: string };
+  return info.type === "page" && ti.subtype !== "iframe";
+}
+
+const DEFAULT_FIRST_TOP_LEVEL_PAGE_TIMEOUT_MS = 5000;
+const CI_FIRST_TOP_LEVEL_PAGE_TIMEOUT_MS = 30000;
+const FIRST_TOP_LEVEL_PAGE_TIMEOUT_ENV =
+  "STAGEHAND_FIRST_TOP_LEVEL_PAGE_TIMEOUT_MS";
+const WAIT_FOR_FIRST_TOP_LEVEL_PAGE_OPERATION =
+  "waitForFirstTopLevelPage (no top-level Page)";
+
+function getFirstTopLevelPageTimeoutMs(): number {
+  return (
+    getEnvTimeoutMs(FIRST_TOP_LEVEL_PAGE_TIMEOUT_ENV) ??
+    (process.env.CI
+      ? CI_FIRST_TOP_LEVEL_PAGE_TIMEOUT_MS
+      : DEFAULT_FIRST_TOP_LEVEL_PAGE_TIMEOUT_MS)
+  );
+}
+
+/**
+ * V3Context
+ *
+ * Owns the root CDP connection and wires Target/Page events into Page.
+ * Maintains one Page per top-level target, adopts OOPIF child sessions into the owner Page,
+ * and tracks target→page and (root) frame→target mappings for lookups.
+ *
+ * IMPORTANT: FrameId → session ownership is managed inside Page (via its FrameRegistry).
+ * Context never “guesses” owners; it simply forwards events (with the emitting session)
+ * so Page can record the correct owner at event time.
+ */
+export class V3Context {
+  private constructor(
+    readonly conn: CdpConnection,
+    private readonly env: "LOCAL" | "BROWSERBASE" = "LOCAL",
+    private readonly apiClient: StagehandAPIClient | null = null,
+    private readonly localBrowserLaunchOptions: LocalBrowserLaunchOptions | null = null,
+  ) {}
+
+  private readonly _piercerInstalled = new Set<string>();
+  // Timestamp for most recent popup/open signal
+  private _lastPopupSignalAt = 0;
+  private readonly _targetSessionListeners = new Set<SessionId>();
+
+  private readonly _sessionInit = new Set<SessionId>();
+  private pagesByTarget = new Map<TargetId, Page>();
+  private mainFrameToTarget = new Map<string, TargetId>();
+  private sessionOwnerPage = new Map<SessionId, Page>();
+  private frameOwnerPage = new Map<string, Page>();
+  private pendingOopifByMainFrame = new Map<string, SessionId>();
+  private createdAtByTarget = new Map<TargetId, number>();
+  private typeByTarget = new Map<TargetId, TargetType>();
+  private _pageOrder: TargetId[] = [];
+  private pendingCreatedTargetUrl = new Map<TargetId, string>();
+  private readonly initScripts: string[] = [];
+  private extraHttpHeaders: Record<string, string> | null = null;
+
+  private installTargetSessionListeners(session: CDPSessionLike): void {
+    const sessionId = session.id;
+    if (!sessionId) return;
+    if (this._targetSessionListeners.has(sessionId)) return;
+    this._targetSessionListeners.add(sessionId);
+
+    session.on<Protocol.Target.AttachedToTargetEvent>(
+      "Target.attachedToTarget",
+      (evt) => {
+        void this.onAttachedToTarget(evt.targetInfo, evt.sessionId);
+      },
+    );
+    session.on<Protocol.Target.DetachedFromTargetEvent>(
+      "Target.detachedFromTarget",
+      (evt) => {
+        this.onDetachedFromTarget(evt.sessionId, evt.targetId ?? null);
+      },
+    );
+    session.on<Protocol.Target.TargetDestroyedEvent>(
+      "Target.targetDestroyed",
+      (evt) => {
+        this.cleanupByTarget(evt.targetId);
+      },
+    );
+  }
+
+  /**
+   * Create a Context for a given CDP websocket URL and bootstrap target wiring.
+   */
+  static async create(
+    wsUrl: string,
+    opts?: {
+      env?: "LOCAL" | "BROWSERBASE";
+      apiClient?: StagehandAPIClient | null;
+      localBrowserLaunchOptions?: LocalBrowserLaunchOptions | null;
+      cdpHeaders?: Record<string, string>;
+    },
+  ): Promise<V3Context> {
+    const connectTask = async () => {
+      const conn = await CdpConnection.connect(wsUrl, {
+        headers: opts?.cdpHeaders,
+      });
+      const ctx = new V3Context(
+        conn,
+        opts?.env ?? "LOCAL",
+        opts?.apiClient ?? null,
+        opts?.localBrowserLaunchOptions ?? null,
+      );
+      await ctx.bootstrap();
+      await ctx.ensureFirstTopLevelPage(getFirstTopLevelPageTimeoutMs());
+      return ctx;
+    };
+
+    const cdpTimeoutMs =
+      opts?.env === "BROWSERBASE"
+        ? getEnvTimeoutMs("BROWSERBASE_CDP_CONNECT_MAX_MS")
+        : undefined;
+
+    if (cdpTimeoutMs) {
+      let timedOut = false;
+      const connectPromise = connectTask();
+      const guarded = withTimeout(
+        connectPromise,
+        cdpTimeoutMs,
+        "Browserbase CDP connect",
+      ).catch((err) => {
+        timedOut = true;
+        throw err;
+      });
+      connectPromise
+        .then((ctx) => {
+          if (timedOut) void ctx.close();
+        })
+        .catch(() => {});
+      return await guarded;
+    }
+
+    return await connectTask();
+  }
+
+  private hasTopLevelPage(): boolean {
+    for (const [targetId, targetType] of this.typeByTarget) {
+      if (targetType === "page" && this.pagesByTarget.has(targetId)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private async ensureFirstTopLevelPage(timeoutMs: number): Promise<void> {
+    if (this.hasTopLevelPage()) return;
+
+    try {
+      await this.waitForFirstTopLevelPage(timeoutMs);
+      return;
+    } catch (err) {
+      if (!(err instanceof TimeoutError)) {
+        throw err;
+      }
+      v3Logger({
+        category: "ctx",
+        message:
+          "No open browser pages found after connect; creating an initial about:blank page",
+        level: 1,
+      });
+    }
+
+    await this.newPage("about:blank");
+  }
+
+  /**
+   * Wait until at least one top-level Page has been created and registered.
+   * We poll internal maps that bootstrap/onAttachedToTarget populate.
+   */
+  private async waitForFirstTopLevelPage(timeoutMs: number): Promise<void> {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      // A top-level Page is present if typeByTarget has an entry "page"
+      // and pagesByTarget has the corresponding Page object.
+      for (const [tid, ttype] of this.typeByTarget) {
+        if (ttype === "page") {
+          const p = this.pagesByTarget.get(tid);
+          if (p) return;
+        }
+      }
+      await new Promise((r) => setTimeout(r, 25));
+    }
+    throw new TimeoutError(WAIT_FOR_FIRST_TOP_LEVEL_PAGE_OPERATION, timeoutMs);
+  }
+
+  private async waitForInitialTopLevelTargets(
+    targetIds: TargetId[],
+    timeoutMs = 3000,
+  ): Promise<void> {
+    if (!targetIds.length) return;
+    const pending = new Set(targetIds);
+    const deadline = Date.now() + timeoutMs;
+    while (pending.size && Date.now() < deadline) {
+      for (const tid of Array.from(pending)) {
+        if (this.pagesByTarget.has(tid)) {
+          pending.delete(tid);
+        }
+      }
+      if (!pending.size) return;
+      await new Promise((r) => setTimeout(r, 25));
+    }
+    if (pending.size) {
+      v3Logger({
+        category: "ctx",
+        message: "Timed out waiting for existing top-level targets to attach",
+        level: 2,
+        auxiliary: {
+          remainingTargets: {
+            value: JSON.stringify(Array.from(pending)),
+            type: "object",
+          },
+        },
+      });
+    }
+  }
+
+  private async ensurePiercer(session: CDPSessionLike): Promise<boolean> {
+    const id = session.id ?? "";
+    if (this._piercerInstalled.has(id)) return true;
+
+    const installed = await installV3PiercerIntoSession(session);
+    if (installed) {
+      this._piercerInstalled.add(id);
+    }
+    return installed;
+  }
+
+  /** Mark a page target as the most-recent one (active). */
+  private _pushActive(tid: TargetId): void {
+    // remove prior entry if any
+    const i = this._pageOrder.indexOf(tid);
+    if (i !== -1) this._pageOrder.splice(i, 1);
+    this._pageOrder.push(tid);
+  }
+
+  /** Remove a page target from the recency list (used on close). */
+  private _removeFromOrder(tid: TargetId): void {
+    const i = this._pageOrder.indexOf(tid);
+    if (i !== -1) this._pageOrder.splice(i, 1);
+  }
+
+  /** Return the current active Page (most-recent page that still exists). */
+  public activePage(): Page | undefined {
+    // prune any stale ids from the tail
+    for (let i = this._pageOrder.length - 1; i >= 0; i--) {
+      const tid = this._pageOrder[i]!;
+      const p = this.pagesByTarget.get(tid);
+      if (p) return p;
+      // stale — remove and continue
+      this._pageOrder.splice(i, 1);
+    }
+    // fallback: pick the newest by createdAt if order is empty
+    let newestTid: TargetId | undefined;
+    let newestTs = -1;
+    for (const [tid] of this.pagesByTarget) {
+      const ts = this.createdAtByTarget.get(tid) ?? 0;
+      if (ts > newestTs) {
+        newestTs = ts;
+        newestTid = tid;
+      }
+    }
+    return newestTid ? this.pagesByTarget.get(newestTid) : undefined;
+  }
+
+  /** Explicitly mark a known Page as the most-recent active page (and focus it). */
+  public setActivePage(page: Page): void {
+    let targetId = page.targetId();
+    if (this.pagesByTarget.get(targetId) !== page) {
+      const lookup = this.findTargetIdByPage(page);
+      if (!lookup) {
+        v3Logger({
+          category: "ctx",
+          message: "setActivePage called with unknown Page",
+          level: 2,
+          auxiliary: {
+            targetId: { value: String(targetId), type: "string" },
+          },
+        });
+        return;
+      }
+      targetId = lookup;
+    }
+
+    this._pushActive(targetId);
+
+    // Bring the tab to the foreground in headful Chrome (best effort).
+    void this.conn.send("Target.activateTarget", { targetId }).catch(() => {});
+  }
+
+  public async addInitScript<Arg>(
+    script: InitScriptSource<Arg>,
+    arg?: Arg,
+  ): Promise<void> {
+    const source = await normalizeInitScriptSource(script, arg);
+    if (this.initScripts.includes(source)) return;
+    this.initScripts.push(source);
+    const pages = this.pages();
+    await Promise.all(pages.map((page) => page.registerInitScript(source)));
+  }
+
+  public async setExtraHTTPHeaders(
+    headers: Record<string, string>,
+  ): Promise<void> {
+    const nextHeaders = { ...headers };
+    this.extraHttpHeaders = nextHeaders;
+
+    const sessions: CDPSessionLike[] = [];
+    for (const sessionId of this._sessionInit) {
+      const session = this.conn.getSession(sessionId);
+      if (session) sessions.push(session);
+    }
+
+    if (!sessions.length) return;
+
+    const results = await Promise.allSettled(
+      sessions.map(async (session) => {
+        await session.send("Network.enable");
+        await session.send("Network.setExtraHTTPHeaders", {
+          headers: nextHeaders,
+        });
+      }),
+    );
+
+    const failures = results
+      .map((result, index) => ({ result, session: sessions[index] }))
+      .filter(
+        (
+          entry,
+        ): entry is {
+          result: PromiseRejectedResult;
+          session: CDPSessionLike;
+        } => entry.result.status === "rejected",
+      )
+      .map((entry) => {
+        const reason = entry.result.reason as Error;
+        const sid = entry.session.id ?? "unknown";
+        const message = reason?.message ?? String(reason);
+        return `session=${sid} error=${message}`;
+      });
+
+    if (failures.length) {
+      throw new StagehandSetExtraHTTPHeadersError(failures);
+    }
+  }
+
+  /**
+   * Return top-level `Page`s (oldest → newest). OOPIF targets are not included.
+   */
+  pages(): Page[] {
+    const rows: Array<{ tid: TargetId; page: Page; created: number }> = [];
+    for (const [tid, page] of this.pagesByTarget) {
+      if (this.typeByTarget.get(tid) === "page") {
+        rows.push({ tid, page, created: this.createdAtByTarget.get(tid) ?? 0 });
+      }
+    }
+    rows.sort((a, b) => a.created - b.created);
+    return rows.map((r) => r.page);
+  }
+
+  private async applyInitScriptsToPage(
+    page: Page,
+    opts?: { seedOnly?: boolean },
+  ): Promise<void> {
+    if (opts?.seedOnly) {
+      for (const source of this.initScripts) {
+        page.seedInitScript(source);
+      }
+      return;
+    }
+    for (const source of this.initScripts) {
+      await page.registerInitScript(source);
+    }
+  }
+
+  /**
+   * Resolve an owning `Page` by the **top-level main frame id**.
+   * Note: child (OOPIF) roots are intentionally not present in this mapping.
+   */
+  resolvePageByMainFrameId(frameId: string): Page | undefined {
+    const targetId = this.mainFrameToTarget.get(frameId);
+    return targetId ? this.pagesByTarget.get(targetId) : undefined;
+  }
+
+  /**
+   * Serialize the full frame tree for a given top-level main frame id.
+   */
+  async getFullFrameTreeByMainFrameId(
+    rootMainFrameId: string,
+  ): Promise<Protocol.Page.FrameTree> {
+    const owner = this.resolvePageByMainFrameId(rootMainFrameId);
+    if (!owner) throw new PageNotFoundError(`mainFrameId=${rootMainFrameId}`);
+    return owner.asProtocolFrameTree(rootMainFrameId);
+  }
+
+  /**
+   * Create a new top-level page (tab) with the given URL and return its Page object.
+   * Waits until the target is attached and registered.
+   */
+  public async newPage(url = "about:blank"): Promise<Page> {
+    const targetUrl = String(url ?? "about:blank");
+    const { targetId } = await this.conn.send<{ targetId: string }>(
+      "Target.createTarget",
+      // Create at about:blank so init scripts can install before first real navigation.
+      { url: "about:blank" },
+    );
+    this.pendingCreatedTargetUrl.set(targetId, "about:blank");
+    // Best-effort bring-to-front
+    await this.conn.send("Target.activateTarget", { targetId }).catch(() => {});
+
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+      const page = this.pagesByTarget.get(targetId);
+      if (page) {
+        // we created at about:blank; navigate only after attach so init scripts run
+        // on the first real document. Fire-and-forget so newPage() resolves on attach.
+        if (targetUrl !== "about:blank") {
+          // Seed requested URL into the page cache before navigation events arrive.
+          page.seedCurrentUrl(targetUrl);
+          void page
+            .sendCDP("Page.navigate", { url: targetUrl })
+            .catch(() => {});
+        }
+        return page;
+      }
+      await new Promise((r) => setTimeout(r, 25));
+    }
+    throw new TimeoutError(`newPage: target not attached (${targetId})`, 5000);
+  }
+
+  /**
+   * Close CDP and clear all mappings. Best-effort cleanup.
+   */
+  async close(): Promise<void> {
+    await this.conn.close();
+    this.pagesByTarget.clear();
+    this.mainFrameToTarget.clear();
+    this.sessionOwnerPage.clear();
+    this.frameOwnerPage.clear();
+    this.pendingOopifByMainFrame.clear();
+    this.createdAtByTarget.clear();
+    this.typeByTarget.clear();
+    this.pendingCreatedTargetUrl.clear();
+  }
+
+  /**
+   * Bootstrap target lifecycle:
+   * - Attach to existing targets.
+   * - Handle auto-attach events.
+   * - Clean up on detach/destroy.
+   */
+  private async bootstrap(): Promise<void> {
+    // Live attach via auto-attach (normal path)
+    this.conn.on<Protocol.Target.AttachedToTargetEvent>(
+      "Target.attachedToTarget",
+      async (evt) => {
+        await this.onAttachedToTarget(evt.targetInfo, evt.sessionId);
+      },
+    );
+
+    // Live detach (clean up session from owner page & frame graph)
+    this.conn.on<Protocol.Target.DetachedFromTargetEvent>(
+      "Target.detachedFromTarget",
+      (evt) => {
+        this.onDetachedFromTarget(evt.sessionId, evt.targetId ?? null);
+      },
+    );
+
+    // Destroyed targets (fallback cleanup by targetId)
+    this.conn.on<Protocol.Target.TargetDestroyedEvent>(
+      "Target.targetDestroyed",
+      (evt) => {
+        this.cleanupByTarget(evt.targetId);
+      },
+    );
+
+    this.conn.on<Protocol.Target.TargetCreatedEvent>(
+      "Target.targetCreated",
+      async (evt) => {
+        const info = evt.targetInfo;
+        // Note popups to help activePage settle
+        const ti = info;
+        if (info.type === "page" && (ti?.openerId || ti?.openerFrameId)) {
+          this._notePopupSignal();
+        }
+      },
+    );
+
+    // Only enable auto-attach after listeners are ready so replayed targets are captured.
+    await this.conn.enableAutoAttach();
+
+    const targets = await this.conn.getTargets();
+    for (const t of targets) {
+      if (t.attached) continue; // auto-attach already handled this target
+      try {
+        await this.conn.attachToTarget(t.targetId);
+      } catch {
+        // ignore attach race
+      }
+    }
+
+    const topLevelTargetIds = targets
+      .filter((t) => isTopLevelPage(t))
+      .map((t) => t.targetId);
+    await this.waitForInitialTopLevelTargets(topLevelTargetIds);
+  }
+
+  /**
+   * Handle a newly attached target (top-level or potential OOPIF):
+   * - Enable Page domain and lifecycle events.
+   * - If top-level → create Page, wire listeners, resume.
+   * - Else → probe child root frame id via `Page.getFrameTree` and adopt immediately
+   *   if the parent is known; otherwise stage until parent `frameAttached`.
+   * - Resume the target only after listeners are wired.
+   */
+  private async onAttachedToTarget(
+    info: Protocol.Target.TargetInfo,
+    sessionId: SessionId,
+  ): Promise<void> {
+    // Skip non-web targets (workers, chrome extensions, background pages, etc.).
+    // They still need to be resumed so we don't leave them paused by
+    // waitForDebuggerOnStart, but injecting the piercer into these targets
+    // can throw or corrupt their internal state (e.g. Chrome's PDF viewer).
+    if (isNonWebTarget(info)) {
+      const session = this.conn.getSession(sessionId);
+      if (session) {
+        await session.send("Runtime.runIfWaitingForDebugger").catch(() => {});
+      }
+      return;
+    }
+
+    const session = this.conn.getSession(sessionId);
+    if (!session) return;
+
+    // Init guard
+    if (this._sessionInit.has(sessionId)) return;
+    this._sessionInit.add(sessionId);
+
+    this.installTargetSessionListeners(session);
+
+    // Register for Runtime events before enabling it so we don't miss initial contexts.
+    executionContexts.attachSession(session);
+
+    // Ensure we only resume once even if multiple code paths hit finally.
+    let resumed = false;
+    const resume = async (): Promise<void> => {
+      if (resumed) return;
+      resumed = true;
+      // waitForDebuggerOnStart pauses new targets; resume once we've done
+      // any "must happen before first document" work.
+      await session.send("Runtime.runIfWaitingForDebugger").catch(() => {});
+    };
+
+    // Attach lifecycle (per target session):
+    // 1) while paused, enable domains + child auto-attach and register init scripts;
+    // 2) resume target execution;
+    // 3) build/adopt Page ownership and frame bridges.
+    // Some CDP backends defer *.enable() responses until after resume, so we
+    // cannot await those responses before resuming. Instead we:
+    // - wait for transport-level dispatch of required pre-resume commands;
+    // - then dispatch resume;
+    // - then await responses.
+    const queuePreResume = (
+      method: string,
+      params?: object,
+      match?: (sentParams?: object) => boolean,
+    ) => {
+      const dispatched = this.conn
+        .waitForSessionDispatch(sessionId, method, match)
+        .then(() => true)
+        .catch(() => false);
+      const response = session
+        .send(method, params)
+        .then(() => true)
+        .catch(() => false);
+      return { dispatched, response };
+    };
+    const initScriptOps: Array<{
+      dispatched: Promise<boolean>;
+      response: Promise<boolean>;
+    }> = [];
+    // Pre-resume ordering matters:
+    // - enable domains;
+    // - enable child auto-attach with waitForDebuggerOnStart;
+    // - register init scripts.
+    // Commands are sent in-order on the same session before resume.
+    const corePreResumeOps = [
+      queuePreResume("Page.enable"),
+      queuePreResume("Runtime.enable"),
+      queuePreResume("Target.setAutoAttach", {
+        autoAttach: true,
+        waitForDebuggerOnStart: true,
+        flatten: true,
+      }),
+    ];
+    const headerPreResumeOps: Array<{
+      dispatched: Promise<boolean>;
+      response: Promise<boolean>;
+    }> = [];
+    if (this.extraHttpHeaders) {
+      const headers = { ...this.extraHttpHeaders };
+      headerPreResumeOps.push(queuePreResume("Network.enable"));
+      headerPreResumeOps.push(
+        queuePreResume("Network.setExtraHTTPHeaders", { headers }),
+      );
+    }
+    // Send init scripts only after auto-attach has been queued.
+    if (this.initScripts.length) {
+      for (const source of this.initScripts) {
+        initScriptOps.push(
+          queuePreResume(
+            "Page.addScriptToEvaluateOnNewDocument",
+            {
+              source,
+              runImmediately: true,
+            },
+            (sentParams) =>
+              (sentParams as { source?: string } | undefined)?.source ===
+              source,
+          ),
+        );
+      }
+    }
+    const piercerPreloadOp = queuePreResume(
+      "Page.addScriptToEvaluateOnNewDocument",
+      {
+        source: v3ScriptContent,
+        runImmediately: true,
+      },
+      (sentParams) =>
+        (sentParams as { source?: string } | undefined)?.source ===
+        v3ScriptContent,
+    );
+    const preResumeDispatched = (
+      await Promise.all([
+        ...corePreResumeOps.map((op) => op.dispatched),
+        ...headerPreResumeOps.map((op) => op.dispatched),
+        ...initScriptOps.map((op) => op.dispatched),
+        piercerPreloadOp.dispatched,
+      ])
+    ).every(Boolean);
+    // Dispatch resume only after pre-resume setup has actually been sent.
+    const resumeOp = queuePreResume("Runtime.runIfWaitingForDebugger");
+    const [resumedDispatched, resumedOk] = await Promise.all([
+      resumeOp.dispatched,
+      resumeOp.response,
+    ]);
+    const [
+      coreResults,
+      headerResults,
+      initScriptResults,
+      piercerPreRegistered,
+    ] = await Promise.all([
+      Promise.all(corePreResumeOps.map((op) => op.response)),
+      Promise.all(headerPreResumeOps.map((op) => op.response)),
+      Promise.all(initScriptOps.map((op) => op.response)),
+      piercerPreloadOp.response,
+    ]);
+    // Header propagation is independent of init-script determinism but still
+    // part of pre-resume attach setup; awaited above for ordering/lifecycle.
+    void headerResults;
+    if (!preResumeDispatched || !resumedDispatched || !resumedOk) {
+      // Short-lived child targets can detach before resume is acknowledged.
+      // Keep this noisy only for top-level pages where missing attach is fatal.
+      if (isTopLevelPage(info)) {
+        v3Logger({
+          category: "ctx",
+          message: "Failed target pre-resume setup ordering",
+          level: 2,
+          auxiliary: {
+            targetId: { value: String(info.targetId), type: "string" },
+            targetType: { value: String(info.type), type: "string" },
+            preResumeDispatched: {
+              value: String(preResumeDispatched),
+              type: "string",
+            },
+            resumedDispatched: {
+              value: String(resumedDispatched),
+              type: "string",
+            },
+            resumedOk: { value: String(resumedOk), type: "string" },
+          },
+        });
+      }
+      return;
+    }
+    resumed = true;
+    const scriptsInstalled =
+      coreResults.every(Boolean) && initScriptResults.every(Boolean);
+
+    try {
+      // Best-effort lifecycle events; do not block top-level page registration
+      // on this optional signal stream.
+      void session
+        .send("Page.setLifecycleEventsEnabled", { enabled: true })
+        .catch(() => {});
+
+      // Top-level handling
+      if (isTopLevelPage(info)) {
+        let page: Page | null = null;
+        let createError: unknown;
+        // Deterministic contract: never drop a newly attached top-level target
+        // because an arbitrary local timeout fired. We wait for Page.create and
+        // let it finish regardless of CDP call latency.
+        try {
+          page = await Page.create(
+            this.conn,
+            session,
+            info.targetId,
+            this.apiClient,
+            this.localBrowserLaunchOptions,
+            this.env === "BROWSERBASE",
+          );
+        } catch (error) {
+          createError = error;
+        }
+        if (!page) {
+          v3Logger({
+            category: "ctx",
+            message: "Failed to create top-level Page",
+            level: 2,
+            auxiliary: {
+              targetId: { value: String(info.targetId), type: "string" },
+              targetType: { value: String(info.type), type: "string" },
+              targetUrl: { value: String(info.url ?? ""), type: "string" },
+              error: {
+                value: String(
+                  createError instanceof Error
+                    ? createError.message
+                    : createError,
+                ),
+                type: "string",
+              },
+            },
+          });
+          return;
+        }
+        this.wireSessionToOwnerPage(sessionId, page);
+        this.pagesByTarget.set(info.targetId, page);
+        this.mainFrameToTarget.set(page.mainFrameId(), info.targetId);
+        this.sessionOwnerPage.set(sessionId, page);
+        this.frameOwnerPage.set(page.mainFrameId(), page);
+        this.typeByTarget.set(info.targetId, "page");
+        if (!this.createdAtByTarget.has(info.targetId)) {
+          this.createdAtByTarget.set(info.targetId, Date.now());
+        }
+        const pendingSeedUrl = this.pendingCreatedTargetUrl.get(info.targetId);
+        this.pendingCreatedTargetUrl.delete(info.targetId);
+        page.seedCurrentUrl(pendingSeedUrl ?? info.url ?? "");
+        this._pushActive(info.targetId);
+        this.installFrameEventBridges(sessionId, page);
+        if (piercerPreRegistered) {
+          this._piercerInstalled.add(sessionId);
+        }
+        // If we already installed scripts at the session level, only seed the
+        // Page's registry to avoid double-installing DOMContentLoaded handlers.
+        await this.applyInitScriptsToPage(page, {
+          seedOnly: scriptsInstalled,
+        });
+        if (!piercerPreRegistered) {
+          void this.ensurePiercer(session).catch(() => {});
+        }
+
+        return;
+      }
+
+      const piercerReady = await this.ensurePiercer(session).catch(() => false);
+      if (!piercerReady) return;
+
+      // Child (iframe / OOPIF)
+      try {
+        const { frameTree } =
+          await session.send<Protocol.Page.GetFrameTreeResponse>(
+            "Page.getFrameTree",
+          );
+        const childMainId = frameTree.frame.id;
+
+        // Try to find owner Page now (it may already have the node in its tree)
+        let owner = this.frameOwnerPage.get(childMainId);
+        if (!owner) {
+          for (const p of this.pagesByTarget.values()) {
+            const tree = p.asProtocolFrameTree(p.mainFrameId());
+            const has = (function find(n: Protocol.Page.FrameTree): boolean {
+              if (n.frame.id === childMainId) return true;
+              for (const c of n.childFrames ?? []) if (find(c)) return true;
+              return false;
+            })(tree);
+            if (has) {
+              owner = p;
+              break;
+            }
+          }
+        }
+
+        if (owner) {
+          owner.adoptOopifSession(session, childMainId);
+          this.sessionOwnerPage.set(sessionId, owner);
+          this.installFrameEventBridges(sessionId, owner);
+          // Prime the execution-context registry so later lookups succeed even if
+          // the frame navigates before we issue a command.
+          void executionContexts
+            .waitForMainWorld(session, childMainId)
+            .catch(() => {});
+        } else {
+          this.pendingOopifByMainFrame.set(childMainId, sessionId);
+        }
+      } catch {
+        // page.getFrameTree failed. Most likely was an ad iframe
+        // that opened & closed before we could attach. ignore
+      }
+    } finally {
+      await resume();
+    }
+  }
+
+  /**
+   * Detach handler:
+   * - Remove child session ownership and prune its subtree.
+   * - If a top-level target, cleanup its `Page` and mappings.
+   * - Drop any staged child for this session.
+   */
+  private onDetachedFromTarget(
+    sessionId: SessionId,
+    targetId: string | null,
+  ): void {
+    const owner = this.sessionOwnerPage.get(sessionId);
+    if (owner) {
+      owner.detachOopifSession(sessionId);
+      this.sessionOwnerPage.delete(sessionId);
+    }
+
+    if (targetId && this.pagesByTarget.has(targetId)) {
+      this.cleanupByTarget(targetId);
+    }
+
+    for (const [fid, sid] of Array.from(
+      this.pendingOopifByMainFrame.entries(),
+    )) {
+      if (sid === sessionId) this.pendingOopifByMainFrame.delete(fid);
+    }
+
+    this._targetSessionListeners.delete(sessionId);
+    this._sessionInit.delete(sessionId);
+    this._piercerInstalled.delete(sessionId);
+  }
+
+  /**
+   * Cleanup a top-level Page by target id, removing its root and staged children.
+   */
+  private cleanupByTarget(targetId: TargetId): void {
+    const page = this.pagesByTarget.get(targetId);
+    if (!page) return;
+
+    const mainId = page.mainFrameId();
+    this.mainFrameToTarget.delete(mainId);
+    this.frameOwnerPage.delete(mainId);
+
+    for (const [sid, p] of Array.from(this.sessionOwnerPage.entries())) {
+      if (p === page) this.sessionOwnerPage.delete(sid);
+    }
+
+    for (const [fid] of Array.from(this.pendingOopifByMainFrame.entries())) {
+      const owner = this.frameOwnerPage.get(fid);
+      if (!owner || owner === page) this.pendingOopifByMainFrame.delete(fid);
+    }
+
+    this._removeFromOrder(targetId);
+    this.pagesByTarget.delete(targetId);
+    this.createdAtByTarget.delete(targetId);
+    this.typeByTarget.delete(targetId);
+    this.pendingCreatedTargetUrl.delete(targetId);
+  }
+
+  /**
+   * Wire Page-domain frame events for a session into the owning Page & mappings.
+   * We forward the *emitting session* with every event so Page can stamp ownership precisely.
+   */
+  private installFrameEventBridges(sessionId: SessionId, owner: Page): void {
+    const session = this.conn.getSession(sessionId);
+    if (!session) return;
+
+    session.on<Protocol.Page.FrameAttachedEvent>(
+      "Page.frameAttached",
+      (evt) => {
+        const { frameId, parentFrameId } = evt;
+
+        owner.onFrameAttached(frameId, parentFrameId ?? null, session);
+
+        // If we were waiting for this id (OOPIF child), adopt now.
+        const pendingChildSessionId = this.pendingOopifByMainFrame.get(frameId);
+        if (pendingChildSessionId) {
+          const child = this.conn.getSession(pendingChildSessionId);
+          if (child) {
+            owner.adoptOopifSession(child, frameId);
+            this.sessionOwnerPage.set(child.id, owner);
+            // Wire bridges for the child so its Page events keep flowing.
+            this.installFrameEventBridges(pendingChildSessionId, owner);
+          }
+          this.pendingOopifByMainFrame.delete(frameId);
+        }
+
+        // Track Page ownership for quick reverse lookups (debug helpers).
+        this.frameOwnerPage.set(frameId, owner);
+
+        // Root handoff: keep mainFrameToTarget aligned for the page
+        if (!parentFrameId) {
+          const newRoot = owner.mainFrameId();
+          const topTargetId = this.findTargetIdByPage(owner);
+          if (topTargetId) {
+            this.mainFrameToTarget.set(newRoot, topTargetId);
+          }
+          this.frameOwnerPage.set(newRoot, owner);
+        }
+      },
+    );
+
+    session.on<Protocol.Page.FrameDetachedEvent>(
+      "Page.frameDetached",
+      (evt) => {
+        owner.onFrameDetached(evt.frameId, evt.reason ?? "remove");
+        if (evt.reason !== "swap") {
+          this.frameOwnerPage.delete(evt.frameId);
+        }
+      },
+    );
+
+    session.on<Protocol.Page.FrameNavigatedEvent>(
+      "Page.frameNavigated",
+      (evt) => {
+        owner.onFrameNavigated(evt.frame, session);
+      },
+    );
+
+    session.on<Protocol.Page.NavigatedWithinDocumentEvent>(
+      "Page.navigatedWithinDocument",
+      (evt) => {
+        owner.onNavigatedWithinDocument(evt.frameId, evt.url, session);
+      },
+    );
+
+    // Observe window.open to anticipate default page changes
+    session.on<Protocol.Page.WindowOpenEvent>("Page.windowOpen", () => {
+      this._notePopupSignal();
+    });
+  }
+
+  /**
+   * Register that a session belongs to a Page (used by event routing).
+   */
+  private wireSessionToOwnerPage(sessionId: SessionId, owner: Page): void {
+    this.sessionOwnerPage.set(sessionId, owner);
+  }
+
+  /**
+   * Utility: reverse-lookup the top-level target id that owns a given Page.
+   */
+  private findTargetIdByPage(page: Page): TargetId | undefined {
+    for (const [tid, p] of this.pagesByTarget) {
+      if (p === page) return tid;
+    }
+    return undefined;
+  }
+
+  private _notePopupSignal(): void {
+    this._lastPopupSignalAt = Date.now();
+  }
+
+  /**
+   * Await the current active page, waiting briefly if a popup/open was just triggered.
+   * Normal path returns immediately; popup path waits up to timeoutMs for the new page.
+   */
+  async awaitActivePage(timeoutMs?: number): Promise<Page> {
+    const defaultTimeout = this.env === "BROWSERBASE" ? 4000 : 2000;
+    timeoutMs = timeoutMs ?? defaultTimeout;
+    // If a popup was just triggered, Chrome (especially on Browserbase)
+    // may briefly pause new targets at document start ("waiting for debugger").
+    const recentWindowMs = this.env === "BROWSERBASE" ? 1000 : 300;
+    const now = Date.now();
+    const hasRecentPopup = now - this._lastPopupSignalAt <= recentWindowMs;
+
+    const immediate = this.activePage();
+    if (!hasRecentPopup && immediate) return immediate;
+
+    const deadline = now + timeoutMs;
+    while (Date.now() < deadline) {
+      // Prefer most-recent by createdAt
+      let newestTid: TargetId | undefined;
+      let newestTs = -1;
+      for (const [tid] of this.pagesByTarget) {
+        const ts = this.createdAtByTarget.get(tid) ?? 0;
+        if (ts > newestTs) {
+          newestTs = ts;
+          newestTid = tid;
+        }
+      }
+      if (newestTid) {
+        const p = this.pagesByTarget.get(newestTid);
+        if (p && newestTs >= this._lastPopupSignalAt) return p;
+      }
+      await new Promise((r) => setTimeout(r, 25));
+    }
+    if (immediate) return immediate;
+    throw new PageNotFoundError("awaitActivePage: no page available");
+  }
+
+  /**
+   * Get all browser cookies, optionally filtered by URL(s).
+   *
+   * When `urls` is omitted or empty every cookie in the browser context is
+   * returned. When one or more URLs are supplied only cookies whose
+   * domain/path/secure attributes match are included.
+   */
+  async cookies(urls?: string | string[]): Promise<Cookie[]> {
+    const urlList = !urls ? [] : typeof urls === "string" ? [urls] : urls;
+
+    const { cookies } = await this.conn.send<{
+      cookies: Protocol.Network.Cookie[];
+    }>("Storage.getCookies");
+
+    const mapped: Cookie[] = cookies.map((c) => ({
+      name: c.name,
+      value: c.value,
+      domain: c.domain,
+      path: c.path,
+      expires: c.expires,
+      httpOnly: c.httpOnly,
+      secure: c.secure,
+      sameSite: (c.sameSite as Cookie["sameSite"]) ?? "Lax",
+    }));
+
+    return filterCookies(mapped, urlList);
+  }
+
+  /**
+   * Add one or more cookies to the browser context.
+   *
+   * Each cookie must specify either a `url` (from which domain/path/secure are
+   * derived) or an explicit `domain` + `path` pair.
+   *
+   * We surface CDP errors if the browser rejects a cookie.
+   */
+  async addCookies(cookies: CookieParam[]): Promise<void> {
+    const normalized = normalizeCookieParams(cookies);
+    if (!normalized.length) return;
+
+    const cdpCookies = normalized.map(toCdpCookieParam);
+
+    try {
+      await this.conn.send("Storage.setCookies", { cookies: cdpCookies });
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      const names = normalized.map((c) => `"${c.name}"`).join(", ");
+      throw new CookieSetError(
+        `Failed to set cookies [${names}] — ` +
+          `the browser rejected the batch. Check that the domain, path, and secure/sameSite values are valid.` +
+          (detail ? ` (CDP error: ${detail})` : ""),
+      );
+    }
+  }
+
+  /**
+   * Clear cookies from the browser context.
+   *
+   * - Called with no arguments: clears **all** cookies atomically via
+   *   `Storage.clearCookies`.
+   * - Called with filter options: fetches all cookies, clears everything,
+   *   then re-adds only the cookies that do NOT match the filter via
+   *   `Storage.setCookies`. This is necessary on the browser endpoint because
+   *   the Storage domain does not support targeted deletes.
+   */
+  async clearCookies(options?: ClearCookieOptions): Promise<void> {
+    const hasFilter =
+      options?.name !== undefined ||
+      options?.domain !== undefined ||
+      options?.path !== undefined;
+
+    if (!hasFilter) {
+      // Atomic single-call wipe — no race condition, no O(N) roundtrips.
+      await this.conn.send("Storage.clearCookies");
+      return;
+    }
+
+    const current = await this.cookies();
+    const toKeep = current.filter((c) => !cookieMatchesFilter(c, options!));
+
+    if (toKeep.length === current.length) return;
+
+    // Storage domain doesn't support targeted deletes on the browser endpoint.
+    // Clear everything, then re-add only the cookies we're keeping.
+    await this.conn.send("Storage.clearCookies");
+    if (toKeep.length) {
+      try {
+        await this.conn.send("Storage.setCookies", {
+          cookies: toKeep.map(toCdpCookieParam),
+        });
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        const names = toKeep.map((c) => `"${c.name}"`).join(", ");
+        throw new CookieSetError(
+          `clearCookies: cookies were cleared but failed to re-add the ${toKeep.length} ` +
+            `non-matching cookie(s) [${names}]. The browser cookie jar is now empty. ` +
+            (detail ? `(CDP error: ${detail})` : ""),
+        );
+      }
+    }
+  }
+}
diff --git a/packages/core/lib/v3/understudy/cookies.ts b/packages/core/lib/v3/understudy/cookies.ts
new file mode 100644
index 000000000..669e88c89
--- /dev/null
+++ b/packages/core/lib/v3/understudy/cookies.ts
@@ -0,0 +1,172 @@
+import {
+  Cookie,
+  CookieParam,
+  ClearCookieOptions,
+} from "../types/public/context.js";
+import { CookieValidationError } from "../types/public/sdkErrors.js";
+
+/**
+ * helpers for browser cookie management.
+ *
+ * Mirrors Playwright's cookie API surface, adapted for direct CDP usage
+ * against a single default browser context.
+ */
+
+/**
+ * Filter cookies by URL matching (domain, path, secure).
+ * If `urls` is empty every cookie passes.
+ */
+export function filterCookies(cookies: Cookie[], urls: string[]): Cookie[] {
+  if (!urls.length) return cookies;
+  const parsed = urls.map((u) => {
+    try {
+      return new URL(u);
+    } catch {
+      throw new CookieValidationError(
+        `Invalid URL passed to cookies(): "${u}"`,
+      );
+    }
+  });
+  return cookies.filter((c) => {
+    for (const url of parsed) {
+      let domain = c.domain;
+      if (!domain.startsWith(".")) domain = "." + domain;
+      if (!("." + url.hostname).endsWith(domain)) continue;
+      // Path must match on a "/" boundary: cookie path "/foo" should match
+      // "/foo" and "/foo/bar" but NOT "/foobar".
+      const p = url.pathname;
+      if (
+        !p.startsWith(c.path) ||
+        (c.path.length < p.length &&
+          !c.path.endsWith("/") &&
+          p[c.path.length] !== "/")
+      )
+        continue;
+      const isLoopback =
+        url.hostname === "localhost" ||
+        url.hostname === "127.0.0.1" ||
+        url.hostname === "[::1]";
+      if (url.protocol !== "https:" && !isLoopback && c.secure) continue;
+      return true;
+    }
+    return false;
+  });
+}
+
+/**
+ * Validate and normalise `CookieParam` values before sending to CDP.
+ *
+ * - Ensures every cookie has either `url` or `domain`+`path`.
+ * - When `url` is provided, derives `domain`, `path`, and `secure` from it.
+ * - Validates that `sameSite: "None"` is paired with `secure: true`
+ *   (browsers silently reject this — we throw early with a clear message).
+ */
+export function normalizeCookieParams(cookies: CookieParam[]): CookieParam[] {
+  return cookies.map((c) => {
+    if (!c.url && !(c.domain && c.path)) {
+      throw new CookieValidationError(
+        `Cookie "${c.name}" must have a url or a domain/path pair`,
+      );
+    }
+    if (c.url && c.domain) {
+      throw new CookieValidationError(
+        `Cookie "${c.name}" should have either url or domain, not both`,
+      );
+    }
+    if (c.url && c.path) {
+      throw new CookieValidationError(
+        `Cookie "${c.name}" should have either url or path, not both`,
+      );
+    }
+    if (c.expires !== undefined && c.expires < 0 && c.expires !== -1) {
+      throw new CookieValidationError(
+        `Cookie "${c.name}" has an invalid expires value; use -1 for session cookies or a positive unix timestamp`,
+      );
+    }
+
+    const copy = { ...c };
+    if (copy.url) {
+      if (copy.url === "about:blank") {
+        throw new CookieValidationError(
+          `Blank page cannot have cookie "${c.name}"`,
+        );
+      }
+      if (copy.url.startsWith("data:")) {
+        throw new CookieValidationError(
+          `Data URL page cannot have cookie "${c.name}"`,
+        );
+      }
+      let url: URL;
+      try {
+        url = new URL(copy.url);
+      } catch {
+        throw new CookieValidationError(
+          `Cookie "${c.name}" has an invalid url: "${copy.url}"`,
+        );
+      }
+      copy.domain = url.hostname;
+      copy.path = url.pathname.substring(0, url.pathname.lastIndexOf("/") + 1);
+      copy.secure = url.protocol === "https:";
+      delete copy.url;
+    }
+
+    // Browsers silently reject SameSite=None cookies that aren't Secure.
+    // Catch this early with a clear error instead of a silent CDP failure.
+    // Use !copy.secure to catch both explicit false AND undefined (omitted),
+    // since CDP defaults secure to false when omitted.
+    if (copy.sameSite === "None" && !copy.secure) {
+      throw new CookieValidationError(
+        `Cookie "${c.name}" has sameSite: "None" without secure: true. ` +
+          `Browsers require secure: true when sameSite is "None".`,
+      );
+    }
+
+    return copy;
+  });
+}
+
+/**
+ * Map a Cookie or CookieParam to the shape CDP's Storage.setCookies expects.
+ * Session cookies (expires === -1) omit the expires field so CDP treats them
+ * as session-scoped.
+ */
+export function toCdpCookieParam(
+  c: Cookie | CookieParam,
+): Record<string, unknown> {
+  return {
+    name: c.name,
+    value: c.value,
+    domain: c.domain,
+    path: c.path,
+    expires: c.expires === -1 ? undefined : c.expires,
+    httpOnly: c.httpOnly,
+    secure: c.secure,
+    sameSite: c.sameSite,
+  };
+}
+
+/**
+ * Returns true if a cookie matches all supplied filter criteria.
+ * Undefined filters are treated as "match anything".
+ */
+export function cookieMatchesFilter(
+  cookie: Cookie,
+  options: ClearCookieOptions,
+): boolean {
+  const check = (
+    prop: "name" | "domain" | "path",
+    value: string | RegExp | undefined,
+  ): boolean => {
+    if (value === undefined) return true;
+    if (value instanceof RegExp) {
+      value.lastIndex = 0;
+      return value.test(cookie[prop]);
+    }
+    return cookie[prop] === value;
+  };
+  return (
+    check("name", options.name) &&
+    check("domain", options.domain) &&
+    check("path", options.path)
+  );
+}
diff --git a/packages/core/lib/v3/understudy/deepLocator.ts b/packages/core/lib/v3/understudy/deepLocator.ts
new file mode 100644
index 000000000..fef1a4790
--- /dev/null
+++ b/packages/core/lib/v3/understudy/deepLocator.ts
@@ -0,0 +1,270 @@
+import { Locator } from "./locator.js";
+import type { Frame } from "./frame.js";
+import type { Page } from "./page.js";
+import { FrameLocator, frameLocatorFromFrame } from "./frameLocator.js";
+import { StagehandInvalidArgumentError } from "../types/public/sdkErrors.js";
+import { IFRAME_STEP_RE } from "./a11y/snapshot/focusSelectors.js";
+
+type Axis = "child" | "desc";
+type Step = { axis: Axis; raw: string; name: string };
+
+export type ResolvedLocatorTarget = {
+  frame: Frame;
+  selector: string;
+};
+
+/** Parse XPath into steps preserving '/' vs '//' and the raw token (with [n]) */
+function parseXPath(path: string): Step[] {
+  const s = path.trim();
+  let i = 0;
+  const steps: Step[] = [];
+  while (i < s.length) {
+    let axis: Axis = "child";
+    if (s.startsWith("//", i)) {
+      axis = "desc";
+      i += 2;
+    } else if (s[i] === "/") {
+      axis = "child";
+      i += 1;
+    }
+
+    const start = i;
+    while (i < s.length && s[i] !== "/") i++;
+    const raw = s.slice(start, i).trim();
+    if (!raw) continue;
+
+    const name = raw.replace(/\[\d+\]\s*$/u, "").toLowerCase();
+    steps.push({ axis, raw, name });
+  }
+  return steps;
+}
+
+function buildXPathFromSteps(steps: ReadonlyArray<Step>): string {
+  let out = "";
+  for (const st of steps) {
+    out += st.axis === "desc" ? "//" : "/";
+    out += st.raw; // keep predicates intact
+  }
+  return out || "/";
+}
+
+/** Build a Locator scoped to the correct frame for a deep XPath crossing iframes. */
+export async function deepLocatorThroughIframes(
+  page: Page,
+  root: Frame,
+  xpathOrSelector: string,
+): Promise<Locator> {
+  const target = await resolveDeepXPathTarget(page, root, xpathOrSelector);
+  return new Locator(target.frame, target.selector);
+}
+
+/**
+ * Unified resolver that supports '>>' hop notation, deep XPath across iframes,
+ * and plain single-frame selectors. Keeps hop logic in one shared place.
+ */
+export async function resolveLocatorTarget(
+  page: Page,
+  root: Frame,
+  selectorRaw: string,
+): Promise<ResolvedLocatorTarget> {
+  const sel = selectorRaw.trim();
+  const parts = sel
+    .split(">>")
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  if (parts.length > 1) {
+    // Build a FrameLocator chain for all but the last segment
+    let fl = frameLocatorFromFrame(page, root, parts[0]!);
+    for (let i = 1; i < parts.length - 1; i++) {
+      fl = fl.frameLocator(parts[i]!);
+    }
+    const targetFrame = await fl.resolveFrame();
+    return { frame: targetFrame, selector: parts[parts.length - 1]! };
+  }
+
+  // No hops — delegate to XPath-aware deep resolver when needed
+  const isXPath = sel.startsWith("xpath=") || sel.startsWith("/");
+  if (isXPath) {
+    return resolveDeepXPathTarget(page, root, sel);
+  }
+  return { frame: root, selector: sel };
+}
+
+export async function resolveLocatorWithHops(
+  page: Page,
+  root: Frame,
+  selectorRaw: string,
+): Promise<Locator> {
+  const target = await resolveLocatorTarget(page, root, selectorRaw);
+  return new Locator(target.frame, target.selector);
+}
+
+/**
+ * DeepLocatorDelegate: a lightweight wrapper that looks like a Locator and
+ * resolves to the correct frame/element on each call using hop/deep-XPath logic.
+ *
+ * Returned by `page.deepLocator()` for ergonomic, await-free chaining:
+ *   page.deepLocator('iframe#ifrA >> #btn').click()
+ */
+export class DeepLocatorDelegate {
+  constructor(
+    private readonly page: Page,
+    private readonly root: Frame,
+    private readonly selector: string,
+    private readonly nthIndex: number = 0,
+  ) {}
+
+  private async real(): Promise<Locator> {
+    const base = await resolveLocatorWithHops(
+      this.page,
+      this.root,
+      this.selector,
+    );
+    return base.nth(this.nthIndex);
+  }
+
+  // Locator API delegates
+  async click(options?: {
+    button?: "left" | "right" | "middle";
+    clickCount?: number;
+  }) {
+    return (await this.real()).click(options);
+  }
+  async count() {
+    return (await this.real()).count();
+  }
+  async hover() {
+    return (await this.real()).hover();
+  }
+  async fill(value: string) {
+    return (await this.real()).fill(value);
+  }
+  async type(text: string, options?: { delay?: number }) {
+    return (await this.real()).type(text, options);
+  }
+  async selectOption(values: string | string[]) {
+    return (await this.real()).selectOption(values);
+  }
+  async scrollTo(percent: number | string) {
+    return (await this.real()).scrollTo(percent);
+  }
+  async isVisible() {
+    return (await this.real()).isVisible();
+  }
+  async isChecked() {
+    return (await this.real()).isChecked();
+  }
+  async inputValue() {
+    return (await this.real()).inputValue();
+  }
+  async textContent() {
+    return (await this.real()).textContent();
+  }
+  async innerHtml() {
+    return (await this.real()).innerHtml();
+  }
+  async innerText() {
+    return (await this.real()).innerText();
+  }
+  async centroid() {
+    return (await this.real()).centroid();
+  }
+  async backendNodeId() {
+    return (await this.real()).backendNodeId();
+  }
+  async highlight(options?: {
+    durationMs?: number;
+    borderColor?: { r: number; g: number; b: number; a?: number };
+    contentColor?: { r: number; g: number; b: number; a?: number };
+  }) {
+    return (await this.real()).highlight(options);
+  }
+  async sendClickEvent(options?: {
+    bubbles?: boolean;
+    cancelable?: boolean;
+    composed?: boolean;
+    detail?: number;
+  }) {
+    return (await this.real()).sendClickEvent(options);
+  }
+  async setInputFiles(
+    files:
+      | string
+      | string[]
+      | {
+          name: string;
+          mimeType: string;
+          buffer: ArrayBuffer | Uint8Array | Buffer | string;
+        }
+      | Array<{
+          name: string;
+          mimeType: string;
+          buffer: ArrayBuffer | Uint8Array | Buffer | string;
+        }>,
+  ) {
+    return (await this.real()).setInputFiles(files);
+  }
+  first() {
+    return this.nth(0);
+  }
+  nth(index: number): DeepLocatorDelegate {
+    const value = Number(index);
+    if (!Number.isFinite(value) || value < 0) {
+      throw new StagehandInvalidArgumentError(
+        "deepLocator().nth() expects a non-negative index",
+      );
+    }
+
+    const nextIndex = Math.floor(value);
+    if (nextIndex === this.nthIndex) return this;
+
+    return new DeepLocatorDelegate(
+      this.page,
+      this.root,
+      this.selector,
+      nextIndex,
+    );
+  }
+}
+
+/** Factory to create a deep locator delegate from a Page + root frame. */
+export function deepLocatorFromPage(
+  page: Page,
+  root: Frame,
+  selector: string,
+): DeepLocatorDelegate {
+  return new DeepLocatorDelegate(page, root, selector);
+}
+
+async function resolveDeepXPathTarget(
+  page: Page,
+  root: Frame,
+  xpathOrSelector: string,
+): Promise<ResolvedLocatorTarget> {
+  let path = xpathOrSelector.trim();
+  if (path.startsWith("xpath=")) path = path.slice("xpath=".length).trim();
+  if (!path.startsWith("/")) path = "/" + path;
+
+  const steps = parseXPath(path);
+  let fl: FrameLocator | undefined;
+  let buf: Step[] = [];
+
+  const flushIntoFrameLocator = () => {
+    if (!buf.length) return;
+    const selectorForIframe = "xpath=" + buildXPathFromSteps(buf);
+    fl = fl
+      ? fl.frameLocator(selectorForIframe)
+      : frameLocatorFromFrame(page, root, selectorForIframe);
+    buf = [];
+  };
+
+  for (const st of steps) {
+    buf.push(st);
+    if (IFRAME_STEP_RE.test(st.name)) flushIntoFrameLocator();
+  }
+
+  const finalSelector = "xpath=" + buildXPathFromSteps(buf);
+  const targetFrame = fl ? await fl.resolveFrame() : root;
+  return { frame: targetFrame, selector: finalSelector };
+}
diff --git a/packages/core/lib/v3/understudy/executionContextRegistry.ts b/packages/core/lib/v3/understudy/executionContextRegistry.ts
new file mode 100644
index 000000000..7edad521a
--- /dev/null
+++ b/packages/core/lib/v3/understudy/executionContextRegistry.ts
@@ -0,0 +1,114 @@
+import type { Protocol } from "devtools-protocol";
+import type { CDPSessionLike } from "./cdp.js";
+
+type FrameId = Protocol.Page.FrameId;
+type ExecId = Protocol.Runtime.ExecutionContextId;
+
+export class ExecutionContextRegistry {
+  private readonly byFrame = new WeakMap<
+    CDPSessionLike,
+    Map<FrameId, ExecId>
+  >();
+  private readonly byExec = new WeakMap<CDPSessionLike, Map<ExecId, FrameId>>();
+
+  /** Wire listeners for this session. Call BEFORE Runtime.enable. */
+  attachSession(session: CDPSessionLike): void {
+    const onCreated = (
+      evt: Protocol.Runtime.ExecutionContextCreatedEvent,
+    ): void => {
+      const aux = (evt.context.auxData ?? {}) as {
+        frameId?: string;
+        isDefault?: boolean;
+      };
+      if (aux.isDefault === true && typeof aux.frameId === "string") {
+        this.register(session, aux.frameId as FrameId, evt.context.id);
+      }
+    };
+    const onDestroyed = (
+      evt: Protocol.Runtime.ExecutionContextDestroyedEvent,
+    ): void => {
+      const rev = this.byExec.get(session);
+      const fwd = this.byFrame.get(session);
+      if (!rev || !fwd) return;
+      const frameId = rev.get(evt.executionContextId);
+      if (!frameId) return;
+      rev.delete(evt.executionContextId);
+      if (fwd.get(frameId) === evt.executionContextId) fwd.delete(frameId);
+    };
+    const onCleared = (): void => {
+      this.byFrame.delete(session);
+      this.byExec.delete(session);
+    };
+
+    session.on("Runtime.executionContextCreated", onCreated);
+    session.on("Runtime.executionContextDestroyed", onDestroyed);
+    session.on("Runtime.executionContextsCleared", onCleared);
+  }
+
+  getMainWorld(session: CDPSessionLike, frameId: FrameId): ExecId | null {
+    return this.byFrame.get(session)?.get(frameId) ?? null;
+  }
+
+  async waitForMainWorld(
+    session: CDPSessionLike,
+    frameId: FrameId,
+    timeoutMs: number = 800,
+  ): Promise<ExecId> {
+    const cached = this.getMainWorld(session, frameId);
+    if (cached) return cached;
+
+    await session.send("Runtime.enable").catch(() => {});
+    const after = this.getMainWorld(session, frameId);
+    if (after) return after;
+
+    return await new Promise<ExecId>((resolve, reject) => {
+      let done = false;
+      const onCreated = (
+        evt: Protocol.Runtime.ExecutionContextCreatedEvent,
+      ): void => {
+        const aux = (evt.context.auxData ?? {}) as {
+          frameId?: string;
+          isDefault?: boolean;
+        };
+        if (aux.isDefault === true && aux.frameId === frameId) {
+          this.register(session, frameId, evt.context.id);
+          if (!done) {
+            done = true;
+            clearTimeout(timer);
+            session.off("Runtime.executionContextCreated", onCreated);
+            resolve(evt.context.id);
+          }
+        }
+      };
+      const timer = setTimeout(() => {
+        if (!done) {
+          done = true;
+          session.off("Runtime.executionContextCreated", onCreated);
+          reject(new Error(`main world not ready for frame ${frameId}`));
+        }
+      }, timeoutMs);
+      session.on("Runtime.executionContextCreated", onCreated);
+    });
+  }
+
+  private register(
+    session: CDPSessionLike,
+    frameId: FrameId,
+    ctxId: ExecId,
+  ): void {
+    let fwd = this.byFrame.get(session);
+    if (!fwd) {
+      fwd = new Map<FrameId, ExecId>();
+      this.byFrame.set(session, fwd);
+    }
+    let rev = this.byExec.get(session);
+    if (!rev) {
+      rev = new Map<ExecId, FrameId>();
+      this.byExec.set(session, rev);
+    }
+    fwd.set(frameId, ctxId);
+    rev.set(ctxId, frameId);
+  }
+}
+
+export const executionContexts = new ExecutionContextRegistry();
diff --git a/packages/core/lib/v3/understudy/fileUploadUtils.ts b/packages/core/lib/v3/understudy/fileUploadUtils.ts
new file mode 100644
index 000000000..446cb754e
--- /dev/null
+++ b/packages/core/lib/v3/understudy/fileUploadUtils.ts
@@ -0,0 +1,102 @@
+import { promises as fs, type Stats } from "fs";
+import path from "path";
+import { Buffer } from "buffer";
+import { StagehandInvalidArgumentError } from "../types/public/sdkErrors.js";
+import {
+  SetInputFilesArgument,
+  SetInputFilePayload,
+} from "../types/public/locator.js";
+import { NormalizedFilePayload } from "../types/private/locator.js";
+
+const DEFAULT_MIME_TYPE = "application/octet-stream";
+
+/**
+ * Normalize user-provided setInputFiles arguments into in-memory payloads.
+ * - Resolves string paths relative to the provided base directory.
+ * - Validates that each path exists and is a regular file.
+ * - Converts all buffers into Node Buffers for downstream processing.
+ */
+export async function normalizeInputFiles(
+  files: SetInputFilesArgument,
+  opts: { baseDir?: string } = {},
+): Promise<NormalizedFilePayload[]> {
+  if (files === null || files === undefined) return [];
+
+  const flattened = Array.isArray(files)
+    ? (files as Array<string | SetInputFilePayload>)
+    : [files];
+  if (!flattened.length) return [];
+
+  const baseDir = opts.baseDir ?? process.cwd();
+  const normalized: NormalizedFilePayload[] = [];
+
+  for (const entry of flattened) {
+    if (typeof entry === "string") {
+      const absolutePath = path.isAbsolute(entry)
+        ? entry
+        : path.resolve(baseDir, entry);
+      const stat = await statFile(absolutePath);
+      if (!stat.isFile()) {
+        throw new StagehandInvalidArgumentError(
+          `setInputFiles(): expected a file but received directory or special entry at ${absolutePath}`,
+        );
+      }
+      const buffer = await fs.readFile(absolutePath);
+      normalized.push({
+        name: path.basename(absolutePath) || "upload.bin",
+        mimeType: DEFAULT_MIME_TYPE,
+        buffer,
+        lastModified: stat.mtimeMs || Date.now(),
+        absolutePath,
+      });
+      continue;
+    }
+
+    if (entry && typeof entry === "object" && "buffer" in entry) {
+      const payload = entry as SetInputFilePayload;
+      const buffer = toBuffer(payload.buffer);
+      normalized.push({
+        name: payload.name || "upload.bin",
+        mimeType: payload.mimeType || DEFAULT_MIME_TYPE,
+        buffer,
+        lastModified:
+          typeof payload.lastModified === "number"
+            ? payload.lastModified
+            : Date.now(),
+      });
+      continue;
+    }
+
+    throw new StagehandInvalidArgumentError(
+      "setInputFiles(): expected file path(s) or payload object(s)",
+    );
+  }
+
+  return normalized;
+}
+
+async function statFile(absolutePath: string): Promise<Stats> {
+  try {
+    return await fs.stat(absolutePath);
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException)?.code;
+    if (code === "ENOENT") {
+      throw new StagehandInvalidArgumentError(
+        `setInputFiles(): file not found at ${absolutePath}`,
+      );
+    }
+    throw error;
+  }
+}
+
+export function toBuffer(
+  data: ArrayBuffer | Uint8Array | Buffer | string,
+): Buffer {
+  if (Buffer.isBuffer(data)) return data;
+  if (data instanceof Uint8Array) return Buffer.from(data);
+  if (typeof data === "string") return Buffer.from(data);
+  if (data instanceof ArrayBuffer) return Buffer.from(new Uint8Array(data));
+  throw new StagehandInvalidArgumentError(
+    "Unsupported file payload buffer type",
+  );
+}
diff --git a/packages/core/lib/v3/understudy/frame.ts b/packages/core/lib/v3/understudy/frame.ts
new file mode 100644
index 000000000..2da4c4f78
--- /dev/null
+++ b/packages/core/lib/v3/understudy/frame.ts
@@ -0,0 +1,319 @@
+// lib/v3/understudy/frame.ts
+import { Protocol } from "devtools-protocol";
+import type { CDPSessionLike } from "./cdp.js";
+import { Locator } from "./locator.js";
+import { StagehandEvalError } from "../types/public/sdkErrors.js";
+import { executionContexts } from "./executionContextRegistry.js";
+
+interface FrameManager {
+  session: CDPSessionLike;
+  frameId: string;
+  pageId: string;
+}
+
+/**
+ * Frame
+ *
+ * A thin, session-bound handle to a specific DOM frame (by frameId).
+ * All CDP calls in this class go through `this.session`, which MUST be the
+ * owning session for `this.frameId`. Page is responsible for constructing
+ * Frames with the correct session.
+ */
+export class Frame implements FrameManager {
+  /** Owning CDP session id (useful for logs); null for root connection (should not happen for targets) */
+  public readonly sessionId: string | null;
+
+  constructor(
+    public session: CDPSessionLike,
+    public frameId: string,
+    public pageId: string,
+    private readonly remoteBrowser: boolean,
+  ) {
+    this.sessionId = this.session.id ?? null;
+  }
+
+  /** True when the controlled browser runs on a different machine. */
+  public isBrowserRemote(): boolean {
+    return this.remoteBrowser;
+  }
+
+  /** DOM.getNodeForLocation → DOM.describeNode */
+  async getNodeAtLocation(x: number, y: number): Promise<Protocol.DOM.Node> {
+    await this.session.send("DOM.enable");
+    const { backendNodeId } = await this.session.send<{
+      backendNodeId: Protocol.DOM.BackendNodeId;
+    }>("DOM.getNodeForLocation", {
+      x,
+      y,
+      includeUserAgentShadowDOM: true,
+      ignorePointerEventsNone: false,
+    });
+
+    const { node } = await this.session.send<{
+      node: Protocol.DOM.Node;
+    }>("DOM.describeNode", { backendNodeId });
+
+    return node;
+  }
+
+  /** CSS selector → DOM.querySelector → DOM.getBoxModel */
+  async getLocationForSelector(
+    selector: string,
+  ): Promise<{ x: number; y: number; width: number; height: number }> {
+    await this.session.send("DOM.enable");
+
+    const { root } = await this.session.send<{ root: Protocol.DOM.Node }>(
+      "DOM.getDocument",
+    );
+
+    const { nodeId } = await this.session.send<{ nodeId: Protocol.DOM.NodeId }>(
+      "DOM.querySelector",
+      { nodeId: root.nodeId, selector },
+    );
+
+    const { model } = await this.session.send<{ model: Protocol.DOM.BoxModel }>(
+      "DOM.getBoxModel",
+      { nodeId },
+    );
+
+    const x = model.content[0];
+    const y = model.content[1];
+    const width = model.width;
+    const height = model.height;
+    return { x, y, width, height };
+  }
+
+  /** Accessibility.getFullAXTree (+ recurse into child frames if requested) */
+  async getAccessibilityTree(
+    withFrames = false,
+  ): Promise<Protocol.Accessibility.AXNode[]> {
+    await this.session.send("Accessibility.enable");
+    let nodes: Protocol.Accessibility.AXNode[];
+    try {
+      ({ nodes } = await this.session.send<{
+        nodes: Protocol.Accessibility.AXNode[];
+      }>("Accessibility.getFullAXTree", { frameId: this.frameId }));
+    } catch (e) {
+      const msg = String((e as Error)?.message ?? e ?? "");
+      const isFrameScopeError =
+        msg.includes("Frame with the given") ||
+        msg.includes("does not belong to the target") ||
+        msg.includes("is not found");
+      if (!isFrameScopeError) throw e;
+      // Retry unscoped: on OOPIF sessions, returns the child doc's AX tree.
+      ({ nodes } = await this.session.send<{
+        nodes: Protocol.Accessibility.AXNode[];
+      }>("Accessibility.getFullAXTree"));
+    }
+
+    if (!withFrames) return nodes;
+
+    const children = await this.childFrames();
+    for (const child of children) {
+      const childNodes = await child.getAccessibilityTree(false);
+      nodes.push(...childNodes);
+    }
+    return nodes;
+  }
+
+  /**
+   * Evaluate a function or expression in this frame's main world.
+   * - If a string is provided, treated as a JS expression.
+   * - If a function is provided, it is stringified and invoked with the optional argument.
+   */
+  async evaluate<R = unknown, Arg = unknown>(
+    pageFunctionOrExpression: string | ((arg: Arg) => R | Promise<R>),
+    arg?: Arg,
+  ): Promise<R> {
+    await this.session.send("Runtime.enable").catch(() => {});
+    const contextId = await this.getMainWorldExecutionContextId();
+
+    const isString = typeof pageFunctionOrExpression === "string";
+    let expression: string;
+
+    if (isString) {
+      expression = String(pageFunctionOrExpression);
+    } else {
+      const fnSrc = pageFunctionOrExpression.toString();
+      const argJson = JSON.stringify(arg);
+      expression = `(() => {
+        const __fn = ${fnSrc};
+        const __arg = ${argJson};
+        try {
+          const __res = __fn(__arg);
+          return Promise.resolve(__res).then(v => {
+            try { return JSON.parse(JSON.stringify(v)); } catch { return v; }
+          });
+        } catch (e) { throw e; }
+      })()`;
+    }
+
+    let res: Protocol.Runtime.EvaluateResponse;
+    try {
+      res = await this.session.send<Protocol.Runtime.EvaluateResponse>(
+        "Runtime.evaluate",
+        {
+          expression,
+          contextId,
+          awaitPromise: true,
+          returnByValue: true,
+        },
+      );
+    } catch (error) {
+      // Execution contexts can be recreated between context lookup and
+      // Runtime.evaluate during popup/navigate churn. Retry once with a fresh id.
+      const msg = error instanceof Error ? error.message : String(error);
+      if (!msg.includes("Cannot find context with specified id")) throw error;
+      const freshContextId = await this.getMainWorldExecutionContextId();
+      res = await this.session.send<Protocol.Runtime.EvaluateResponse>(
+        "Runtime.evaluate",
+        {
+          expression,
+          contextId: freshContextId,
+          awaitPromise: true,
+          returnByValue: true,
+        },
+      );
+    }
+    if (res.exceptionDetails) {
+      throw new StagehandEvalError(
+        res.exceptionDetails.text ?? "Evaluation failed",
+      );
+    }
+    return res.result.value as R;
+  }
+
+  /** Page.captureScreenshot (frame-scoped session) */
+  async screenshot(options?: {
+    fullPage?: boolean;
+    clip?: { x: number; y: number; width: number; height: number };
+    type?: "png" | "jpeg";
+    quality?: number;
+    scale?: number;
+  }): Promise<Buffer> {
+    await this.session.send("Page.enable");
+    const format = options?.type ?? "png";
+    const params: Protocol.Page.CaptureScreenshotRequest & { scale?: number } =
+      {
+        format,
+        fromSurface: true,
+        captureBeyondViewport: options?.fullPage,
+      };
+
+    const clampScale = (value: number): number =>
+      Math.min(2, Math.max(0.1, value));
+
+    const normalizedScale =
+      typeof options?.scale === "number"
+        ? clampScale(options.scale)
+        : undefined;
+
+    if (options?.clip) {
+      const clip = {
+        x: options.clip.x,
+        y: options.clip.y,
+        width: options.clip.width,
+        height: options.clip.height,
+        scale: normalizedScale ?? 1,
+      };
+      params.clip = clip;
+    } else if (normalizedScale !== undefined && normalizedScale !== 1) {
+      params.scale = normalizedScale;
+    }
+
+    if (format === "jpeg" && typeof options?.quality === "number") {
+      const q = Math.round(options.quality);
+      params.quality = Math.min(100, Math.max(0, q));
+    }
+
+    const { data } =
+      await this.session.send<Protocol.Page.CaptureScreenshotResponse>(
+        "Page.captureScreenshot",
+        params,
+      );
+    return Buffer.from(data, "base64");
+  }
+
+  /** Child frames via Page.getFrameTree */
+  async childFrames(): Promise<Frame[]> {
+    const { frameTree } = await this.session.send<{
+      frameTree: Protocol.Page.FrameTree;
+    }>("Page.getFrameTree");
+    const frames: Frame[] = [];
+
+    const collect = (tree: Protocol.Page.FrameTree) => {
+      if (tree.frame.parentId === this.frameId) {
+        frames.push(
+          new Frame(
+            this.session,
+            tree.frame.id,
+            this.pageId,
+            this.remoteBrowser,
+          ),
+        );
+      }
+      tree.childFrames?.forEach(collect);
+    };
+
+    collect(frameTree);
+    return frames;
+  }
+
+  /** Wait for a lifecycle state (load/domcontentloaded/networkidle) */
+  async waitForLoadState(
+    state: "load" | "domcontentloaded" | "networkidle" = "load",
+    timeoutMs: number = 15_000,
+  ): Promise<void> {
+    await this.session.send("Page.enable");
+    const targetState = state.toLowerCase();
+    const timeout = Math.max(0, timeoutMs);
+    await new Promise<void>((resolve, reject) => {
+      let done = false;
+      let timer: ReturnType<typeof setTimeout> | null = null;
+      const finish = () => {
+        if (done) return;
+        done = true;
+        this.session.off("Page.lifecycleEvent", handler);
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        resolve();
+      };
+      const handler = (evt: Protocol.Page.LifecycleEventEvent) => {
+        const sameFrame = evt.frameId === this.frameId;
+        // need to normalize here because CDP lifecycle names look like 'DOMContentLoaded'
+        // but we accept 'domcontentloaded'
+        const lifecycleName = String(evt.name ?? "").toLowerCase();
+        if (sameFrame && lifecycleName === targetState) {
+          finish();
+        }
+      };
+      this.session.on("Page.lifecycleEvent", handler);
+
+      timer = setTimeout(() => {
+        if (done) return;
+        done = true;
+        this.session.off("Page.lifecycleEvent", handler);
+        reject(
+          new Error(
+            `waitForLoadState(${state}) timed out after ${timeout}ms for frame ${this.frameId}`,
+          ),
+        );
+      }, timeout);
+    });
+  }
+
+  /** Simple placeholder for your own locator abstraction */
+  locator(
+    selector: string,
+    options?: { deep?: boolean; depth?: number },
+  ): Locator {
+    return new Locator(this, selector, options);
+  }
+
+  /** Resolve the main-world execution context id for this frame. */
+  private async getMainWorldExecutionContextId(): Promise<number> {
+    return executionContexts.waitForMainWorld(this.session, this.frameId, 1000);
+  }
+}
diff --git a/packages/core/lib/v3/understudy/frameLocator.ts b/packages/core/lib/v3/understudy/frameLocator.ts
new file mode 100644
index 000000000..f562eb880
--- /dev/null
+++ b/packages/core/lib/v3/understudy/frameLocator.ts
@@ -0,0 +1,304 @@
+import type { Protocol } from "devtools-protocol";
+import { Locator } from "./locator.js";
+import type { Page } from "./page.js";
+import { Frame } from "./frame.js";
+import { executionContexts } from "./executionContextRegistry.js";
+import {
+  ContentFrameNotFoundError,
+  StagehandInvalidArgumentError,
+} from "../types/public/sdkErrors.js";
+
+/**
+ * FrameLocator: resolves iframe elements to their child Frames and allows
+ * creating locators scoped to that frame. Supports chaining.
+ */
+export class FrameLocator {
+  private readonly parent?: FrameLocator;
+  private readonly selector: string;
+  private readonly page: Page;
+  private readonly root?: Frame;
+
+  constructor(
+    page: Page,
+    selector: string,
+    parent?: FrameLocator,
+    root?: Frame,
+  ) {
+    this.page = page;
+    this.selector = selector;
+    this.parent = parent;
+    this.root = root;
+  }
+
+  /** Create a nested FrameLocator under this one. */
+  frameLocator(selector: string): FrameLocator {
+    return new FrameLocator(this.page, selector, this);
+  }
+
+  /** Resolve to the concrete Frame for this FrameLocator chain. */
+  async resolveFrame(): Promise<Frame> {
+    const parentFrame: Frame = this.parent
+      ? await this.parent.resolveFrame()
+      : (this.root ?? this.page.mainFrame());
+
+    // Resolve the iframe element inside the parent frame
+    const tmp = parentFrame.locator(this.selector);
+    const parentSession = parentFrame.session;
+    const { objectId } = await tmp.resolveNode();
+
+    try {
+      await parentSession.send("DOM.enable").catch(() => {});
+      const desc = await parentSession.send<Protocol.DOM.DescribeNodeResponse>(
+        "DOM.describeNode",
+        { objectId },
+      );
+      const iframeBackendNodeId = desc.node.backendNodeId;
+
+      // Find direct child frames under the parent by consulting the Page's registry
+      const childIds = await listDirectChildFrameIdsFromRegistry(
+        this.page,
+        parentFrame.frameId,
+        1000,
+      );
+
+      for (const fid of childIds) {
+        try {
+          const owner = await parentSession.send<{
+            backendNodeId: Protocol.DOM.BackendNodeId;
+            nodeId?: Protocol.DOM.NodeId;
+          }>("DOM.getFrameOwner", { frameId: fid as Protocol.Page.FrameId });
+          if (owner.backendNodeId === iframeBackendNodeId) {
+            // Ensure child frame is ready (handles OOPIF adoption or same-process)
+            await ensureChildFrameReady(this.page, parentFrame, fid, 1200);
+            return this.page.frameForId(fid);
+          }
+        } catch {
+          // ignore and try next
+        }
+      }
+      throw new ContentFrameNotFoundError(this.selector);
+    } finally {
+      await parentSession
+        .send("Runtime.releaseObject", { objectId })
+        .catch(() => {});
+    }
+  }
+
+  /** Return a Locator scoped to this frame. Methods delegate to the frame lazily. */
+  locator(selector: string): LocatorDelegate {
+    return new LocatorDelegate(this, selector);
+  }
+}
+
+/** A small delegating wrapper that resolves the frame lazily per call. */
+class LocatorDelegate {
+  constructor(
+    private readonly fl: FrameLocator,
+    private readonly sel: string,
+    private readonly nthIndex: number = -1,
+  ) {}
+
+  private async real(): Promise<Locator> {
+    const frame = await this.fl.resolveFrame();
+    const locator = frame.locator(this.sel);
+    if (this.nthIndex < 0) return locator;
+    return locator.nth(this.nthIndex);
+  }
+
+  // Locator API delegates
+  async click(options?: {
+    button?: "left" | "right" | "middle";
+    clickCount?: number;
+  }) {
+    return (await this.real()).click(options);
+  }
+  async hover() {
+    return (await this.real()).hover();
+  }
+  async fill(value: string) {
+    return (await this.real()).fill(value);
+  }
+  async type(text: string, options?: { delay?: number }) {
+    return (await this.real()).type(text, options);
+  }
+  async selectOption(values: string | string[]) {
+    return (await this.real()).selectOption(values);
+  }
+  async scrollTo(percent: number | string) {
+    return (await this.real()).scrollTo(percent);
+  }
+  async isVisible() {
+    return (await this.real()).isVisible();
+  }
+  async isChecked() {
+    return (await this.real()).isChecked();
+  }
+  async inputValue() {
+    return (await this.real()).inputValue();
+  }
+  async textContent() {
+    return (await this.real()).textContent();
+  }
+  async innerHtml() {
+    return (await this.real()).innerHtml();
+  }
+  async innerText() {
+    return (await this.real()).innerText();
+  }
+  async count() {
+    return (await this.real()).count();
+  }
+  first(): LocatorDelegate {
+    return this.nth(0);
+  }
+  nth(index: number): LocatorDelegate {
+    const value = Number(index);
+    if (!Number.isFinite(value) || value < 0) {
+      throw new StagehandInvalidArgumentError(
+        "locator().nth() expects a non-negative index",
+      );
+    }
+
+    const nextIndex = Math.floor(value);
+    if (nextIndex === this.nthIndex) return this;
+
+    return new LocatorDelegate(this.fl, this.sel, nextIndex);
+  }
+}
+
+/** Factory to start a FrameLocator chain from an arbitrary root Frame. */
+export function frameLocatorFromFrame(
+  page: Page,
+  root: Frame,
+  selector: string,
+): FrameLocator {
+  return new FrameLocator(page, selector, undefined, root);
+}
+
+async function listDirectChildFrameIdsFromRegistry(
+  page: Page,
+  parentFrameId: string,
+  timeoutMs: number,
+): Promise<string[]> {
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    try {
+      const tree = page.getFullFrameTree();
+      const node = findFrameNode(tree, parentFrameId);
+      const ids = node?.childFrames?.map((c) => c.frame.id as string) ?? [];
+      if (ids.length > 0 || Date.now() >= deadline) return ids;
+    } catch {
+      // ignore
+    }
+    await new Promise((r) => setTimeout(r, 50));
+  }
+}
+
+function findFrameNode(
+  tree: Protocol.Page.FrameTree,
+  targetId: string,
+): Protocol.Page.FrameTree | undefined {
+  if (tree.frame.id === targetId) return tree;
+  for (const c of tree.childFrames ?? []) {
+    const hit = findFrameNode(c, targetId);
+    if (hit) return hit;
+  }
+  return undefined;
+}
+
+/**
+ * Ensure we can evaluate in the child frame with minimal delay.
+ * - If the child is same-process: parent session owns it and main world appears quickly.
+ * - If OOPIF and adoption not finished: wait briefly for ownership change, then main world.
+ */
+async function ensureChildFrameReady(
+  page: Page,
+  parentFrame: Frame,
+  childFrameId: string,
+  budgetMs: number,
+): Promise<void> {
+  const parentSession = parentFrame.session;
+  const deadline = Date.now() + Math.max(0, budgetMs);
+
+  // If already owned by a different session (OOPIF adopted), wait briefly there.
+  const owner = page.getSessionForFrame(childFrameId);
+  if (owner && owner !== parentSession) {
+    try {
+      await executionContexts.waitForMainWorld(owner, childFrameId, 600);
+    } catch {
+      // best effort
+    }
+    return;
+  }
+
+  const hasMainWorldOnParent = (): boolean => {
+    try {
+      return (
+        executionContexts.getMainWorld(parentSession, childFrameId) !== null
+      );
+    } catch {
+      return false;
+    }
+  };
+
+  if (hasMainWorldOnParent()) return;
+
+  await parentSession
+    .send("Page.setLifecycleEventsEnabled", { enabled: true })
+    .catch(() => {});
+  await parentSession.send("Runtime.enable").catch(() => {});
+
+  await new Promise<void>((resolve) => {
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      parentSession.off("Page.lifecycleEvent", onLifecycle);
+      resolve();
+    };
+    const onLifecycle = (evt: Protocol.Page.LifecycleEventEvent) => {
+      if (
+        evt.frameId !== childFrameId ||
+        (evt.name !== "DOMContentLoaded" &&
+          evt.name !== "load" &&
+          evt.name !== "networkIdle" &&
+          evt.name !== "networkidle")
+      ) {
+        return;
+      }
+      if (hasMainWorldOnParent()) return finish();
+      try {
+        const nowOwner = page.getSessionForFrame(childFrameId);
+        if (nowOwner && nowOwner !== parentSession) {
+          const left = Math.max(150, deadline - Date.now());
+          executionContexts
+            .waitForMainWorld(nowOwner, childFrameId, left)
+            .finally(finish);
+        }
+      } catch {
+        // ignore
+      }
+    };
+    parentSession.on("Page.lifecycleEvent", onLifecycle);
+
+    const tick = () => {
+      if (done) return;
+      if (hasMainWorldOnParent()) return finish();
+      try {
+        const nowOwner = page.getSessionForFrame(childFrameId);
+        if (nowOwner && nowOwner !== parentSession) {
+          const left = Math.max(150, deadline - Date.now());
+          executionContexts
+            .waitForMainWorld(nowOwner, childFrameId, left)
+            .finally(finish);
+          return;
+        }
+      } catch {
+        // ignore
+      }
+      if (Date.now() >= deadline) return finish();
+      setTimeout(tick, 50);
+    };
+    tick();
+  });
+}
diff --git a/packages/core/lib/v3/understudy/frameRegistry.ts b/packages/core/lib/v3/understudy/frameRegistry.ts
new file mode 100644
index 000000000..c2fb3eb8e
--- /dev/null
+++ b/packages/core/lib/v3/understudy/frameRegistry.ts
@@ -0,0 +1,396 @@
+// lib/v3/understudy/frameRegistry.ts
+import type { Protocol } from "devtools-protocol";
+
+/**
+ * FrameRegistry
+ *
+ * Purpose:
+ * A single, authoritative source of truth for **both**:
+ *   1) Frame topology (parent/children, current main/root id, last-seen CDP `Frame`)
+ *   2) Frame → Session ownership (which CDP session owns a given frameId)
+ *   3) Optional iframe-owner metadata (backendNodeId of the <iframe> element in the parent doc)
+ *
+ *
+ * Model:
+ *  - This class is **CDP-agnostic**; it stores **sessionId strings** (not session objects).
+ *  - Context bridges (wiring Target/Page events) must call the mutators below (onAttached,
+ *    onNavigated, onDetached, adoptChildSession, seedFromFrameTree, setOwnerBackendNodeId).
+ *  - Consumers ask read APIs (getOwnerSessionId, getParent, asProtocolFrameTree, listAll, …)
+ *    and never probe ownership at run time.
+ */
+
+type FrameId = string;
+type SessionId = string;
+
+type FrameInfo = {
+  /** Parent frame id, or null for root */
+  parentId: FrameId | null;
+  /** Children frame ids (direct) */
+  children: Set<FrameId>;
+  /** Last-seen CDP Frame metadata for this id (may be a shell if never seen) */
+  lastSeen?: Protocol.Page.Frame;
+
+  /** Owning session id (CDP child session for OOPIF, top-level session for same-process) */
+  ownerSessionId?: SessionId;
+
+  /**
+   * The backendNodeId of the <iframe> element **in the parent document** that hosts this frame.
+   * Useful for building absolute XPath prefixes or DOM scoping in the parent session.
+   */
+  ownerBackendNodeId?: number;
+};
+
+/** Minimal “shell” CDP frame used when we haven’t yet seen a real Frame from events. */
+function shellFrame(id: FrameId): Protocol.Page.Frame {
+  return {
+    id,
+    loaderId: "",
+    url: "",
+    domainAndRegistry: "",
+    securityOrigin: "",
+    mimeType: "text/html",
+    secureContextType: "InsecureScheme",
+    crossOriginIsolatedContextType: "NotIsolated",
+    gatedAPIFeatures: [],
+  } as Protocol.Page.Frame;
+}
+
+export class FrameRegistry {
+  /** Owner target id (top-level target); informational only */
+  private readonly ownerTargetId: string;
+
+  /** Current main/root frame id (changes on root swaps) */
+  private rootFrameId: FrameId;
+
+  /** frameId → FrameInfo */
+  private frames = new Map<FrameId, FrameInfo>();
+
+  /** sessionId → Set<frameId> (inverse map for diagnostics/fast membership checks) */
+  private framesBySession = new Map<SessionId, Set<FrameId>>();
+
+  constructor(ownerTargetId: string, mainFrameId: FrameId) {
+    this.ownerTargetId = ownerTargetId;
+    this.rootFrameId = mainFrameId;
+    this.ensureNode(mainFrameId);
+  }
+
+  // ---------------------- Mutators (called by Context/Page bridges) ----------------------
+
+  /**
+   * Record that a frame attached. If `parentId` is null and `frameId` differs from the current
+   * root, this is a root swap and we rename the root id.
+   *
+   * IMPORTANT: The emitter's `sessionId` is the **owner** for the new/attached frame.
+   */
+  onFrameAttached(
+    frameId: FrameId,
+    parentId: FrameId | null,
+    sessionId: SessionId,
+  ): void {
+    // Root swap (parentId === null for main frames).
+    if (!parentId && frameId !== this.rootFrameId) {
+      this.renameNodeId(this.rootFrameId, frameId);
+      this.rootFrameId = frameId;
+      // ownership moves to this session as well
+      this.setOwnerSessionIdInternal(frameId, sessionId);
+      return;
+    }
+
+    // Normal attach
+    this.ensureNode(frameId);
+    if (parentId) this.ensureNode(parentId);
+
+    const info = this.frames.get(frameId)!;
+    info.parentId = parentId ?? null;
+
+    if (parentId) {
+      this.frames.get(parentId)!.children.add(frameId);
+    }
+
+    // Ownership: the session that emitted frameAttached owns this frame.
+    this.setOwnerSessionIdInternal(frameId, sessionId);
+  }
+
+  /**
+   * Record a navigation with the full CDP `Frame`. Also updates ownership based on the emitting
+   * session id. Handles root swap if the navigated frame is the new main (no parentId).
+   */
+  onFrameNavigated(frame: Protocol.Page.Frame, sessionId: SessionId): void {
+    this.ensureNode(frame.id);
+    const info = this.frames.get(frame.id)!;
+    info.lastSeen = frame;
+
+    // Ownership follows the session that reported the navigation
+    this.setOwnerSessionIdInternal(frame.id, sessionId);
+
+    // If this frame has no parent, it might be the (new) main/root
+    if (!("parentId" in frame) || !frame.parentId) {
+      if (frame.id !== this.rootFrameId) {
+        // carry ordinal semantics by renaming the root id
+        this.renameNodeId(this.rootFrameId, frame.id);
+        this.rootFrameId = frame.id;
+      }
+    }
+  }
+
+  onNavigatedWithinDocument(
+    frameId: FrameId,
+    url: string,
+    sessionId: SessionId,
+  ): void {
+    this.ensureNode(frameId);
+    const info = this.frames.get(frameId)!;
+    const lastSeen = info.lastSeen ?? shellFrame(frameId);
+    info.lastSeen = { ...lastSeen, url };
+    this.setOwnerSessionIdInternal(frameId, sessionId);
+  }
+
+  /**
+   * Record that a frame detached. If `reason !== "swap"`, remove the subtree from the graph,
+   * and clean the inverse maps. For “swap” we keep the node to preserve continuity.
+   */
+  onFrameDetached(
+    frameId: FrameId,
+    reason: "remove" | "swap" | string = "remove",
+  ): void {
+    if (reason === "swap") return;
+
+    // Collect subtree starting from frameId.
+    const toRemove: FrameId[] = [];
+    const collect = (fid: FrameId) => {
+      toRemove.push(fid);
+      const kids = this.frames.get(fid)?.children ?? new Set<FrameId>();
+      for (const k of kids) collect(k);
+    };
+    collect(frameId);
+
+    // Remove nodes, fix parents and inverse maps
+    for (const fid of toRemove) {
+      const info = this.frames.get(fid);
+      if (!info) continue;
+
+      // unlink from parent
+      if (info.parentId) {
+        const p = this.frames.get(info.parentId);
+        p?.children.delete(fid);
+      }
+
+      // unlink inverse session map
+      if (info.ownerSessionId) {
+        const bag = this.framesBySession.get(info.ownerSessionId);
+        bag?.delete(fid);
+        if (bag && bag.size === 0)
+          this.framesBySession.delete(info.ownerSessionId);
+      }
+
+      this.frames.delete(fid);
+    }
+
+    // Guard root if we removed it; assign a placeholder root if needed
+    if (!this.frames.has(this.rootFrameId)) {
+      // Choose an arbitrary remaining node as root
+      const iter = this.frames.keys().next();
+      if (!iter.done) this.rootFrameId = iter.value;
+    }
+  }
+
+  /**
+   * An adopted OOPIF child session was created whose **main** frame id equals the parent iframe’s frameId.
+   * We mark the entire child subtree as owned by `childSessionId`.
+   * (Topology edges remain aligned by the parent session’s `frameAttached` events.)
+   */
+  adoptChildSession(
+    childSessionId: SessionId,
+    childMainFrameId: FrameId,
+  ): void {
+    // The child session will emit its own navigations/attachments; as a seed,
+    // mark the root frame as owned by the child session.
+    this.setOwnerSessionIdInternal(childMainFrameId, childSessionId);
+  }
+
+  /**
+   * Seed topology and ownership from an existing `Page.getFrameTree` snapshot, typically right after
+   * a session is attached. This is a best-effort: we record frames and set the provided `sessionId`
+   * as owner for the subtree **if** an owner isn't already set.
+   */
+  seedFromFrameTree(
+    sessionId: SessionId,
+    frameTree: Protocol.Page.FrameTree,
+  ): void {
+    const walk = (tree: Protocol.Page.FrameTree, parent: FrameId | null) => {
+      this.ensureNode(tree.frame.id);
+      // topology
+      this.frames.get(tree.frame.id)!.parentId = parent;
+      if (parent) this.frames.get(parent)!.children.add(tree.frame.id);
+      // last-seen frame
+      this.frames.get(tree.frame.id)!.lastSeen = tree.frame;
+      // ownership (only if unknown)
+      if (!this.frames.get(tree.frame.id)!.ownerSessionId) {
+        this.setOwnerSessionIdInternal(tree.frame.id, sessionId);
+      }
+      for (const c of tree.childFrames ?? []) walk(c, tree.frame.id);
+    };
+    walk(frameTree, null);
+  }
+
+  /**
+   * Set the backendNodeId of the `<iframe>` element for a child frame **as seen from its parent**.
+   * This is useful for building absolute XPath prefixes later (from the parent document).
+   */
+  setOwnerBackendNodeId(childFrameId: FrameId, backendNodeId: number): void {
+    this.ensureNode(childFrameId);
+    this.frames.get(childFrameId)!.ownerBackendNodeId = backendNodeId;
+  }
+
+  // ---------------------- Readers (consumed by Page/snapshot/locators) ----------------------
+
+  mainFrameId(): FrameId {
+    return this.rootFrameId;
+  }
+
+  /**
+   * Return the owner session id for this frame. If unknown, returns `undefined`.
+   */
+  getOwnerSessionId(frameId: FrameId): SessionId | undefined {
+    return this.frames.get(frameId)?.ownerSessionId;
+  }
+
+  /**
+   * Return the owner backendNodeId (iframe element) if recorded.
+   * This is in the **parent** document; pair it with `getParent`.
+   */
+  getOwnerBackendNodeId(frameId: FrameId): number | undefined {
+    return this.frames.get(frameId)?.ownerBackendNodeId;
+  }
+
+  /**
+   * Return the parent frame id, or null for root/unknown.
+   */
+  getParent(frameId: FrameId): FrameId | null {
+    return this.frames.get(frameId)?.parentId ?? null;
+  }
+
+  /**
+   * List frame ids in root-first DFS order (same shape as CDP’s FrameTree traversal).
+   */
+  listAllFrames(): FrameId[] {
+    const out: FrameId[] = [];
+    const dfs = (fid: FrameId) => {
+      out.push(fid);
+      const kids = this.frames.get(fid)?.children ?? new Set<FrameId>();
+      for (const k of kids) dfs(k);
+    };
+    if (this.frames.has(this.rootFrameId)) dfs(this.rootFrameId);
+    return out;
+  }
+
+  /**
+   * Serialize to `Protocol.Page.FrameTree` starting at the given root id (typically mainFrameId()).
+   */
+  asProtocolFrameTree(rootId: FrameId): Protocol.Page.FrameTree {
+    const build = (fid: FrameId): Protocol.Page.FrameTree => {
+      const info = this.frames.get(fid);
+      const frame = info?.lastSeen ?? shellFrame(fid);
+
+      const kids = info?.children ?? new Set<FrameId>();
+      const childFrames = kids.size
+        ? [...kids].map((k) => build(k))
+        : undefined;
+
+      return childFrames ? { frame, childFrames } : { frame };
+    };
+
+    return build(rootId);
+  }
+
+  /**
+   * For diagnostics: return the current owner sessions for a frame id (0..n),
+   * usually 0 or 1, but helpful to see potential inconsistencies during wiring.
+   */
+  sessionsForFrame(frameId: FrameId): SessionId[] {
+    const info = this.frames.get(frameId);
+    return info?.ownerSessionId ? [info.ownerSessionId] : [];
+  }
+
+  /**
+   * For diagnostics: return current frame set per session.
+   */
+  framesForSession(sessionId: SessionId): FrameId[] {
+    return [...(this.framesBySession.get(sessionId) ?? new Set())];
+  }
+
+  // ---------------------- Internal helpers ----------------------
+
+  private ensureNode(fid: FrameId): void {
+    if (this.frames.has(fid)) return;
+    this.frames.set(fid, {
+      parentId: null,
+      children: new Set<FrameId>(),
+      lastSeen: shellFrame(fid),
+      ownerSessionId: undefined,
+      ownerBackendNodeId: undefined,
+    });
+  }
+
+  private renameNodeId(oldId: FrameId, newId: FrameId): void {
+    if (oldId === newId) return;
+    this.ensureNode(oldId);
+
+    const info = this.frames.get(oldId)!;
+
+    // Move info under new id
+    this.frames.delete(oldId);
+    this.frames.set(newId, { ...info });
+
+    // Fix parent’s children set
+    if (info.parentId) {
+      const p = this.frames.get(info.parentId);
+      if (p) {
+        p.children.delete(oldId);
+        p.children.add(newId);
+      }
+    }
+
+    // Fix children’s parent pointers
+    for (const c of info.children) {
+      const ci = this.frames.get(c);
+      if (ci) ci.parentId = newId;
+    }
+
+    // Fix inverse map (session -> frames)
+    if (info.ownerSessionId) {
+      const bag = this.framesBySession.get(info.ownerSessionId);
+      if (bag) {
+        bag.delete(oldId);
+        bag.add(newId);
+      }
+    }
+
+    // If root moved, keep the root id updated is handled by caller
+  }
+
+  private setOwnerSessionIdInternal(
+    frameId: FrameId,
+    sessionId: SessionId,
+  ): void {
+    this.ensureNode(frameId);
+    const info = this.frames.get(frameId)!;
+
+    // If the owner is unchanged, do nothing
+    if (info.ownerSessionId === sessionId) return;
+
+    // Remove from previous owner bag
+    if (info.ownerSessionId) {
+      const prev = this.framesBySession.get(info.ownerSessionId);
+      prev?.delete(frameId);
+      if (prev && prev.size === 0)
+        this.framesBySession.delete(info.ownerSessionId);
+    }
+
+    // Set new owner and update bag
+    info.ownerSessionId = sessionId;
+    const bag = this.framesBySession.get(sessionId) ?? new Set<FrameId>();
+    bag.add(frameId);
+    this.framesBySession.set(sessionId, bag);
+  }
+}
diff --git a/packages/core/lib/v3/understudy/initScripts.ts b/packages/core/lib/v3/understudy/initScripts.ts
new file mode 100644
index 000000000..3a5eade85
--- /dev/null
+++ b/packages/core/lib/v3/understudy/initScripts.ts
@@ -0,0 +1,52 @@
+import { promises as fs } from "fs";
+import { InitScriptSource } from "../types/private/index.js";
+import { StagehandInvalidArgumentError } from "../types/public/sdkErrors.js";
+
+const DEFAULT_CALLER = "context.addInitScript";
+
+function appendSourceURL(source: string, filePath: string): string {
+  const sanitized = filePath.replace(/\n/g, "");
+  return `${source}\n//# sourceURL=${sanitized}`;
+}
+
+export async function normalizeInitScriptSource<Arg>(
+  script: InitScriptSource<Arg>,
+  arg?: Arg,
+  caller: string = DEFAULT_CALLER,
+): Promise<string> {
+  if (typeof script === "function") {
+    const argString = Object.is(arg, undefined)
+      ? "undefined"
+      : JSON.stringify(arg);
+    return `(${script.toString()})(${argString})`;
+  }
+
+  if (!Object.is(arg, undefined)) {
+    throw new StagehandInvalidArgumentError(
+      `${caller}: 'arg' is only supported when passing a function.`,
+    );
+  }
+
+  if (typeof script === "string") {
+    return script;
+  }
+
+  if (!script || typeof script !== "object") {
+    throw new StagehandInvalidArgumentError(
+      `${caller}: provide a string, function, or an object with path/content.`,
+    );
+  }
+
+  if (typeof script.content === "string") {
+    return script.content;
+  }
+
+  if (typeof script.path === "string" && script.path.trim()) {
+    const raw = await fs.readFile(script.path, "utf8");
+    return appendSourceURL(raw, script.path);
+  }
+
+  throw new StagehandInvalidArgumentError(
+    `${caller}: provide a string, function, or an object with path/content.`,
+  );
+}
diff --git a/packages/core/lib/v3/understudy/lifecycleWatcher.ts b/packages/core/lib/v3/understudy/lifecycleWatcher.ts
new file mode 100644
index 000000000..b0e902364
--- /dev/null
+++ b/packages/core/lib/v3/understudy/lifecycleWatcher.ts
@@ -0,0 +1,289 @@
+import type { Protocol } from "devtools-protocol";
+import type { LoadState } from "../types/public/page.js";
+import type { CDPSessionLike } from "./cdp.js";
+import type { NetworkManager } from "./networkManager.js";
+import type { Page } from "./page.js";
+import { TimeoutError } from "../types/public/sdkErrors.js";
+import {
+  DEFAULT_IDLE_WAIT,
+  IGNORED_RESOURCE_TYPES,
+  type NetworkRequestInfo,
+  WaitForIdleHandle,
+} from "../types/private/network.js";
+
+/**
+ * Coordinates page lifecycle waits (load/domcontentloaded/networkidle) while
+ * following main-frame swaps and navigation aborts. Each navigation spawns a
+ * one-off watcher that listens for relevant CDP events and resolves or rejects
+ * depending on the requested `waitUntil` state.
+ */
+
+/**
+ * Small utility that mirrors Playwright's lifecycle watcher semantics. Bridges
+ * main-frame lifecycle events with the NetworkManager's idle signal so callers
+ * can await `load`, `domcontentloaded`, or `networkidle` with a single promise.
+ */
+export class LifecycleWatcher {
+  private readonly page: Page;
+  private readonly mainSession: CDPSessionLike;
+  private readonly networkManager: NetworkManager;
+  private readonly waitUntil: LoadState;
+  private readonly timeoutMs: number;
+  private readonly startTime: number;
+  private readonly navigationCommandId: number;
+  private currentLoaderId: string | undefined;
+  private idleStartTime: number;
+
+  private cleanupCallbacks: Array<() => void> = [];
+  private idleHandle: WaitForIdleHandle | null = null;
+
+  private abortReject: ((error: Error) => void) | null = null;
+  private abortPromise: Promise<never>;
+  private abortError: Error | null = null;
+  private disposed = false;
+
+  private expectedLoaderId: string | undefined;
+  private initialLoaderId: string | undefined;
+  private pendingFollowupNavigation = false;
+
+  /**
+   * Create a watcher; callers should subsequently invoke {@link wait}.
+   */
+  constructor(params: {
+    page: Page;
+    mainSession: CDPSessionLike;
+    networkManager: NetworkManager;
+    waitUntil: LoadState;
+    timeoutMs: number;
+    navigationCommandId: number;
+  }) {
+    this.page = params.page;
+    this.mainSession = params.mainSession;
+    this.networkManager = params.networkManager;
+    this.waitUntil = params.waitUntil;
+    this.timeoutMs = params.timeoutMs;
+    this.startTime = Date.now();
+    this.navigationCommandId = params.navigationCommandId;
+    this.idleStartTime = this.startTime;
+
+    this.abortPromise = new Promise<never>((_, reject) => {
+      this.abortReject = reject;
+    });
+
+    this.installSessionListeners();
+  }
+
+  /** Hint the watcher with the loader id returned by Page.navigate. */
+  public setExpectedLoaderId(loaderId: string | undefined): void {
+    if (!loaderId) return;
+    this.expectedLoaderId = loaderId;
+    this.initialLoaderId = loaderId;
+    this.currentLoaderId = loaderId;
+    this.idleStartTime = Date.now();
+  }
+
+  /** Wait for the requested lifecycle state or throw on timeout/abort. */
+  public async wait(): Promise<void> {
+    const deadline = Date.now() + this.timeoutMs;
+
+    try {
+      if (this.waitUntil === "domcontentloaded") {
+        await this.awaitWithAbort(
+          this.page.waitForMainLoadState(
+            "domcontentloaded",
+            this.timeRemaining(deadline),
+          ),
+        );
+        return;
+      }
+
+      while (true) {
+        await this.awaitWithAbort(
+          this.page.waitForMainLoadState("load", this.timeRemaining(deadline)),
+        );
+
+        if (this.waitUntil !== "networkidle") break;
+
+        try {
+          await this.awaitWithAbort(this.waitForNetworkIdle(deadline));
+          break;
+        } catch (error) {
+          if (this.shouldRestartAfterFollowup(error)) {
+            continue;
+          }
+          throw error;
+        }
+      }
+    } finally {
+      this.dispose();
+    }
+
+    if (this.abortError) throw this.abortError;
+  }
+
+  /** Cancel any outstanding network-idle waits and remove event listeners. */
+  public dispose(): void {
+    if (this.disposed) return;
+    this.disposed = true;
+
+    if (this.idleHandle) {
+      void this.idleHandle.promise.catch(() => {});
+      this.idleHandle.dispose();
+      this.idleHandle = null;
+    }
+
+    for (const fn of this.cleanupCallbacks) {
+      try {
+        fn();
+      } catch {
+        // ignore listener cleanup errors
+      }
+    }
+    this.cleanupCallbacks = [];
+    this.abortReject = null;
+  }
+
+  /** Subscribe to main-frame events to detect abort conditions. */
+  private installSessionListeners(): void {
+    const onFrameNavigated = (evt: Protocol.Page.FrameNavigatedEvent) => {
+      if (!evt?.frame?.id) return;
+
+      const mainFrameId = this.page.mainFrameId();
+      if (evt.frame.id !== mainFrameId) return;
+
+      const loaderId = evt.frame.loaderId;
+      if (!loaderId) return;
+
+      if (!this.initialLoaderId) {
+        this.initialLoaderId = loaderId;
+        this.currentLoaderId = loaderId;
+        this.idleStartTime = Date.now();
+      }
+
+      if (!this.expectedLoaderId) {
+        this.expectedLoaderId = loaderId;
+        this.currentLoaderId = loaderId;
+        this.idleStartTime = Date.now();
+        return;
+      }
+
+      if (loaderId !== this.expectedLoaderId) {
+        if (!this.page.isCurrentNavigationCommand(this.navigationCommandId)) {
+          this.triggerAbort(
+            new Error("Navigation was superseded by a new request"),
+          );
+          return;
+        }
+
+        this.adoptNewMainLoader(loaderId);
+      }
+    };
+
+    const onFrameDetached = (evt: Protocol.Page.FrameDetachedEvent) => {
+      if (!evt?.frameId) return;
+      const mainFrameId = this.page.mainFrameId();
+      if (evt.frameId !== mainFrameId) return;
+      if (evt.reason === "swap") return;
+      this.triggerAbort(new Error("Main frame was detached"));
+    };
+
+    this.mainSession.on("Page.frameNavigated", onFrameNavigated);
+    this.cleanupCallbacks.push(() => {
+      this.mainSession.off("Page.frameNavigated", onFrameNavigated);
+    });
+
+    this.mainSession.on("Page.frameDetached", onFrameDetached);
+    this.cleanupCallbacks.push(() => {
+      this.mainSession.off("Page.frameDetached", onFrameDetached);
+    });
+  }
+
+  /** Compute remaining time until the shared deadline elapses. */
+  private timeRemaining(deadline: number): number {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+      throw new TimeoutError("Lifecycle wait", this.timeoutMs);
+    }
+    return remaining;
+  }
+
+  /** Await an operation but abort early if navigation replacement fires. */
+  private async awaitWithAbort<T>(operation: Promise<T>): Promise<T> {
+    try {
+      return await Promise.race([operation, this.abortPromise]);
+    } catch (error) {
+      if (this.abortError) throw this.abortError;
+      throw error;
+    }
+  }
+
+  /** Mark the watcher as aborted and reject any pending waiters. */
+  private triggerAbort(error: Error): void {
+    if (this.abortError) return;
+    this.abortError = error;
+    if (this.abortReject) {
+      this.abortReject(error);
+      this.abortReject = null;
+    }
+  }
+  private waitForNetworkIdle(deadline: number): Promise<void> {
+    this.pendingFollowupNavigation = false;
+    const remaining = this.timeRemaining(deadline);
+    const idleWindow = Math.min(DEFAULT_IDLE_WAIT, remaining);
+    this.idleHandle = this.networkManager.waitForIdle({
+      startTime: this.idleStartTime,
+      timeoutMs: remaining,
+      totalBudgetMs: this.timeoutMs,
+      idleTimeMs: idleWindow,
+      filter: this.buildIdleFilter(),
+    });
+
+    return this.idleHandle.promise.catch((error) => {
+      if (this.abortError) throw this.abortError;
+      throw error;
+    });
+  }
+
+  private shouldRestartAfterFollowup(error: unknown): boolean {
+    if (!this.pendingFollowupNavigation) return false;
+    if (!(error instanceof Error)) return false;
+    if (error.message !== "waitForIdle disposed") return false;
+    this.pendingFollowupNavigation = false;
+    return true;
+  }
+
+  private adoptNewMainLoader(loaderId: string): void {
+    this.expectedLoaderId = loaderId;
+    this.currentLoaderId = loaderId;
+    this.idleStartTime = Date.now();
+    if (this.waitUntil !== "networkidle") return;
+
+    this.pendingFollowupNavigation = true;
+
+    if (this.idleHandle) {
+      const handle = this.idleHandle;
+      this.idleHandle = null;
+      void handle.promise.catch(() => {});
+      handle.dispose();
+    }
+  }
+
+  private buildIdleFilter(): (info: NetworkRequestInfo) => boolean {
+    const loaderId = this.currentLoaderId;
+    const mainFrameId = this.page.mainFrameId();
+
+    return (info: NetworkRequestInfo) => {
+      if (IGNORED_RESOURCE_TYPES.has(info.resourceType)) return false;
+
+      if (loaderId && info.loaderId) {
+        return info.loaderId === loaderId;
+      }
+
+      if (!info.loaderId && info.frameId) {
+        return info.frameId === mainFrameId;
+      }
+
+      return true;
+    };
+  }
+}
diff --git a/packages/core/lib/v3/understudy/locator.ts b/packages/core/lib/v3/understudy/locator.ts
new file mode 100644
index 000000000..b97cbf866
--- /dev/null
+++ b/packages/core/lib/v3/understudy/locator.ts
@@ -0,0 +1,941 @@
+// lib/v3/understudy/locator.ts
+import { Protocol } from "devtools-protocol";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import {
+  locatorScriptBootstrap,
+  locatorScriptGlobalRefs,
+  locatorScriptSources,
+} from "../dom/build/locatorScripts.generated.js";
+import type { Frame } from "./frame.js";
+import {
+  FrameSelectorResolver,
+  type SelectorQuery,
+} from "./selectorResolver.js";
+import {
+  StagehandElementNotFoundError,
+  StagehandInvalidArgumentError,
+  StagehandLocatorError,
+  ElementNotVisibleError,
+} from "../types/public/sdkErrors.js";
+import { normalizeInputFiles } from "./fileUploadUtils.js";
+import { SetInputFilesArgument, MouseButton } from "../types/public/locator.js";
+import { NormalizedFilePayload } from "../types/private/locator.js";
+
+const MAX_REMOTE_UPLOAD_BYTES = 50 * 1024 * 1024; // 50MB guard copied from Playwright
+
+/**
+ * Locator
+ *
+ * Purpose:
+ * A small, CDP-based element interaction helper scoped to a specific `Frame`.
+ * It resolves a CSS/XPath selector inside the frame’s **isolated world**, and then
+ * performs low-level actions (click, type, select) using DOM/Runtime/Input
+ * protocol domains with minimal abstraction.
+ *
+ * Key change:
+ * - Prefer **objectId**-based CDP calls (scroll, geometry) to avoid brittle
+ *   frontend nodeId mappings. nodeId is resolved on a best-effort basis and
+ *   returned for compatibility, but actions do not depend on it.
+ *
+ * Notes:
+ * - Resolution is lazy: every action resolves the selector again.
+ * - Uses `Page.createIsolatedWorld` so evaluation is isolated from page scripts.
+ * - Releases remote objects (`Runtime.releaseObject`) where appropriate.
+ */
+export class Locator {
+  private readonly selectorResolver: FrameSelectorResolver;
+
+  private readonly selectorQuery: SelectorQuery;
+
+  // -1 means "no explicit nth()"; default locator resolves to first match for actions.
+  private readonly nthIndex: number;
+
+  constructor(
+    private readonly frame: Frame,
+    private readonly selector: string,
+    private readonly options?: { deep?: boolean; depth?: number },
+    nthIndex: number = -1,
+  ) {
+    this.selectorResolver = new FrameSelectorResolver(this.frame);
+    this.selectorQuery = FrameSelectorResolver.parseSelector(selector);
+    const normalized = Number.isFinite(nthIndex) ? Math.floor(nthIndex) : -1;
+    this.nthIndex = normalized < 0 ? -1 : normalized;
+  }
+
+  /** Return the owning Frame for this locator (typed accessor, no private access). */
+  public getFrame(): Frame {
+    return this.frame;
+  }
+
+  /**
+   * Set files on an <input type="file"> element.
+   *
+   * Mirrors Playwright's Locator.setInputFiles basics:
+   * - Accepts file path(s) or payload object(s) { name, mimeType, buffer }.
+   * - Uses CDP DOM.setFileInputFiles under the hood.
+   * - Best‑effort dispatches change/input via CDP (Chrome does by default).
+   * - Passing an empty array clears the selection.
+   */
+  public async setInputFiles(files: SetInputFilesArgument): Promise<void> {
+    const session = this.frame.session;
+    const { objectId } = await this.resolveNode();
+
+    const tempFiles: string[] = [];
+
+    try {
+      // Validate element is an <input type="file">
+      try {
+        const res = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
+          "Runtime.callFunctionOn",
+          {
+            objectId,
+            functionDeclaration: locatorScriptSources.ensureFileInputElement,
+            returnByValue: true,
+          },
+        );
+        const ok = Boolean(res.result.value);
+        if (!ok)
+          throw new StagehandInvalidArgumentError(
+            'Target is not an <input type="file"> element',
+          );
+      } catch (e) {
+        throw new StagehandInvalidArgumentError(
+          e instanceof Error
+            ? e.message
+            : "Unable to verify file input element",
+        );
+      }
+
+      const normalized = await normalizeInputFiles(files);
+
+      if (!normalized.length) {
+        await session.send<never>("DOM.setFileInputFiles", {
+          objectId,
+          files: [],
+        });
+        return;
+      }
+
+      if (this.frame.isBrowserRemote()) {
+        await this.assignFilesViaPayloadInjection(objectId, normalized);
+        return;
+      }
+
+      const filePaths: string[] = [];
+      for (const payload of normalized) {
+        if (payload.absolutePath) {
+          filePaths.push(payload.absolutePath);
+          continue;
+        }
+        const ext = path.extname(payload.name);
+        const tmp = path.join(
+          os.tmpdir(),
+          `stagehand-upload-${Date.now()}-${Math.random().toString(36).slice(2)}${ext}`,
+        );
+        await fs.promises.writeFile(tmp, payload.buffer);
+        tempFiles.push(tmp);
+        filePaths.push(tmp);
+      }
+
+      await session.send<never>("DOM.setFileInputFiles", {
+        objectId,
+        files: filePaths,
+      });
+    } finally {
+      // Cleanup: release element and remove any temporary files we created
+      await session
+        .send<never>("Runtime.releaseObject", { objectId })
+        .catch(() => {});
+      for (const p of tempFiles) {
+        try {
+          await fs.promises.unlink(p);
+        } catch {
+          // ignore
+        }
+      }
+    }
+  }
+
+  /**
+   * Remote browser fallback: build File objects inside the page and attach them via JS.
+   *
+   * When Stagehand is driving a browser that cannot see the local filesystem (Browserbase,
+   * remote CDP, etc.), CDP's DOM.setFileInputFiles would fail because Chrome can't reach
+   * our temp files. Instead we base64-encode the payloads, send them into the page, and
+   * let a DOM helper create File objects + dispatch change/input events.
+   */
+  private async assignFilesViaPayloadInjection(
+    objectId: Protocol.Runtime.RemoteObjectId,
+    files: NormalizedFilePayload[],
+  ): Promise<void> {
+    const session = this.frame.session;
+
+    for (const payload of files) {
+      if (payload.buffer.length > MAX_REMOTE_UPLOAD_BYTES) {
+        throw new StagehandInvalidArgumentError(
+          `setInputFiles(): file "${payload.name}" is larger than the 50MB limit for remote uploads`,
+        );
+      }
+    }
+
+    const serialized = files.map((payload) => ({
+      name: payload.name,
+      mimeType: payload.mimeType,
+      lastModified: payload.lastModified,
+      base64: payload.buffer.toString("base64"),
+    }));
+
+    const res = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
+      "Runtime.callFunctionOn",
+      {
+        objectId,
+        functionDeclaration:
+          locatorScriptSources.assignFilePayloadsToInputElement,
+        arguments: [
+          {
+            value: serialized,
+          },
+        ],
+        returnByValue: true,
+      },
+    );
+
+    const ok = Boolean(res.result?.value);
+    if (!ok) {
+      throw new StagehandInvalidArgumentError(
+        "Unable to assign file payloads to remote input element",
+      );
+    }
+  }
+
+  /**
+   * Return the DOM backendNodeId for this locator's target element.
+   * Useful for identity comparisons without needing element handles.
+   */
+  async backendNodeId(): Promise<Protocol.DOM.BackendNodeId> {
+    const session = this.frame.session;
+    const { objectId } = await this.resolveNode();
+    try {
+      await session.send("DOM.enable").catch(() => {});
+      const { node } = await session.send<{ node: Protocol.DOM.Node }>(
+        "DOM.describeNode",
+        { objectId },
+      );
+      return node.backendNodeId as Protocol.DOM.BackendNodeId;
+    } finally {
+      await session
+        .send<never>("Runtime.releaseObject", { objectId })
+        .catch(() => {});
+    }
+  }
+
+  /** Return how many nodes the current selector resolves to. */
+  public async count(): Promise<number> {
+    const session = this.frame.session;
+    await session.send("Runtime.enable");
+    await session.send("DOM.enable");
+    return this.selectorResolver.count(this.selectorQuery);
+  }
+
+  /**
+   * Return the center of the element's bounding box in the owning frame's viewport
+   * (CSS pixels), rounded to integers. Scrolls into view best-effort.
+   */
+  public async centroid(): Promise<{ x: number; y: number }> {
+    const session = this.frame.session;
+    const { objectId } = await this.resolveNode();
+    try {
+      await session
+        .send("DOM.scrollIntoViewIfNeeded", { objectId })
+        .catch(() => {});
+      const box = await session.send<Protocol.DOM.GetBoxModelResponse>(
+        "DOM.getBoxModel",
+        { objectId },
+      );
+      if (!box.model) throw new ElementNotVisibleError(this.selector);
+      const { cx, cy } = this.centerFromBoxContent(box.model.content);
+      return { x: Math.round(cx), y: Math.round(cy) };
+    } finally {
+      await session
+        .send<never>("Runtime.releaseObject", { objectId })
+        .catch(() => {});
+    }
+  }
+
+  /**
+   * Highlight the element's bounding box using the CDP Overlay domain.
+   * - Scrolls element into view best-effort.
+   * - Shows a semi-transparent overlay briefly, then hides it.
+   */
+  public async highlight(options?: {
+    durationMs?: number;
+    borderColor?: { r: number; g: number; b: number; a?: number };
+    contentColor?: { r: number; g: number; b: number; a?: number };
+  }): Promise<void> {
+    const session = this.frame.session;
+    const { objectId } = await this.resolveNode();
+    const duration = Math.max(0, options?.durationMs ?? 800);
+
+    const borderColor = options?.borderColor ?? { r: 255, g: 0, b: 0, a: 0.9 };
+    const contentColor =
+      options?.contentColor ?? ({ r: 255, g: 200, b: 0, a: 0.2 } as const);
+
+    try {
+      await session.send("Overlay.enable").catch(() => {});
+      await session
+        .send("DOM.scrollIntoViewIfNeeded", { objectId })
+        .catch(() => {});
+
+      // Prefer backendNodeId to keep highlight stable even if objectId is released.
+      await session.send("DOM.enable").catch(() => {});
+      let backendNodeId: Protocol.DOM.BackendNodeId | undefined;
+      try {
+        const { node } = await session.send<{ node: Protocol.DOM.Node }>(
+          "DOM.describeNode",
+          { objectId },
+        );
+        backendNodeId = node.backendNodeId as Protocol.DOM.BackendNodeId;
+      } catch {
+        backendNodeId = undefined;
+      }
+
+      const highlightConfig: Protocol.Overlay.HighlightConfig = {
+        showInfo: false,
+        showStyles: false,
+        showRulers: false,
+        showExtensionLines: false,
+        borderColor,
+        contentColor,
+      } as Protocol.Overlay.HighlightConfig;
+
+      const highlightOnce = async () => {
+        await session.send<never>("Overlay.highlightNode", {
+          ...(backendNodeId ? { backendNodeId } : { objectId }),
+          highlightConfig,
+        });
+      };
+
+      // Initial draw
+      await highlightOnce();
+
+      // Keep alive until duration elapses to resist overlay clears on mouse move/repaints
+      if (duration > 0) {
+        const start = Date.now();
+        const tick = Math.min(300, Math.max(100, Math.floor(duration / 50)));
+        while (Date.now() - start < duration) {
+          await new Promise((r) => setTimeout(r, tick));
+          try {
+            await highlightOnce();
+          } catch {
+            // ignore transient errors
+          }
+        }
+        await session.send<never>("Overlay.hideHighlight").catch(() => {});
+      }
+    } finally {
+      // Releasing objectId should not affect highlight when using backendNodeId.
+      await session
+        .send<never>("Runtime.releaseObject", { objectId })
+        .catch(() => {});
+    }
+  }
+
+  /**
+   * Move the mouse cursor to the element's visual center without clicking.
+   * - Scrolls into view best-effort, resolves geometry, then dispatches a mouse move.
+   */
+  async hover(): Promise<void> {
+    const session = this.frame.session;
+    const { objectId } = await this.resolveNode();
+    try {
+      await session
+        .send("DOM.scrollIntoViewIfNeeded", { objectId })
+        .catch(() => {});
+
+      const box = await session.send<Protocol.DOM.GetBoxModelResponse>(
+        "DOM.getBoxModel",
+        { objectId },
+      );
+      if (!box.model) throw new ElementNotVisibleError(this.selector);
+      const { cx, cy } = this.centerFromBoxContent(box.model.content);
+
+      await session.send<never>("Input.dispatchMouseEvent", {
+        type: "mouseMoved",
+        x: cx,
+        y: cy,
+        button: "none",
+      } as Protocol.Input.DispatchMouseEventRequest);
+    } finally {
+      await session
+        .send<never>("Runtime.releaseObject", { objectId })
+        .catch(() => {});
+    }
+  }
+
+  /**
+   * Click the element at its visual center.
+   * Steps:
+   *  1) Resolve selector to { objectId } in the frame world.
+   *  2) Scroll into view via `DOM.scrollIntoViewIfNeeded({ objectId })`.
+   *  3) Read geometry via `DOM.getBoxModel({ objectId })` → compute a center point.
+   *  4) Synthesize mouse press + release via `Input.dispatchMouseEvent`.
+   */
+  async click(options?: {
+    button?: MouseButton;
+    clickCount?: number;
+  }): Promise<void> {
+    const session = this.frame.session;
+    const { objectId } = await this.resolveNode();
+
+    const button = options?.button ?? "left";
+    const clickCount = options?.clickCount ?? 1;
+
+    try {
+      // Scroll into view using objectId (avoids frontend nodeId dependence)
+      await session.send("DOM.scrollIntoViewIfNeeded", { objectId });
+
+      // Get geometry using objectId
+      const box = await session.send<Protocol.DOM.GetBoxModelResponse>(
+        "DOM.getBoxModel",
+        { objectId },
+      );
+      if (!box.model) throw new ElementNotVisibleError(this.selector);
+      const { cx, cy } = this.centerFromBoxContent(box.model.content);
+
+      // Dispatch click events in a pipelined burst to reduce inter-click delay
+      // from network/CPU jitter between round trips.
+      const dispatches: Array<Promise<unknown>> = [];
+      dispatches.push(
+        session.send<never>("Input.dispatchMouseEvent", {
+          type: "mouseMoved",
+          x: cx,
+          y: cy,
+          button: "none",
+        } as Protocol.Input.DispatchMouseEventRequest),
+      );
+
+      for (let i = 1; i <= clickCount; i++) {
+        dispatches.push(
+          session.send<never>("Input.dispatchMouseEvent", {
+            type: "mousePressed",
+            x: cx,
+            y: cy,
+            button,
+            clickCount: i,
+          } as Protocol.Input.DispatchMouseEventRequest),
+        );
+        dispatches.push(
+          session.send<never>("Input.dispatchMouseEvent", {
+            type: "mouseReleased",
+            x: cx,
+            y: cy,
+            button,
+            clickCount: i,
+          } as Protocol.Input.DispatchMouseEventRequest),
+        );
+      }
+      await Promise.all(dispatches);
+    } finally {
+      // release the element handle
+      try {
+        await session.send<never>("Runtime.releaseObject", { objectId });
+      } catch {
+        // If the context navigated or was destroyed (e.g., link opens new tab),
+        // releaseObject may fail with -32000. Ignore as best-effort cleanup.
+      }
+    }
+  }
+
+  /**
+   * Dispatch a DOM 'click' MouseEvent on the element itself.
+   * - Does not synthesize real pointer input; directly dispatches an event.
+   * - Useful for elements that rely on click handlers without needing hit-testing.
+   */
+  async sendClickEvent(options?: {
+    bubbles?: boolean;
+    cancelable?: boolean;
+    composed?: boolean;
+    detail?: number;
+  }): Promise<void> {
+    const session = this.frame.session;
+    const { objectId } = await this.resolveNode();
+    const bubbles = options?.bubbles ?? true;
+    const cancelable = options?.cancelable ?? true;
+    const composed = options?.composed ?? true;
+    const detail = options?.detail ?? 1;
+    try {
+      await session
+        .send("DOM.scrollIntoViewIfNeeded", { objectId })
+        .catch(() => {});
+      await session.send<Protocol.Runtime.CallFunctionOnResponse>(
+        "Runtime.callFunctionOn",
+        {
+          objectId,
+          functionDeclaration: locatorScriptSources.dispatchDomClick,
+          arguments: [
+            {
+              value: { bubbles, cancelable, composed, detail },
+            },
+          ],
+          returnByValue: true,
+        },
+      );
+    } finally {
+      await session
+        .send<never>("Runtime.releaseObject", { objectId })
+        .catch(() => {});
+    }
+  }
+
+  /**
+   * Scroll the element vertically to a given percentage (0–100).
+   * - If the element is <html> or <body>, scrolls the window/document.
+   * - Otherwise, scrolls the element itself via element.scrollTo.
+   */
+  async scrollTo(percent: number | string): Promise<void> {
+    const session = this.frame.session;
+    const { objectId } = await this.resolveNode();
+    try {
+      await session.send<Protocol.Runtime.CallFunctionOnResponse>(
+        "Runtime.callFunctionOn",
+        {
+          objectId,
+          functionDeclaration: locatorScriptSources.scrollElementToPercent,
+          arguments: [{ value: percent as unknown as number }],
+          returnByValue: true,
+        },
+      );
+    } finally {
+      await session
+        .send<never>("Runtime.releaseObject", { objectId })
+        .catch(() => {});
+    }
+  }
+
+  /**
+   * Fill an input/textarea/contenteditable element.
+   * Mirrors Playwright semantics: the DOM helper either applies the native
+   * value setter (for special input types) or asks us to type text via the CDP
+   * Input domain after focusing/selecting.
+   */
+  async fill(value: string): Promise<void> {
+    const session = this.frame.session;
+    // Use the bundled locator globals; the raw fill snippet depends on helper symbols.
+    const fillDeclaration = `function(value) { ${locatorScriptBootstrap}; return ${locatorScriptGlobalRefs.fillElementValue}.call(this, value); }`;
+    const { objectId } = await this.resolveNode();
+
+    let releaseNeeded = true;
+
+    try {
+      const res = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
+        "Runtime.callFunctionOn",
+        {
+          objectId,
+          functionDeclaration: fillDeclaration,
+          arguments: [{ value }],
+          returnByValue: true,
+        },
+      );
+      if (res.exceptionDetails) {
+        // prefer exception.description over text (eg "Uncaught")
+        const message =
+          res.exceptionDetails.exception?.description ??
+          res.exceptionDetails.text ??
+          "Unknown exception during locator().fill()";
+        throw new StagehandLocatorError("Filling", this.selector, message);
+      }
+
+      const result = res.result.value as
+        | { status?: string; reason?: string; value?: string }
+        | null
+        | undefined;
+      const status =
+        typeof result === "object" && result ? result.status : undefined;
+
+      if (status === "done") {
+        return;
+      }
+
+      if (status === "needsinput") {
+        // Release the current handle before synthesizing keyboard input to avoid leaking it.
+        await session
+          .send<never>("Runtime.releaseObject", { objectId })
+          .catch(() => {});
+        releaseNeeded = false;
+
+        const valueToType =
+          typeof result?.value === "string" ? result.value : value;
+
+        let prepared = false;
+        try {
+          const { objectId: prepObjectId } = await this.resolveNode();
+          try {
+            const prepRes =
+              await session.send<Protocol.Runtime.CallFunctionOnResponse>(
+                "Runtime.callFunctionOn",
+                {
+                  objectId: prepObjectId,
+                  functionDeclaration:
+                    locatorScriptSources.prepareElementForTyping,
+                  returnByValue: true,
+                },
+              );
+            prepared = Boolean(prepRes.result.value);
+          } finally {
+            await session
+              .send<never>("Runtime.releaseObject", { objectId: prepObjectId })
+              .catch(() => {});
+          }
+        } catch {
+          // Ignore preparation failures; we'll fall back to typing best-effort.
+        }
+
+        if (!prepared && valueToType.length > 0) {
+          await this.type(valueToType);
+          return;
+        }
+
+        if (valueToType.length === 0) {
+          // Simulate deleting the currently selected text to clear the field.
+          await session.send<never>("Input.dispatchKeyEvent", {
+            type: "keyDown",
+            key: "Backspace",
+            code: "Backspace",
+            windowsVirtualKeyCode: 8,
+            nativeVirtualKeyCode: 8,
+          } as Protocol.Input.DispatchKeyEventRequest);
+          await session.send<never>("Input.dispatchKeyEvent", {
+            type: "keyUp",
+            key: "Backspace",
+            code: "Backspace",
+            windowsVirtualKeyCode: 8,
+            nativeVirtualKeyCode: 8,
+          } as Protocol.Input.DispatchKeyEventRequest);
+        } else {
+          await session.send<never>("Input.insertText", { text: valueToType });
+        }
+
+        return;
+      }
+
+      if (status === "error") {
+        const reason =
+          typeof result?.reason === "string" && result.reason.length > 0
+            ? result.reason
+            : "Failed to fill element";
+        throw new StagehandInvalidArgumentError(
+          `Failed to fill element (${reason})`,
+        );
+      }
+
+      // Backward compatibility: if no status is returned (older bundle), fall back to setter logic.
+      if (!status) {
+        await this.type(value);
+      }
+    } finally {
+      if (releaseNeeded) {
+        await session
+          .send<never>("Runtime.releaseObject", { objectId })
+          .catch(() => {});
+      }
+    }
+  }
+
+  /**
+   * Type text into the element (focuses first).
+   * - Focus via element.focus() in page JS (no DOM.focus(nodeId)).
+   * - If no delay, uses `Input.insertText` for efficiency.
+   * - With delay, synthesizes `keyDown`/`keyUp` per character.
+   */
+  async type(text: string, options?: { delay?: number }): Promise<void> {
+    const session = this.frame.session;
+    const { objectId } = await this.resolveNode();
+
+    try {
+      // Focus using JS (avoids DOM.focus(nodeId))
+      await session.send<Protocol.Runtime.CallFunctionOnResponse>(
+        "Runtime.callFunctionOn",
+        {
+          objectId,
+          functionDeclaration: locatorScriptSources.focusElement,
+          returnByValue: true,
+        },
+      );
+
+      if (!options?.delay) {
+        await session.send<never>("Input.insertText", { text });
+        return;
+      }
+
+      for (const ch of text) {
+        await session.send<never>("Input.dispatchKeyEvent", {
+          type: "keyDown",
+          text: ch,
+          key: ch,
+        } as Protocol.Input.DispatchKeyEventRequest);
+
+        await session.send<never>("Input.dispatchKeyEvent", {
+          type: "keyUp",
+          text: ch,
+          key: ch,
+        } as Protocol.Input.DispatchKeyEventRequest);
+
+        await new Promise((r) => setTimeout(r, options.delay));
+      }
+    } finally {
+      await session.send<never>("Runtime.releaseObject", { objectId });
+    }
+  }
+
+  /**
+   * Select one or more options on a `<select>` element.
+   * Returns the values actually selected after the operation.
+   */
+  async selectOption(values: string | string[]): Promise<string[]> {
+    const session = this.frame.session;
+    const desired = Array.isArray(values) ? values : [values];
+    const { objectId } = await this.resolveNode();
+
+    try {
+      const res = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
+        "Runtime.callFunctionOn",
+        {
+          objectId,
+          functionDeclaration: locatorScriptSources.selectElementOptions,
+          arguments: [{ value: desired }],
+          returnByValue: true,
+        },
+      );
+
+      return (res.result.value as string[]) ?? [];
+    } finally {
+      await session.send<never>("Runtime.releaseObject", { objectId });
+    }
+  }
+
+  /**
+   * Return true if the element is attached and visible (rough heuristic).
+   */
+  async isVisible(): Promise<boolean> {
+    const session = this.frame.session;
+    const { objectId } = await this.resolveNode();
+    try {
+      const res = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
+        "Runtime.callFunctionOn",
+        {
+          objectId,
+          functionDeclaration: locatorScriptSources.isElementVisible,
+          returnByValue: true,
+        },
+      );
+      return Boolean(res.result.value);
+    } finally {
+      await session.send<never>("Runtime.releaseObject", { objectId });
+    }
+  }
+
+  /**
+   * Return true if the element is an input[type=checkbox|radio] and is checked.
+   * Also considers aria-checked for ARIA widgets.
+   */
+  async isChecked(): Promise<boolean> {
+    const session = this.frame.session;
+    const { objectId } = await this.resolveNode();
+    try {
+      const res = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
+        "Runtime.callFunctionOn",
+        {
+          objectId,
+          functionDeclaration: locatorScriptSources.isElementChecked,
+          returnByValue: true,
+        },
+      );
+      return Boolean(res.result.value);
+    } finally {
+      await session.send<never>("Runtime.releaseObject", { objectId });
+    }
+  }
+
+  /**
+   * Return the element's input value (for input/textarea/select/contenteditable).
+   */
+  async inputValue(): Promise<string> {
+    const session = this.frame.session;
+    const { objectId } = await this.resolveNode();
+    try {
+      const res = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
+        "Runtime.callFunctionOn",
+        {
+          objectId,
+          functionDeclaration: locatorScriptSources.readElementInputValue,
+          returnByValue: true,
+        },
+      );
+      return String(res.result.value ?? "");
+    } finally {
+      await session.send<never>("Runtime.releaseObject", { objectId });
+    }
+  }
+
+  /**
+   * Return the element's textContent (raw, not innerText).
+   */
+  async textContent(): Promise<string> {
+    const session = this.frame.session;
+    const { objectId } = await this.resolveNode();
+    try {
+      const res = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
+        "Runtime.callFunctionOn",
+        {
+          objectId,
+          functionDeclaration: locatorScriptSources.readElementTextContent,
+          returnByValue: true,
+        },
+      );
+      return String(res.result.value ?? "");
+    } finally {
+      await session.send<never>("Runtime.releaseObject", { objectId });
+    }
+  }
+
+  /**
+   * Return the element's innerHTML string.
+   */
+  async innerHtml(): Promise<string> {
+    const session = this.frame.session;
+    const { objectId } = await this.resolveNode();
+    try {
+      const res = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
+        "Runtime.callFunctionOn",
+        {
+          objectId,
+          functionDeclaration: locatorScriptSources.readElementInnerHTML,
+          returnByValue: true,
+        },
+      );
+      return String(res.result.value ?? "");
+    } finally {
+      await session.send<never>("Runtime.releaseObject", { objectId });
+    }
+  }
+
+  /**
+   * Return the element's innerText (layout-aware, visible text).
+   */
+  async innerText(): Promise<string> {
+    const session = this.frame.session;
+    const { objectId } = await this.resolveNode();
+    try {
+      const res = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
+        "Runtime.callFunctionOn",
+        {
+          objectId,
+          functionDeclaration: locatorScriptSources.readElementInnerText,
+          returnByValue: true,
+        },
+      );
+      return String(res.result.value ?? "");
+    } finally {
+      await session.send<never>("Runtime.releaseObject", { objectId });
+    }
+  }
+
+  /**
+   * Return a locator narrowed to the first match.
+   */
+  first(): Locator {
+    return this.nth(0);
+  }
+
+  /** Return a locator narrowed to the element at the given zero-based index. */
+  nth(index: number): Locator {
+    const value = Number(index);
+    if (!Number.isFinite(value) || value < 0) {
+      throw new StagehandInvalidArgumentError(
+        "locator().nth() expects a non-negative index",
+      );
+    }
+
+    const nextIndex = Math.floor(value);
+    if (nextIndex === this.nthIndex) {
+      return this;
+    }
+
+    return new Locator(this.frame, this.selector, this.options, nextIndex);
+  }
+
+  // ---------- helpers ----------
+
+  /**
+   * Resolve `this.selector` within the frame to `{ objectId, nodeId? }`:
+   * Delegates to a shared selector resolver so all selector logic stays in sync.
+   */
+  public async resolveNode(): Promise<{
+    nodeId: Protocol.DOM.NodeId | null;
+    objectId: Protocol.Runtime.RemoteObjectId;
+  }> {
+    const session = this.frame.session;
+
+    await session.send("Runtime.enable");
+    await session.send("DOM.enable");
+
+    const index = this.nthIndex < 0 ? 0 : this.nthIndex;
+    const resolved = await this.selectorResolver.resolveAtIndex(
+      this.selectorQuery,
+      index,
+    );
+    if (!resolved) {
+      throw new StagehandElementNotFoundError([this.selector]);
+    }
+
+    return resolved;
+  }
+
+  /**
+   * Resolve all matching nodes for this locator.
+   * If the locator is narrowed via nth(), only that index is returned.
+   */
+  public async resolveNodesForMask(): Promise<
+    Array<{
+      nodeId: Protocol.DOM.NodeId | null;
+      objectId: Protocol.Runtime.RemoteObjectId;
+    }>
+  > {
+    const session = this.frame.session;
+
+    await session.send("Runtime.enable");
+    await session.send("DOM.enable");
+
+    if (this.nthIndex >= 0) {
+      const resolved = await this.selectorResolver.resolveAtIndex(
+        this.selectorQuery,
+        this.nthIndex,
+      );
+      if (!resolved) {
+        throw new StagehandElementNotFoundError([this.selector]);
+      }
+      return [resolved];
+    }
+
+    const resolved = await this.selectorResolver.resolveAll(this.selectorQuery);
+    if (!resolved.length) {
+      throw new StagehandElementNotFoundError([this.selector]);
+    }
+    return resolved;
+  }
+
+  /** Compute a center point from a BoxModel content quad */
+  private centerFromBoxContent(content: number[]): { cx: number; cy: number } {
+    // content is [x1,y1, x2,y2, x3,y3, x4,y4]
+    if (!content || content.length < 8) {
+      throw new StagehandInvalidArgumentError("Invalid box model content quad");
+    }
+    const xs = [content[0], content[2], content[4], content[6]];
+    const ys = [content[1], content[3], content[5], content[7]];
+    const cx = (xs[0] + xs[1] + xs[2] + xs[3]) / 4;
+    const cy = (ys[0] + ys[1] + ys[2] + ys[3]) / 4;
+    return { cx, cy };
+  }
+}
diff --git a/packages/core/lib/v3/understudy/locatorInvocation.ts b/packages/core/lib/v3/understudy/locatorInvocation.ts
new file mode 100644
index 000000000..5a8a8a69d
--- /dev/null
+++ b/packages/core/lib/v3/understudy/locatorInvocation.ts
@@ -0,0 +1,19 @@
+import {
+  locatorScriptBootstrap,
+  locatorScriptGlobalRefs,
+  type LocatorScriptName,
+} from "../dom/build/locatorScripts.generated.js";
+
+/**
+ * Build an expression that injects the locator bundle (if needed) and invokes a
+ * specific helper via its stable global reference. This keeps Runtime.evaluate
+ * payloads tiny while guaranteeing our selector utilities are present in any
+ * execution context.
+ */
+export function buildLocatorInvocation(
+  name: LocatorScriptName,
+  args: string[],
+): string {
+  const invocation = `${locatorScriptGlobalRefs[name]}(${args.join(", ")})`;
+  return `(() => { ${locatorScriptBootstrap}; return ${invocation}; })()`;
+}
diff --git a/packages/core/lib/v3/understudy/navigationResponseTracker.ts b/packages/core/lib/v3/understudy/navigationResponseTracker.ts
new file mode 100644
index 000000000..0a28df949
--- /dev/null
+++ b/packages/core/lib/v3/understudy/navigationResponseTracker.ts
@@ -0,0 +1,265 @@
+/**
+ * NavigationResponseTracker
+ * -------------------------
+ *
+ * Tracks DevTools Protocol network events for a single navigation command so
+ * Stagehand can surface a Playwright-like response object from `Page.goto` and
+ * related APIs. The tracker listens for `Network.responseReceived` events that
+ * correspond to the targeted document navigation, handles loader-id churn that
+ * arises from redirects or preloading, and enriches the resulting
+ * `Response` with extra header information. It also observes
+ * `Network.loadingFinished` / `Network.loadingFailed` to fulfil the
+ * `response.finished()` contract exposed to consumers.
+ */
+
+import type { Protocol } from "devtools-protocol";
+import type { CDPSessionLike } from "./cdp.js";
+import type { Page } from "./page.js";
+import { Response } from "./response.js";
+
+/**
+ * Watches CDP events on a given session and resolves with the navigation's
+ * primary document response once identified.
+ */
+export class NavigationResponseTracker {
+  private readonly page: Page;
+  private readonly session: CDPSessionLike;
+  private readonly navigationCommandId: number;
+
+  private expectedLoaderId: string | undefined;
+  private selectedRequestId: string | null = null;
+  private selectedResponse: Response | null = null;
+  private acceptNextWithoutLoader = false;
+
+  private responseResolved = false;
+  private resolveResponse!: (value: Response | null) => void;
+  private responsePromise: Promise<Response | null>;
+
+  private readonly pendingResponsesByLoader = new Map<
+    string,
+    Protocol.Network.ResponseReceivedEvent
+  >();
+  private readonly pendingExtraInfo = new Map<
+    string,
+    Protocol.Network.ResponseReceivedExtraInfoEvent
+  >();
+
+  private readonly listeners: Array<{
+    event: string;
+    handler: (event: unknown) => void;
+  }> = [];
+
+  /**
+   * Create a tracker bound to a specific navigation command. The tracker begins
+   * listening for network events immediately so it should be constructed before
+   * the navigation request is dispatched.
+   */
+  constructor(params: {
+    page: Page;
+    session: CDPSessionLike;
+    navigationCommandId: number;
+  }) {
+    this.page = params.page;
+    this.session = params.session;
+    this.navigationCommandId = params.navigationCommandId;
+
+    this.responsePromise = new Promise<Response | null>((resolve) => {
+      this.resolveResponse = (value) => {
+        if (this.responseResolved) return;
+        this.responseResolved = true;
+        resolve(value);
+      };
+    });
+
+    this.installListeners();
+  }
+
+  /** Stop listening for CDP events and release any pending bookkeeping. */
+  public dispose(): void {
+    for (const { event, handler } of this.listeners) {
+      this.session.off(event, handler as never);
+    }
+    this.listeners.length = 0;
+    this.pendingResponsesByLoader.clear();
+    this.pendingExtraInfo.clear();
+  }
+
+  /**
+   * Hint the tracker with the loader id returned by `Page.navigate`. Chrome only
+   * emits this once the browser begins navigating, so we store early responses
+   * and match them once the loader id is known.
+   */
+  public setExpectedLoaderId(loaderId: string | undefined): void {
+    if (!loaderId) return;
+    this.expectedLoaderId = loaderId;
+    const pending = this.pendingResponsesByLoader.get(loaderId);
+    if (pending) {
+      this.pendingResponsesByLoader.delete(loaderId);
+      this.selectResponse(pending);
+    }
+  }
+
+  /**
+   * Some navigation APIs (reload/history traversal) do not provide a loader id
+   * up front. This flag instructs the tracker to accept the next qualifying
+   * document response even if no loader id has been announced yet.
+   */
+  public expectNavigationWithoutKnownLoader(): void {
+    this.acceptNextWithoutLoader = true;
+  }
+
+  /**
+   * Returns a promise that resolves with the matched response (or `null` when
+   * no document response was observed).
+   */
+  public async navigationCompleted(): Promise<Response | null> {
+    if (!this.responseResolved) {
+      queueMicrotask(() => {
+        if (!this.responseResolved) this.resolveResponse(null);
+      });
+    }
+    return this.responsePromise;
+  }
+
+  /** Expose the raw response promise (mainly for tests). */
+  public async response(): Promise<Response | null> {
+    return this.responsePromise;
+  }
+
+  /** Register all CDP listeners relevant to navigation tracking. */
+  private installListeners(): void {
+    this.addListener("Network.responseReceived", (event) => {
+      this.onResponseReceived(event as Protocol.Network.ResponseReceivedEvent);
+    });
+    this.addListener("Network.responseReceivedExtraInfo", (event) => {
+      this.onResponseReceivedExtraInfo(
+        event as Protocol.Network.ResponseReceivedExtraInfoEvent,
+      );
+    });
+    this.addListener("Network.loadingFinished", (event) => {
+      this.onLoadingFinished(event as Protocol.Network.LoadingFinishedEvent);
+    });
+    this.addListener("Network.loadingFailed", (event) => {
+      this.onLoadingFailed(event as Protocol.Network.LoadingFailedEvent);
+    });
+  }
+
+  /** Attach a CDP listener and track it for later disposal. */
+  private addListener(event: string, handler: (event: unknown) => void): void {
+    this.session.on(event, handler as never);
+    this.listeners.push({ event, handler });
+  }
+
+  /** Handle the initial response payload for document navigations. */
+  private onResponseReceived(
+    event: Protocol.Network.ResponseReceivedEvent,
+  ): void {
+    if (!this.page.isCurrentNavigationCommand(this.navigationCommandId)) return;
+    if (!event || !event.response) return;
+    if (event.type !== "Document") return;
+    if (event.frameId !== this.page.mainFrameId()) return;
+
+    const loaderId = event.loaderId ?? "";
+    if (this.acceptNextWithoutLoader) {
+      this.acceptNextWithoutLoader = false;
+      this.selectResponse(event);
+      return;
+    }
+
+    if (this.expectedLoaderId) {
+      if (loaderId && loaderId !== this.expectedLoaderId) {
+        this.pendingResponsesByLoader.set(loaderId, event);
+        return;
+      }
+      this.selectResponse(event);
+      return;
+    }
+
+    if (loaderId) {
+      this.pendingResponsesByLoader.set(loaderId, event);
+      return;
+    }
+
+    this.selectResponse(event);
+  }
+
+  /** Merge auxiliary header information once Chrome exposes it. */
+  private onResponseReceivedExtraInfo(
+    event: Protocol.Network.ResponseReceivedExtraInfoEvent,
+  ): void {
+    if (!event || !event.requestId) return;
+    if (this.selectedRequestId && event.requestId === this.selectedRequestId) {
+      this.selectedResponse?.applyExtraInfo(event);
+      return;
+    }
+    this.pendingExtraInfo.set(event.requestId, event);
+  }
+
+  /** Resolve the response's finished promise when the request completes. */
+  private onLoadingFinished(
+    event: Protocol.Network.LoadingFinishedEvent,
+  ): void {
+    if (!event || !event.requestId) return;
+    if (event.requestId !== this.selectedRequestId) return;
+    this.selectedResponse?.markFinished(null);
+  }
+
+  /** Resolve the response's finished promise with an error on failure. */
+  private onLoadingFailed(event: Protocol.Network.LoadingFailedEvent): void {
+    // Ignore malformed events or ones without a request id
+    if (!event || !event.requestId) return;
+    // Only the tracked document request should toggle the response state
+    if (event.requestId !== this.selectedRequestId) return;
+    // Surface Chrome's failure text through response.finished()
+    const errorText = event.errorText || "Navigation request failed";
+    this.selectedResponse?.markFinished(new Error(errorText));
+  }
+
+  /**
+   * Create the `Response` wrapper for the chosen document response and
+   * resolve awaiting consumers. Subsequent events flesh out the header/body
+   * helpers and mark the request as finished.
+   */
+  private selectResponse(event: Protocol.Network.ResponseReceivedEvent): void {
+    if (event.loaderId) {
+      this.pendingResponsesByLoader.delete(event.loaderId);
+    }
+
+    if (this.responseResolved) return;
+    if (this.selectedResponse) return;
+
+    const protocol = event.response?.protocol?.toLowerCase() ?? "";
+    const url = event.response?.url ?? "";
+    const isDataUrl = protocol === "data" || url.startsWith("data:");
+    const isAboutUrl = protocol === "about" || url.startsWith("about:");
+
+    if (isDataUrl || isAboutUrl) {
+      this.pendingExtraInfo.delete(event.requestId);
+      this.selectedRequestId = null;
+      this.selectedResponse = null;
+      this.resolveResponse(null);
+      return;
+    }
+
+    const response = new Response({
+      page: this.page,
+      session: this.session,
+      requestId: event.requestId,
+      frameId: event.frameId,
+      loaderId: event.loaderId,
+      response: event.response,
+      fromServiceWorker: Boolean(event.response?.fromServiceWorker),
+    });
+
+    this.selectedRequestId = event.requestId;
+    this.selectedResponse = response;
+
+    const extraInfo = this.pendingExtraInfo.get(event.requestId);
+    if (extraInfo) {
+      response.applyExtraInfo(extraInfo);
+      this.pendingExtraInfo.delete(event.requestId);
+    }
+
+    this.resolveResponse(response);
+  }
+}
diff --git a/packages/core/lib/v3/understudy/networkManager.ts b/packages/core/lib/v3/understudy/networkManager.ts
new file mode 100644
index 000000000..e169e0c46
--- /dev/null
+++ b/packages/core/lib/v3/understudy/networkManager.ts
@@ -0,0 +1,343 @@
+import type { Protocol } from "devtools-protocol";
+import type { CDPSessionLike } from "./cdp.js";
+import {
+  DEFAULT_IDLE_WAIT,
+  IGNORED_RESOURCE_TYPES,
+  NetworkObserver,
+  NetworkRequestInfo,
+  WaitForIdleHandle,
+  WaitForIdleOptions,
+} from "../types/private/network.js";
+
+/**
+ * Cross-session network tracker.
+ *
+ * Centralises network bookkeeping for a Page: every CDP session (top-level and OOPIF)
+ * funnels `Network.*` events through here so higher-level waiters can reason about
+ * in-flight requests across the entire frame tree. The manager exposes a simple
+ * observer interface plus a "wait until idle" helper that resolves once no filtered
+ * requests remain for a quiet window.
+ */
+
+/**
+ * Aggregates network information for all CDP sessions owned by a Page.
+ */
+export class NetworkManager {
+  private readonly sessions = new Map<
+    string,
+    {
+      session: CDPSessionLike;
+      detach: () => void;
+    }
+  >();
+
+  private readonly observers = new Set<NetworkObserver>();
+
+  private readonly requests = new Map<string, NetworkRequestInfo>();
+
+  private readonly documentRequestsByFrame = new Map<string, string>();
+
+  /**
+   * Begin tracking network traffic for a CDP session (top-level or OOPIF).
+   * Safe to call multiple times; duplicate registrations are ignored.
+   */
+  public trackSession(session: CDPSessionLike): void {
+    const sid = this.sessionKey(session);
+    if (this.sessions.has(sid)) return;
+
+    const onRequest = (evt: Protocol.Network.RequestWillBeSentEvent) => {
+      if (!evt || !evt.requestId) return;
+
+      const info: NetworkRequestInfo = {
+        sessionId: sid,
+        requestId: evt.requestId,
+        requestKey: this.requestKey(sid, evt.requestId),
+        frameId: evt.frameId ?? undefined,
+        loaderId: evt.loaderId ?? undefined,
+        url: evt.request?.url,
+        timestamp: Date.now(),
+        resourceType: evt.type,
+        documentRequest: evt.type === "Document",
+      };
+
+      this.requests.set(info.requestKey, info);
+      if (info.documentRequest && info.frameId) {
+        this.documentRequestsByFrame.set(info.frameId, info.requestKey);
+      }
+
+      this.emitStart(info);
+    };
+
+    const finish = (reqId: string) => {
+      const key = this.requestKey(sid, reqId);
+      const stored = this.requests.get(key);
+      if (stored?.frameId) {
+        this.documentRequestsByFrame.delete(stored.frameId);
+      }
+      const info: NetworkRequestInfo = stored ?? {
+        sessionId: sid,
+        requestId: reqId,
+        requestKey: key,
+        timestamp: Date.now(),
+        documentRequest: false,
+      };
+      this.requests.delete(key);
+      this.emitFinish(info);
+    };
+
+    const fail = (reqId: string) => {
+      const key = this.requestKey(sid, reqId);
+      const stored = this.requests.get(key);
+      if (stored?.frameId) {
+        this.documentRequestsByFrame.delete(stored.frameId);
+      }
+      const info: NetworkRequestInfo = stored ?? {
+        sessionId: sid,
+        requestId: reqId,
+        requestKey: key,
+        timestamp: Date.now(),
+        documentRequest: false,
+      };
+      this.requests.delete(key);
+      this.emitFailure(info);
+    };
+
+    const onFinished = (evt: { requestId: string }) => {
+      if (!evt?.requestId) return;
+      finish(evt.requestId);
+    };
+
+    const onFailed = (evt: Protocol.Network.LoadingFailedEvent) => {
+      if (!evt?.requestId) return;
+      fail(evt.requestId);
+    };
+
+    const onResponse = (evt: Protocol.Network.ResponseReceivedEvent) => {
+      if (!evt?.requestId) return;
+      const url = evt.response?.url ?? "";
+      if (url.startsWith("data:")) finish(evt.requestId);
+    };
+
+    const onFrameStopped = (evt: Protocol.Page.FrameStoppedLoadingEvent) => {
+      if (!evt?.frameId) return;
+      const key = this.documentRequestsByFrame.get(evt.frameId);
+      if (!key) return;
+      const stored = this.requests.get(key);
+      if (!stored) {
+        this.documentRequestsByFrame.delete(evt.frameId);
+        return;
+      }
+      this.requests.delete(key);
+      this.documentRequestsByFrame.delete(evt.frameId);
+      this.emitFinish({ ...stored, timestamp: Date.now() });
+    };
+
+    session.on("Network.requestWillBeSent", onRequest);
+    session.on("Network.loadingFinished", onFinished);
+    session.on("Network.loadingFailed", onFailed);
+    session.on("Network.requestServedFromCache", onFinished);
+    session.on("Network.responseReceived", onResponse);
+    session.on("Page.frameStoppedLoading", onFrameStopped);
+
+    void session.send("Network.enable").catch(() => {});
+    void session.send("Page.enable").catch(() => {});
+
+    this.sessions.set(sid, {
+      session,
+      detach: () => {
+        session.off("Network.requestWillBeSent", onRequest);
+        session.off("Network.loadingFinished", onFinished);
+        session.off("Network.loadingFailed", onFailed);
+        session.off("Network.requestServedFromCache", onFinished);
+        session.off("Network.responseReceived", onResponse);
+        session.off("Page.frameStoppedLoading", onFrameStopped);
+      },
+    });
+  }
+
+  /**
+   * Stop tracking a session and discard any inflight bookkeeping owned by it.
+   */
+  public untrackSession(rawSessionId: string | undefined): void {
+    const sid = rawSessionId ?? "__main__";
+    const entry = this.sessions.get(sid);
+    if (!entry) return;
+    entry.detach();
+    this.sessions.delete(sid);
+
+    for (const key of [...this.requests.keys()]) {
+      if (key.startsWith(`${sid}:`)) this.requests.delete(key);
+    }
+
+    for (const [frameId, key] of [...this.documentRequestsByFrame.entries()]) {
+      if (key.startsWith(`${sid}:`)) {
+        this.documentRequestsByFrame.delete(frameId);
+      }
+    }
+  }
+
+  /**
+   * Register a passive observer for request lifecycle notifications.
+   * Returns a disposer that removes the observer.
+   */
+  public addObserver(observer: NetworkObserver): () => void {
+    this.observers.add(observer);
+    return () => {
+      this.observers.delete(observer);
+    };
+  }
+
+  /**
+   * Resolve once no (filtered) requests are in flight for the given quiet window.
+   * The waiter automatically unregisters itself on completion or timeout.
+   */
+  public waitForIdle(options: WaitForIdleOptions): WaitForIdleHandle {
+    const startTime = options.startTime ?? Date.now();
+    const idleTimeMs = options.idleTimeMs ?? DEFAULT_IDLE_WAIT;
+    const timeoutMs = options.timeoutMs;
+    const remainingBudgetMs = Number.isFinite(timeoutMs)
+      ? timeoutMs
+      : undefined;
+    const originalBudgetMs = Number.isFinite(options.totalBudgetMs ?? NaN)
+      ? (options.totalBudgetMs as number)
+      : remainingBudgetMs;
+
+    const filter =
+      options.filter ??
+      ((info: NetworkRequestInfo) => {
+        return !IGNORED_RESOURCE_TYPES.has(info.resourceType);
+      });
+
+    const tracked = new Set<string>();
+    let idleTimer: ReturnType<typeof setTimeout> | null = null;
+    let timeoutTimer: ReturnType<typeof setTimeout> | null = null;
+    let settled = false;
+
+    let resolveFn: (() => void) | null = null;
+    let rejectFn: ((error: Error) => void) | null = null;
+
+    const cleanup = (error?: Error) => {
+      if (settled) return;
+      settled = true;
+      if (idleTimer) clearTimeout(idleTimer);
+      if (timeoutTimer) clearTimeout(timeoutTimer);
+      removeObserver();
+      tracked.clear();
+      if (error) {
+        rejectFn?.(error);
+      } else {
+        resolveFn?.();
+      }
+    };
+
+    const maybeIdle = () => {
+      if (settled) return;
+      if (tracked.size === 0) {
+        if (!idleTimer) {
+          idleTimer = setTimeout(() => {
+            cleanup();
+          }, idleTimeMs);
+        }
+      } else if (idleTimer) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+      }
+    };
+
+    const observer: NetworkObserver = {
+      onRequestStarted: (info) => {
+        if (settled) return;
+        if (info.timestamp < startTime) return;
+        if (!filter(info)) return;
+        tracked.add(info.requestKey);
+        if (idleTimer) {
+          clearTimeout(idleTimer);
+          idleTimer = null;
+        }
+      },
+      onRequestFinished: (info) => {
+        if (settled) return;
+        if (!tracked.delete(info.requestKey)) return;
+        maybeIdle();
+      },
+      onRequestFailed: (info) => {
+        if (settled) return;
+        if (!tracked.delete(info.requestKey)) return;
+        maybeIdle();
+      },
+    };
+
+    const removeObserver = this.addObserver(observer);
+
+    const promise = new Promise<void>((resolve, reject) => {
+      resolveFn = resolve;
+      rejectFn = reject;
+    });
+
+    // Trigger initial idle check so that we still respect the quiet window
+    maybeIdle();
+
+    if (Number.isFinite(timeoutMs)) {
+      timeoutTimer = setTimeout(
+        () => {
+          const elapsed = Date.now() - startTime;
+          const message =
+            originalBudgetMs !== undefined
+              ? `networkidle timed out after ${originalBudgetMs}ms`
+              : `networkidle timed out after ${elapsed}ms`;
+          cleanup(new Error(message));
+        },
+        Math.max(0, timeoutMs),
+      );
+    }
+
+    return {
+      promise,
+      dispose: () => cleanup(new Error("waitForIdle disposed")),
+    };
+  }
+
+  /**
+   * Tear down all session listeners and clear observers/bookkeeping.
+   */
+  public dispose(): void {
+    for (const { detach } of this.sessions.values()) {
+      detach();
+    }
+    this.sessions.clear();
+    this.observers.clear();
+    this.requests.clear();
+    this.documentRequestsByFrame.clear();
+  }
+
+  /** Fan-out helper when a tracked request starts. */
+  private emitStart(info: NetworkRequestInfo): void {
+    for (const obs of this.observers) {
+      obs.onRequestStarted(info);
+    }
+  }
+
+  /** Fan-out helper when a tracked request completes successfully. */
+  private emitFinish(info: NetworkRequestInfo): void {
+    for (const obs of this.observers) {
+      obs.onRequestFinished(info);
+    }
+  }
+
+  /** Fan-out helper when a tracked request fails mid-flight. */
+  private emitFailure(info: NetworkRequestInfo): void {
+    for (const obs of this.observers) {
+      obs.onRequestFailed(info);
+    }
+  }
+
+  /** Compute a stable key for a session (falls back to synthetic root id). */
+  private sessionKey(session: CDPSessionLike): string {
+    return session.id ?? "__main__";
+  }
+
+  /** Compose the unique key for tracking a request under a session. */
+  private requestKey(sessionId: string, requestId: string): string {
+    return `${sessionId}:${requestId}`;
+  }
+}
diff --git a/packages/core/lib/v3/understudy/page.ts b/packages/core/lib/v3/understudy/page.ts
new file mode 100644
index 000000000..4e9ace408
--- /dev/null
+++ b/packages/core/lib/v3/understudy/page.ts
@@ -0,0 +1,2371 @@
+import { Protocol } from "devtools-protocol";
+import { promises as fs } from "fs";
+import { v3Logger } from "../logger.js";
+import { logAction } from "../flowLogger.js";
+import type { CDPSessionLike } from "./cdp.js";
+import { CdpConnection } from "./cdp.js";
+import { Frame } from "./frame.js";
+import { FrameLocator } from "./frameLocator.js";
+import { deepLocatorFromPage, resolveLocatorTarget } from "./deepLocator.js";
+import {
+  captureHybridSnapshot,
+  resolveXpathForLocation,
+} from "./a11y/snapshot/index.js";
+import { FrameRegistry } from "./frameRegistry.js";
+import { executionContexts } from "./executionContextRegistry.js";
+import {
+  LoadState,
+  SnapshotResult,
+  PageSnapshotOptions,
+} from "../types/public/page.js";
+import { NetworkManager } from "./networkManager.js";
+import { LifecycleWatcher } from "./lifecycleWatcher.js";
+import { NavigationResponseTracker } from "./navigationResponseTracker.js";
+import { Response, isSerializableResponse } from "./response.js";
+import { ConsoleMessage, ConsoleListener } from "./consoleMessage.js";
+import type { StagehandAPIClient } from "../api.js";
+import {
+  LocalBrowserLaunchOptions,
+  StagehandSetExtraHTTPHeadersError,
+  StagehandSnapshotError,
+} from "../types/public/index.js";
+import type { Locator } from "./locator.js";
+import {
+  StagehandInvalidArgumentError,
+  StagehandEvalError,
+} from "../types/public/sdkErrors.js";
+import { normalizeInitScriptSource } from "./initScripts.js";
+import { buildLocatorInvocation } from "./locatorInvocation.js";
+import type {
+  ScreenshotAnimationsOption,
+  ScreenshotCaretOption,
+  ScreenshotOptions,
+  ScreenshotScaleOption,
+} from "../types/public/screenshotTypes.js";
+import {
+  applyMaskOverlays,
+  applyStyleToFrames,
+  collectFramesForScreenshot,
+  computeScreenshotScale,
+  disableAnimations,
+  hideCaret,
+  normalizeScreenshotClip,
+  runScreenshotCleanups,
+  setTransparentBackground,
+  type ScreenshotCleanup,
+} from "./screenshotUtils.js";
+import { InitScriptSource } from "../types/private/index.js";
+import { withTimeout } from "../timeoutConfig.js";
+
+/**
+ * Page
+ *
+ * One instance per **top-level target**. It owns:
+ *  - the top-level CDP session (for the page target)
+ *  - all adopted OOPIF child sessions (Target.attachToTarget with flatten: true)
+ *  - a **FrameRegistry** that is the single source of truth for BOTH:
+ *      • frame topology (parent/children, root swaps, last-seen CDP Frame)
+ *      • frame → session ownership (which session owns which frameId)
+ *
+ * Page exposes convenient APIs (goto/reload/url/screenshot/locator),
+ * and simple bridges that Context uses to feed Page/Target events in.
+ */
+
+const LIFECYCLE_NAME: Record<LoadState, string> = {
+  load: "load",
+  domcontentloaded: "DOMContentLoaded",
+  networkidle: "networkIdle",
+};
+
+export class Page {
+  /** Every CDP child session this page owns (top-level + adopted OOPIF sessions). */
+  private readonly sessions = new Map<string, CDPSessionLike>(); // sessionId -> session
+
+  /** Unified truth for frame topology + ownership. */
+  private readonly registry: FrameRegistry;
+
+  /** A convenience wrapper bound to the current main frame id (top-level session). */
+  private mainFrameWrapper: Frame;
+
+  /** Compact ordinal per frameId (used by snapshot encoding). */
+  private frameOrdinals = new Map<string, number>();
+  private nextOrdinal = 0;
+
+  /** cache Frames per frameId so everyone uses the same one */
+  private readonly frameCache = new Map<string, Frame>();
+  private readonly browserIsRemote: boolean;
+
+  /** Stable id for Frames created by this Page (use top-level TargetId). */
+  private readonly pageId: string;
+  /** Cached current URL for synchronous page.url() */
+  private _currentUrl: string = "about:blank";
+
+  private navigationCommandSeq = 0;
+  private latestNavigationCommandId = 0;
+
+  private readonly networkManager: NetworkManager;
+  /** Optional API client for routing page operations to the API */
+  private readonly apiClient: StagehandAPIClient | null = null;
+  private readonly consoleListeners = new Set<ConsoleListener>();
+  private readonly consoleHandlers = new Map<
+    string,
+    (evt: Protocol.Runtime.ConsoleAPICalledEvent) => void
+  >();
+  /** Document-start scripts installed across every session this page owns. */
+  private readonly initScripts: string[] = [];
+  private extraHTTPHeaders: Record<string, string>;
+
+  private constructor(
+    private readonly conn: CdpConnection,
+    private readonly mainSession: CDPSessionLike,
+    private readonly _targetId: string,
+    mainFrameId: string,
+    apiClient?: StagehandAPIClient | null,
+    browserIsRemote = false,
+  ) {
+    this.pageId = _targetId;
+    this.apiClient = apiClient ?? null;
+    this.browserIsRemote = browserIsRemote;
+
+    // own the main session
+    if (mainSession.id) this.sessions.set(mainSession.id, mainSession);
+
+    // initialize registry with root/main frame id
+    this.registry = new FrameRegistry(_targetId, mainFrameId);
+
+    // main-frame wrapper is always bound to the **top-level** session
+    this.mainFrameWrapper = new Frame(
+      this.mainSession,
+      mainFrameId,
+      this.pageId,
+      this.browserIsRemote,
+    );
+
+    this.networkManager = new NetworkManager();
+    this.networkManager.trackSession(this.mainSession);
+  }
+
+  // Send a single init script to a specific CDP session.
+  private async installInitScriptOnSession(
+    session: CDPSessionLike,
+    source: string,
+  ): Promise<void> {
+    await session.send("Page.addScriptToEvaluateOnNewDocument", {
+      source: source,
+    });
+  }
+
+  // Replay every previously registered init script onto a newly adopted session.
+  private async applyInitScriptsToSession(
+    session: CDPSessionLike,
+  ): Promise<void> {
+    for (const source of this.initScripts) {
+      await this.installInitScriptOnSession(session, source);
+    }
+  }
+
+  // Register a new init script and fan it out to all active sessions for this page.
+  public async registerInitScript(source: string): Promise<void> {
+    if (this.initScripts.includes(source)) return;
+    this.initScripts.push(source);
+
+    const installs: Array<Promise<void>> = [];
+    installs.push(this.installInitScriptOnSession(this.mainSession, source));
+    for (const session of this.sessions.values()) {
+      if (session === this.mainSession) continue;
+      installs.push(this.installInitScriptOnSession(session, source));
+    }
+    await Promise.all(installs);
+  }
+
+  // Seed an init script without re-installing it on the current sessions.
+  public seedInitScript(source: string): void {
+    if (this.initScripts.includes(source)) return;
+    this.initScripts.push(source);
+  }
+
+  // --- Optional visual cursor overlay management ---
+  private cursorEnabled = false;
+  private async ensureCursorScript(): Promise<void> {
+    const script = `(() => {
+      const ID = '__v3_cursor_overlay__';
+      const state = { el: null, last: null };
+      // Expose API early so move() calls before install are buffered
+      try {
+        if (!window.__v3Cursor || !window.__v3Cursor.__installed) {
+          const api = {
+            __installed: false,
+            move(x, y) {
+              if (state.el) {
+                state.el.style.left = Math.max(0, x) + 'px';
+                state.el.style.top = Math.max(0, y) + 'px';
+              } else {
+                state.last = [x, y];
+              }
+            },
+            show() { if (state.el) state.el.style.display = 'block'; },
+            hide() { if (state.el) state.el.style.display = 'none'; },
+          };
+          window.__v3Cursor = api;
+        }
+      } catch {}
+
+      function install() {
+        try {
+          if (state.el) return; // already installed
+          let el = document.getElementById(ID);
+          if (!el) {
+            const root = document.documentElement || document.body || document.head;
+            if (!root) { setTimeout(install, 50); return; }
+            el = document.createElement('div');
+            el.id = ID;
+            el.style.position = 'fixed';
+            el.style.left = '0px';
+            el.style.top = '0px';
+            el.style.width = '16px';
+            el.style.height = '24px';
+            el.style.zIndex = '2147483647';
+            el.style.pointerEvents = 'none';
+            el.style.userSelect = 'none';
+            el.style.mixBlendMode = 'normal';
+            el.style.contain = 'layout style paint';
+            el.style.willChange = 'transform,left,top';
+            el.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="24" viewBox="0 0 16 24"><path d="M1 0 L1 22 L6 14 L15 14 Z" fill="black" stroke="white" stroke-width="0.7"/></svg>';
+            root.appendChild(el);
+          }
+          state.el = el;
+          try { window.__v3Cursor.__installed = true; } catch {}
+          if (state.last) {
+            window.__v3Cursor.move(state.last[0], state.last[1]);
+            state.last = null;
+          }
+        } catch {}
+      }
+
+      if (document.readyState === 'complete' || document.readyState === 'interactive') {
+        install();
+      } else {
+        document.addEventListener('DOMContentLoaded', install, { once: true });
+        setTimeout(install, 100);
+      }
+    })();`;
+
+    // Ensure future documents get the cursor at doc-start
+    await this.mainSession
+      .send("Page.addScriptToEvaluateOnNewDocument", { source: script })
+      .catch(() => {});
+    // Inject into current document now
+    await this.mainSession
+      .send("Runtime.evaluate", {
+        expression: script,
+        includeCommandLineAPI: false,
+      })
+      .catch(() => {});
+  }
+
+  public async enableCursorOverlay(): Promise<void> {
+    if (this.cursorEnabled) return;
+    await this.ensureCursorScript();
+    this.cursorEnabled = true;
+  }
+
+  private async updateCursor(x: number, y: number): Promise<void> {
+    if (!this.cursorEnabled) return;
+    try {
+      await this.mainSession.send("Runtime.evaluate", {
+        expression: `typeof window.__v3Cursor!=="undefined"&&window.__v3Cursor.move(${Math.round(x)}, ${Math.round(y)})`,
+      });
+    } catch {
+      //
+    }
+  }
+
+  public async addInitScript<Arg>(
+    script: InitScriptSource<Arg>,
+    arg?: Arg,
+  ): Promise<void> {
+    const source = await normalizeInitScriptSource(
+      script,
+      arg,
+      "page.addInitScript",
+    );
+    await this.registerInitScript(source);
+  }
+
+  /**
+   * Factory: create Page and seed registry with the shallow tree from Page.getFrameTree.
+   * Assumes Page domain is already enabled on the session passed in.
+   */
+  static async create(
+    conn: CdpConnection,
+    session: CDPSessionLike,
+    targetId: string,
+    apiClient?: StagehandAPIClient | null,
+    localBrowserLaunchOptions?: LocalBrowserLaunchOptions | null,
+    browserIsRemote = false,
+  ): Promise<Page> {
+    // Context already issues Page.enable + lifecycle enable before resume.
+    // Re-issue here only as best-effort and do not block page registration on
+    // their acknowledgements; some remote CDP backends can delay these replies
+    // long after the target is otherwise ready.
+    void session.send("Page.enable").catch(() => {});
+    void session
+      .send("Page.setLifecycleEventsEnabled", { enabled: true })
+      .catch(() => {});
+    const { frameTree } = await session.send<{
+      frameTree: Protocol.Page.FrameTree;
+    }>("Page.getFrameTree");
+    const mainFrameId = frameTree.frame.id;
+
+    const page = new Page(
+      conn,
+      session,
+      targetId,
+      mainFrameId,
+      apiClient,
+      browserIsRemote,
+    );
+    // Seed current URL from initial frame tree
+    try {
+      page._currentUrl = String(frameTree?.frame?.url ?? page._currentUrl);
+      if (localBrowserLaunchOptions?.viewport) {
+        await page.setViewportSize(
+          localBrowserLaunchOptions.viewport.width,
+          localBrowserLaunchOptions.viewport.height,
+          {
+            deviceScaleFactor: localBrowserLaunchOptions.deviceScaleFactor ?? 1,
+          },
+        );
+      }
+    } catch {
+      // ignore
+    }
+
+    // Seed topology + ownership for nodes known at creation time.
+    page.registry.seedFromFrameTree(session.id ?? "root", frameTree);
+
+    return page;
+  }
+
+  // ---------------- Event-driven updates from Context ----------------
+
+  /**
+   * Parent/child session emitted a `frameAttached`.
+   * Topology update + ownership stamped to **emitting session**.
+   */
+  public onFrameAttached(
+    frameId: string,
+    parentId: string | null,
+    session: CDPSessionLike,
+  ): void {
+    this.ensureOrdinal(frameId);
+    this.registry.onFrameAttached(frameId, parentId, session.id ?? "root");
+    // Cache is keyed by frameId → invalidate to ensure future frameForId resolves with latest owner
+    this.frameCache.delete(frameId);
+  }
+
+  /**
+   * Parent/child session emitted a `frameDetached`.
+   */
+  public onFrameDetached(
+    frameId: string,
+    reason: "remove" | "swap" | string = "remove",
+  ): void {
+    this.registry.onFrameDetached(frameId, reason);
+    this.frameCache.delete(frameId);
+  }
+
+  /**
+   * Parent/child session emitted a `frameNavigated`.
+   * Topology + ownership update. Handles root swaps.
+   */
+  public onFrameNavigated(
+    frame: Protocol.Page.Frame,
+    session: CDPSessionLike,
+  ): void {
+    const prevRoot = this.mainFrameId();
+    this.registry.onFrameNavigated(frame, session.id ?? "root");
+
+    // If the root changed, keep the convenience wrapper in sync
+    const newRoot = this.mainFrameId();
+    if (newRoot !== prevRoot) {
+      const oldOrd = this.frameOrdinals.get(prevRoot) ?? 0;
+      this.frameOrdinals.set(newRoot, oldOrd);
+      this.mainFrameWrapper = new Frame(
+        this.mainSession,
+        newRoot,
+        this.pageId,
+        this.browserIsRemote,
+      );
+    }
+
+    // Update cached URL if this navigation pertains to the current main frame
+    if (frame.id === this.mainFrameId()) {
+      try {
+        // Prefer frame.url; fallback keeps previous value
+        this._currentUrl = String(
+          (frame as { url?: string })?.url ?? this._currentUrl,
+        );
+      } catch {
+        // ignore
+      }
+    }
+
+    // Invalidate the cached Frame for this id (session may have changed)
+    this.frameCache.delete(frame.id);
+  }
+
+  public onNavigatedWithinDocument(
+    frameId: string,
+    url: string,
+    session: CDPSessionLike,
+  ): void {
+    const normalized = String(url ?? "").trim();
+    if (!normalized) return;
+
+    this.registry.onNavigatedWithinDocument(
+      frameId,
+      normalized,
+      session.id ?? "root",
+    );
+
+    if (frameId === this.mainFrameId()) {
+      this._currentUrl = normalized;
+    }
+  }
+
+  /**
+   * An OOPIF child session whose **main** frame id equals the parent iframe’s frameId
+   * has been attached; adopt the session into this Page and seed ownership for its subtree.
+   */
+  public adoptOopifSession(
+    childSession: CDPSessionLike,
+    childMainFrameId: string,
+  ): void {
+    if (childSession.id) this.sessions.set(childSession.id, childSession);
+
+    this.networkManager.trackSession(childSession);
+    if (this.extraHTTPHeaders)
+      void this.applyExtraHTTPHeadersToSession(
+        childSession,
+        this.extraHTTPHeaders,
+      ).catch(() => {});
+
+    void this.applyInitScriptsToSession(childSession).catch(() => {});
+
+    if (this.consoleListeners.size > 0) {
+      this.installConsoleTap(childSession);
+    }
+
+    // session will start emitting its own page events; mark ownership seed now
+    this.registry.adoptChildSession(
+      childSession.id ?? "child",
+      childMainFrameId,
+    );
+    this.frameCache.delete(childMainFrameId);
+
+    // Bridge events from the child session to keep registry in sync
+    childSession.on<Protocol.Page.FrameNavigatedEvent>(
+      "Page.frameNavigated",
+      (evt) => {
+        this.onFrameNavigated(evt.frame, childSession);
+      },
+    );
+    childSession.on<Protocol.Page.FrameAttachedEvent>(
+      "Page.frameAttached",
+      (evt) => {
+        this.onFrameAttached(
+          evt.frameId,
+          evt.parentFrameId ?? null,
+          childSession,
+        );
+      },
+    );
+    childSession.on<Protocol.Page.FrameDetachedEvent>(
+      "Page.frameDetached",
+      (evt) => {
+        this.onFrameDetached(evt.frameId, evt.reason ?? "remove");
+      },
+    );
+
+    // One-shot seed the child's subtree ownership from its current tree
+    void (async () => {
+      try {
+        await childSession.send("Page.enable").catch(() => {});
+        let { frameTree } =
+          await childSession.send<Protocol.Page.GetFrameTreeResponse>(
+            "Page.getFrameTree",
+          );
+
+        // Normalize: ensure the child’s reported root id matches our known main id
+        if (frameTree.frame.id !== childMainFrameId) {
+          frameTree = {
+            ...frameTree,
+            frame: { ...frameTree.frame, id: childMainFrameId },
+          };
+        }
+
+        this.registry.seedFromFrameTree(childSession.id ?? "child", frameTree);
+      } catch {
+        // If snapshot races, live events will still converge the registry.
+      }
+    })();
+  }
+
+  /** Detach an adopted child session and prune its subtree */
+  public detachOopifSession(sessionId: string): void {
+    // Find which frames were owned by this session and prune by tree starting from each root.
+    for (const fid of this.registry.framesForSession(sessionId)) {
+      this.registry.onFrameDetached(fid, "remove");
+      this.frameCache.delete(fid);
+    }
+    this.teardownConsoleTap(sessionId);
+    this.sessions.delete(sessionId);
+    this.networkManager.untrackSession(sessionId);
+  }
+
+  // ---------------- Ownership helpers / lookups ----------------
+
+  /** Return the owning CDP session for a frameId (falls back to main session) */
+  public getSessionForFrame(frameId: string): CDPSessionLike {
+    const sid = this.registry.getOwnerSessionId(frameId);
+    if (!sid) return this.mainSession;
+    return this.sessions.get(sid) ?? this.mainSession;
+  }
+
+  /** Always returns a Frame bound to the owning session */
+  public frameForId(frameId: string): Frame {
+    const hit = this.frameCache.get(frameId);
+    if (hit) return hit;
+
+    const sess = this.getSessionForFrame(frameId);
+    const f = new Frame(sess, frameId, this.pageId, this.browserIsRemote);
+    this.frameCache.set(frameId, f);
+    return f;
+  }
+
+  /** Expose a session by id (used by snapshot to resolve session id -> session) */
+  public getSessionById(id: string): CDPSessionLike | undefined {
+    return this.sessions.get(id);
+  }
+
+  public registerSessionForNetwork(session: CDPSessionLike): void {
+    this.networkManager.trackSession(session);
+  }
+
+  public unregisterSessionForNetwork(sessionId: string | undefined): void {
+    this.networkManager.untrackSession(sessionId);
+  }
+
+  public on(event: "console", listener: ConsoleListener): Page {
+    if (event !== "console") {
+      throw new StagehandInvalidArgumentError(`Unsupported event: ${event}`);
+    }
+
+    const firstListener = this.consoleListeners.size === 0;
+    this.consoleListeners.add(listener);
+
+    if (firstListener) {
+      this.ensureConsoleTaps();
+    }
+
+    return this;
+  }
+
+  public once(event: "console", listener: ConsoleListener): Page {
+    if (event !== "console") {
+      throw new StagehandInvalidArgumentError(`Unsupported event: ${event}`);
+    }
+
+    const wrapper: ConsoleListener = (message) => {
+      this.off("console", wrapper);
+      listener(message);
+    };
+
+    return this.on("console", wrapper);
+  }
+
+  public off(event: "console", listener: ConsoleListener): Page {
+    if (event !== "console") {
+      throw new StagehandInvalidArgumentError(`Unsupported event: ${event}`);
+    }
+
+    this.consoleListeners.delete(listener);
+
+    if (this.consoleListeners.size === 0) {
+      this.removeAllConsoleTaps();
+    }
+
+    return this;
+  }
+
+  // ---------------- MAIN APIs ----------------
+
+  public targetId(): string {
+    return this._targetId;
+  }
+
+  /**
+   * Send a CDP command through the main session.
+   * Allows external consumers to execute arbitrary Chrome DevTools Protocol commands.
+   *
+   * @param method - The CDP method name (e.g., "Page.enable", "Runtime.evaluate")
+   * @param params - Optional parameters for the CDP command
+   * @returns Promise resolving to the typed CDP response
+   *
+   * @example
+   * // Enable the Runtime domain
+   * await page.sendCDP("Runtime.enable");
+   *
+   * @example
+   * // Evaluate JavaScript with typed response
+   * const result = await page.sendCDP<Protocol.Runtime.EvaluateResponse>(
+   *   "Runtime.evaluate",
+   *   { expression: "1 + 1" }
+   * );
+   */
+  public sendCDP<T = unknown>(method: string, params?: object): Promise<T> {
+    return this.mainSession.send<T>(method, params);
+  }
+
+  /** Seed the cached URL before navigation events converge. */
+  public seedCurrentUrl(url: string | undefined | null): void {
+    if (!url) return;
+    try {
+      const normalized = String(url).trim();
+      if (!normalized) return;
+      this._currentUrl = normalized;
+    } catch {
+      // ignore invalid url seeds
+    }
+  }
+
+  public mainFrameId(): string {
+    return this.registry.mainFrameId();
+  }
+
+  public mainFrame(): Frame {
+    return this.mainFrameWrapper;
+  }
+
+  /**
+   * Close this top-level page (tab). Best-effort via Target.closeTarget.
+   */
+  @logAction("Page.close")
+  public async close(): Promise<void> {
+    try {
+      await this.conn.send("Target.closeTarget", { targetId: this._targetId });
+    } catch {
+      // ignore
+    }
+    const deadline = Date.now() + 2000;
+    while (Date.now() < deadline) {
+      try {
+        const targets = await this.conn.getTargets();
+        if (!targets.some((t) => t.targetId === this._targetId)) {
+          this.networkManager.dispose();
+          return;
+        }
+      } catch {
+        // ignore and retry
+      }
+      await new Promise((r) => setTimeout(r, 25));
+    }
+    this.networkManager.dispose();
+    this.removeAllConsoleTaps();
+    this.consoleListeners.clear();
+  }
+
+  public getFullFrameTree(): Protocol.Page.FrameTree {
+    return this.asProtocolFrameTree(this.mainFrameId());
+  }
+
+  public asProtocolFrameTree(rootMainFrameId: string): Protocol.Page.FrameTree {
+    return this.registry.asProtocolFrameTree(rootMainFrameId);
+  }
+
+  private async applyExtraHTTPHeadersToSession(
+    session: CDPSessionLike,
+    headers: Record<string, string>,
+  ): Promise<void> {
+    await session.send("Network.enable");
+    await session.send("Network.setExtraHTTPHeaders", {
+      headers: headers,
+    });
+  }
+
+  private ensureOrdinal(frameId: string): number {
+    const hit = this.frameOrdinals.get(frameId);
+    if (hit !== undefined) return hit;
+    const ord = this.nextOrdinal++;
+    this.frameOrdinals.set(frameId, ord);
+    return ord;
+  }
+
+  /** Public getter for snapshot code / handlers. */
+  public getOrdinal(frameId: string): number {
+    return this.ensureOrdinal(frameId);
+  }
+
+  public listAllFrameIds(): string[] {
+    return this.registry.listAllFrames();
+  }
+
+  private ensureConsoleTaps(): void {
+    if (this.consoleListeners.size === 0) return;
+
+    this.installConsoleTap(this.mainSession);
+    for (const session of this.sessions.values()) {
+      this.installConsoleTap(session);
+    }
+  }
+
+  private installConsoleTap(session: CDPSessionLike): void {
+    const key = this.sessionKey(session);
+    if (this.consoleHandlers.has(key)) return;
+
+    void session.send("Runtime.enable").catch(() => {});
+
+    const handler = (evt: Protocol.Runtime.ConsoleAPICalledEvent) => {
+      this.emitConsole(evt);
+    };
+
+    session.on<Protocol.Runtime.ConsoleAPICalledEvent>(
+      "Runtime.consoleAPICalled",
+      handler,
+    );
+
+    this.consoleHandlers.set(key, handler);
+  }
+
+  private sessionKey(session: CDPSessionLike): string {
+    return session.id ?? "__root__";
+  }
+
+  private resolveSessionByKey(key: string): CDPSessionLike | undefined {
+    if (this.mainSession.id) {
+      if (this.mainSession.id === key) return this.mainSession;
+    } else if (key === "__root__") {
+      return this.mainSession;
+    }
+
+    return this.sessions.get(key);
+  }
+
+  private teardownConsoleTap(key: string): void {
+    const handler = this.consoleHandlers.get(key);
+    if (!handler) return;
+
+    const session = this.resolveSessionByKey(key);
+    session?.off("Runtime.consoleAPICalled", handler);
+    this.consoleHandlers.delete(key);
+  }
+
+  private removeAllConsoleTaps(): void {
+    for (const key of [...this.consoleHandlers.keys()]) {
+      this.teardownConsoleTap(key);
+    }
+  }
+
+  private emitConsole(evt: Protocol.Runtime.ConsoleAPICalledEvent): void {
+    if (this.consoleListeners.size === 0) return;
+
+    const message = new ConsoleMessage(evt, this);
+    const listeners = [...this.consoleListeners];
+
+    for (const listener of listeners) {
+      try {
+        listener(message);
+      } catch (error) {
+        v3Logger({
+          category: "page",
+          message: "Console listener threw",
+          level: 2,
+          auxiliary: {
+            error: { value: String(error), type: "string" },
+            type: { value: evt.type, type: "string" },
+          },
+        });
+      }
+    }
+  }
+
+  // -------- Convenience APIs delegated to the current main frame --------
+
+  /**
+   * Navigate the page; optionally wait for a lifecycle state.
+   * Waits on the **current** main frame and follows root swaps during navigation.
+   */
+  @logAction("Page.goto")
+  async goto(
+    url: string,
+    options?: { waitUntil?: LoadState; timeoutMs?: number },
+  ): Promise<Response | null> {
+    const waitUntil: LoadState = options?.waitUntil ?? "domcontentloaded";
+    const timeout = options?.timeoutMs ?? 15000;
+
+    const navigationCommandId = this.beginNavigationCommand();
+    const tracker = new NavigationResponseTracker({
+      page: this,
+      session: this.mainSession,
+      navigationCommandId,
+    });
+
+    const watcher = new LifecycleWatcher({
+      page: this,
+      mainSession: this.mainSession,
+      networkManager: this.networkManager,
+      waitUntil,
+      timeoutMs: timeout,
+      navigationCommandId,
+    });
+
+    try {
+      // Route to API if available
+      if (this.apiClient) {
+        const result = await this.apiClient.goto(
+          url,
+          { waitUntil: options?.waitUntil },
+          this.mainFrameId(),
+        );
+        this._currentUrl = url;
+
+        if (isSerializableResponse(result)) {
+          return Response.fromSerializable(result, {
+            page: this,
+            session: this.mainSession,
+          });
+        }
+        return result;
+      }
+      const response =
+        await this.mainSession.send<Protocol.Page.NavigateResponse>(
+          "Page.navigate",
+          { url },
+        );
+      this._currentUrl = url;
+      if (response?.loaderId) {
+        watcher.setExpectedLoaderId(response.loaderId);
+        tracker.setExpectedLoaderId(response.loaderId);
+      }
+      await watcher.wait();
+      return await tracker.navigationCompleted();
+    } finally {
+      watcher.dispose();
+      tracker.dispose();
+    }
+  }
+
+  /**
+   * Reload the page; optionally wait for a lifecycle state.
+   */
+  @logAction("Page.reload")
+  async reload(options?: {
+    waitUntil?: LoadState;
+    timeoutMs?: number;
+    ignoreCache?: boolean;
+  }): Promise<Response | null> {
+    const waitUntil = options?.waitUntil;
+    const timeout = options?.timeoutMs ?? 15000;
+
+    const navigationCommandId = this.beginNavigationCommand();
+
+    const tracker = new NavigationResponseTracker({
+      page: this,
+      session: this.mainSession,
+      navigationCommandId,
+    });
+    tracker.expectNavigationWithoutKnownLoader();
+
+    const watcher = waitUntil
+      ? new LifecycleWatcher({
+          page: this,
+          mainSession: this.mainSession,
+          networkManager: this.networkManager,
+          waitUntil,
+          timeoutMs: timeout,
+          navigationCommandId,
+        })
+      : null;
+
+    try {
+      await this.mainSession.send("Page.reload", {
+        ignoreCache: options?.ignoreCache ?? false,
+      });
+
+      if (watcher) {
+        await watcher.wait();
+      }
+      return await tracker.navigationCompleted();
+    } finally {
+      watcher?.dispose();
+      tracker.dispose();
+    }
+  }
+
+  /**
+   * Navigate back in history if possible; optionally wait for a lifecycle state.
+   */
+  @logAction("Page.goBack")
+  async goBack(options?: {
+    waitUntil?: LoadState;
+    timeoutMs?: number;
+  }): Promise<Response | null> {
+    const { entries, currentIndex } =
+      await this.mainSession.send<Protocol.Page.GetNavigationHistoryResponse>(
+        "Page.getNavigationHistory",
+      );
+    const prev = entries[currentIndex - 1];
+    if (!prev) return null; // nothing to do
+    const waitUntil = options?.waitUntil;
+    const timeout = options?.timeoutMs ?? 15000;
+
+    const navigationCommandId = this.beginNavigationCommand();
+
+    const tracker = new NavigationResponseTracker({
+      page: this,
+      session: this.mainSession,
+      navigationCommandId,
+    });
+    tracker.expectNavigationWithoutKnownLoader();
+
+    const watcher = waitUntil
+      ? new LifecycleWatcher({
+          page: this,
+          mainSession: this.mainSession,
+          networkManager: this.networkManager,
+          waitUntil,
+          timeoutMs: timeout,
+          navigationCommandId,
+        })
+      : null;
+
+    try {
+      await this.mainSession.send("Page.navigateToHistoryEntry", {
+        entryId: prev.id,
+      });
+      this._currentUrl = prev.url ?? this._currentUrl;
+
+      if (watcher) {
+        await watcher.wait();
+      }
+      return await tracker.navigationCompleted();
+    } finally {
+      watcher?.dispose();
+      tracker.dispose();
+    }
+  }
+
+  /**
+   * Navigate forward in history if possible; optionally wait for a lifecycle state.
+   */
+  @logAction("Page.goForward")
+  async goForward(options?: {
+    waitUntil?: LoadState;
+    timeoutMs?: number;
+  }): Promise<Response | null> {
+    const { entries, currentIndex } =
+      await this.mainSession.send<Protocol.Page.GetNavigationHistoryResponse>(
+        "Page.getNavigationHistory",
+      );
+    const next = entries[currentIndex + 1];
+    if (!next) return null; // nothing to do
+    const waitUntil = options?.waitUntil;
+    const timeout = options?.timeoutMs ?? 15000;
+
+    const navigationCommandId = this.beginNavigationCommand();
+
+    const tracker = new NavigationResponseTracker({
+      page: this,
+      session: this.mainSession,
+      navigationCommandId,
+    });
+    tracker.expectNavigationWithoutKnownLoader();
+
+    const watcher = waitUntil
+      ? new LifecycleWatcher({
+          page: this,
+          mainSession: this.mainSession,
+          networkManager: this.networkManager,
+          waitUntil,
+          timeoutMs: timeout,
+          navigationCommandId,
+        })
+      : null;
+
+    try {
+      await this.mainSession.send("Page.navigateToHistoryEntry", {
+        entryId: next.id,
+      });
+      this._currentUrl = next.url ?? this._currentUrl;
+
+      if (watcher) {
+        await watcher.wait();
+      }
+      return await tracker.navigationCompleted();
+    } finally {
+      watcher?.dispose();
+      tracker.dispose();
+    }
+  }
+
+  /**
+   * Return the current page URL (synchronous, cached from navigation events).
+   */
+  url(): string {
+    return this._currentUrl;
+  }
+
+  private beginNavigationCommand(): number {
+    const id = ++this.navigationCommandSeq;
+    this.latestNavigationCommandId = id;
+    return id;
+  }
+
+  public isCurrentNavigationCommand(id: number): boolean {
+    return this.latestNavigationCommandId === id;
+  }
+
+  /**
+   * Return the current page title.
+   * Prefers reading from the active document via Runtime.evaluate to reflect dynamic changes.
+   * Falls back to navigation history title if evaluation is unavailable.
+   */
+  async title(): Promise<string> {
+    try {
+      await this.mainSession.send("Runtime.enable").catch(() => {});
+      const ctxId = await this.mainWorldExecutionContextId();
+      const { result } =
+        await this.mainSession.send<Protocol.Runtime.EvaluateResponse>(
+          "Runtime.evaluate",
+          {
+            expression: "document.title",
+            contextId: ctxId,
+            returnByValue: true,
+          },
+        );
+      return String(result?.value ?? "");
+    } catch {
+      // Fallback: use navigation history entry title
+      try {
+        const { entries, currentIndex } =
+          await this.mainSession.send<Protocol.Page.GetNavigationHistoryResponse>(
+            "Page.getNavigationHistory",
+          );
+        return entries[currentIndex]?.title ?? "";
+      } catch {
+        return "";
+      }
+    }
+  }
+
+  /**
+   * Capture a screenshot with Playwright-style options.
+   *
+   * @param options Optional screenshot configuration.
+   * @param options.animations Control CSS/Web animations during capture. Use
+   * "disabled" to fast-forward finite animations and pause infinite ones.
+   * @param options.caret Either hide the text caret (default) or leave it
+   * visible via "initial".
+   * @param options.clip Restrict capture to a specific rectangle (in CSS
+   * pixels). Cannot be combined with `fullPage`.
+   * @param options.fullPage Capture the full scrollable page instead of the
+   * current viewport.
+   * @param options.mask Array of locators that should be covered with an
+   * overlay while the screenshot is taken.
+   * @param options.maskColor CSS color used for the mask overlay (default
+   * `#FF00FF`).
+   * @param options.omitBackground Make the default page background transparent
+   * (PNG only).
+   * @param options.path File path to write the screenshot to. The file extension
+   * determines the image type when `type` is not explicitly provided.
+   * @param options.quality JPEG quality (0–100). Only applies when
+   * `type === "jpeg"`.
+   * @param options.scale Render scale: use "css" for one pixel per CSS pixel,
+   * otherwise the default "device" leverages the current device pixel ratio.
+   * @param options.style Additional CSS text injected into every frame before
+   * capture (removed afterwards).
+   * @param options.timeout Maximum capture duration in milliseconds before a
+   * timeout error is thrown.
+   * @param options.type Image format (`"png"` by default).
+   */
+  @logAction("Page.screenshot")
+  async screenshot(options?: ScreenshotOptions): Promise<Buffer> {
+    const opts = options ?? {};
+    const type = opts.type ?? "png";
+
+    if (type !== "png" && type !== "jpeg") {
+      throw new StagehandInvalidArgumentError(
+        `screenshot: unsupported image type "${type}"`,
+      );
+    }
+
+    if (opts.fullPage && opts.clip) {
+      throw new StagehandInvalidArgumentError(
+        "screenshot: clip and fullPage cannot be used together",
+      );
+    }
+
+    if (type === "png" && typeof opts.quality === "number") {
+      throw new StagehandInvalidArgumentError(
+        'screenshot: quality option is only valid for type="jpeg"',
+      );
+    }
+
+    const caretMode: ScreenshotCaretOption = opts.caret ?? "hide";
+    const animationsMode: ScreenshotAnimationsOption =
+      opts.animations ?? "allow";
+    const scaleMode: ScreenshotScaleOption = opts.scale ?? "device";
+    const frames = collectFramesForScreenshot(this);
+    const clip = opts.clip ? normalizeScreenshotClip(opts.clip) : undefined;
+    const captureScale = await computeScreenshotScale(this, scaleMode);
+    const maskLocators = (opts.mask ?? []).filter(
+      (locator): locator is Locator => Boolean(locator),
+    );
+
+    const cleanupTasks: ScreenshotCleanup[] = [];
+
+    const exec = async (): Promise<Buffer> => {
+      try {
+        if (opts.omitBackground) {
+          cleanupTasks.push(await setTransparentBackground(this.mainSession));
+        }
+
+        if (animationsMode === "disabled") {
+          cleanupTasks.push(await disableAnimations(frames));
+        }
+
+        if (caretMode === "hide") {
+          cleanupTasks.push(await hideCaret(frames));
+        }
+
+        if (opts.style && opts.style.trim()) {
+          cleanupTasks.push(
+            await applyStyleToFrames(frames, opts.style, "custom"),
+          );
+        }
+
+        if (maskLocators.length > 0) {
+          cleanupTasks.push(
+            await applyMaskOverlays(maskLocators, opts.maskColor ?? "#FF00FF"),
+          );
+        }
+
+        const buffer = await this.mainFrameWrapper.screenshot({
+          fullPage: opts.fullPage,
+          clip,
+          type,
+          quality: type === "jpeg" ? opts.quality : undefined,
+          scale: captureScale,
+        });
+
+        if (opts.path) {
+          await fs.writeFile(opts.path, buffer);
+        }
+
+        return buffer;
+      } finally {
+        await runScreenshotCleanups(cleanupTasks);
+      }
+    };
+
+    return await withTimeout(exec(), opts.timeout, "screenshot");
+  }
+
+  /**
+   * specifies additional HTTP headers to be included in every request sent by
+   * the root CDP session of the page, and all of its child CDP sessions.
+   *
+   * @param headers - the headers to be set.
+   * @throws {StagehandSetExtraHTTPHeadersError}
+   * Thrown when one or more CDP sessions fail to enable the Network domain or fail
+   * to apply the headers (i.e. `Network.enable` and/or `Network.setExtraHTTPHeaders` rejects).
+   * @return void
+   */
+  async setExtraHTTPHeaders(headers: Record<string, string>): Promise<void> {
+    const headersToSet = { ...headers };
+    this.extraHTTPHeaders = headersToSet;
+
+    // get the session(s) for this page:
+    const sessions: CDPSessionLike[] = [this.mainSession];
+    for (const session of this.sessions.values()) {
+      if (session === this.mainSession) continue;
+      sessions.push(session);
+    }
+
+    const results = await Promise.allSettled(
+      sessions.map(async (session) => {
+        await this.applyExtraHTTPHeadersToSession(session, headersToSet);
+      }),
+    );
+
+    // get list of objects containing results & corresponding session IDs
+    const pairs = results.map((result, index) => ({
+      result,
+      id: sessions[index].id,
+    }));
+
+    const filtered = pairs.filter(
+      (pair): pair is { result: PromiseRejectedResult; id: string | null } =>
+        pair.result.status === "rejected",
+    );
+
+    const errors = filtered.map((pair) => {
+      const reason = pair.result.reason;
+      const sessId = pair.id ?? "root";
+      const message = reason?.message ?? String(reason);
+      return `session=${sessId} error=${message}`;
+    });
+
+    if (errors.length > 0) {
+      throw new StagehandSetExtraHTTPHeadersError(errors);
+    }
+  }
+
+  /**
+   * Create a locator bound to the current main frame.
+   */
+  locator(selector: string): ReturnType<Frame["locator"]> {
+    return this.mainFrameWrapper.locator(selector);
+  }
+
+  /**
+   * Deep locator that supports cross-iframe traversal.
+   * - Recognizes '>>' hop notation to enter iframe contexts.
+   * - Supports deep XPath that includes iframe steps (e.g., '/html/body/iframe[2]//div').
+   * Returns a Locator scoped to the appropriate frame.
+   */
+  deepLocator(selector: string) {
+    return deepLocatorFromPage(this, this.mainFrameWrapper, selector);
+  }
+
+  /**
+   * Frame locator similar to Playwright: targets iframe elements and scopes
+   * subsequent locators to that frame. Supports chaining.
+   */
+  frameLocator(selector: string): FrameLocator {
+    return new FrameLocator(this, selector);
+  }
+
+  /**
+   * List all frames belonging to this page as Frame objects bound to their owning sessions.
+   * The list is ordered by a stable ordinal assigned during the page lifetime.
+   */
+  frames(): Frame[] {
+    const ids = this.listAllFrameIds();
+    const withOrd = ids.map((id) => ({ id, ord: this.getOrdinal(id) }));
+    withOrd.sort((a, b) => a.ord - b.ord);
+    return withOrd.map(({ id }) => this.frameForId(id));
+  }
+
+  /**
+   * Wait until the page reaches a lifecycle state on the current main frame.
+   * Mirrors Playwright's API signatures.
+   */
+  @logAction("Page.waitForLoadState")
+  async waitForLoadState(state: LoadState, timeoutMs?: number): Promise<void> {
+    await this.waitForMainLoadState(state, timeoutMs ?? 15000);
+  }
+
+  /**
+   * Wait for a specified amount of time.
+   *
+   * @param ms The number of milliseconds to wait.
+   */
+  async waitForTimeout(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Wait for an element matching the selector to appear in the DOM.
+   * Uses MutationObserver for efficiency
+   * Pierces shadow DOM by default.
+   * Supports iframe hop notation with '>>' (e.g., 'iframe#checkout >> .submit-btn').
+   *
+   * @param selector CSS selector to wait for (supports '>>' for iframe hops)
+   * @param options
+   * @param options.state Element state to wait for: 'attached' | 'detached' | 'visible' | 'hidden' (default: 'visible')
+   * @param options.timeout Maximum time to wait in milliseconds (default: 30000)
+   * @param options.pierceShadow Whether to search inside shadow DOM (default: true)
+   * @returns True when the condition is met
+   * @throws Error if timeout is reached before the condition is met
+   */
+  @logAction("Page.waitForSelector")
+  async waitForSelector(
+    selector: string,
+    options?: {
+      state?: "attached" | "detached" | "visible" | "hidden";
+      timeout?: number;
+      pierceShadow?: boolean;
+    },
+  ): Promise<boolean> {
+    const timeout = options?.timeout ?? 30000;
+    const state = options?.state ?? "visible";
+    const pierceShadow = options?.pierceShadow ?? true;
+    const startTime = Date.now();
+    const root = this.mainFrameWrapper;
+    const { frame: targetFrame, selector: finalSelector } =
+      await resolveLocatorTarget(this, root, selector);
+    const elapsed = Date.now() - startTime;
+    const remainingTimeout = Math.max(0, timeout - elapsed);
+
+    const expression = buildLocatorInvocation("waitForSelector", [
+      JSON.stringify(finalSelector),
+      JSON.stringify(state),
+      String(remainingTimeout),
+      String(pierceShadow),
+    ]);
+    return targetFrame.evaluate(expression);
+  }
+
+  /**
+   * Evaluate a function or expression in the current main frame's main world.
+   * - If a string is provided, it is treated as a JS expression.
+   * - If a function is provided, it is stringified and invoked with the optional argument.
+   * - The return value should be JSON-serializable. Non-serializable objects will
+   *   best-effort serialize via JSON.stringify inside the page context.
+   */
+  @logAction("Page.evaluate")
+  async evaluate<R = unknown, Arg = unknown>(
+    pageFunctionOrExpression: string | ((arg: Arg) => R | Promise<R>),
+    arg?: Arg,
+  ): Promise<R> {
+    await this.mainSession.send("Runtime.enable").catch(() => {});
+    const ctxId = await this.mainWorldExecutionContextId();
+
+    const isString = typeof pageFunctionOrExpression === "string";
+    let expression: string;
+
+    if (isString) {
+      expression = String(pageFunctionOrExpression);
+    } else {
+      const fnSrc = pageFunctionOrExpression.toString();
+      const argJson = JSON.stringify(arg);
+      expression = `(() => {
+          const __fn = ${fnSrc};
+          const __arg = ${argJson};
+          try {
+            const __res = __fn(__arg);
+            return Promise.resolve(__res).then(v => {
+              try { return JSON.parse(JSON.stringify(v)); } catch { return v; }
+            });
+          } catch (e) { throw e; }
+        })()`;
+    }
+
+    const { result, exceptionDetails } =
+      await this.mainSession.send<Protocol.Runtime.EvaluateResponse>(
+        "Runtime.evaluate",
+        {
+          expression,
+          contextId: ctxId,
+          returnByValue: true,
+          awaitPromise: true,
+        },
+      );
+
+    if (exceptionDetails) {
+      const msg =
+        exceptionDetails.text ||
+        exceptionDetails.exception?.description ||
+        "Evaluation failed";
+      throw new StagehandEvalError(msg);
+    }
+
+    return result?.value as R;
+  }
+
+  /**
+   * Force the page viewport to an exact CSS size and device scale factor.
+   * Ensures screenshots match width x height pixels when deviceScaleFactor = 1.
+   */
+  // @logAction("Page.setViewportSize")  // disabled because it's pretty noisy, can always re-enable if needed for debugging
+  async setViewportSize(
+    width: number,
+    height: number,
+    options?: { deviceScaleFactor?: number },
+  ): Promise<void> {
+    const dsf = Math.max(0.01, options?.deviceScaleFactor ?? 1);
+    await this.mainSession
+      .send("Emulation.setDeviceMetricsOverride", {
+        width,
+        height,
+        deviceScaleFactor: dsf,
+        mobile: false,
+        screenWidth: width,
+        screenHeight: height,
+        positionX: 0,
+        positionY: 0,
+        scale: 1,
+      } as Protocol.Emulation.SetDeviceMetricsOverrideRequest)
+      .catch(() => {});
+
+    // Best-effort ensure visible size in headless
+    await this.mainSession
+      .send("Emulation.setVisibleSize", { width, height })
+      .catch(() => {});
+  }
+
+  /**
+   * Click at absolute page coordinates (CSS pixels).
+   * Dispatches mouseMoved → mousePressed → mouseReleased via CDP Input domain
+   * on the top-level page target's session. Coordinates are relative to the
+   * viewport origin (top-left). Does not scroll.
+   */
+  @logAction("Page.click")
+  async click(
+    x: number,
+    y: number,
+    options?: {
+      button?: "left" | "right" | "middle";
+      clickCount?: number;
+      returnXpath?: boolean;
+    },
+  ): Promise<string> {
+    const button = options?.button ?? "left";
+    const clickCount = options?.clickCount ?? 1;
+
+    let xpathResult: string | undefined;
+    if (options?.returnXpath) {
+      // Resolve the deepest node at the given coordinates and compute absolute XPath efficiently
+      try {
+        const hit = await resolveXpathForLocation(this, x, y);
+        if (hit) {
+          v3Logger({
+            category: "page",
+            message: "click resolved hit",
+            level: 2,
+            auxiliary: {
+              frameId: { value: String(hit.frameId), type: "string" },
+              backendNodeId: {
+                value: String(hit.backendNodeId),
+                type: "string",
+              },
+              x: { value: String(x), type: "integer" },
+              y: { value: String(y), type: "integer" },
+            },
+          });
+          xpathResult = hit.absoluteXPath;
+          v3Logger({
+            category: "page",
+            message: `click resolved xpath`,
+            level: 2,
+            auxiliary: {
+              xpath: { value: String(xpathResult ?? ""), type: "string" },
+            },
+          });
+        }
+      } catch {
+        // best-effort; fall through if any step fails
+      }
+    }
+
+    // Synthesize a simple mouse move + press + release sequence.
+    await this.updateCursor(x, y);
+    // Dispatch click events in a pipelined burst to reduce inter-click delay
+    // from network/CPU jitter between round trips.
+    const dispatches: Array<Promise<unknown>> = [];
+    dispatches.push(
+      this.mainSession.send<never>("Input.dispatchMouseEvent", {
+        type: "mouseMoved",
+        x,
+        y,
+        button: "none",
+      } as Protocol.Input.DispatchMouseEventRequest),
+    );
+
+    for (let i = 1; i <= clickCount; i++) {
+      dispatches.push(
+        this.mainSession.send<never>("Input.dispatchMouseEvent", {
+          type: "mousePressed",
+          x,
+          y,
+          button,
+          clickCount: i,
+        } as Protocol.Input.DispatchMouseEventRequest),
+      );
+      dispatches.push(
+        this.mainSession.send<never>("Input.dispatchMouseEvent", {
+          type: "mouseReleased",
+          x,
+          y,
+          button,
+          clickCount: i,
+        } as Protocol.Input.DispatchMouseEventRequest),
+      );
+    }
+    await Promise.all(dispatches);
+
+    return xpathResult ?? "";
+  }
+
+  /**
+   * Hover at absolute page coordinates (CSS pixels).
+   * Dispatches mouseMoved via CDP Input domain on the top-level page target's
+   * session.
+   */
+  @logAction("Page.hover")
+  async hover(
+    x: number,
+    y: number,
+    options?: { returnXpath?: boolean },
+  ): Promise<string> {
+    let xpathResult: string | undefined;
+    if (options?.returnXpath) {
+      try {
+        const hit = await resolveXpathForLocation(this, x, y);
+        if (hit) {
+          v3Logger({
+            category: "page",
+            message: "hover resolved hit",
+            level: 2,
+            auxiliary: {
+              frameId: { value: String(hit.frameId), type: "string" },
+              backendNodeId: {
+                value: String(hit.backendNodeId),
+                type: "string",
+              },
+              x: { value: String(x), type: "integer" },
+              y: { value: String(y), type: "integer" },
+            },
+          });
+          xpathResult = hit.absoluteXPath;
+        }
+      } catch {
+        v3Logger({
+          category: "page",
+          message: "Failed to resolve xpath for hover",
+          level: 2,
+          auxiliary: {
+            x: { value: String(x), type: "integer" },
+            y: { value: String(y), type: "integer" },
+          },
+        });
+      }
+    }
+
+    await this.updateCursor(x, y);
+    await this.mainSession.send<never>("Input.dispatchMouseEvent", {
+      type: "mouseMoved",
+      x,
+      y,
+      button: "none",
+    } as Protocol.Input.DispatchMouseEventRequest);
+
+    return xpathResult ?? "";
+  }
+
+  @logAction("Page.scroll")
+  async scroll(
+    x: number,
+    y: number,
+    deltaX: number,
+    deltaY: number,
+    options?: { returnXpath?: boolean },
+  ): Promise<string> {
+    let xpathResult: string | undefined;
+    if (options?.returnXpath) {
+      try {
+        const hit = await resolveXpathForLocation(this, x, y);
+        if (hit) xpathResult = hit.absoluteXPath;
+      } catch {
+        // best-effort
+      }
+    }
+
+    await this.updateCursor(x, y);
+    await this.mainSession.send<never>("Input.dispatchMouseEvent", {
+      type: "mouseMoved",
+      x,
+      y,
+      button: "none",
+    } as Protocol.Input.DispatchMouseEventRequest);
+
+    // Synthesize a simple mouse move + press + release sequence
+    await this.mainSession.send<never>("Input.dispatchMouseEvent", {
+      type: "mouseWheel",
+      x,
+      y,
+      button: "none",
+      deltaX,
+      deltaY,
+    } as Protocol.Input.DispatchMouseEventRequest);
+
+    return xpathResult ?? "";
+  }
+
+  /**
+   * Drag from (fromX, fromY) to (toX, toY) using mouse events.
+   * Sends mouseMoved → mousePressed → mouseMoved (steps) → mouseReleased.
+   */
+  @logAction("Page.dragAndDrop")
+  async dragAndDrop(
+    fromX: number,
+    fromY: number,
+    toX: number,
+    toY: number,
+    options?: {
+      button?: "left" | "right" | "middle";
+      steps?: number;
+      delay?: number;
+      returnXpath?: boolean;
+    },
+  ): Promise<[string, string]> {
+    const button = options?.button ?? "left";
+    const steps = Math.max(1, Math.floor(options?.steps ?? 1));
+    const delay = Math.max(0, options?.delay ?? 0);
+
+    const sleep = (ms: number) =>
+      new Promise<void>((r) => (ms > 0 ? setTimeout(r, ms) : r()));
+
+    const buttonMask = (b: typeof button): number => {
+      switch (b) {
+        case "left":
+          return 1;
+        case "right":
+          return 2;
+        case "middle":
+          return 4;
+        default:
+          return 1;
+      }
+    };
+
+    let fromXpath: string | undefined;
+    let toXpath: string | undefined;
+    if (options?.returnXpath) {
+      try {
+        const start = await resolveXpathForLocation(this, fromX, fromY);
+        if (start) fromXpath = start.absoluteXPath;
+      } catch {
+        //
+      }
+      try {
+        const end = await resolveXpathForLocation(this, toX, toY);
+        if (end) toXpath = end.absoluteXPath;
+      } catch {
+        //
+      }
+    }
+
+    // Move to start
+    await this.updateCursor(fromX, fromY);
+    await this.mainSession.send<never>("Input.dispatchMouseEvent", {
+      type: "mouseMoved",
+      x: fromX,
+      y: fromY,
+      button: "none",
+    } as Protocol.Input.DispatchMouseEventRequest);
+
+    // Press
+    await this.mainSession.send<never>("Input.dispatchMouseEvent", {
+      type: "mousePressed",
+      x: fromX,
+      y: fromY,
+      button,
+      buttons: buttonMask(button),
+      clickCount: 1,
+    } as Protocol.Input.DispatchMouseEventRequest);
+
+    // Intermediate moves
+    for (let i = 1; i <= steps; i++) {
+      const t = i / steps;
+      const x = fromX + (toX - fromX) * t;
+      const y = fromY + (toY - fromY) * t;
+      await this.updateCursor(x, y);
+      await this.mainSession.send<never>("Input.dispatchMouseEvent", {
+        type: "mouseMoved",
+        x,
+        y,
+        button,
+        buttons: buttonMask(button),
+      } as Protocol.Input.DispatchMouseEventRequest);
+      if (delay) await sleep(delay);
+    }
+
+    // Release at end
+    await this.updateCursor(toX, toY);
+    await this.mainSession.send<never>("Input.dispatchMouseEvent", {
+      type: "mouseReleased",
+      x: toX,
+      y: toY,
+      button,
+      buttons: buttonMask(button),
+      clickCount: 1,
+    } as Protocol.Input.DispatchMouseEventRequest);
+
+    return [fromXpath ?? "", toXpath ?? ""];
+  }
+
+  /**
+   * Type a string by dispatching keyDown/keyUp events per character.
+   * Focus must already be on the desired element. Uses CDP Input.dispatchKeyEvent
+   * and never falls back to Input.insertText. Optional delay applies between
+   * successive characters.
+   */
+  @logAction("Page.type")
+  async type(
+    text: string,
+    options?: { delay?: number; withMistakes?: boolean },
+  ): Promise<void> {
+    const delay = Math.max(0, options?.delay ?? 0);
+    const withMistakes = !!options?.withMistakes;
+
+    const sleep = (ms: number) =>
+      new Promise<void>((r) => (ms > 0 ? setTimeout(r, ms) : r()));
+
+    const keyStroke = async (
+      ch: string,
+      override?: {
+        key?: string;
+        code?: string;
+        windowsVirtualKeyCode?: number;
+      },
+    ) => {
+      if (override) {
+        const base: Protocol.Input.DispatchKeyEventRequest = {
+          type: "keyDown",
+          key: override.key,
+          code: override.code,
+          windowsVirtualKeyCode: override.windowsVirtualKeyCode,
+        } as Protocol.Input.DispatchKeyEventRequest;
+        await this.mainSession.send("Input.dispatchKeyEvent", base);
+        await this.mainSession.send("Input.dispatchKeyEvent", {
+          ...base,
+          type: "keyUp",
+        } as Protocol.Input.DispatchKeyEventRequest);
+        return;
+      }
+
+      // Printable character: include key, code, and text for maximum compatibility
+      // Some sites (like Wordle) check event.key rather than relying on text input
+      const isLetter = /^[a-zA-Z]$/.test(ch);
+      const isDigit = /^[0-9]$/.test(ch);
+
+      let key = ch;
+      let code = "";
+      let windowsVirtualKeyCode: number | undefined;
+
+      if (isLetter) {
+        // For letters, key is the character, code is KeyX where X is uppercase
+        key = ch;
+        code = `Key${ch.toUpperCase()}`;
+        windowsVirtualKeyCode = ch.toUpperCase().charCodeAt(0);
+      } else if (isDigit) {
+        key = ch;
+        code = `Digit${ch}`;
+        windowsVirtualKeyCode = ch.charCodeAt(0);
+      } else if (ch === " ") {
+        key = " ";
+        code = "Space";
+        windowsVirtualKeyCode = 32;
+      }
+
+      const down: Protocol.Input.DispatchKeyEventRequest = {
+        type: "keyDown",
+        key,
+        code: code || undefined,
+        text: ch,
+        unmodifiedText: ch,
+        windowsVirtualKeyCode,
+      };
+      await this.mainSession.send("Input.dispatchKeyEvent", down);
+      await this.mainSession.send("Input.dispatchKeyEvent", {
+        type: "keyUp",
+        key,
+        code: code || undefined,
+        windowsVirtualKeyCode,
+      } as Protocol.Input.DispatchKeyEventRequest);
+    };
+
+    const pressBackspace = async () =>
+      keyStroke("\b", {
+        key: "Backspace",
+        code: "Backspace",
+        windowsVirtualKeyCode: 8,
+      });
+
+    const randomPrintable = (avoid: string): string => {
+      const pool =
+        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 .,;:'\"!?@#$%^&*()-_=+[]{}<>/\\|`~";
+      let c = avoid;
+      while (c === avoid) {
+        c = pool[Math.floor(Math.random() * pool.length)];
+      }
+      return c;
+    };
+
+    for (const ch of text) {
+      // Control keys that we explicitly map
+      if (ch === "\n" || ch === "\r") {
+        await keyStroke(ch, {
+          key: "Enter",
+          code: "Enter",
+          windowsVirtualKeyCode: 13,
+        });
+      } else if (ch === "\t") {
+        await keyStroke(ch, {
+          key: "Tab",
+          code: "Tab",
+          windowsVirtualKeyCode: 9,
+        });
+      } else {
+        if (withMistakes && Math.random() < 0.12) {
+          // Type a wrong character, then backspace to correct
+          const wrong = randomPrintable(ch);
+          await keyStroke(wrong);
+          if (delay) await sleep(delay);
+          await pressBackspace();
+          if (delay) await sleep(delay);
+        }
+        await keyStroke(ch);
+      }
+
+      if (delay) await sleep(delay);
+    }
+  }
+
+  /**
+   * Press a single key or key combination (keyDown then keyUp).
+   * For printable characters, uses the text path on keyDown; for named keys, sets key/code/VK.
+   * Supports key combinations with modifiers like "Cmd+A", "Ctrl+C", "Shift+Tab", etc.
+   */
+  @logAction("Page.keyPress")
+  async keyPress(key: string, options?: { delay?: number }): Promise<void> {
+    const delay = Math.max(0, options?.delay ?? 0);
+    const sleep = (ms: number) =>
+      new Promise<void>((r) => (ms > 0 ? setTimeout(r, ms) : r()));
+
+    // Split key combination by + but handle the special case of "+" key itself
+    function split(keyString: string): string[] {
+      // Special case: if the entire string is just "+", return it as-is
+      if (keyString === "+") {
+        return ["+"];
+      }
+
+      const keys: string[] = [];
+      let building = "";
+      for (const char of keyString) {
+        if (char === "+" && building) {
+          keys.push(building);
+          building = "";
+        } else {
+          building += char;
+        }
+      }
+      if (building) {
+        keys.push(building);
+      }
+      return keys;
+    }
+
+    const tokens = split(key);
+    const mainKey = tokens[tokens.length - 1];
+    const modifierKeys = tokens.slice(0, -1);
+
+    try {
+      for (const modKey of modifierKeys) {
+        await this.keyDown(modKey);
+      }
+
+      await this.keyDown(mainKey);
+      if (delay) await sleep(delay);
+      await this.keyUp(mainKey);
+
+      for (let i = modifierKeys.length - 1; i >= 0; i--) {
+        await this.keyUp(modifierKeys[i]);
+      }
+    } catch (error) {
+      // Clear stuck modifiers on error to prevent affecting subsequent keyPress calls
+      this._pressedModifiers.clear();
+      throw error;
+    }
+  }
+
+  @logAction("Page.snapshot")
+  async snapshot(options?: PageSnapshotOptions): Promise<SnapshotResult> {
+    try {
+      const { combinedTree, combinedXpathMap, combinedUrlMap } =
+        await captureHybridSnapshot(this, {
+          pierceShadow: true,
+          includeIframes: options?.includeIframes,
+        });
+
+      return {
+        formattedTree: combinedTree,
+        xpathMap: combinedXpathMap,
+        urlMap: combinedUrlMap,
+      };
+    } catch (err) {
+      throw new StagehandSnapshotError(err);
+    }
+  }
+
+  // Track pressed modifier keys
+  private _pressedModifiers = new Set<string>();
+
+  /** Press a key down without releasing it */
+  private async keyDown(key: string): Promise<void> {
+    const normalizedKey = this.normalizeModifierKey(key);
+
+    const modifierKeys = ["Alt", "Control", "Meta", "Shift"];
+    if (modifierKeys.includes(normalizedKey)) {
+      this._pressedModifiers.add(normalizedKey);
+    }
+
+    let modifiers = 0;
+    if (this._pressedModifiers.has("Alt")) modifiers |= 1;
+    if (this._pressedModifiers.has("Control")) modifiers |= 2;
+    if (this._pressedModifiers.has("Meta")) modifiers |= 4;
+    if (this._pressedModifiers.has("Shift")) modifiers |= 8;
+
+    const named = this.getNamedKeys();
+
+    if (normalizedKey.length === 1) {
+      const hasNonShiftModifier =
+        this._pressedModifiers.has("Alt") ||
+        this._pressedModifiers.has("Control") ||
+        this._pressedModifiers.has("Meta");
+      if (hasNonShiftModifier) {
+        // For accelerators (e.g., Cmd/Ctrl/Alt + key), do not send text. Use rawKeyDown with key/code/VK.
+        const desc = this.describePrintableKey(normalizedKey);
+        const macCommands = this.isMacOS()
+          ? this.macCommandsFor(desc.code ?? "")
+          : [];
+        const req: Protocol.Input.DispatchKeyEventRequest = {
+          type: "rawKeyDown",
+          modifiers,
+          key: desc.key,
+          ...(desc.code ? { code: desc.code } : {}),
+          ...(typeof desc.vk === "number"
+            ? { windowsVirtualKeyCode: desc.vk }
+            : {}),
+          ...(macCommands.length ? { commands: macCommands } : {}),
+        } as Protocol.Input.DispatchKeyEventRequest;
+        await this.mainSession.send("Input.dispatchKeyEvent", req);
+      } else {
+        // Typing path (no non-Shift modifiers): send text to generate input
+        await this.mainSession.send("Input.dispatchKeyEvent", {
+          type: "keyDown",
+          text: normalizedKey,
+          unmodifiedText: normalizedKey,
+          modifiers,
+        } as Protocol.Input.DispatchKeyEventRequest);
+      }
+      return;
+    }
+
+    const entry = named[normalizedKey] ?? null;
+    if (entry) {
+      const macCommands = this.isMacOS() ? this.macCommandsFor(entry.code) : [];
+      const includeText = !!entry.text && modifiers === 0;
+      const keyDown: Protocol.Input.DispatchKeyEventRequest = {
+        type: includeText ? "keyDown" : "rawKeyDown",
+        key: entry.key,
+        code: entry.code,
+        windowsVirtualKeyCode: entry.vk,
+        modifiers,
+        ...(includeText
+          ? {
+              text: entry.text,
+              unmodifiedText: entry.unmodifiedText ?? entry.text,
+            }
+          : {}),
+        ...(macCommands.length ? { commands: macCommands } : {}),
+      } as Protocol.Input.DispatchKeyEventRequest;
+      await this.mainSession.send("Input.dispatchKeyEvent", keyDown);
+      return;
+    }
+
+    // Fallback: send with key property only
+    await this.mainSession.send("Input.dispatchKeyEvent", {
+      type: "keyDown",
+      key: normalizedKey,
+      modifiers,
+    } as Protocol.Input.DispatchKeyEventRequest);
+  }
+
+  /** Release a pressed key */
+  private async keyUp(key: string): Promise<void> {
+    const normalizedKey = this.normalizeModifierKey(key);
+
+    let modifiers = 0;
+    if (this._pressedModifiers.has("Alt")) modifiers |= 1;
+    if (this._pressedModifiers.has("Control")) modifiers |= 2;
+    if (this._pressedModifiers.has("Meta")) modifiers |= 4;
+    if (this._pressedModifiers.has("Shift")) modifiers |= 8;
+
+    const modifierKeys = ["Alt", "Control", "Meta", "Shift"];
+    if (modifierKeys.includes(normalizedKey)) {
+      this._pressedModifiers.delete(normalizedKey);
+    }
+
+    const named = this.getNamedKeys();
+
+    if (normalizedKey.length === 1) {
+      const desc = this.describePrintableKey(normalizedKey);
+      await this.mainSession.send("Input.dispatchKeyEvent", {
+        type: "keyUp",
+        key: desc.key,
+        code: desc.code,
+        windowsVirtualKeyCode:
+          typeof desc.vk === "number" ? desc.vk : undefined,
+        modifiers,
+      } as Protocol.Input.DispatchKeyEventRequest);
+      return;
+    }
+
+    const entry = named[normalizedKey] ?? null;
+    if (entry) {
+      await this.mainSession.send("Input.dispatchKeyEvent", {
+        type: "keyUp",
+        key: entry.key,
+        code: entry.code,
+        windowsVirtualKeyCode: entry.vk,
+        modifiers,
+      } as Protocol.Input.DispatchKeyEventRequest);
+      return;
+    }
+
+    // Fallback: send with key property only
+    await this.mainSession.send("Input.dispatchKeyEvent", {
+      type: "keyUp",
+      key: normalizedKey,
+      modifiers,
+    } as Protocol.Input.DispatchKeyEventRequest);
+  }
+
+  /** Normalize key names to match CDP expectations */
+  private normalizeModifierKey(key: string): string {
+    const lower = key.toLowerCase();
+    switch (lower) {
+      // Modifier keys
+      case "cmd":
+      case "command":
+      case "controlormeta":
+        // On Mac, Cmd is Meta; elsewhere map to Control for common shortcuts
+        return this.isMacOS() ? "Meta" : "Control";
+      case "win":
+      case "windows":
+        return "Meta";
+      case "ctrl":
+      case "control":
+        return "Control";
+      case "option":
+      case "alt":
+        return "Alt";
+      case "shift":
+        return "Shift";
+      case "meta":
+        return "Meta";
+      // Action keys
+      case "enter":
+      case "return":
+        return "Enter";
+      case "esc":
+      case "escape":
+        return "Escape";
+      case "backspace":
+        return "Backspace";
+      case "tab":
+        return "Tab";
+      case "space":
+      case "spacebar":
+        return " ";
+      case "delete":
+      case "del":
+        return "Delete";
+      // Arrow keys
+      case "left":
+      case "arrowleft":
+        return "ArrowLeft";
+      case "right":
+      case "arrowright":
+        return "ArrowRight";
+      case "up":
+      case "arrowup":
+        return "ArrowUp";
+      case "down":
+      case "arrowdown":
+        return "ArrowDown";
+      // Navigation keys
+      case "home":
+        return "Home";
+      case "end":
+        return "End";
+      case "pageup":
+      case "pgup":
+        return "PageUp";
+      case "pagedown":
+      case "pgdn":
+        return "PageDown";
+      default:
+        return key;
+    }
+  }
+
+  /**
+   * Get the map of named keys with their properties
+   */
+  private getNamedKeys(): Record<
+    string,
+    {
+      key: string;
+      code: string;
+      vk: number;
+      text?: string;
+      unmodifiedText?: string;
+    }
+  > {
+    return {
+      Enter: {
+        key: "Enter",
+        code: "Enter",
+        vk: 13,
+        text: "\r",
+        unmodifiedText: "\r",
+      },
+      Tab: { key: "Tab", code: "Tab", vk: 9 },
+      Backspace: { key: "Backspace", code: "Backspace", vk: 8 },
+      Escape: { key: "Escape", code: "Escape", vk: 27 },
+      Delete: { key: "Delete", code: "Delete", vk: 46 },
+      ArrowLeft: { key: "ArrowLeft", code: "ArrowLeft", vk: 37 },
+      ArrowUp: { key: "ArrowUp", code: "ArrowUp", vk: 38 },
+      ArrowRight: { key: "ArrowRight", code: "ArrowRight", vk: 39 },
+      ArrowDown: { key: "ArrowDown", code: "ArrowDown", vk: 40 },
+      Home: { key: "Home", code: "Home", vk: 36 },
+      End: { key: "End", code: "End", vk: 35 },
+      PageUp: { key: "PageUp", code: "PageUp", vk: 33 },
+      PageDown: { key: "PageDown", code: "PageDown", vk: 34 },
+      // Modifier keys
+      Alt: { key: "Alt", code: "AltLeft", vk: 18 },
+      Control: { key: "Control", code: "ControlLeft", vk: 17 },
+      Meta: { key: "Meta", code: "MetaLeft", vk: 91 },
+      Shift: { key: "Shift", code: "ShiftLeft", vk: 16 },
+    };
+  }
+
+  /**
+   * Minimal description for printable keys (letters/digits/space) to provide code and VK.
+   * Used when non-Shift modifiers are pressed to avoid sending text while keeping accelerator info.
+   */
+  private describePrintableKey(ch: string): {
+    key: string;
+    code?: string;
+    vk?: number;
+  } {
+    const shiftDown = this._pressedModifiers.has("Shift");
+    const isLetter = /^[a-zA-Z]$/.test(ch);
+    const isDigit = /^[0-9]$/.test(ch);
+
+    if (isLetter) {
+      const upper = ch.toUpperCase();
+      return {
+        key: shiftDown ? upper : upper.toLowerCase(),
+        code: `Key${upper}`,
+        vk: upper.charCodeAt(0), // 'A'..'Z' => 65..90
+      };
+    }
+
+    if (isDigit) {
+      return {
+        key: ch,
+        code: `Digit${ch}`,
+        vk: ch.charCodeAt(0), // '0'..'9' => 48..57
+      };
+    }
+
+    if (ch === " ") {
+      return { key: " ", code: "Space", vk: 32 };
+    }
+
+    // Fallback: just return the character as-is; VK best-effort from ASCII
+    return {
+      key: shiftDown ? ch.toUpperCase() : ch,
+      vk: ch.toUpperCase().charCodeAt(0),
+    };
+  }
+
+  private isMacOS(): boolean {
+    try {
+      return process.platform === "darwin";
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Return Chromium mac editing commands (without trailing ':') for a given code like 'KeyA'
+   * Only used on macOS to trigger system editing shortcuts (e.g., selectAll, copy, paste...).
+   */
+  private macCommandsFor(code: string): string[] {
+    if (!this.isMacOS()) return [];
+    const parts: string[] = [];
+    if (this._pressedModifiers.has("Shift")) parts.push("Shift");
+    if (this._pressedModifiers.has("Control")) parts.push("Control");
+    if (this._pressedModifiers.has("Alt")) parts.push("Alt");
+    if (this._pressedModifiers.has("Meta")) parts.push("Meta");
+    parts.push(code);
+    const shortcut = parts.join("+");
+    const table: Record<string, string | string[]> = {
+      "Meta+KeyA": "selectAll:",
+      "Meta+KeyC": "copy:",
+      "Meta+KeyX": "cut:",
+      "Meta+KeyV": "paste:",
+      "Meta+KeyZ": "undo:",
+    };
+    const value = table[shortcut];
+    if (!value) return [];
+    const list = Array.isArray(value) ? value : [value];
+    return list
+      .filter((c) => !c.startsWith("insert"))
+      .map((c) => c.substring(0, c.length - 1));
+  }
+
+  // ---- Page-level lifecycle waiter that follows main frame id swaps ----
+
+  /** Resolve the main-world execution context for the current main frame. */
+  private async mainWorldExecutionContextId(): Promise<number> {
+    return executionContexts.waitForMainWorld(
+      this.mainSession,
+      this.mainFrameId(),
+      1000,
+    );
+  }
+
+  private async isMainLoadStateReady(
+    state: "domcontentloaded" | "load",
+  ): Promise<boolean> {
+    try {
+      const ctxId = await this.mainWorldExecutionContextId();
+      const { result } =
+        await this.mainSession.send<Protocol.Runtime.EvaluateResponse>(
+          "Runtime.evaluate",
+          {
+            expression: "document.readyState",
+            contextId: ctxId,
+            returnByValue: true,
+          },
+        );
+      const readyState = String(result?.value ?? "");
+      if (state === "domcontentloaded") {
+        return readyState === "interactive" || readyState === "complete";
+      }
+      return readyState === "complete";
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Wait until the **current** main frame reaches a lifecycle state.
+   * - Fast path via `document.readyState`.
+   * - Event path listens at the session level and compares incoming `frameId`
+   *   to `mainFrameId()` **at event time** to follow root swaps.
+   */
+  async waitForMainLoadState(
+    state: LoadState,
+    timeoutMs = 15000,
+  ): Promise<void> {
+    await this.mainSession
+      .send("Page.setLifecycleEventsEnabled", { enabled: true })
+      .catch(() => {});
+
+    // Fast path: check the *current* main frame's readyState.
+    if (
+      (state === "domcontentloaded" || state === "load") &&
+      (await this.isMainLoadStateReady(state))
+    ) {
+      return;
+    }
+
+    const wanted = LIFECYCLE_NAME[state];
+    return new Promise<void>((resolve, reject) => {
+      let done = false;
+      let timer: ReturnType<typeof setTimeout> | null = null;
+      let pollTimer: ReturnType<typeof setTimeout> | null = null;
+      let pollInFlight = false;
+
+      const off = () => {
+        this.mainSession.off("Page.lifecycleEvent", onLifecycle);
+        this.mainSession.off("Page.domContentEventFired", onDomContent);
+        this.mainSession.off("Page.loadEventFired", onLoad);
+      };
+      const clearPollTimer = () => {
+        if (pollTimer) {
+          clearTimeout(pollTimer);
+          pollTimer = null;
+        }
+      };
+
+      const finish = () => {
+        if (done) return;
+        done = true;
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        clearPollTimer();
+        off();
+        resolve();
+      };
+
+      const onLifecycle = (evt: Protocol.Page.LifecycleEventEvent) => {
+        if (evt.name !== wanted) return;
+        // Compare against the *current* main frame id when the event arrives.
+        if (evt.frameId === this.mainFrameId()) finish();
+      };
+
+      const onDomContent = () => {
+        if (state === "domcontentloaded") finish();
+      };
+
+      const onLoad = () => {
+        if (state === "load") finish();
+      };
+
+      this.mainSession.on("Page.lifecycleEvent", onLifecycle);
+      // Backups for sites that don't emit lifecycle consistently
+      this.mainSession.on("Page.domContentEventFired", onDomContent);
+      this.mainSession.on("Page.loadEventFired", onLoad);
+
+      // Fallback polling closes lifecycle-event races in remote environments
+      // where readyState has advanced but the corresponding event was missed.
+      const pollReadyState = async () => {
+        if (done || pollInFlight) return;
+        pollInFlight = true;
+        try {
+          if (done) return;
+          if (
+            (state === "domcontentloaded" || state === "load") &&
+            (await this.isMainLoadStateReady(state))
+          ) {
+            finish();
+            return;
+          }
+        } finally {
+          pollInFlight = false;
+        }
+        if (!done) {
+          clearPollTimer();
+          pollTimer = setTimeout(() => {
+            void pollReadyState();
+          }, 100);
+        }
+      };
+      void pollReadyState();
+
+      timer = setTimeout(() => {
+        if (done) return;
+        done = true;
+        clearPollTimer();
+        off();
+        reject(
+          new Error(
+            `waitForMainLoadState(${state}) timed out after ${timeoutMs}ms`,
+          ),
+        );
+      }, timeoutMs);
+    });
+  }
+}
diff --git a/packages/core/lib/v3/understudy/piercer.ts b/packages/core/lib/v3/understudy/piercer.ts
new file mode 100644
index 000000000..0b3e3f045
--- /dev/null
+++ b/packages/core/lib/v3/understudy/piercer.ts
@@ -0,0 +1,74 @@
+import type { Protocol } from "devtools-protocol";
+import { v3Logger } from "../logger.js";
+import type { CDPSessionLike } from "./cdp.js";
+import { v3ScriptContent } from "../dom/build/scriptV3Content.js";
+import { reRenderScriptContent } from "../dom/build/reRenderScriptContent.js";
+
+export async function installV3PiercerIntoSession(
+  session: CDPSessionLike,
+): Promise<boolean> {
+  const pageEnabled = await session
+    .send("Page.enable")
+    .then(() => true)
+    .catch(() => false);
+  if (!pageEnabled) return false;
+
+  await session.send("Runtime.enable").catch(() => {});
+  try {
+    await session.send<Protocol.Page.AddScriptToEvaluateOnNewDocumentResponse>(
+      "Page.addScriptToEvaluateOnNewDocument",
+      { source: v3ScriptContent, runImmediately: true },
+    );
+  } catch (e) {
+    const msg = String((e as Error)?.message ?? e ?? "");
+    // If the session vanished during attach (common with short-lived OOPIFs),
+    // swallow and report failure so callers can early-return.
+    if (msg.includes("Session with given id not found")) return false;
+    // For other errors, keep going but don't throw — the next evaluate is idempotent.
+  }
+  await session
+    .send<Protocol.Runtime.EvaluateResponse>("Runtime.evaluate", {
+      expression: v3ScriptContent,
+      returnByValue: true,
+      awaitPromise: true,
+    })
+    .catch(() => {});
+
+  // After the piercer is in place, re-render any custom elements whose
+  // shadow roots were created before we patched attachShadow so their
+  // closed roots are recreated under the hook.
+  await session
+    .send<Protocol.Runtime.EvaluateResponse>("Runtime.evaluate", {
+      expression: reRenderScriptContent,
+      returnByValue: true,
+      awaitPromise: false,
+    })
+    .catch(() => {});
+  return true;
+}
+
+/** (Optional) stream patch logs in your node console during bring-up */
+export function tapPiercerConsole(
+  session: CDPSessionLike,
+  label: string,
+): void {
+  session.on<Protocol.Runtime.ConsoleAPICalledEvent>(
+    "Runtime.consoleAPICalled",
+    (evt) => {
+      const head = evt.args?.[0]?.value as string | undefined;
+      if (head?.startsWith?.("[v3-piercer]")) {
+        v3Logger({
+          category: "piercer",
+          message: `[${label}] ${head}`,
+          level: 2,
+          auxiliary: {
+            value: {
+              value: String(evt.args?.[1]?.value ?? ""),
+              type: "string",
+            },
+          },
+        });
+      }
+    },
+  );
+}
diff --git a/packages/core/lib/v3/understudy/response.ts b/packages/core/lib/v3/understudy/response.ts
new file mode 100644
index 000000000..3ce7b90c0
--- /dev/null
+++ b/packages/core/lib/v3/understudy/response.ts
@@ -0,0 +1,399 @@
+/**
+ * Response
+ * -----------------
+ *
+ * This module implements a Playwright-inspired response wrapper that exposes
+ * navigation metadata and helpers for retrieving HTTP response bodies. The
+ * abstraction is consumed by navigation routines (e.g. `Page.goto`) so callers
+ * can synchronously inspect status codes, lazily fetch body text, or await the
+ * network layer finishing the request. The implementation is built directly on
+ * Chrome DevTools Protocol primitives – it holds the originating `requestId`
+ * so it can request payloads via `Network.getResponseBody`, and it listens for
+ * `responseReceivedExtraInfo`, `loadingFinished`, and `loadingFailed` events to
+ * hydrate the richer header view and resolve callers waiting on completion.
+ */
+
+import type { Protocol } from "devtools-protocol";
+import type { SerializableResponse } from "../types/private/index.js";
+import {
+  ResponseBodyError,
+  ResponseParseError,
+} from "../types/public/sdkErrors.js";
+import type { CDPSessionLike } from "./cdp.js";
+import type { Frame } from "./frame.js";
+import type { Page } from "./page.js";
+
+type ServerAddr = { ipAddress: string; port: number };
+
+export function isSerializableResponse(
+  value: unknown,
+): value is SerializableResponse {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<SerializableResponse>;
+  if (typeof candidate.requestId !== "string") return false;
+  if (!candidate.response || typeof candidate.response !== "object") {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Minimal deferred helper that lets navigation tracking hand out a promise and
+ * later control the resolution from event callbacks. Each response owns a
+ * single deferred covering the "finished" promise so consumers can mirror
+ * Playwright's `response.finished()` behaviour.
+ */
+type Deferred<T> = {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (error: Error) => void;
+};
+
+function createDeferred<T>(): Deferred<T> {
+  let resolve!: (value: T) => void;
+  let reject!: (error: Error) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+/** Normalise header names to lowercase for case-insensitive lookups. */
+function normaliseHeaderName(name: string): string {
+  return name.toLowerCase();
+}
+
+/** Split multi-value header strings into discrete values while trimming. */
+function splitHeaderValues(value: string): string[] {
+  return value
+    .split(/\r?\n/)
+    .map((part) => part.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Parse an HTTP header text block (as emitted by CDP) into an ordered array of
+ * name/value pairs while preserving the wire casing.
+ */
+function parseHeadersText(
+  headersText: string | undefined,
+): Array<{ name: string; value: string }> {
+  if (!headersText) return [];
+  const lines = headersText.split(/\r?\n/);
+  const entries: Array<{ name: string; value: string }> = [];
+  for (const line of lines) {
+    if (!line || line.startsWith("HTTP/")) continue;
+    const index = line.indexOf(":");
+    if (index === -1) continue;
+    const name = line.slice(0, index).trim();
+    const value = line.slice(index + 1).trim();
+    entries.push({ name, value });
+  }
+  return entries;
+}
+
+/**
+ * Thin wrapper around CDP response metadata that mirrors the ergonomics of
+ * Playwright's `Response` class. The class intentionally keeps the same method
+ * names so upstream integrations can transition with minimal code changes.
+ */
+export class Response {
+  private readonly page: Page;
+  private readonly session: CDPSessionLike;
+  private readonly requestId: string;
+  private readonly frameId?: string;
+  private readonly loaderId?: string;
+  private readonly response: Protocol.Network.Response;
+  private readonly fromServiceWorkerFlag: boolean;
+  private readonly serverAddress?: ServerAddr | null;
+
+  private headersObject: Record<string, string>;
+  private headersArrayCache: Array<{ name: string; value: string }> | null =
+    null;
+  private allHeadersCache: Record<string, string> | null = null;
+  private readonly headerValuesMap = new Map<string, string[]>();
+
+  private finishedDeferred = createDeferred<null | Error>();
+  private finishedSettled = false;
+
+  private extraInfoHeaders: Protocol.Network.Headers | null = null;
+  private extraInfoHeadersText: string | undefined;
+
+  /**
+   * Build a response wrapper from the CDP notification associated with a
+   * navigation. The constructor captures the owning page/session so follow-up
+   * methods (body/text/json) can query CDP on-demand. The `response` payload is
+   * the raw `Protocol.Network.Response` object emitted by Chrome.
+   */
+  constructor(params: {
+    page: Page;
+    session: CDPSessionLike;
+    requestId: string;
+    frameId?: string;
+    loaderId?: string;
+    response: Protocol.Network.Response;
+    fromServiceWorker: boolean;
+  }) {
+    this.page = params.page;
+    this.session = params.session;
+    this.requestId = params.requestId;
+    this.frameId = params.frameId;
+    this.loaderId = params.loaderId;
+    this.response = params.response;
+    this.fromServiceWorkerFlag = params.fromServiceWorker;
+
+    if (
+      params.response.remoteIPAddress &&
+      params.response.remotePort !== undefined
+    ) {
+      this.serverAddress = {
+        ipAddress: params.response.remoteIPAddress,
+        port: params.response.remotePort,
+      };
+    } else {
+      this.serverAddress = null;
+    }
+
+    this.headersObject = {};
+    for (const [name, value] of Object.entries(this.response.headers ?? {})) {
+      const lower = normaliseHeaderName(name);
+      if (value === undefined) continue;
+      const values = splitHeaderValues(String(value));
+      this.headerValuesMap.set(lower, values);
+      this.headersObject[lower] = values.join(", ");
+    }
+  }
+
+  /** URL associated with the navigation request. */
+  url(): string {
+    return this.response.url;
+  }
+
+  /** HTTP status code reported by Chrome. */
+  status(): number {
+    return this.response.status;
+  }
+
+  /** Human-readable status text that accompanied the response. */
+  statusText(): string {
+    return this.response.statusText;
+  }
+
+  /** Convenience predicate that checks for 2xx statuses. */
+  ok(): boolean {
+    const status = this.status();
+    return status >= 200 && status <= 299;
+  }
+
+  /** Returns the Stagehand frame object that initiated the navigation. */
+  frame(): Frame | null {
+    if (!this.frameId) return null;
+    try {
+      return this.page.frameForId(this.frameId);
+    } catch {
+      return null;
+    }
+  }
+
+  /** Indicates whether the response was serviced by a Service Worker. */
+  fromServiceWorker(): boolean {
+    return this.fromServiceWorkerFlag;
+  }
+
+  /**
+   * Returns TLS security metadata when provided by the browser. In practice
+   * this includes certificate issuer, protocol, and validity interval.
+   */
+  async securityDetails(): Promise<Protocol.Network.SecurityDetails | null> {
+    return this.response.securityDetails ?? null;
+  }
+
+  /** Returns the resolved server address for the navigation when available. */
+  async serverAddr(): Promise<ServerAddr | null> {
+    return this.serverAddress ?? null;
+  }
+
+  /**
+   * Returns the response headers normalised to lowercase keys. Matches the
+   * behaviour of Playwright's `headers()` by eliding duplicate header entries.
+   */
+  headers(): Record<string, string> {
+    return { ...this.headersObject };
+  }
+
+  /**
+   * Returns all headers including those only surfaced through
+   * `responseReceivedExtraInfo` such as `set-cookie`. Values are reported as the
+   * browser sends them (no further splitting or concatenation).
+   */
+  async allHeaders(): Promise<Record<string, string>> {
+    if (this.allHeadersCache) return { ...this.allHeadersCache };
+    const source = this.extraInfoHeaders ?? this.response.headers ?? {};
+    const map: Record<string, string> = {};
+    for (const [name, value] of Object.entries(source)) {
+      map[name] = String(value);
+    }
+    this.allHeadersCache = map;
+    return { ...map };
+  }
+
+  /** Returns a concatenated header string for the supplied header name. */
+  async headerValue(name: string): Promise<string | null> {
+    const values = await this.headerValues(name);
+    if (!values.length) return null;
+    return values.join(", ");
+  }
+
+  /** Returns all values for a header (case-insensitive lookup). */
+  async headerValues(name: string): Promise<string[]> {
+    const lower = normaliseHeaderName(name);
+    if (this.extraInfoHeaders) {
+      const raw = this.extraInfoHeaders[name] ?? this.extraInfoHeaders[lower];
+      if (raw !== undefined) {
+        return splitHeaderValues(String(raw));
+      }
+    }
+    const values = this.headerValuesMap.get(lower);
+    return values ? [...values] : [];
+  }
+
+  /**
+   * Returns header entries preserving their original wire casing and ordering.
+   * Falls back to the CDP object when the raw header text is unavailable.
+   */
+  async headersArray(): Promise<Array<{ name: string; value: string }>> {
+    if (this.headersArrayCache) return [...this.headersArrayCache];
+
+    const entriesFromText = parseHeadersText(this.extraInfoHeadersText);
+    if (entriesFromText.length > 0) {
+      this.headersArrayCache = entriesFromText;
+      return [...entriesFromText];
+    }
+
+    const entries: Array<{ name: string; value: string }> = [];
+    const source = this.extraInfoHeaders ?? this.response.headers ?? {};
+    for (const [name, value] of Object.entries(source)) {
+      const values = splitHeaderValues(String(value));
+      for (const val of values) {
+        entries.push({ name, value: val });
+      }
+    }
+    this.headersArrayCache = entries;
+    return [...entries];
+  }
+
+  /**
+   * Requests the raw response body from Chrome DevTools Protocol. The method is
+   * intentionally lazy because not every caller needs the payload, and CDP only
+   * allows retrieving it once the response completes.
+   */
+  async body(): Promise<Buffer> {
+    const result = await this.session
+      .send<Protocol.Network.GetResponseBodyResponse>(
+        "Network.getResponseBody",
+        { requestId: this.requestId },
+      )
+      .catch((error) => {
+        throw new ResponseBodyError(String(error));
+      });
+
+    if (result.base64Encoded) {
+      return Buffer.from(result.body, "base64");
+    }
+    return Buffer.from(result.body, "utf-8");
+  }
+
+  /** Decodes the response body as UTF-8 text. */
+  async text(): Promise<string> {
+    const buffer = await this.body();
+    return buffer.toString("utf-8");
+  }
+
+  /** Parses the response body as JSON and throws if parsing fails. */
+  async json<T = unknown>(): Promise<T> {
+    const text = await this.text();
+    try {
+      return JSON.parse(text) as T;
+    } catch (error) {
+      throw new ResponseParseError(String(error));
+    }
+  }
+
+  /**
+   * Resolves once the underlying network request completes or fails. Mirrors
+   * Playwright's behaviour by resolving to `null` on success and to an `Error`
+   * instance when Chrome reports `Network.loadingFailed`.
+   */
+  async finished(): Promise<null | Error> {
+    return this.finishedDeferred.promise;
+  }
+
+  /**
+   * Internal helper invoked by the navigation tracker when CDP reports extra
+   * header information. This keeps the cached header views in sync with the
+   * richer metadata.
+   */
+  public applyExtraInfo(
+    event: Protocol.Network.ResponseReceivedExtraInfoEvent,
+  ): void {
+    this.extraInfoHeaders = event.headers;
+    this.extraInfoHeadersText = event.headersText;
+    this.allHeadersCache = null;
+    this.headersArrayCache = null;
+    this.headersObject = {};
+    this.headerValuesMap.clear();
+
+    const source = event.headers ?? {};
+    for (const [name, value] of Object.entries(source)) {
+      const lower = normaliseHeaderName(name);
+      const segments = splitHeaderValues(String(value));
+      this.headerValuesMap.set(lower, segments);
+      this.headersObject[lower] = segments.join(", ");
+    }
+  }
+
+  /**
+   * Internal helper for creating a Response object from a Serializable
+   * goto response from the Stagehand API
+   */
+  public static fromSerializable(
+    serialized: SerializableResponse,
+    context: { page: Page; session: CDPSessionLike },
+  ): Response {
+    const reconstructed = new Response({
+      page: context.page,
+      session: context.session,
+      requestId: serialized.requestId,
+      frameId: serialized.frameId,
+      loaderId: serialized.loaderId,
+      response: serialized.response as Protocol.Network.Response,
+      fromServiceWorker: serialized.fromServiceWorkerFlag ?? false,
+    });
+
+    if (serialized.extraInfoHeaders) {
+      reconstructed.applyExtraInfo({
+        requestId: serialized.requestId,
+        headers: serialized.extraInfoHeaders,
+        headersText: serialized.extraInfoHeadersText,
+      } as Protocol.Network.ResponseReceivedExtraInfoEvent);
+    }
+
+    if (serialized.finishedSettled) {
+      reconstructed.markFinished(null);
+    }
+
+    return reconstructed;
+  }
+
+  /** Marks the response as finished and resolves the `finished()` promise. */
+  public markFinished(error: Error | null): void {
+    if (this.finishedSettled) return;
+    this.finishedSettled = true;
+    if (error) {
+      this.finishedDeferred.resolve(error);
+    } else {
+      this.finishedDeferred.resolve(null);
+    }
+  }
+}
diff --git a/packages/core/lib/v3/understudy/screenshotUtils.ts b/packages/core/lib/v3/understudy/screenshotUtils.ts
new file mode 100644
index 000000000..a9a44504a
--- /dev/null
+++ b/packages/core/lib/v3/understudy/screenshotUtils.ts
@@ -0,0 +1,442 @@
+import { Protocol } from "devtools-protocol";
+import type { CDPSessionLike } from "./cdp.js";
+import type { Frame } from "./frame.js";
+import type { Locator } from "./locator.js";
+import type { Page } from "./page.js";
+import type {
+  ScreenshotClip,
+  ScreenshotScaleOption,
+} from "../types/public/screenshotTypes.js";
+import { StagehandInvalidArgumentError } from "../types/public/sdkErrors.js";
+import { screenshotScriptSources } from "../dom/build/screenshotScripts.generated.js";
+
+export type ScreenshotCleanup = () => Promise<void> | void;
+
+export function collectFramesForScreenshot(page: Page): Frame[] {
+  const seen = new Map<string, Frame>();
+  const main = page.mainFrame();
+  seen.set(main.frameId, main);
+  for (const frame of page.frames()) {
+    seen.set(frame.frameId, frame);
+  }
+  return Array.from(seen.values());
+}
+
+export function normalizeScreenshotClip(clip: ScreenshotClip): ScreenshotClip {
+  const x = Number(clip.x);
+  const y = Number(clip.y);
+  const width = Number(clip.width);
+  const height = Number(clip.height);
+
+  for (const [key, value] of Object.entries({ x, y, width, height })) {
+    if (!Number.isFinite(value)) {
+      throw new StagehandInvalidArgumentError(
+        `screenshot: clip.${key} must be a finite number`,
+      );
+    }
+  }
+
+  if (width <= 0 || height <= 0) {
+    throw new StagehandInvalidArgumentError(
+      "screenshot: clip width/height must be positive",
+    );
+  }
+
+  return { x, y, width, height };
+}
+
+export async function computeScreenshotScale(
+  page: Page,
+  mode: ScreenshotScaleOption,
+): Promise<number | undefined> {
+  if (mode !== "css") return undefined;
+  try {
+    const frame = page.mainFrame();
+    const dpr = await frame
+      .evaluate(() => {
+        const ratio = Number(window.devicePixelRatio || 1);
+        return Number.isFinite(ratio) && ratio > 0 ? ratio : 1;
+      })
+      .catch(() => 1);
+    const safeRatio = Number.isFinite(dpr) && dpr > 0 ? dpr : 1;
+    return Math.min(2, Math.max(0.1, 1 / safeRatio));
+  } catch {
+    return 1;
+  }
+}
+
+export async function setTransparentBackground(
+  session: CDPSessionLike,
+): Promise<ScreenshotCleanup> {
+  await session
+    .send("Emulation.setDefaultBackgroundColorOverride", {
+      color: { r: 0, g: 0, b: 0, a: 0 },
+    })
+    .catch(() => {});
+
+  return async () => {
+    await session
+      .send("Emulation.setDefaultBackgroundColorOverride", {})
+      .catch(() => {});
+  };
+}
+
+export async function applyStyleToFrames(
+  frames: Frame[],
+  css: string,
+  label: string,
+): Promise<ScreenshotCleanup> {
+  const trimmed = css.trim();
+  if (!trimmed) return async () => {};
+  const token = `__v3_style_${label}_${Date.now()}_${Math.random()
+    .toString(36)
+    .slice(2)}`;
+
+  await Promise.all(
+    frames.map((frame) =>
+      frame
+        .evaluate(
+          ({ css, token }) => {
+            try {
+              const doc = document;
+              if (!doc) return;
+              const style = doc.createElement("style");
+              style.setAttribute("data-stagehand-style", token);
+              style.textContent = css;
+              const parent = doc.head || doc.documentElement || doc.body;
+              parent?.appendChild(style);
+            } catch {
+              // ignore
+            }
+          },
+          { css: trimmed, token },
+        )
+        .catch(() => {}),
+    ),
+  );
+
+  return async () => {
+    await Promise.all(
+      frames.map((frame) =>
+        frame
+          .evaluate((token) => {
+            try {
+              const doc = document;
+              if (!doc) return;
+              const nodes = doc.querySelectorAll(
+                `[data-stagehand-style="${token}"]`,
+              );
+              nodes.forEach((node) => node.remove());
+            } catch {
+              // ignore
+            }
+          }, token)
+          .catch(() => {}),
+      ),
+    );
+  };
+}
+
+export async function disableAnimations(
+  frames: Frame[],
+): Promise<ScreenshotCleanup> {
+  const css = `
+*,
+*::before,
+*::after {
+  animation-delay: 0s !important;
+  animation-duration: 0s !important;
+  animation-iteration-count: 1 !important;
+  animation-play-state: paused !important;
+  transition-property: none !important;
+  transition-duration: 0s !important;
+  transition-delay: 0s !important;
+}`;
+
+  const cleanup = await applyStyleToFrames(frames, css, "animations");
+
+  await Promise.all(
+    frames.map((frame) =>
+      frame
+        .evaluate(() => {
+          try {
+            const animations =
+              typeof document.getAnimations === "function"
+                ? document.getAnimations()
+                : [];
+            for (const animation of animations) {
+              try {
+                const details = animation.effect?.getComputedTiming?.();
+                if (details && details.iterations !== Infinity) {
+                  animation.finish?.();
+                } else {
+                  animation.cancel?.();
+                }
+              } catch {
+                animation.cancel?.();
+              }
+            }
+          } catch {
+            // ignore
+          }
+        })
+        .catch(() => {}),
+    ),
+  );
+
+  return cleanup;
+}
+
+export async function hideCaret(frames: Frame[]): Promise<ScreenshotCleanup> {
+  const css = `
+input,
+textarea,
+[contenteditable],
+[contenteditable=""],
+[contenteditable="true"],
+[contenteditable="plaintext-only"],
+*:focus {
+  caret-color: transparent !important;
+}`;
+
+  return applyStyleToFrames(frames, css, "caret");
+}
+
+export async function applyMaskOverlays(
+  locators: Locator[],
+  color: string,
+): Promise<ScreenshotCleanup> {
+  type MaskRectSpec = ScreenshotClip & { rootToken?: string | null };
+  const rectsByFrame = new Map<
+    Frame,
+    { rects: MaskRectSpec[]; rootTokens: Set<string> }
+  >();
+
+  const token = `__v3_mask_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+
+  for (const locator of locators) {
+    try {
+      const info = await resolveMaskRects(locator, token);
+      if (!info) continue;
+      const entry = rectsByFrame.get(info.frame) ?? {
+        rects: [],
+        rootTokens: new Set<string>(),
+      };
+      entry.rects.push(...info.rects);
+      for (const rect of info.rects) {
+        if (rect.rootToken) entry.rootTokens.add(rect.rootToken);
+      }
+      rectsByFrame.set(info.frame, entry);
+    } catch {
+      // ignore individual locator failures
+    }
+  }
+
+  if (rectsByFrame.size === 0) {
+    return async () => {};
+  }
+
+  await Promise.all(
+    Array.from(rectsByFrame.entries()).map(([frame, { rects }]) =>
+      frame
+        .evaluate(
+          ({ rects, color, token }) => {
+            try {
+              const doc = document;
+              if (!doc) return;
+              for (const rect of rects) {
+                const defaultRoot = doc.documentElement || doc.body;
+                if (!defaultRoot) return;
+                const root = rect.rootToken
+                  ? doc.querySelector(
+                      `[data-stagehand-mask-root="${rect.rootToken}"]`,
+                    ) || defaultRoot
+                  : defaultRoot;
+                if (!root) continue;
+                if (rect.rootToken) {
+                  try {
+                    const style = window.getComputedStyle(root as Element);
+                    if (style && style.position === "static") {
+                      const rootEl = root as HTMLElement;
+                      if (
+                        !rootEl.hasAttribute("data-stagehand-mask-root-pos")
+                      ) {
+                        rootEl.setAttribute(
+                          "data-stagehand-mask-root-pos",
+                          rootEl.style.position || "",
+                        );
+                      }
+                      rootEl.style.position = "relative";
+                    }
+                  } catch {
+                    // ignore
+                  }
+                }
+                const el = doc.createElement("div");
+                el.setAttribute("data-stagehand-mask", token);
+                el.style.position = "absolute";
+                el.style.left = `${rect.x}px`;
+                el.style.top = `${rect.y}px`;
+                el.style.width = `${rect.width}px`;
+                el.style.height = `${rect.height}px`;
+                el.style.backgroundColor = color;
+                el.style.pointerEvents = "none";
+                el.style.zIndex = "2147483647";
+                el.style.opacity = "1";
+                el.style.mixBlendMode = "normal";
+                (root as Element).appendChild(el);
+              }
+            } catch {
+              // ignore
+            }
+          },
+          { rects, color, token },
+        )
+        .catch(() => {}),
+    ),
+  );
+
+  return async () => {
+    await Promise.all(
+      Array.from(rectsByFrame.entries()).map(([frame, { rootTokens }]) =>
+        frame
+          .evaluate(
+            ({ token, rootTokens }) => {
+              try {
+                const doc = document;
+                if (!doc) return;
+                const nodes = doc.querySelectorAll(
+                  `[data-stagehand-mask="${token}"]`,
+                );
+                nodes.forEach((node) => node.remove());
+                for (const rootToken of rootTokens) {
+                  const root = doc.querySelector(
+                    `[data-stagehand-mask-root="${rootToken}"]`,
+                  ) as HTMLElement | null;
+                  if (!root) continue;
+                  const prev = root.getAttribute(
+                    "data-stagehand-mask-root-pos",
+                  );
+                  if (prev !== null) {
+                    root.style.position = prev;
+                    root.removeAttribute("data-stagehand-mask-root-pos");
+                  }
+                  root.removeAttribute("data-stagehand-mask-root");
+                }
+              } catch {
+                // ignore
+              }
+            },
+            { token, rootTokens: Array.from(rootTokens) },
+          )
+          .catch(() => {}),
+      ),
+    );
+  };
+}
+
+async function resolveMaskRects(
+  locator: Locator,
+  maskToken: string,
+): Promise<{
+  frame: Frame;
+  rects: Array<ScreenshotClip & { rootToken?: string | null }>;
+} | null> {
+  const frame = locator.getFrame();
+  const session = frame.session;
+  try {
+    const resolved: Array<{
+      objectId: Protocol.Runtime.RemoteObjectId;
+      nodeId: Protocol.DOM.NodeId | null;
+    }> = await locator.resolveNodesForMask();
+    const rects: Array<ScreenshotClip & { rootToken?: string | null }> = [];
+
+    for (const { objectId } of resolved) {
+      try {
+        const rect = await resolveMaskRectForObject(
+          session,
+          objectId,
+          maskToken,
+        );
+        if (rect) rects.push(rect);
+      } catch {
+        // ignore individual element failures
+      } finally {
+        await session
+          .send<never>("Runtime.releaseObject", { objectId })
+          .catch(() => {});
+      }
+    }
+
+    if (!rects.length) return null;
+
+    return { frame, rects };
+  } catch {
+    return null;
+  }
+}
+
+async function resolveMaskRectForObject(
+  session: CDPSessionLike,
+  objectId: Protocol.Runtime.RemoteObjectId,
+  maskToken: string,
+): Promise<(ScreenshotClip & { rootToken?: string | null }) | null> {
+  const result = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
+    "Runtime.callFunctionOn",
+    {
+      objectId,
+      functionDeclaration: screenshotScriptSources.resolveMaskRect,
+      arguments: [{ value: maskToken }],
+      returnByValue: true,
+    },
+  );
+
+  if (result.exceptionDetails) {
+    return null;
+  }
+
+  const rect = result.result.value as
+    | (ScreenshotClip & { rootToken?: string | null })
+    | null;
+  if (!rect) return null;
+
+  const { x, y, width, height } = rect;
+  if (
+    !Number.isFinite(x) ||
+    !Number.isFinite(y) ||
+    !Number.isFinite(width) ||
+    !Number.isFinite(height) ||
+    width <= 0 ||
+    height <= 0
+  ) {
+    return null;
+  }
+
+  return {
+    x,
+    y,
+    width,
+    height,
+    rootToken:
+      rect.rootToken && typeof rect.rootToken === "string"
+        ? rect.rootToken
+        : undefined,
+  };
+}
+
+export async function runScreenshotCleanups(
+  cleanups: ScreenshotCleanup[],
+): Promise<void> {
+  for (let i = cleanups.length - 1; i >= 0; i -= 1) {
+    const fn = cleanups[i];
+    if (!fn) continue;
+    try {
+      const result = fn();
+      if (result && typeof (result as Promise<void>).then === "function") {
+        await result;
+      }
+    } catch {
+      // ignore cleanup errors
+    }
+  }
+}
diff --git a/packages/core/lib/v3/understudy/selectorResolver.ts b/packages/core/lib/v3/understudy/selectorResolver.ts
new file mode 100644
index 000000000..02d7b42cf
--- /dev/null
+++ b/packages/core/lib/v3/understudy/selectorResolver.ts
@@ -0,0 +1,441 @@
+import type { Protocol } from "devtools-protocol";
+import {
+  locatorScriptBootstrap,
+  locatorScriptGlobalRefs,
+  type LocatorScriptName,
+} from "../dom/build/locatorScripts.generated.js";
+import { v3Logger } from "../logger.js";
+import type { Frame } from "./frame.js";
+import { executionContexts } from "./executionContextRegistry.js";
+
+export type SelectorQuery =
+  | { kind: "css"; value: string }
+  | { kind: "text"; value: string }
+  | { kind: "xpath"; value: string };
+
+export interface ResolvedNode {
+  objectId: Protocol.Runtime.RemoteObjectId;
+  nodeId: Protocol.DOM.NodeId | null;
+}
+
+export interface ResolveManyOptions {
+  limit?: number;
+}
+
+export class FrameSelectorResolver {
+  constructor(private readonly frame: Frame) {}
+
+  public static parseSelector(raw: string): SelectorQuery {
+    const trimmed = raw.trim();
+
+    const isText = /^text=/i.test(trimmed);
+    const looksLikeXPath =
+      /^xpath=/i.test(trimmed) ||
+      trimmed.startsWith("/") ||
+      trimmed.startsWith("(");
+    const isCssPrefixed = /^css=/i.test(trimmed);
+
+    if (isText) {
+      let value = trimmed.replace(/^text=/i, "").trim();
+      if (
+        (value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))
+      ) {
+        value = value.slice(1, -1);
+      }
+      return { kind: "text", value };
+    }
+
+    if (looksLikeXPath) {
+      const value = trimmed.replace(/^xpath=/i, "");
+      return { kind: "xpath", value };
+    }
+
+    let selector = isCssPrefixed ? trimmed.replace(/^css=/i, "") : trimmed;
+    if (selector.includes(">>")) {
+      selector = selector
+        .split(">>")
+        .map((piece) => piece.trim())
+        .filter(Boolean)
+        .join(" ");
+    }
+
+    return { kind: "css", value: selector };
+  }
+
+  public async resolveFirst(
+    query: SelectorQuery,
+  ): Promise<ResolvedNode | null> {
+    return this.resolveAtIndex(query, 0);
+  }
+
+  public async resolveAll(
+    query: SelectorQuery,
+    { limit = Infinity }: ResolveManyOptions = {},
+  ): Promise<ResolvedNode[]> {
+    if (limit <= 0) return [];
+    switch (query.kind) {
+      case "css":
+        return this.resolveCss(query.value, limit);
+      case "text":
+        return this.resolveText(query.value, limit);
+      case "xpath":
+        return this.resolveXPath(query.value, limit);
+      default:
+        return [];
+    }
+  }
+
+  public async count(query: SelectorQuery): Promise<number> {
+    switch (query.kind) {
+      case "css":
+        return this.countCss(query.value);
+      case "text":
+        return this.countText(query.value);
+      case "xpath":
+        return this.countXPath(query.value);
+      default:
+        return 0;
+    }
+  }
+
+  public async resolveAtIndex(
+    query: SelectorQuery,
+    index: number,
+  ): Promise<ResolvedNode | null> {
+    if (index < 0 || !Number.isFinite(index)) return null;
+    const results = await this.resolveAll(query, { limit: index + 1 });
+    return results[index] ?? null;
+  }
+
+  private buildLocatorInvocation(
+    name: LocatorScriptName,
+    args: string[],
+  ): string {
+    const call = `${locatorScriptGlobalRefs[name]}(${args.join(", ")})`;
+    return `(() => { ${locatorScriptBootstrap}; return ${call}; })()`;
+  }
+
+  private async resolveCss(
+    selector: string,
+    limit: number,
+  ): Promise<ResolvedNode[]> {
+    if (limit <= 0) return [];
+
+    const session = this.frame.session;
+    const { executionContextId } = await session.send<{
+      executionContextId: Protocol.Runtime.ExecutionContextId;
+    }>("Page.createIsolatedWorld", {
+      frameId: this.frame.frameId,
+      worldName: "v3-world",
+    });
+
+    const ctxId = await executionContexts.waitForMainWorld(
+      session,
+      this.frame.frameId,
+      1000,
+    );
+
+    const results: ResolvedNode[] = [];
+    let loggedFallback = false;
+
+    for (let index = 0; index < limit; index += 1) {
+      const primaryExpr = this.buildLocatorInvocation("resolveCssSelector", [
+        JSON.stringify(selector),
+        String(index),
+      ]);
+      const primary = await this.evaluateElement(
+        primaryExpr,
+        executionContextId,
+      );
+      if (primary) {
+        results.push(primary);
+        continue;
+      }
+
+      if (!loggedFallback) {
+        v3Logger({
+          category: "locator",
+          message: "css pierce-fallback",
+          level: 2,
+          auxiliary: {
+            frameId: { value: String(this.frame.frameId), type: "string" },
+            selector: { value: selector, type: "string" },
+          },
+        });
+        loggedFallback = true;
+      }
+
+      const fallbackExpr = this.buildLocatorInvocation(
+        "resolveCssSelectorPierce",
+        [JSON.stringify(selector), String(index)],
+      );
+      const fallback = await this.evaluateElement(fallbackExpr, ctxId);
+      if (fallback) {
+        results.push(fallback);
+        continue;
+      }
+
+      break;
+    }
+
+    return results;
+  }
+
+  private async resolveText(
+    value: string,
+    limit: number,
+  ): Promise<ResolvedNode[]> {
+    if (limit <= 0) return [];
+
+    const session = this.frame.session;
+    const ctxId = await executionContexts.waitForMainWorld(
+      session,
+      this.frame.frameId,
+      1000,
+    );
+
+    const results: ResolvedNode[] = [];
+    for (let index = 0; index < limit; index += 1) {
+      const expr = this.buildLocatorInvocation("resolveTextSelector", [
+        JSON.stringify(value),
+        String(index),
+      ]);
+      const resolved = await this.evaluateElement(expr, ctxId);
+      if (!resolved) break;
+      results.push(resolved);
+    }
+
+    return results;
+  }
+
+  private async resolveXPath(
+    value: string,
+    limit: number,
+  ): Promise<ResolvedNode[]> {
+    if (limit <= 0) return [];
+
+    const session = this.frame.session;
+    const ctxId = await executionContexts.waitForMainWorld(
+      session,
+      this.frame.frameId,
+      1000,
+    );
+
+    const results: ResolvedNode[] = [];
+    for (let index = 0; index < limit; index += 1) {
+      const expr = this.buildLocatorInvocation("resolveXPathMainWorld", [
+        JSON.stringify(value),
+        String(index),
+      ]);
+      const resolved = await this.evaluateElement(expr, ctxId);
+      if (!resolved) break;
+      results.push(resolved);
+    }
+
+    return results;
+  }
+
+  private async countCss(selector: string): Promise<number> {
+    const session = this.frame.session;
+
+    const { executionContextId } = await session.send<{
+      executionContextId: Protocol.Runtime.ExecutionContextId;
+    }>("Page.createIsolatedWorld", {
+      frameId: this.frame.frameId,
+      worldName: "v3-world",
+    });
+
+    const primaryExpr = this.buildLocatorInvocation("countCssMatchesPrimary", [
+      JSON.stringify(selector),
+    ]);
+    const primary = await this.evaluateCount(primaryExpr, executionContextId);
+
+    const ctxId = await executionContexts.waitForMainWorld(
+      session,
+      this.frame.frameId,
+      1000,
+    );
+
+    const fallbackExpr = this.buildLocatorInvocation("countCssMatchesPierce", [
+      JSON.stringify(selector),
+    ]);
+    const fallback = await this.evaluateCount(fallbackExpr, ctxId);
+
+    return Math.max(primary, fallback);
+  }
+
+  private async countText(value: string): Promise<number> {
+    const session = this.frame.session;
+    const ctxId = await executionContexts.waitForMainWorld(
+      session,
+      this.frame.frameId,
+      1000,
+    );
+
+    const expr = this.buildLocatorInvocation("countTextMatches", [
+      JSON.stringify(value),
+    ]);
+
+    try {
+      const evalRes = await session.send<Protocol.Runtime.EvaluateResponse>(
+        "Runtime.evaluate",
+        {
+          expression: expr,
+          contextId: ctxId,
+          returnByValue: true,
+          awaitPromise: true,
+        },
+      );
+
+      if (evalRes.exceptionDetails) {
+        const details = evalRes.exceptionDetails;
+        v3Logger({
+          category: "locator",
+          message: "count text evaluate exception",
+          level: 0,
+          auxiliary: {
+            frameId: { value: String(this.frame.frameId), type: "string" },
+            selector: { value: value, type: "string" },
+            exception: {
+              value:
+                details.text ??
+                String(
+                  details.exception?.description ??
+                    details.exception?.value ??
+                    "",
+                ),
+              type: "string",
+            },
+          },
+        });
+        return 0;
+      }
+
+      const data = (evalRes.result.value ?? {}) as {
+        count?: unknown;
+      };
+
+      const num =
+        typeof data.count === "number" ? data.count : Number(data.count);
+      if (!Number.isFinite(num)) return 0;
+      return Math.max(0, Math.floor(num));
+    } catch {
+      return 0;
+    }
+  }
+
+  private async countXPath(value: string): Promise<number> {
+    const session = this.frame.session;
+
+    const ctxId = await executionContexts.waitForMainWorld(
+      session,
+      this.frame.frameId,
+      1000,
+    );
+
+    const expr = this.buildLocatorInvocation("countXPathMatchesMainWorld", [
+      JSON.stringify(value),
+    ]);
+
+    try {
+      const evalRes = await session.send<Protocol.Runtime.EvaluateResponse>(
+        "Runtime.evaluate",
+        {
+          expression: expr,
+          contextId: ctxId,
+          returnByValue: true,
+          awaitPromise: true,
+        },
+      );
+
+      if (evalRes.exceptionDetails) {
+        return 0;
+      }
+
+      const num =
+        typeof evalRes.result.value === "number"
+          ? evalRes.result.value
+          : Number(evalRes.result.value);
+      if (!Number.isFinite(num)) return 0;
+      return Math.max(0, Math.floor(num));
+    } catch {
+      return 0;
+    }
+  }
+
+  private async resolveFromObjectId(
+    objectId: Protocol.Runtime.RemoteObjectId,
+  ): Promise<ResolvedNode | null> {
+    const session = this.frame.session;
+    let nodeId: Protocol.DOM.NodeId | null;
+    try {
+      const rn = await session.send<{ nodeId: Protocol.DOM.NodeId }>(
+        "DOM.requestNode",
+        { objectId },
+      );
+      nodeId = rn.nodeId ?? null;
+    } catch {
+      nodeId = null;
+    }
+
+    return { objectId, nodeId };
+  }
+
+  private async evaluateCount(
+    expression: string,
+    contextId: Protocol.Runtime.ExecutionContextId,
+  ): Promise<number> {
+    const session = this.frame.session;
+
+    try {
+      const evalRes = await session.send<Protocol.Runtime.EvaluateResponse>(
+        "Runtime.evaluate",
+        {
+          expression,
+          contextId,
+          returnByValue: true,
+          awaitPromise: true,
+        },
+      );
+
+      if (evalRes.exceptionDetails) {
+        return 0;
+      }
+
+      const value = evalRes.result.value;
+      const num = typeof value === "number" ? value : Number(value);
+      if (!Number.isFinite(num)) return 0;
+      return Math.max(0, Math.floor(num));
+    } catch {
+      return 0;
+    }
+  }
+
+  private async evaluateElement(
+    expression: string,
+    contextId: Protocol.Runtime.ExecutionContextId,
+  ): Promise<ResolvedNode | null> {
+    const session = this.frame.session;
+
+    try {
+      const evalRes = await session.send<Protocol.Runtime.EvaluateResponse>(
+        "Runtime.evaluate",
+        {
+          expression,
+          contextId,
+          returnByValue: false,
+          awaitPromise: true,
+        },
+      );
+
+      if (evalRes.exceptionDetails || !evalRes.result.objectId) {
+        return null;
+      }
+
+      return this.resolveFromObjectId(evalRes.result.objectId);
+    } catch {
+      return null;
+    }
+  }
+}
diff --git a/packages/core/lib/v3/v3.ts b/packages/core/lib/v3/v3.ts
new file mode 100644
index 000000000..cde254843
--- /dev/null
+++ b/packages/core/lib/v3/v3.ts
@@ -0,0 +1,2116 @@
+import { EventEmitter } from "events";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import process from "process";
+import { v7 as uuidv7 } from "uuid";
+import { z } from "zod";
+import {
+  InferStagehandSchema,
+  StagehandZodSchema,
+  toJsonSchema,
+} from "./zodCompat.js";
+import { loadApiKeyFromEnv } from "../utils.js";
+import { extractModelName } from "../modelUtils.js";
+import { StagehandLogger, LoggerOptions } from "../logger.js";
+import { ActCache } from "./cache/ActCache.js";
+import { AgentCache } from "./cache/AgentCache.js";
+import { CacheStorage } from "./cache/CacheStorage.js";
+import { ActHandler } from "./handlers/actHandler.js";
+import { ExtractHandler } from "./handlers/extractHandler.js";
+import { ObserveHandler } from "./handlers/observeHandler.js";
+import { V3AgentHandler } from "./handlers/v3AgentHandler.js";
+import { V3CuaAgentHandler } from "./handlers/v3CuaAgentHandler.js";
+import { createBrowserbaseSession } from "./launch/browserbase.js";
+import { launchLocalChrome } from "./launch/local.js";
+import { LLMClient } from "./llm/LLMClient.js";
+import { LLMProvider } from "./llm/LLMProvider.js";
+import {
+  bindInstanceLogger,
+  unbindInstanceLogger,
+  withInstanceLogContext,
+} from "./logger.js";
+import { cleanupLocalBrowser } from "./shutdown/cleanupLocal.js";
+import { startShutdownSupervisor } from "./shutdown/supervisorClient.js";
+import { resolveTools } from "./mcp/utils.js";
+import {
+  ActHandlerParams,
+  ExtractHandlerParams,
+  ObserveHandlerParams,
+  AgentReplayStep,
+  InitState,
+  AgentCacheContext,
+} from "./types/private/index.js";
+import type {
+  ShutdownSupervisorConfig,
+  ShutdownSupervisorHandle,
+} from "./types/private/shutdown.js";
+import {
+  AgentConfig,
+  AgentExecuteCallbacks,
+  AgentExecuteOptions,
+  AgentStreamExecuteOptions,
+  AgentResult,
+  AVAILABLE_CUA_MODELS,
+  LogLine,
+  StagehandMetrics,
+  Action,
+  ActOptions,
+  ActResult,
+  defaultExtractSchema,
+  ExtractOptions,
+  HistoryEntry,
+  ObserveOptions,
+  pageTextSchema,
+  V3FunctionName,
+  AvailableModel,
+  ClientOptions,
+  ModelConfiguration,
+  LocalBrowserLaunchOptions,
+  V3Options,
+  AnyPage,
+  PatchrightPage,
+  PlaywrightPage,
+  PuppeteerPage,
+  CuaModelRequiredError,
+  StagehandInvalidArgumentError,
+  StagehandNotInitializedError,
+  MissingEnvironmentVariableError,
+  StagehandInitError,
+  AgentStreamResult,
+} from "./types/public/index.js";
+import { V3Context } from "./understudy/context.js";
+import { Page } from "./understudy/page.js";
+import { resolveModel } from "../modelUtils.js";
+import { StagehandAPIClient } from "./api.js";
+import { validateExperimentalFeatures } from "./agent/utils/validateExperimentalFeatures.js";
+import { flattenVariables } from "./agent/utils/variables.js";
+import { SessionFileLogger, logStagehandStep } from "./flowLogger.js";
+import { createTimeoutGuard } from "./handlers/handlerUtils/timeoutGuard.js";
+import { ActTimeoutError } from "./types/public/sdkErrors.js";
+
+const DEFAULT_MODEL_NAME = "openai/gpt-4.1-mini";
+const DEFAULT_VIEWPORT = { width: 1288, height: 711 };
+const DEFAULT_AGENT_TOOL_TIMEOUT_MS = 45000;
+
+type ResolvedModelConfiguration = {
+  modelName: AvailableModel;
+  clientOptions?: ClientOptions;
+};
+
+function resolveModelConfiguration(
+  model?: V3Options["model"],
+): ResolvedModelConfiguration {
+  if (!model) {
+    return { modelName: DEFAULT_MODEL_NAME };
+  }
+
+  if (typeof model === "string") {
+    return { modelName: model as AvailableModel };
+  }
+
+  if (model && typeof model === "object") {
+    const { modelName, ...clientOptions } = model;
+    if (!modelName) {
+      throw new StagehandInvalidArgumentError(
+        "model.modelName is required when providing client options.",
+      );
+    }
+    return {
+      modelName,
+      clientOptions: clientOptions as ClientOptions,
+    };
+  }
+
+  return { modelName: DEFAULT_MODEL_NAME };
+}
+
+/**
+ * V3
+ *
+ * Purpose:
+ * A high-level orchestrator for Stagehand V3. Abstracts away whether the browser
+ * runs **locally via Chrome** or remotely on **Browserbase**, and exposes simple
+ * entrypoints (`act`, `extract`, `observe`) that delegate to the corresponding
+ * handler classes.
+ *
+ * Responsibilities:
+ * - Bootstraps Chrome or Browserbase, ensures a working CDP WebSocket, and builds a `V3Context`.
+ * - Manages lifecycle: init, context access, cleanup.
+ * - Bridges external page objects (Playwright/Puppeteer) into internal frameIds for handlers.
+ * - Provides a stable API surface for downstream code regardless of runtime environment.
+ */
+export class V3 {
+  private readonly opts: V3Options;
+  private state: InitState = { kind: "UNINITIALIZED" };
+  private actHandler: ActHandler | null = null;
+  private extractHandler: ExtractHandler | null = null;
+  private observeHandler: ObserveHandler | null = null;
+  private ctx: V3Context | null = null;
+  public llmClient!: LLMClient;
+
+  /**
+   * Event bus for internal communication.
+   * Emits events like 'screenshot' when screenshots are captured during agent execution.
+   */
+  public readonly bus: EventEmitter = new EventEmitter();
+  private modelName: AvailableModel;
+  private modelClientOptions: ClientOptions;
+  private llmProvider: LLMProvider;
+  private overrideLlmClients: Map<string, LLMClient> = new Map();
+  private readonly domSettleTimeoutMs?: number;
+  private _isClosing = false;
+  public browserbaseSessionId?: string;
+  private browserbaseSessionUrl?: string;
+  private browserbaseDebugUrl?: string;
+  public get browserbaseSessionID(): string | undefined {
+    return this.browserbaseSessionId;
+  }
+  public get browserbaseSessionURL(): string | undefined {
+    return this.browserbaseSessionUrl;
+  }
+  public get browserbaseDebugURL(): string | undefined {
+    return this.browserbaseDebugUrl;
+  }
+  /**
+   * Returns true if the browser is running on Browserbase.
+   */
+  public get isBrowserbase(): boolean {
+    return this.state.kind === "BROWSERBASE";
+  }
+
+  /**
+   * Returns true if advancedStealth is enabled in Browserbase settings.
+   */
+  public get isAdvancedStealth(): boolean {
+    return (
+      this.opts.browserbaseSessionCreateParams?.browserSettings
+        ?.advancedStealth === true
+    );
+  }
+
+  /**
+   * Returns the configured viewport dimensions from launch options.
+   * Falls back to default 1288x711 if not configured.
+   */
+  public get configuredViewport(): { width: number; height: number } {
+    const defaultWidth = 1288;
+    const defaultHeight = 711;
+
+    if (this.opts.env === "BROWSERBASE") {
+      const vp =
+        this.opts.browserbaseSessionCreateParams?.browserSettings?.viewport;
+      return {
+        width: vp?.width ?? defaultWidth,
+        height: vp?.height ?? defaultHeight,
+      };
+    }
+
+    // LOCAL env
+    const vp = this.opts.localBrowserLaunchOptions?.viewport;
+    return {
+      width: vp?.width ?? defaultWidth,
+      height: vp?.height ?? defaultHeight,
+    };
+  }
+
+  private _onCdpClosed = (why: string) => {
+    if (this.state.kind === "BROWSERBASE") {
+      void this._logBrowserbaseSessionStatus();
+    }
+
+    // Single place to react to the transport closing
+    this._immediateShutdown(`CDP transport closed: ${why}`).catch(() => {});
+  };
+  public readonly experimental: boolean = false;
+  public readonly logInferenceToFile: boolean = false;
+  public readonly disableAPI: boolean = false;
+  private externalLogger?: (logLine: LogLine) => void;
+  public verbose: 0 | 1 | 2 = 1;
+  private stagehandLogger: StagehandLogger;
+  private _history: Array<HistoryEntry> = [];
+  private readonly instanceId: string;
+  private static _processGuardsInstalled = false;
+  private static _instances: Set<V3> = new Set();
+  private cacheStorage: CacheStorage;
+  private actCache: ActCache;
+  private agentCache: AgentCache;
+  private apiClient: StagehandAPIClient | null = null;
+  private keepAlive?: boolean;
+  private shutdownSupervisor: ShutdownSupervisorHandle | null = null;
+
+  public stagehandMetrics: StagehandMetrics = {
+    actPromptTokens: 0,
+    actCompletionTokens: 0,
+    actReasoningTokens: 0,
+    actCachedInputTokens: 0,
+    actInferenceTimeMs: 0,
+    extractPromptTokens: 0,
+    extractCompletionTokens: 0,
+    extractReasoningTokens: 0,
+    extractCachedInputTokens: 0,
+    extractInferenceTimeMs: 0,
+    observePromptTokens: 0,
+    observeCompletionTokens: 0,
+    observeReasoningTokens: 0,
+    observeCachedInputTokens: 0,
+    observeInferenceTimeMs: 0,
+    agentPromptTokens: 0,
+    agentCompletionTokens: 0,
+    agentReasoningTokens: 0,
+    agentCachedInputTokens: 0,
+    agentInferenceTimeMs: 0,
+    totalPromptTokens: 0,
+    totalCompletionTokens: 0,
+    totalReasoningTokens: 0,
+    totalCachedInputTokens: 0,
+    totalInferenceTimeMs: 0,
+  };
+
+  constructor(opts: V3Options) {
+    this.externalLogger = opts.logger;
+    this.verbose = opts.verbose ?? 1;
+    this.instanceId = uuidv7();
+    this.keepAlive =
+      opts.keepAlive ?? opts.browserbaseSessionCreateParams?.keepAlive;
+
+    // Create per-instance StagehandLogger (handles usePino, verbose, externalLogger)
+    // This gives each V3 instance independent logger configuration
+    // while still sharing the underlying Pino worker thread via StagehandLogger.sharedPinoLogger
+    const loggerOptions: LoggerOptions = {
+      pretty: true,
+      level: "info", // Most permissive - filtering happens at instance level
+    };
+
+    if (opts.disablePino !== undefined) {
+      loggerOptions.usePino = !opts.disablePino;
+    }
+
+    this.stagehandLogger = new StagehandLogger(loggerOptions, opts.logger);
+    this.stagehandLogger.setVerbosity(this.verbose);
+
+    // Also bind to AsyncLocalStorage for v3Logger() calls from handlers
+    // This maintains backward compatibility with code that uses v3Logger() directly
+    try {
+      if (this.externalLogger) {
+        // Use external logger directly when provided
+        bindInstanceLogger(this.instanceId, this.externalLogger);
+      } else {
+        // Fall back to stagehandLogger when no external logger
+        bindInstanceLogger(this.instanceId, (line) => {
+          this.stagehandLogger.log(line);
+        });
+      }
+    } catch {
+      // ignore
+    }
+    const { modelName, clientOptions } = resolveModelConfiguration(opts.model);
+    this.modelName = modelName;
+    this.experimental = opts.experimental ?? false;
+    this.logInferenceToFile = opts.logInferenceToFile ?? false;
+    this.llmProvider = new LLMProvider(this.logger);
+    this.domSettleTimeoutMs = opts.domSettleTimeout;
+    this.disableAPI = opts.disableAPI ?? false;
+
+    const baseClientOptions: ClientOptions = clientOptions
+      ? ({ ...clientOptions } as ClientOptions)
+      : ({} as ClientOptions);
+    if (opts.llmClient) {
+      this.llmClient = opts.llmClient;
+      this.modelClientOptions = baseClientOptions;
+      this.disableAPI = true;
+    } else {
+      // Ensure API key is set
+      let apiKey = (baseClientOptions as { apiKey?: string }).apiKey;
+      if (!apiKey) {
+        try {
+          apiKey = loadApiKeyFromEnv(
+            this.modelName.split("/")[0], // "openai", "anthropic", etc
+            this.logger,
+          );
+        } catch (error) {
+          this.logger({
+            category: "init",
+            message: `Error loading API key for model ${this.modelName}: ${error}. Continuing without LLM client.`,
+            level: 0,
+          });
+          throw error;
+        }
+      }
+      this.modelClientOptions = {
+        ...baseClientOptions,
+        apiKey,
+      } as ClientOptions;
+
+      // Get the default client for this model
+      this.llmClient = this.llmProvider.getClient(
+        this.modelName,
+        this.modelClientOptions,
+        { experimental: this.experimental, disableAPI: this.disableAPI },
+      );
+    }
+
+    this.cacheStorage = CacheStorage.create(opts.cacheDir, this.logger, {
+      label: "cache directory",
+    });
+    this.actCache = new ActCache({
+      storage: this.cacheStorage,
+      logger: this.logger,
+      getActHandler: () => this.actHandler,
+      getDefaultLlmClient: () => this.resolveLlmClient(),
+      domSettleTimeoutMs: this.domSettleTimeoutMs,
+    });
+    this.agentCache = new AgentCache({
+      storage: this.cacheStorage,
+      logger: this.logger,
+      getActHandler: () => this.actHandler,
+      getContext: () => this.ctx,
+      getDefaultLlmClient: () => this.resolveLlmClient(),
+      getBaseModelName: () => this.modelName,
+      getSystemPrompt: () => opts.systemPrompt,
+      domSettleTimeoutMs: this.domSettleTimeoutMs,
+      act: this.act.bind(this),
+    });
+
+    this.opts = opts;
+
+    // Initialize session file logger
+    SessionFileLogger.init(this.instanceId, opts);
+
+    // Track instance for global process guard handling
+    V3._instances.add(this);
+  }
+
+  /**
+   * Async property for metrics so callers can `await v3.metrics`.
+   * When using API mode, fetches metrics from the API. Otherwise returns local metrics.
+   */
+  public get metrics(): Promise<StagehandMetrics> {
+    if (this.apiClient) {
+      // Fetch metrics from the API
+      return this.apiClient.getReplayMetrics().catch((error) => {
+        this.logger({
+          category: "metrics",
+          message: `Failed to fetch metrics from API: ${error}`,
+          level: 0,
+        });
+        // Fall back to local metrics on error
+        return this.stagehandMetrics;
+      });
+    }
+    // Return local metrics wrapped in a Promise for consistency
+    return Promise.resolve(this.stagehandMetrics);
+  }
+
+  private resolveLlmClient(model?: ModelConfiguration): LLMClient {
+    if (!model) {
+      return this.llmClient;
+    }
+
+    let modelName: AvailableModel | string;
+    let clientOptions: ClientOptions | undefined;
+
+    if (typeof model === "string") {
+      modelName = model;
+    } else {
+      const { modelName: overrideModelName, ...rest } = model;
+      modelName = overrideModelName;
+      clientOptions = rest as ClientOptions;
+    }
+
+    if (
+      modelName === this.modelName &&
+      (!clientOptions || Object.keys(clientOptions).length === 0)
+    ) {
+      return this.llmClient;
+    }
+
+    const overrideProvider = String(modelName).split("/")[0];
+    const baseProvider = String(this.modelName).split("/")[0];
+
+    const mergedOptions = {
+      ...(overrideProvider === baseProvider ? this.modelClientOptions : {}),
+      ...(clientOptions ?? {}),
+    } as ClientOptions;
+
+    const providerKey = overrideProvider;
+    if (!(mergedOptions as { apiKey?: string }).apiKey) {
+      const apiKey = loadApiKeyFromEnv(providerKey, this.logger);
+      if (apiKey) {
+        (mergedOptions as { apiKey?: string }).apiKey = apiKey;
+      }
+    }
+
+    const cacheKey = JSON.stringify({
+      modelName,
+      clientOptions: mergedOptions,
+    });
+
+    const cached = this.overrideLlmClients.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const client = this.llmProvider.getClient(
+      modelName as AvailableModel,
+      mergedOptions,
+      { experimental: this.experimental, disableAPI: this.disableAPI },
+    );
+
+    this.overrideLlmClients.set(cacheKey, client);
+    return client;
+  }
+
+  private beginAgentReplayRecording(): void {
+    this.agentCache.beginRecording();
+  }
+
+  private endAgentReplayRecording(): AgentReplayStep[] {
+    return this.agentCache.endRecording();
+  }
+
+  private discardAgentReplayRecording(): void {
+    this.agentCache.discardRecording();
+  }
+
+  private isAgentReplayRecording(): boolean {
+    return this.agentCache.isRecording();
+  }
+
+  public isAgentReplayActive(): boolean {
+    return this.agentCache.isReplayActive();
+  }
+
+  public recordAgentReplayStep(step: AgentReplayStep): void {
+    this.agentCache.recordStep(step);
+  }
+
+  /**
+   * Async property for history so callers can `await v3.history`.
+   * Returns a frozen copy to avoid external mutation.
+   */
+  public get history(): Promise<ReadonlyArray<HistoryEntry>> {
+    return Promise.resolve(Object.freeze([...this._history]));
+  }
+
+  public addToHistory(
+    method: HistoryEntry["method"],
+    parameters: unknown,
+    result?: unknown,
+  ): void {
+    this._history.push({
+      method,
+      parameters,
+      result: result ?? null,
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  public updateMetrics(
+    functionName: V3FunctionName,
+    promptTokens: number,
+    completionTokens: number,
+    reasoningTokens: number,
+    cachedInputTokens: number,
+    inferenceTimeMs: number,
+  ): void {
+    switch (functionName) {
+      case V3FunctionName.ACT:
+        this.stagehandMetrics.actPromptTokens += promptTokens;
+        this.stagehandMetrics.actCompletionTokens += completionTokens;
+        this.stagehandMetrics.actReasoningTokens += reasoningTokens;
+        this.stagehandMetrics.actCachedInputTokens += cachedInputTokens;
+        this.stagehandMetrics.actInferenceTimeMs += inferenceTimeMs;
+        break;
+
+      case V3FunctionName.EXTRACT:
+        this.stagehandMetrics.extractPromptTokens += promptTokens;
+        this.stagehandMetrics.extractCompletionTokens += completionTokens;
+        this.stagehandMetrics.extractReasoningTokens += reasoningTokens;
+        this.stagehandMetrics.extractCachedInputTokens += cachedInputTokens;
+        this.stagehandMetrics.extractInferenceTimeMs += inferenceTimeMs;
+        break;
+
+      case V3FunctionName.OBSERVE:
+        this.stagehandMetrics.observePromptTokens += promptTokens;
+        this.stagehandMetrics.observeCompletionTokens += completionTokens;
+        this.stagehandMetrics.observeReasoningTokens += reasoningTokens;
+        this.stagehandMetrics.observeCachedInputTokens += cachedInputTokens;
+        this.stagehandMetrics.observeInferenceTimeMs += inferenceTimeMs;
+        break;
+
+      case V3FunctionName.AGENT:
+        this.stagehandMetrics.agentPromptTokens += promptTokens;
+        this.stagehandMetrics.agentCompletionTokens += completionTokens;
+        this.stagehandMetrics.agentReasoningTokens += reasoningTokens;
+        this.stagehandMetrics.agentCachedInputTokens += cachedInputTokens;
+        this.stagehandMetrics.agentInferenceTimeMs += inferenceTimeMs;
+        break;
+    }
+    this.updateTotalMetrics(
+      promptTokens,
+      completionTokens,
+      reasoningTokens,
+      cachedInputTokens,
+      inferenceTimeMs,
+    );
+  }
+
+  private updateTotalMetrics(
+    promptTokens: number,
+    completionTokens: number,
+    reasoningTokens: number,
+    cachedInputTokens: number,
+    inferenceTimeMs: number,
+  ): void {
+    this.stagehandMetrics.totalPromptTokens += promptTokens;
+    this.stagehandMetrics.totalCompletionTokens += completionTokens;
+    this.stagehandMetrics.totalReasoningTokens += reasoningTokens;
+    this.stagehandMetrics.totalCachedInputTokens += cachedInputTokens;
+    this.stagehandMetrics.totalInferenceTimeMs += inferenceTimeMs;
+  }
+
+  private async _immediateShutdown(reason: string): Promise<void> {
+    try {
+      this.logger({
+        category: "v3",
+        message: `initiating shutdown → ${reason}`,
+        level: 0,
+      });
+    } catch {
+      //
+    }
+
+    try {
+      this.logger({
+        category: "v3",
+        message: `closing resources → ${reason}`,
+        level: 0,
+      });
+      await this.close({ force: true });
+    } catch {
+      // swallow — already shutting down
+    }
+  }
+
+  /** Spawn a crash-only supervisor that cleans up when this process dies. */
+  private startShutdownSupervisor(
+    config: ShutdownSupervisorConfig,
+  ): ShutdownSupervisorHandle | null {
+    if (this.shutdownSupervisor) return this.shutdownSupervisor;
+    this.shutdownSupervisor = startShutdownSupervisor(config, {
+      onError: (error, context) => {
+        try {
+          this.logger({
+            category: "v3",
+            message:
+              "Shutdown supervisor unavailable; crash cleanup disabled. " +
+              "If this process exits unexpectedly, local Chrome or Browserbase " +
+              "sessions may remain running even with keepAlive=false.",
+            level: 0,
+            auxiliary: {
+              context: { value: context, type: "string" },
+              error: { value: error.message, type: "string" },
+            },
+          });
+        } catch {
+          // ignore logging failures
+        }
+      },
+    });
+    return this.shutdownSupervisor;
+  }
+
+  /** Stop the supervisor during a normal shutdown. */
+  private stopShutdownSupervisor(): void {
+    if (!this.shutdownSupervisor) return;
+    try {
+      this.shutdownSupervisor.stop();
+    } catch {
+      // best-effort
+    }
+    this.shutdownSupervisor = null;
+  }
+
+  /**
+   * Entrypoint: initializes handlers, launches Chrome or Browserbase,
+   * and sets up a CDP context.
+   */
+  async init(): Promise<void> {
+    try {
+      return await withInstanceLogContext(this.instanceId, async () => {
+        this.actHandler = new ActHandler(
+          this.llmClient,
+          this.modelName,
+          this.modelClientOptions,
+          (model) => this.resolveLlmClient(model),
+          this.opts.systemPrompt ?? "",
+          this.logInferenceToFile,
+          this.opts.selfHeal ?? true,
+          (
+            functionName,
+            promptTokens,
+            completionTokens,
+            reasoningTokens,
+            cachedInputTokens,
+            inferenceTimeMs,
+          ) =>
+            this.updateMetrics(
+              functionName,
+              promptTokens,
+              completionTokens,
+              reasoningTokens,
+              cachedInputTokens,
+              inferenceTimeMs,
+            ),
+          this.domSettleTimeoutMs,
+        );
+        this.extractHandler = new ExtractHandler(
+          this.llmClient,
+          this.modelName,
+          this.modelClientOptions,
+          (model) => this.resolveLlmClient(model),
+          this.opts.systemPrompt ?? "",
+          this.logInferenceToFile,
+          this.experimental,
+          (
+            functionName,
+            promptTokens,
+            completionTokens,
+            reasoningTokens,
+            cachedInputTokens,
+            inferenceTimeMs,
+          ) =>
+            this.updateMetrics(
+              functionName,
+              promptTokens,
+              completionTokens,
+              reasoningTokens,
+              cachedInputTokens,
+              inferenceTimeMs,
+            ),
+        );
+        this.observeHandler = new ObserveHandler(
+          this.llmClient,
+          this.modelName,
+          this.modelClientOptions,
+          (model) => this.resolveLlmClient(model),
+          this.opts.systemPrompt ?? "",
+          this.logInferenceToFile,
+          this.experimental,
+          (
+            functionName,
+            promptTokens,
+            completionTokens,
+            reasoningTokens,
+            cachedInputTokens,
+            inferenceTimeMs,
+          ) =>
+            this.updateMetrics(
+              functionName,
+              promptTokens,
+              completionTokens,
+              reasoningTokens,
+              cachedInputTokens,
+              inferenceTimeMs,
+            ),
+        );
+        if (this.opts.env === "LOCAL") {
+          // chrome-launcher conditionally adds --headless when the environment variable
+          // HEADLESS is set, without parsing its value.
+          // if it is not equal to true, then we delete it from the process
+          const envHeadless = process.env.HEADLESS;
+          if (envHeadless !== undefined) {
+            const normalized = envHeadless.trim().toLowerCase();
+            if (normalized !== "true") {
+              delete process.env.HEADLESS;
+            }
+          }
+          const lbo: LocalBrowserLaunchOptions =
+            this.opts.localBrowserLaunchOptions ?? {};
+
+          if (lbo.cdpHeaders && !lbo.cdpUrl) {
+            this.logger({
+              category: "init",
+              message:
+                "`cdpHeaders` was provided but `cdpUrl` is not set — cdpHeaders will be ignored. Set `cdpUrl` to connect to an existing browser via CDP.",
+              level: 2,
+            });
+          }
+
+          // If a CDP URL is provided, attach instead of launching.
+          if (lbo.cdpUrl) {
+            this.logger({
+              category: "init",
+              message: "Connecting to local browser",
+              level: 1,
+            });
+            this.ctx = await V3Context.create(lbo.cdpUrl, {
+              env: "LOCAL",
+              cdpHeaders: lbo.cdpHeaders,
+            });
+            const logCtx = SessionFileLogger.getContext();
+            this.ctx.conn.cdpLogger = (info) =>
+              SessionFileLogger.logCdpCallEvent(info, logCtx);
+            this.ctx.conn.cdpEventLogger = (info) =>
+              SessionFileLogger.logCdpMessageEvent(info, logCtx);
+            this.ctx.conn.onTransportClosed(this._onCdpClosed);
+            this.state = {
+              kind: "LOCAL",
+              // no LaunchedChrome when attaching externally; create a stub kill
+              chrome: {
+                kill: async () => {},
+              } as unknown as import("chrome-launcher").LaunchedChrome,
+              ws: lbo.cdpUrl,
+            };
+            this.resetBrowserbaseSessionMetadata();
+            // Post-connect settings (downloads and viewport) if provided
+            await this._applyPostConnectLocalOptions(lbo);
+            return;
+          }
+          this.logger({
+            category: "init",
+            message: "Launching local browser",
+            level: 1,
+          });
+
+          // Determine or create user data dir
+          let userDataDir = lbo.userDataDir;
+          let createdTemp = false;
+          if (!userDataDir) {
+            const base = path.join(os.tmpdir(), "stagehand-v3");
+            fs.mkdirSync(base, { recursive: true });
+            userDataDir = fs.mkdtempSync(path.join(base, "profile-"));
+            createdTemp = true;
+          }
+
+          // Build chrome flags
+          const defaults = [
+            "--remote-allow-origins=*",
+            "--no-first-run",
+            "--no-default-browser-check",
+            "--disable-dev-shm-usage",
+            "--site-per-process",
+          ];
+          let chromeFlags: string[];
+          const ignore = lbo.ignoreDefaultArgs;
+          if (ignore === true) {
+            // drop defaults
+            chromeFlags = [];
+          } else if (Array.isArray(ignore)) {
+            chromeFlags = defaults.filter(
+              (f) => !ignore.some((ex) => f.includes(ex)),
+            );
+          } else {
+            chromeFlags = [...defaults];
+          }
+
+          // headless handled by launchLocalChrome
+          if (lbo.devtools) chromeFlags.push("--auto-open-devtools-for-tabs");
+          if (lbo.locale) chromeFlags.push(`--lang=${lbo.locale}`);
+          if (!lbo.viewport) {
+            lbo.viewport = DEFAULT_VIEWPORT;
+          }
+          if (lbo.viewport?.width && lbo.viewport?.height) {
+            chromeFlags.push(
+              `--window-size=${lbo.viewport.width},${lbo.viewport.height + 87}`, // Added pixels to the window to account for the address bar
+            );
+          }
+          if (typeof lbo.deviceScaleFactor === "number") {
+            chromeFlags.push(
+              `--force-device-scale-factor=${Math.max(0.1, lbo.deviceScaleFactor)}`,
+            );
+          }
+          if (lbo.hasTouch) chromeFlags.push("--touch-events=enabled");
+          if (lbo.ignoreHTTPSErrors)
+            chromeFlags.push("--ignore-certificate-errors");
+          if (lbo.proxy?.server)
+            chromeFlags.push(`--proxy-server=${lbo.proxy.server}`);
+          if (lbo.proxy?.bypass)
+            chromeFlags.push(`--proxy-bypass-list=${lbo.proxy.bypass}`);
+
+          // add user-supplied args last
+          if (Array.isArray(lbo.args)) chromeFlags.push(...lbo.args);
+
+          const keepAlive = this.keepAlive === true;
+          const { ws, chrome } = await launchLocalChrome({
+            chromePath: lbo.executablePath,
+            chromeFlags,
+            port: lbo.port,
+            headless: lbo.headless,
+            userDataDir,
+            connectTimeoutMs: lbo.connectTimeoutMs,
+            handleSIGINT: !keepAlive,
+          });
+          if (keepAlive) {
+            try {
+              chrome.process?.unref?.();
+            } catch {
+              // best-effort: avoid keeping the event loop alive
+            }
+          }
+          this.ctx = await V3Context.create(ws, {
+            env: "LOCAL",
+            localBrowserLaunchOptions: lbo,
+          });
+          const logCtx = SessionFileLogger.getContext();
+          this.ctx.conn.cdpLogger = (info) =>
+            SessionFileLogger.logCdpCallEvent(info, logCtx);
+          this.ctx.conn.cdpEventLogger = (info) =>
+            SessionFileLogger.logCdpMessageEvent(info, logCtx);
+          this.ctx.conn.onTransportClosed(this._onCdpClosed);
+          this.state = {
+            kind: "LOCAL",
+            chrome,
+            ws,
+            userDataDir,
+            createdTempProfile: createdTemp,
+            preserveUserDataDir: !!lbo.preserveUserDataDir,
+          };
+          this.resetBrowserbaseSessionMetadata();
+          const chromePid = chrome.process?.pid ?? chrome.pid;
+          if (!keepAlive && chromePid) {
+            this.startShutdownSupervisor({
+              kind: "LOCAL",
+              pid: chromePid,
+              userDataDir,
+              createdTempProfile: createdTemp,
+              preserveUserDataDir: !!lbo.preserveUserDataDir,
+            });
+          }
+
+          // Post-connect settings (downloads and viewport) if provided
+          await this._applyPostConnectLocalOptions(lbo);
+          return;
+        }
+
+        if (this.opts.env === "BROWSERBASE") {
+          const { apiKey, projectId } = this.requireBrowserbaseCreds();
+          this.logger({
+            category: "init",
+            message: "Starting browserbase session",
+            level: 1,
+          });
+          const baseSessionParams =
+            this.opts.browserbaseSessionCreateParams ?? {};
+          const resolvedKeepAlive = this.keepAlive;
+          const keepAlive = this.keepAlive === true;
+          const effectiveSessionParams =
+            resolvedKeepAlive !== undefined
+              ? { ...baseSessionParams, keepAlive: resolvedKeepAlive }
+              : baseSessionParams;
+          if (!this.disableAPI && !this.experimental) {
+            this.apiClient = new StagehandAPIClient({
+              apiKey,
+              projectId,
+              logger: this.logger,
+              serverCache: this.opts.serverCache,
+            });
+            const {
+              projectId: overrideProjectId,
+              browserSettings,
+              userMetadata,
+              ...restSessionParams
+            } = effectiveSessionParams;
+            const resolvedProjectId = overrideProjectId ?? projectId;
+            const createSessionPayload = {
+              ...(resolvedProjectId ? { projectId: resolvedProjectId } : {}),
+              ...restSessionParams,
+              browserSettings: {
+                ...(browserSettings ?? {}),
+                viewport: browserSettings?.viewport ?? {
+                  width: 1288,
+                  height: 711,
+                },
+              },
+              userMetadata: {
+                ...(userMetadata ?? {}),
+                stagehand: "true",
+              },
+            };
+            const { sessionId, available } = await this.apiClient.init({
+              modelName: this.modelName,
+              modelApiKey: this.modelClientOptions.apiKey,
+              domSettleTimeoutMs: this.domSettleTimeoutMs,
+              verbose: this.verbose,
+              systemPrompt: this.opts.systemPrompt,
+              selfHeal: this.opts.selfHeal,
+              browserbaseSessionCreateParams: createSessionPayload,
+              browserbaseSessionID: this.opts.browserbaseSessionID,
+            });
+            if (!available) {
+              this.apiClient = null;
+            }
+            this.opts.browserbaseSessionID = sessionId;
+          }
+          const { ws, sessionId, bb } = await createBrowserbaseSession(
+            apiKey,
+            projectId,
+            effectiveSessionParams,
+            this.opts.browserbaseSessionID,
+          );
+          this.ctx = await V3Context.create(ws, {
+            env: "BROWSERBASE",
+            apiClient: this.apiClient,
+          });
+          const logCtx = SessionFileLogger.getContext();
+          this.ctx.conn.cdpLogger = (info) =>
+            SessionFileLogger.logCdpCallEvent(info, logCtx);
+          this.ctx.conn.cdpEventLogger = (info) =>
+            SessionFileLogger.logCdpMessageEvent(info, logCtx);
+          this.ctx.conn.onTransportClosed(this._onCdpClosed);
+          this.state = { kind: "BROWSERBASE", sessionId, ws, bb };
+          this.browserbaseSessionId = sessionId;
+          if (!keepAlive && !this.disableAPI) {
+            this.startShutdownSupervisor({
+              kind: "STAGEHAND_API",
+              sessionId,
+              apiKey,
+              projectId,
+            });
+          }
+
+          await this._ensureBrowserbaseDownloadsEnabled();
+
+          const resumed = !!this.opts.browserbaseSessionID;
+          let debugUrl: string | undefined;
+          try {
+            const dbg = (await bb.sessions.debug(sessionId)) as unknown as {
+              debuggerUrl?: string;
+            };
+            debugUrl = dbg?.debuggerUrl;
+          } catch {
+            // Ignore debug fetch failures; continue with sessionUrl only
+          }
+          const sessionUrl = `https://www.browserbase.com/sessions/${sessionId}`;
+          this.browserbaseSessionUrl = sessionUrl;
+          this.browserbaseDebugUrl = debugUrl;
+
+          try {
+            this.logger({
+              category: "init",
+              message: resumed
+                ? this.apiClient
+                  ? "Browserbase session started"
+                  : "Browserbase session resumed"
+                : "Browserbase session started",
+              level: 1,
+              auxiliary: {
+                sessionUrl: { value: sessionUrl, type: "string" },
+                ...(debugUrl && {
+                  debugUrl: { value: debugUrl, type: "string" },
+                }),
+                sessionId: { value: sessionId, type: "string" },
+              },
+            });
+          } catch {
+            // best-effort logging — ignore failures
+          }
+          return;
+        }
+
+        const neverEnv: never = this.opts.env;
+        throw new StagehandInitError(`Unsupported env: ${neverEnv}`);
+      });
+    } catch (error) {
+      // Cleanup instanceLoggers map on init failure to prevent memory leak
+      if (this.externalLogger) {
+        try {
+          unbindInstanceLogger(this.instanceId);
+        } catch {
+          // ignore cleanup errors
+        }
+      }
+      throw error;
+    }
+  }
+
+  /** Apply post-connect local browser options that require CDP. */
+  private async _applyPostConnectLocalOptions(
+    lbo: LocalBrowserLaunchOptions,
+  ): Promise<void> {
+    try {
+      // Downloads behavior
+      if (lbo.downloadsPath || lbo.acceptDownloads !== undefined) {
+        const behavior = lbo.acceptDownloads === false ? "deny" : "allow";
+        await this.ctx?.conn
+          .send("Browser.setDownloadBehavior", {
+            behavior,
+            downloadPath: lbo.downloadsPath,
+            eventsEnabled: true,
+          })
+          .catch(() => {});
+      }
+    } catch {
+      // best-effort only
+    }
+  }
+
+  private async _ensureBrowserbaseDownloadsEnabled(): Promise<void> {
+    const conn = this.ctx?.conn;
+    if (!conn) return;
+    try {
+      await conn.send("Browser.setDownloadBehavior", {
+        behavior: "allow",
+        downloadPath: "downloads",
+        eventsEnabled: true,
+      });
+    } catch {
+      // best-effort only
+    }
+  }
+
+  private resetBrowserbaseSessionMetadata(): void {
+    this.browserbaseSessionId = undefined;
+    this.browserbaseSessionUrl = undefined;
+    this.browserbaseDebugUrl = undefined;
+  }
+
+  /**
+   * Run an "act" instruction through the ActHandler.
+   *
+   * New API:
+   * - act(instruction: string, options?: ActOptions)
+   * - act(action: Action, options?: ActOptions)
+   */
+  async act(instruction: string, options?: ActOptions): Promise<ActResult>;
+  async act(action: Action, options?: ActOptions): Promise<ActResult>;
+
+  @logStagehandStep("Stagehand.act", "ACT")
+  async act(input: string | Action, options?: ActOptions): Promise<ActResult> {
+    return await withInstanceLogContext(this.instanceId, async () => {
+      if (!this.actHandler) throw new StagehandNotInitializedError("act()");
+
+      let actResult: ActResult;
+
+      if (isObserveResult(input)) {
+        // Resolve page: use provided page if any, otherwise default active page
+        const v3Page = await this.resolvePage(options?.page);
+
+        // Use selector as provided to support XPath, CSS, and other engines
+        const selector = input.selector;
+        if (this.apiClient) {
+          actResult = await this.apiClient.act({
+            input,
+            options,
+            frameId: v3Page.mainFrameId(),
+          });
+        } else {
+          const ensureTimeRemaining = createTimeoutGuard(
+            options?.timeout,
+            (ms) => new ActTimeoutError(ms),
+          );
+          actResult = await this.actHandler.takeDeterministicAction(
+            { ...input, selector },
+            v3Page,
+            this.domSettleTimeoutMs,
+            this.resolveLlmClient(options?.model),
+            ensureTimeRemaining,
+            options?.variables,
+          );
+        }
+
+        // history: record ObserveResult-based act call
+        this.addToHistory(
+          "act",
+          {
+            observeResult: input,
+          },
+          actResult,
+        );
+        return actResult;
+      }
+      // instruction path
+      if (typeof input !== "string" || !input.trim()) {
+        throw new StagehandInvalidArgumentError(
+          "act(): instruction string is required unless passing an Action",
+        );
+      }
+
+      // Resolve page from options or default
+      const page = await this.resolvePage(options?.page);
+      const actCacheLlmClient = options?.model
+        ? this.resolveLlmClient(options.model)
+        : undefined;
+
+      let actCacheContext: Awaited<
+        ReturnType<typeof this.actCache.prepareContext>
+      > | null = null;
+      const canUseCache =
+        typeof input === "string" &&
+        !this.isAgentReplayRecording() &&
+        this.actCache.enabled;
+      if (canUseCache) {
+        actCacheContext = await this.actCache.prepareContext(
+          input,
+          page,
+          flattenVariables(options?.variables),
+        );
+        if (actCacheContext) {
+          const cachedResult = await this.actCache.tryReplay(
+            actCacheContext,
+            page,
+            options?.timeout,
+            actCacheLlmClient,
+          );
+          if (cachedResult) {
+            this.addToHistory(
+              "act",
+              {
+                instruction: input,
+                variables: options?.variables,
+                timeout: options?.timeout,
+                cacheHit: true,
+              },
+              cachedResult,
+            );
+            return cachedResult;
+          }
+        }
+      }
+
+      const handlerParams: ActHandlerParams = {
+        instruction: input,
+        page,
+        variables: options?.variables,
+        timeout: options?.timeout,
+        model: options?.model,
+      };
+      if (this.apiClient) {
+        const frameId = page.mainFrameId();
+        actResult = await this.apiClient.act({ input, options, frameId });
+      } else {
+        actResult = await this.actHandler.act(handlerParams);
+      }
+      // history: record instruction-based act call (omit page object)
+      this.addToHistory(
+        "act",
+        {
+          instruction: input,
+          variables: options?.variables,
+          timeout: options?.timeout,
+        },
+        actResult,
+      );
+
+      if (
+        actCacheContext &&
+        actResult.success &&
+        Array.isArray(actResult.actions) &&
+        actResult.actions.length > 0
+      ) {
+        await this.actCache.store(actCacheContext, actResult);
+      }
+      return actResult;
+    });
+  }
+
+  /**
+   * Run an "extract" instruction through the ExtractHandler.
+   *
+   * Accepted forms:
+   * - extract() → pageText
+   * - extract(options) → pageText
+   * - extract(instruction) → defaultExtractSchema
+   * - extract(instruction, schema) → schema-inferred
+   * - extract(instruction, schema, options)
+   */
+
+  async extract(): Promise<z.infer<typeof pageTextSchema>>;
+  async extract(
+    options: ExtractOptions,
+  ): Promise<z.infer<typeof pageTextSchema>>;
+  async extract(
+    instruction: string,
+    options?: ExtractOptions,
+  ): Promise<z.infer<typeof defaultExtractSchema>>;
+  async extract<T extends StagehandZodSchema>(
+    instruction: string,
+    schema: T,
+    options?: ExtractOptions,
+  ): Promise<InferStagehandSchema<T>>;
+
+  @logStagehandStep("Stagehand.extract", "EXTRACT")
+  async extract(
+    a?: string | ExtractOptions,
+    b?: StagehandZodSchema | ExtractOptions,
+    c?: ExtractOptions,
+  ): Promise<unknown> {
+    return await withInstanceLogContext(this.instanceId, async () => {
+      if (!this.extractHandler) {
+        throw new StagehandNotInitializedError("extract()");
+      }
+
+      // Normalize args
+      let instruction: string | undefined;
+      let schema: StagehandZodSchema | undefined;
+      let options: ExtractOptions | undefined;
+
+      if (typeof a === "string") {
+        instruction = a;
+        const isZodSchema = (val: unknown): val is StagehandZodSchema =>
+          !!val &&
+          typeof val === "object" &&
+          "parse" in val &&
+          "safeParse" in val;
+        if (isZodSchema(b)) {
+          schema = b as StagehandZodSchema;
+          options = c as ExtractOptions | undefined;
+        } else {
+          options = b as ExtractOptions | undefined;
+        }
+      } else {
+        // a is options or undefined
+        options = (a as ExtractOptions) || undefined;
+      }
+
+      if (!instruction && schema) {
+        throw new StagehandInvalidArgumentError(
+          "extract(): schema provided without instruction",
+        );
+      }
+
+      // If instruction without schema → defaultExtractSchema
+      const effectiveSchema =
+        instruction && !schema ? defaultExtractSchema : schema;
+
+      // Resolve page from options or use active page
+      const page = await this.resolvePage(options?.page);
+
+      const handlerParams: ExtractHandlerParams<StagehandZodSchema> = {
+        instruction,
+        schema: effectiveSchema as StagehandZodSchema | undefined,
+        model: options?.model,
+        timeout: options?.timeout,
+        selector: options?.selector,
+        page,
+      };
+      let result: z.infer<typeof effectiveSchema> | { pageText: string };
+      if (this.apiClient) {
+        const frameId = page.mainFrameId();
+        result = await this.apiClient.extract({
+          instruction: handlerParams.instruction,
+          schema: handlerParams.schema,
+          options,
+          frameId,
+        });
+      } else {
+        result =
+          await this.extractHandler.extract<StagehandZodSchema>(handlerParams);
+      }
+      const historySchemaDescriptor = effectiveSchema
+        ? toJsonSchema(effectiveSchema)
+        : undefined;
+      this.addToHistory(
+        "extract",
+        {
+          instruction,
+          selector: options?.selector,
+          timeout: options?.timeout,
+          schema: historySchemaDescriptor,
+        },
+        result,
+      );
+      return result;
+    });
+  }
+
+  /**
+   * Run an "observe" instruction through the ObserveHandler.
+   */
+  async observe(): Promise<Action[]>;
+  async observe(options: ObserveOptions): Promise<Action[]>;
+  async observe(
+    instruction: string,
+    options?: ObserveOptions,
+  ): Promise<Action[]>;
+  @logStagehandStep("Stagehand.observe", "OBSERVE")
+  async observe(
+    a?: string | ObserveOptions,
+    b?: ObserveOptions,
+  ): Promise<Action[]> {
+    return await withInstanceLogContext(this.instanceId, async () => {
+      if (!this.observeHandler) {
+        throw new StagehandNotInitializedError("observe()");
+      }
+
+      // Normalize args
+      let instruction: string | undefined;
+      let options: ObserveOptions | undefined;
+      if (typeof a === "string") {
+        instruction = a;
+        options = b;
+      } else {
+        options = a as ObserveOptions | undefined;
+      }
+
+      // Resolve to our internal Page type
+      const page = await this.resolvePage(options?.page);
+
+      const handlerParams: ObserveHandlerParams = {
+        instruction,
+        model: options?.model,
+        timeout: options?.timeout,
+        selector: options?.selector,
+        page: page!,
+      };
+
+      let results: Action[];
+      if (this.apiClient) {
+        const frameId = page.mainFrameId();
+        results = await this.apiClient.observe({
+          instruction,
+          options,
+          frameId,
+        });
+      } else {
+        results = await this.observeHandler.observe(handlerParams);
+      }
+
+      // history: record observe call (omit page object)
+      this.addToHistory(
+        "observe",
+        {
+          instruction,
+          timeout: options?.timeout,
+        },
+        results,
+      );
+      return results;
+    });
+  }
+
+  /** Return the browser-level CDP WebSocket endpoint. */
+  connectURL(): string {
+    if (this.state.kind === "UNINITIALIZED") {
+      throw new StagehandNotInitializedError("connectURL()");
+    }
+    return this.state.ws;
+  }
+
+  /** Expose the current CDP-backed context. */
+  public get context(): V3Context {
+    return this.ctx;
+  }
+
+  /** Best-effort cleanup of context and launched resources. */
+  async close(opts?: { force?: boolean }): Promise<void> {
+    // If we're already closing and this isn't a forced close, no-op.
+    if (this._isClosing && !opts?.force) return;
+    this._isClosing = true;
+
+    const keepAlive = this.keepAlive === true;
+
+    // Unhook CDP transport close handler BEFORE ending the API session.
+    // apiClient.end() can cause the hosted API to terminate the Browserbase
+    // session, which closes the CDP WebSocket. If the handler is still
+    // registered, _onCdpClosed fires and re-enters close() with force=true,
+    // causing a double-close cascade.
+    try {
+      if (this.ctx?.conn && this._onCdpClosed) {
+        this.ctx.conn.offTransportClosed?.(this._onCdpClosed);
+      }
+    } catch {
+      // ignore
+    }
+
+    // End Browserbase session via API when keepAlive is not enabled
+    if (!keepAlive && this.apiClient) {
+      try {
+        await this.apiClient.end();
+      } catch {
+        // best-effort cleanup
+      }
+    }
+
+    try {
+      // Close session file logger
+      try {
+        await SessionFileLogger.close();
+      } catch {
+        // ignore
+      }
+
+      // Close CDP context
+      try {
+        await this.ctx?.close();
+      } catch {
+        // ignore
+      }
+
+      // Kill local Chrome and clean up temp profile when keepAlive is not enabled
+      if (!keepAlive && this.state.kind === "LOCAL") {
+        const localState = this.state;
+        await cleanupLocalBrowser({
+          killChrome: () => localState.chrome.kill(),
+          userDataDir: localState.userDataDir,
+          createdTempProfile: localState.createdTempProfile,
+          preserveUserDataDir: localState.preserveUserDataDir,
+        });
+      }
+    } finally {
+      this.stopShutdownSupervisor();
+
+      // Reset internal state
+      this.state = { kind: "UNINITIALIZED" };
+      this.ctx = null;
+      this._isClosing = false;
+      this.resetBrowserbaseSessionMetadata();
+      try {
+        unbindInstanceLogger(this.instanceId);
+      } catch {
+        // ignore
+      }
+      try {
+        this.bus.removeAllListeners();
+      } catch {
+        // ignore
+      }
+      this._history = [];
+      this.actHandler = null;
+      this.extractHandler = null;
+      this.observeHandler = null;
+      V3._instances.delete(this);
+    }
+  }
+
+  /** Guard: ensure Browserbase credentials exist in options. */
+  private requireBrowserbaseCreds(): {
+    apiKey: string;
+    projectId?: string;
+  } {
+    let { apiKey, projectId } = this.opts;
+
+    // Fall back to environment variables if not explicitly provided
+    if (!apiKey)
+      apiKey = process.env.BROWSERBASE_API_KEY ?? process.env.BB_API_KEY;
+    if (!projectId)
+      projectId =
+        process.env.BROWSERBASE_PROJECT_ID ?? process.env.BB_PROJECT_ID;
+
+    if (!apiKey) {
+      throw new MissingEnvironmentVariableError(
+        "BROWSERBASE_API_KEY",
+        "Browserbase",
+      );
+    }
+
+    // Cache resolved values back into opts for consistency
+    this.opts.apiKey = apiKey;
+    if (projectId) this.opts.projectId = projectId;
+
+    // Informational log
+    this.logger({
+      category: "init",
+      message: "Using Browserbase credentials",
+      level: 1,
+    });
+
+    return { apiKey, projectId };
+  }
+
+  public get logger(): (logLine: LogLine) => void {
+    // Delegate to per-instance StagehandLogger
+    // StagehandLogger handles: verbosity filtering, usePino selection, external logger routing
+    // This provides per-instance configuration while maintaining shared Pino optimization
+    return (logLine: LogLine) => {
+      const line = { ...logLine, level: logLine.level ?? 1 };
+      this.stagehandLogger.log(line);
+    };
+  }
+
+  /**
+   * Normalize a Playwright/Puppeteer page object into its top frame id,
+   * so handlers can resolve it to a `Page` within our V3Context.
+   */
+  private async resolveTopFrameId(
+    page: PlaywrightPage | PuppeteerPage | PatchrightPage,
+  ): Promise<string> {
+    if (this.isPlaywrightPage(page)) {
+      const cdp = await page.context().newCDPSession(page);
+      const { frameTree } = await cdp.send("Page.getFrameTree");
+      return frameTree.frame.id;
+    }
+
+    if (this.isPatchrightPage(page)) {
+      const cdp = await page.context().newCDPSession(page);
+      const { frameTree } = await cdp.send("Page.getFrameTree");
+      return frameTree.frame.id;
+    }
+
+    if (this.isPuppeteerPage(page)) {
+      const cdp = await page.createCDPSession();
+      const { frameTree } = await cdp.send("Page.getFrameTree");
+      this.logger({
+        category: "v3",
+        message: "Puppeteer frame id",
+        level: 2,
+        auxiliary: { frameId: { value: frameTree.frame.id, type: "string" } },
+      });
+      return frameTree.frame.id;
+    }
+
+    throw new StagehandInvalidArgumentError(
+      "Unsupported page object passed to V3.act()",
+    );
+  }
+
+  private isPlaywrightPage(p: unknown): p is PlaywrightPage {
+    return (
+      typeof p === "object" &&
+      p !== null &&
+      typeof (p as PlaywrightPage).context === "function"
+    );
+  }
+
+  private isPatchrightPage(p: unknown): p is PatchrightPage {
+    return (
+      typeof p === "object" &&
+      p !== null &&
+      typeof (p as PatchrightPage).context === "function"
+    );
+  }
+
+  private isPuppeteerPage(p: unknown): p is PuppeteerPage {
+    return (
+      typeof p === "object" &&
+      p !== null &&
+      typeof (p as PuppeteerPage).target === "function"
+    );
+  }
+
+  /** Resolve an external page reference or fall back to the active V3 page. */
+  private async resolvePage(page?: AnyPage): Promise<Page> {
+    if (page) {
+      return await this.normalizeToV3Page(page);
+    }
+    const ctx = this.ctx;
+    if (!ctx) {
+      throw new StagehandNotInitializedError("resolvePage()");
+    }
+    return await ctx.awaitActivePage();
+  }
+
+  private async normalizeToV3Page(input: AnyPage): Promise<Page> {
+    if (input instanceof (await import("./understudy/page.js")).Page) {
+      return input as Page;
+    }
+    if (this.isPlaywrightPage(input)) {
+      const frameId = await this.resolveTopFrameId(input);
+      const page = this.ctx!.resolvePageByMainFrameId(frameId);
+      if (!page)
+        throw new StagehandInitError(
+          "Failed to resolve V3 Page from Playwright page.",
+        );
+      return page;
+    }
+    if (this.isPatchrightPage(input)) {
+      const frameId = await this.resolveTopFrameId(input);
+      const page = this.ctx!.resolvePageByMainFrameId(frameId);
+      if (!page)
+        throw new StagehandInitError(
+          "Failed to resolve V3 Page from Patchright page.",
+        );
+      return page;
+    }
+    if (this.isPuppeteerPage(input)) {
+      const frameId = await this.resolveTopFrameId(input);
+      const page = this.ctx!.resolvePageByMainFrameId(frameId);
+      if (!page)
+        throw new StagehandInitError(
+          "Failed to resolve V3 Page from Puppeteer page.",
+        );
+      return page;
+    }
+    throw new StagehandInvalidArgumentError("Unsupported page object.");
+  }
+
+  private async _logBrowserbaseSessionStatus(): Promise<void> {
+    if (this.state.kind !== "BROWSERBASE") {
+      return;
+    }
+
+    try {
+      const snapshot = (await this.state.bb.sessions.retrieve(
+        this.state.sessionId,
+      )) as { id?: string; status?: string };
+      if (!snapshot?.status) return;
+
+      const sessionId = snapshot.id ?? this.state.sessionId;
+      const message =
+        snapshot.status === "TIMED_OUT"
+          ? `Browserbase session timed out (sessionId: ${sessionId})`
+          : `Browserbase session status: ${snapshot.status}`;
+
+      this.logger({
+        category: "v3",
+        message,
+        level: 0,
+      });
+    } catch {
+      // Ignore failures; nothing to log
+    }
+  }
+
+  /**
+   * Prepares shared context for agent execution (both execute and stream).
+   * Extracts duplicated setup logic into a single helper.
+   */
+  private async prepareAgentExecution(
+    options: AgentConfig | undefined,
+    instructionOrOptions:
+      | string
+      | AgentExecuteOptions
+      | AgentStreamExecuteOptions,
+    agentConfigSignature: string,
+  ): Promise<{
+    handler: V3AgentHandler;
+    resolvedOptions: AgentExecuteOptions | AgentStreamExecuteOptions;
+    instruction: string;
+    cacheContext: AgentCacheContext | null;
+    llmClient: LLMClient;
+  }> {
+    // Note: experimental validation is done at the call site before this method
+    // Warn if mode is not explicitly set (defaults to "dom")
+    if (options?.mode === undefined) {
+      this.logger({
+        category: "agent",
+        message:
+          "Using agent in default DOM mode (legacy). Agent will default to 'hybrid' on an upcoming release for improved performance.\n  → https://docs.stagehand.dev/v3/basics/agent\n",
+        level: 0,
+      });
+    }
+
+    const tools = options?.integrations
+      ? await resolveTools(options.integrations, options.tools)
+      : (options?.tools ?? {});
+
+    const agentLlmClient = options?.model
+      ? this.resolveLlmClient(options.model)
+      : this.llmClient;
+
+    const resolvedExecutionModel = options?.executionModel ?? options?.model;
+
+    const handler = new V3AgentHandler(
+      this,
+      this.logger,
+      agentLlmClient,
+      resolvedExecutionModel,
+      options?.systemPrompt,
+      tools,
+      options?.mode,
+    );
+
+    const resolvedOptions: AgentExecuteOptions | AgentStreamExecuteOptions =
+      typeof instructionOrOptions === "string"
+        ? {
+            instruction: instructionOrOptions,
+            toolTimeout: DEFAULT_AGENT_TOOL_TIMEOUT_MS,
+          }
+        : {
+            ...instructionOrOptions,
+            toolTimeout:
+              instructionOrOptions.toolTimeout ?? DEFAULT_AGENT_TOOL_TIMEOUT_MS,
+          };
+
+    const callbacksWithSafety = resolvedOptions.callbacks as
+      | AgentExecuteCallbacks
+      | undefined;
+    if (callbacksWithSafety?.onSafetyConfirmation) {
+      throw new StagehandInvalidArgumentError(
+        'onSafetyConfirmation callback is only supported when using mode: "cua" agents.',
+      );
+    }
+
+    if (resolvedOptions.page) {
+      const normalizedPage = await this.normalizeToV3Page(resolvedOptions.page);
+      this.ctx!.setActivePage(normalizedPage);
+    }
+
+    const instruction = resolvedOptions.instruction.trim();
+    const sanitizedOptions =
+      this.agentCache.sanitizeExecuteOptions(resolvedOptions);
+
+    const cacheVariables = flattenVariables(resolvedOptions.variables);
+
+    const cacheContext = this.agentCache.shouldAttemptCache(instruction)
+      ? await this.agentCache.prepareContext({
+          instruction,
+          options: sanitizedOptions,
+          configSignature: agentConfigSignature,
+          page: await this.ctx!.awaitActivePage(),
+          variables: cacheVariables,
+        })
+      : null;
+
+    return {
+      handler,
+      resolvedOptions,
+      instruction,
+      cacheContext,
+      llmClient: agentLlmClient,
+    };
+  }
+
+  /**
+   * Create a v3 agent instance (AISDK tool-based) with execute().
+   * Mirrors the v2 Stagehand.agent() tool mode (no CUA provider here).
+   *
+   * @overload When stream: true, returns a streaming agent where execute() returns AgentStreamResult
+   * @overload When stream is false/undefined, returns a non-streaming agent where execute() returns AgentResult
+   */
+  agent(options: AgentConfig & { stream: true }): {
+    execute: (
+      instructionOrOptions: string | AgentStreamExecuteOptions,
+    ) => Promise<AgentStreamResult>;
+  };
+  agent(options?: AgentConfig & { stream?: false }): {
+    execute: (
+      instructionOrOptions: string | AgentExecuteOptions,
+    ) => Promise<AgentResult>;
+  };
+  agent(options?: AgentConfig): {
+    execute: (
+      instructionOrOptions:
+        | string
+        | AgentExecuteOptions
+        | AgentStreamExecuteOptions,
+    ) => Promise<AgentResult | AgentStreamResult>;
+  } {
+    // Determine if CUA mode is enabled (via mode: "cua" or deprecated cua: true)
+    const isCuaMode =
+      options?.mode !== undefined
+        ? options.mode === "cua"
+        : options?.cua === true;
+
+    // Emit deprecation warning for cua: true
+    if (options?.cua === true) {
+      this.logger({
+        category: "agent",
+        message:
+          '[DEPRECATED] The "cua: true" option is deprecated. Use "mode: \'cua\'" instead. This option will be removed in a future version.',
+        level: 0,
+      });
+      console.warn(
+        '[Stagehand] DEPRECATED: The "cua: true" option is deprecated. Use "mode: \'cua\'" instead.',
+      );
+    }
+
+    this.logger({
+      category: "agent",
+      message: "Creating v3 agent instance",
+      level: 1,
+      auxiliary: {
+        cua: { value: isCuaMode ? "true" : "false", type: "boolean" },
+        mode: { value: options?.mode ?? "dom", type: "string" },
+        model: {
+          value: extractModelName(options?.model) ?? this.llmClient.modelName,
+          type: "string",
+        },
+        systemPrompt: { value: options?.systemPrompt ?? "", type: "string" },
+        tools: { value: JSON.stringify(options?.tools ?? {}), type: "object" },
+        ...(options?.integrations && {
+          integrations: {
+            value: JSON.stringify(options.integrations),
+            type: "object",
+          },
+        }),
+      },
+    });
+
+    // If CUA mode is enabled (via mode: "cua" or deprecated cua: true), use the computer-use agent path
+    if (isCuaMode) {
+      // Validate agent config at creation time (includes CUA+streaming conflict check)
+      validateExperimentalFeatures({
+        isExperimental: this.experimental,
+        agentConfig: options,
+      });
+
+      const modelToUse = options?.model || {
+        modelName: this.modelName,
+        ...this.modelClientOptions,
+      };
+
+      const { modelName, isCua, clientOptions } = resolveModel(modelToUse);
+
+      if (!isCua) {
+        throw new CuaModelRequiredError(AVAILABLE_CUA_MODELS);
+      }
+
+      const agentConfigSignature =
+        this.agentCache.buildConfigSignature(options);
+      return {
+        execute: async (instructionOrOptions: string | AgentExecuteOptions) =>
+          withInstanceLogContext(this.instanceId, async () => {
+            validateExperimentalFeatures({
+              isExperimental: this.experimental,
+              agentConfig: options,
+              executeOptions:
+                typeof instructionOrOptions === "object"
+                  ? instructionOrOptions
+                  : null,
+            });
+
+            SessionFileLogger.logAgentTaskStarted({
+              invocation: "Agent.execute",
+              args: [instructionOrOptions],
+            });
+            const tools = options?.integrations
+              ? await resolveTools(options.integrations, options.tools)
+              : (options?.tools ?? {});
+
+            const handler = new V3CuaAgentHandler(
+              this,
+              this.logger,
+              {
+                modelName,
+                clientOptions,
+                userProvidedInstructions:
+                  options.systemPrompt ??
+                  `You are a helpful assistant that can use a web browser.\nDo not ask follow up questions, the user will trust your judgement.`,
+              },
+              tools,
+            );
+
+            const resolvedOptions: AgentExecuteOptions =
+              typeof instructionOrOptions === "string"
+                ? {
+                    instruction: instructionOrOptions,
+                    toolTimeout: DEFAULT_AGENT_TOOL_TIMEOUT_MS,
+                  }
+                : {
+                    ...instructionOrOptions,
+                    toolTimeout:
+                      instructionOrOptions.toolTimeout ??
+                      DEFAULT_AGENT_TOOL_TIMEOUT_MS,
+                  };
+            if (resolvedOptions.page) {
+              const normalizedPage = await this.normalizeToV3Page(
+                resolvedOptions.page,
+              );
+              this.ctx!.setActivePage(normalizedPage);
+            }
+            const instruction = resolvedOptions.instruction.trim();
+            const sanitizedOptions =
+              this.agentCache.sanitizeExecuteOptions(resolvedOptions);
+
+            const cacheVariables = flattenVariables(resolvedOptions.variables);
+
+            let cacheContext: AgentCacheContext | null = null;
+            if (this.agentCache.shouldAttemptCache(instruction)) {
+              const startPage = await this.ctx!.awaitActivePage();
+              cacheContext = await this.agentCache.prepareContext({
+                instruction,
+                options: sanitizedOptions,
+                configSignature: agentConfigSignature,
+                page: startPage,
+                variables: cacheVariables,
+              });
+              if (cacheContext) {
+                const replayed = await this.agentCache.tryReplay(cacheContext);
+                if (replayed) {
+                  SessionFileLogger.logAgentTaskCompleted({ cacheHit: true });
+                  return replayed;
+                }
+              }
+            }
+
+            let agentSteps: AgentReplayStep[] = [];
+            const shouldRecordLocally =
+              !!cacheContext && (!this.apiClient || this.experimental);
+            if (shouldRecordLocally) {
+              this.beginAgentReplayRecording();
+            }
+
+            let result: AgentResult;
+            try {
+              if (this.apiClient && !this.experimental) {
+                const page = await this.ctx!.awaitActivePage();
+                result = await this.apiClient.agentExecute(
+                  options,
+                  resolvedOptions,
+                  page.mainFrameId(),
+                  !!cacheContext,
+                );
+                if (cacheContext) {
+                  const transferredEntry =
+                    this.apiClient.consumeLatestAgentCacheEntry();
+                  await this.agentCache.storeTransferredEntry(transferredEntry);
+                }
+              } else {
+                result = await handler.execute(instructionOrOptions);
+              }
+              if (shouldRecordLocally) {
+                agentSteps = this.endAgentReplayRecording();
+              }
+
+              if (
+                shouldRecordLocally &&
+                cacheContext &&
+                result.success &&
+                agentSteps.length > 0
+              ) {
+                await this.agentCache.store(cacheContext, agentSteps, result);
+              }
+
+              return result;
+            } catch (err) {
+              if (shouldRecordLocally) this.discardAgentReplayRecording();
+              throw err;
+            } finally {
+              if (shouldRecordLocally) {
+                this.discardAgentReplayRecording();
+              }
+              SessionFileLogger.logAgentTaskCompleted();
+            }
+          }),
+      };
+    }
+
+    // Default: AISDK tools-based agent
+    const agentConfigSignature = this.agentCache.buildConfigSignature(options);
+    const isStreaming = options?.stream ?? false;
+
+    return {
+      execute: async (
+        instructionOrOptions:
+          | string
+          | AgentExecuteOptions
+          | AgentStreamExecuteOptions,
+      ): Promise<AgentResult | AgentStreamResult> =>
+        withInstanceLogContext(this.instanceId, async () => {
+          validateExperimentalFeatures({
+            isExperimental: this.experimental,
+            agentConfig: options,
+            executeOptions:
+              typeof instructionOrOptions === "object"
+                ? instructionOrOptions
+                : null,
+            isStreaming,
+          });
+          SessionFileLogger.logAgentTaskStarted({
+            invocation: "Agent.execute",
+            args: [instructionOrOptions],
+          });
+
+          // Streaming mode
+          if (isStreaming) {
+            const { handler, resolvedOptions, cacheContext, llmClient } =
+              await this.prepareAgentExecution(
+                options,
+                instructionOrOptions,
+                agentConfigSignature,
+              );
+
+            if (cacheContext) {
+              const replayed = await this.agentCache.tryReplayAsStream(
+                cacheContext,
+                llmClient,
+              );
+              if (replayed) {
+                SessionFileLogger.logAgentTaskCompleted({ cacheHit: true });
+                return replayed;
+              }
+            }
+
+            const streamResult = await handler.stream(
+              resolvedOptions as AgentStreamExecuteOptions,
+            );
+
+            if (cacheContext) {
+              const wrappedStream = this.agentCache.wrapStreamForCaching(
+                cacheContext,
+                streamResult,
+                () => this.beginAgentReplayRecording(),
+                () => this.endAgentReplayRecording(),
+                () => this.discardAgentReplayRecording(),
+              );
+              // Log completion when stream is returned (stream completes asynchronously)
+              SessionFileLogger.logAgentTaskCompleted();
+              return wrappedStream;
+            }
+
+            // Log completion when stream is returned (stream completes asynchronously)
+            SessionFileLogger.logAgentTaskCompleted();
+            return streamResult;
+          }
+
+          // Non-streaming mode (default)
+          const { handler, resolvedOptions, cacheContext, llmClient } =
+            await this.prepareAgentExecution(
+              options,
+              instructionOrOptions,
+              agentConfigSignature,
+            );
+
+          if (cacheContext) {
+            const replayed = await this.agentCache.tryReplay(
+              cacheContext,
+              llmClient,
+            );
+            if (replayed) {
+              SessionFileLogger.logAgentTaskCompleted({ cacheHit: true });
+              return replayed;
+            }
+          }
+
+          let agentSteps: AgentReplayStep[] = [];
+          const shouldRecordLocally =
+            !!cacheContext && (!this.apiClient || this.experimental);
+          if (shouldRecordLocally) {
+            this.beginAgentReplayRecording();
+          }
+          let result: AgentResult;
+
+          try {
+            if (this.apiClient && !this.experimental) {
+              const page = await this.ctx!.awaitActivePage();
+              result = await this.apiClient.agentExecute(
+                options ?? {},
+                resolvedOptions as AgentExecuteOptions,
+                page.mainFrameId(),
+                !!cacheContext,
+              );
+              if (cacheContext) {
+                const transferredEntry =
+                  this.apiClient.consumeLatestAgentCacheEntry();
+                await this.agentCache.storeTransferredEntry(transferredEntry);
+              }
+            } else {
+              result = await handler.execute(
+                resolvedOptions as AgentExecuteOptions,
+              );
+            }
+            if (shouldRecordLocally) {
+              agentSteps = this.endAgentReplayRecording();
+            }
+
+            if (
+              shouldRecordLocally &&
+              cacheContext &&
+              result.success &&
+              agentSteps.length > 0
+            ) {
+              await this.agentCache.store(cacheContext, agentSteps, result);
+            }
+
+            return result;
+          } catch (err) {
+            if (shouldRecordLocally) this.discardAgentReplayRecording();
+            throw err;
+          } finally {
+            if (shouldRecordLocally) {
+              this.discardAgentReplayRecording();
+            }
+            SessionFileLogger.logAgentTaskCompleted();
+          }
+        }),
+    };
+  }
+}
+
+function isObserveResult(v: unknown): v is Action {
+  return (
+    !!v && typeof v === "object" && "selector" in (v as Record<string, unknown>)
+  );
+}
diff --git a/packages/core/lib/v3/zodCompat.ts b/packages/core/lib/v3/zodCompat.ts
new file mode 100644
index 000000000..2ff7ea057
--- /dev/null
+++ b/packages/core/lib/v3/zodCompat.ts
@@ -0,0 +1,49 @@
+import { z } from "zod";
+import type {
+  ZodObject as Zod4Object,
+  ZodRawShape as Zod4RawShape,
+  ZodTypeAny as Zod4TypeAny,
+} from "zod";
+import zodToJsonSchema from "zod-to-json-schema";
+import type * as z3 from "zod/v3";
+export type StagehandZodSchema = Zod4TypeAny | z3.ZodTypeAny;
+
+export type StagehandZodObject =
+  | Zod4Object<Zod4RawShape>
+  | z3.ZodObject<z3.ZodRawShape>;
+
+export type InferStagehandSchema<T extends StagehandZodSchema> =
+  T extends z3.ZodTypeAny
+    ? z3.infer<T>
+    : T extends Zod4TypeAny
+      ? z.infer<T>
+      : never;
+
+export const isZod4Schema = (
+  schema: StagehandZodSchema,
+): schema is Zod4TypeAny & { _zod: unknown } =>
+  typeof (schema as { _zod?: unknown })._zod !== "undefined";
+
+export const isZod3Schema = (
+  schema: StagehandZodSchema,
+): schema is z3.ZodTypeAny => !isZod4Schema(schema);
+
+export type JsonSchemaDocument = Record<string, unknown>;
+
+export function toJsonSchema(schema: StagehandZodSchema): JsonSchemaDocument {
+  if (!isZod4Schema(schema)) {
+    return zodToJsonSchema(schema);
+  }
+
+  // For v4 schemas, use built-in z.toJSONSchema() method
+  const zodWithJsonSchema = z as typeof z & {
+    toJSONSchema?: (schema: Zod4TypeAny) => JsonSchemaDocument;
+  };
+
+  if (zodWithJsonSchema.toJSONSchema) {
+    return zodWithJsonSchema.toJSONSchema(schema as Zod4TypeAny);
+  }
+
+  // This should never happen with Zod v4.1+
+  throw new Error("Zod v4 toJSONSchema method not found");
+}
diff --git a/packages/core/lib/v3Evaluator.ts b/packages/core/lib/v3Evaluator.ts
new file mode 100644
index 000000000..42dd8b20e
--- /dev/null
+++ b/packages/core/lib/v3Evaluator.ts
@@ -0,0 +1,296 @@
+/**
+ * V3Evaluator mirrors Evaluator but operates on a V3 instance instead of Stagehand.
+ * It uses the V3 page/screenshot APIs and constructs an LLM client to run
+ * structured evaluations (YES/NO with reasoning) on screenshots and/or text.
+ */
+
+import { z } from "zod";
+import type { AvailableModel, ClientOptions } from "./v3/types/public/model.js";
+import type {
+  EvaluateOptions,
+  BatchAskOptions,
+  EvaluationResult,
+} from "./v3/types/private/evaluator.js";
+import { LLMParsedResponse } from "./inference.js";
+import { LLMResponse, LLMClient } from "./v3/llm/LLMClient.js";
+import { LogLine } from "./v3/types/public/logs.js";
+import { V3 } from "./v3/v3.js";
+import { LLMProvider } from "./v3/llm/LLMProvider.js";
+import { StagehandInvalidArgumentError } from "./v3/types/public/sdkErrors.js";
+
+const EvaluationSchema = z.object({
+  evaluation: z.enum(["YES", "NO"]),
+  reasoning: z.string(),
+});
+
+const BatchEvaluationSchema = z.array(EvaluationSchema);
+
+export class V3Evaluator {
+  private v3: V3;
+  private modelName: AvailableModel;
+  private modelClientOptions: ClientOptions | { apiKey: string };
+  private silentLogger: (message: LogLine) => void = () => {};
+
+  constructor(
+    v3: V3,
+    modelName?: AvailableModel,
+    modelClientOptions?: ClientOptions,
+  ) {
+    this.v3 = v3;
+    this.modelName = modelName || ("google/gemini-2.5-flash" as AvailableModel);
+    this.modelClientOptions = modelClientOptions || {
+      apiKey:
+        process.env.GEMINI_API_KEY ||
+        process.env.GOOGLE_GENERATIVE_AI_API_KEY ||
+        "",
+    };
+  }
+
+  private getClient(): LLMClient {
+    // Prefer a dedicated provider so we can override model per-evaluation
+    const provider = new LLMProvider(this.v3.logger);
+    return provider.getClient(this.modelName, this.modelClientOptions);
+  }
+
+  async ask(options: EvaluateOptions): Promise<EvaluationResult> {
+    const {
+      question,
+      answer,
+      screenshot = true,
+      systemPrompt,
+      screenshotDelayMs = 250,
+      agentReasoning,
+    } = options;
+    if (!question)
+      throw new StagehandInvalidArgumentError(
+        "Question cannot be an empty string",
+      );
+    if (!answer && !screenshot)
+      throw new StagehandInvalidArgumentError(
+        "Either answer (text) or screenshot must be provided",
+      );
+
+    if (Array.isArray(screenshot)) {
+      return this._evaluateWithMultipleScreenshots({
+        question,
+        screenshots: screenshot,
+        systemPrompt,
+        agentReasoning,
+      });
+    }
+
+    const defaultSystemPrompt = `You are an expert evaluator that confidently returns YES or NO based on if the original goal was achieved. You have access to  ${screenshot ? "a screenshot" : "the agents reasoning and actions throughout the task"} that you can use to evaluate the tasks completion. Provide detailed reasoning for your answer.\n          Today's date is ${new Date().toLocaleDateString()}`;
+
+    await new Promise((r) => setTimeout(r, screenshotDelayMs));
+    let imageBuffer: Buffer | undefined;
+    if (screenshot) {
+      const page = await this.v3.context.awaitActivePage();
+      imageBuffer = await page.screenshot({ fullPage: false });
+    }
+
+    const llmClient = this.getClient();
+
+    const response = await llmClient.createChatCompletion<
+      LLMParsedResponse<LLMResponse>
+    >({
+      logger: this.silentLogger,
+      options: {
+        messages: [
+          { role: "system", content: systemPrompt || defaultSystemPrompt },
+          {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: agentReasoning
+                  ? `Question: ${question}\n\nAgent's reasoning and actions taken:\n${agentReasoning}`
+                  : question,
+              },
+              ...(screenshot && imageBuffer
+                ? [
+                    {
+                      type: "image_url" as const,
+                      image_url: {
+                        url: `data:image/jpeg;base64,${imageBuffer.toString("base64")}`,
+                      },
+                    },
+                  ]
+                : []),
+              ...(answer
+                ? [{ type: "text" as const, text: `the answer is ${answer}` }]
+                : []),
+            ],
+          },
+        ],
+        response_model: { name: "EvaluationResult", schema: EvaluationSchema },
+      },
+    });
+
+    try {
+      const result = response.data as unknown as z.infer<
+        typeof EvaluationSchema
+      >;
+      return { evaluation: result.evaluation, reasoning: result.reasoning };
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      return {
+        evaluation: "INVALID",
+        reasoning: `Failed to get structured response: ${errorMessage}`,
+      } as const;
+    }
+  }
+
+  async batchAsk(options: BatchAskOptions): Promise<EvaluationResult[]> {
+    const {
+      questions,
+      screenshot = true,
+      systemPrompt = "You are an expert evaluator that returns YES or NO with a concise reasoning.",
+      screenshotDelayMs = 250,
+    } = options;
+    if (!questions?.length)
+      throw new StagehandInvalidArgumentError(
+        "Questions array cannot be empty",
+      );
+
+    await new Promise((r) => setTimeout(r, screenshotDelayMs));
+    let imageBuffer: Buffer | undefined;
+    if (screenshot) {
+      const page = await this.v3.context.awaitActivePage();
+      imageBuffer = await page.screenshot({ fullPage: false });
+    }
+
+    const llmClient = this.getClient();
+
+    const formatted = questions
+      .map(
+        (item, i) =>
+          `${i + 1}. ${item.question}${item.answer ? `\n   Answer: ${item.answer}` : ""}`,
+      )
+      .join("\n\n");
+
+    const response = await llmClient.createChatCompletion<
+      LLMParsedResponse<LLMResponse>
+    >({
+      logger: this.silentLogger,
+      options: {
+        messages: [
+          {
+            role: "system",
+            content: `${systemPrompt}\n\nYou will be given multiple questions${screenshot ? " with a screenshot" : ""}. ${questions.some((q) => q.answer) ? "Some questions include answers to evaluate." : ""} Answer each question by returning an object in the specified JSON format. Return a single JSON array containing one object for each question in the order they were asked.`,
+          },
+          {
+            role: "user",
+            content: [
+              { type: "text", text: formatted },
+              ...(screenshot && imageBuffer
+                ? [
+                    {
+                      type: "image_url" as const,
+                      image_url: {
+                        url: `data:image/jpeg;base64,${imageBuffer.toString("base64")}`,
+                      },
+                    },
+                  ]
+                : []),
+            ],
+          },
+        ],
+        response_model: {
+          name: "BatchEvaluationResult",
+          schema: BatchEvaluationSchema,
+        },
+      },
+    });
+
+    try {
+      const results = response.data as unknown as z.infer<
+        typeof BatchEvaluationSchema
+      >;
+      return results.map((r) => ({
+        evaluation: r.evaluation,
+        reasoning: r.reasoning,
+      }));
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      return questions.map(() => ({
+        evaluation: "INVALID" as const,
+        reasoning: `Failed to get structured response: ${errorMessage}`,
+      }));
+    }
+  }
+
+  private async _evaluateWithMultipleScreenshots(options: {
+    question: string;
+    screenshots: Buffer[];
+    systemPrompt?: string;
+    agentReasoning?: string;
+  }): Promise<EvaluationResult> {
+    const {
+      question,
+      screenshots,
+      agentReasoning,
+      systemPrompt = `You are an expert evaluator that confidently returns YES or NO given a question and multiple screenshots showing the progression of a task.
+        ${agentReasoning ? "You also have access to the agent's detailed reasoning and thought process throughout the task." : ""}
+        Analyze ALL screenshots to understand the complete journey. Look for evidence of task completion across all screenshots, not just the last one.
+        Success criteria may appear at different points in the sequence (confirmation messages, intermediate states, etc).
+        ${agentReasoning ? "The agent's reasoning provides crucial context about what actions were attempted, what was observed, and the decision-making process. Use this alongside the visual evidence to make a comprehensive evaluation." : ""}
+        Today's date is ${new Date().toLocaleDateString()}`,
+    } = options;
+
+    if (!question)
+      throw new StagehandInvalidArgumentError(
+        "Question cannot be an empty string",
+      );
+    if (!screenshots || screenshots.length === 0)
+      throw new StagehandInvalidArgumentError(
+        "At least one screenshot must be provided",
+      );
+
+    const llmClient = this.getClient();
+
+    const imageContents = screenshots.map((s) => ({
+      type: "image_url" as const,
+      image_url: { url: `data:image/jpeg;base64,${s.toString("base64")}` },
+    }));
+
+    const response = await llmClient.createChatCompletion<
+      LLMParsedResponse<LLMResponse>
+    >({
+      logger: this.silentLogger,
+      options: {
+        messages: [
+          { role: "system", content: systemPrompt },
+          {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: agentReasoning
+                  ? `Question: ${question}\n\nAgent's reasoning and actions throughout the task:\n${agentReasoning}\n\nI'm providing ${screenshots.length} screenshots showing the progression of the task. Please analyze both the agent's reasoning and all screenshots to determine if the task was completed successfully.`
+                  : `${question}\n\nI'm providing ${screenshots.length} screenshots showing the progression of the task. Please analyze all of them to determine if the task was completed successfully.`,
+              },
+              ...imageContents,
+            ],
+          },
+        ],
+        response_model: { name: "EvaluationResult", schema: EvaluationSchema },
+      },
+    });
+
+    try {
+      const result = response.data as unknown as z.infer<
+        typeof EvaluationSchema
+      >;
+      return { evaluation: result.evaluation, reasoning: result.reasoning };
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      return {
+        evaluation: "INVALID",
+        reasoning: `Failed to get structured response: ${errorMessage}`,
+      } as const;
+    }
+  }
+}
diff --git a/packages/core/package.json b/packages/core/package.json
new file mode 100644
index 000000000..4764028ff
--- /dev/null
+++ b/packages/core/package.json
@@ -0,0 +1,136 @@
+{
+  "name": "@browserbasehq/stagehand",
+  "version": "3.1.0",
+  "description": "An AI web browsing framework focused on simplicity and extensibility.",
+  "type": "module",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./cli": {
+      "types": "./dist/esm/lib/v3/cli.d.ts",
+      "import": "./dist/esm/lib/v3/cli.js",
+      "require": "./dist/cjs/cli.js"
+    },
+    "./*.js": {
+      "types": "./dist/esm/*.d.ts",
+      "import": "./dist/esm/*.js"
+    },
+    "./*": {
+      "types": "./dist/esm/*.d.ts",
+      "import": "./dist/esm/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "scripts": {
+    "gen-version": "tsx scripts/gen-version.ts",
+    "build-dom-scripts": "pnpm run --parallel \"/^build-dom-scripts:(dom|locator|screenshot|a11y)$/\"",
+    "build-dom-scripts:dom": "tsx lib/v3/dom/genDomScripts.ts",
+    "build-dom-scripts:locator": "tsx lib/v3/dom/genLocatorScripts.ts",
+    "build-dom-scripts:screenshot": "tsx lib/v3/dom/genScreenshotScripts.ts",
+    "build-dom-scripts:a11y": "tsx lib/v3/dom/genA11yScripts.ts",
+    "build:cjs": "tsx scripts/build-cjs.ts",
+    "build:esm": "tsx scripts/build-esm.ts",
+    "build": "pnpm --filter @browserbasehq/stagehand run --parallel \"/^build:(esm|cjs)$/\"",
+    "example": "node --import tsx -e \"const args=process.argv.slice(1).filter(a=>a!=='--'); const [p]=args; const n=(p||'example').replace(/^\\.\\//,'').replace(/\\.ts$/i,''); import('node:path').then(path=>import(new URL(path.resolve('examples', n + '.ts'), 'file:')));\" --",
+    "test": "pnpm -w --dir ../.. exec turbo run test:core test:e2e --filter=@browserbasehq/stagehand --",
+    "test:core": "tsx scripts/test-core.ts",
+    "test:e2e": "tsx scripts/test-e2e.ts",
+    "format": "prettier --write .",
+    "typecheck": "pnpm -w --dir ../.. exec tsc -p packages/core/tsconfig.json --noEmit",
+    "eslint": "eslint .",
+    "lint": "cd ../.. && prettier --check packages/core && cd packages/core && pnpm run eslint && pnpm run typecheck"
+  },
+  "files": [
+    "dist/esm",
+    "dist/cjs"
+  ],
+  "keywords": [
+    "ai",
+    "browser",
+    "automation",
+    "web-scraping",
+    "testing"
+  ],
+  "author": "Browserbase",
+  "license": "MIT",
+  "peerDependencies": {
+    "deepmerge": "^4.3.1",
+    "zod": "^3.25.76 || ^4.2.0"
+  },
+  "dependencies": {
+    "@ai-sdk/provider": "^2.0.0",
+    "@anthropic-ai/sdk": "0.39.0",
+    "@browserbasehq/sdk": "^2.7.0",
+    "@google/genai": "^1.22.0",
+    "@langchain/openai": "^0.4.4",
+    "@modelcontextprotocol/sdk": "^1.17.2",
+    "ai": "^5.0.133",
+    "devtools-protocol": "^0.0.1464554",
+    "fetch-cookie": "^3.1.0",
+    "openai": "^4.87.1",
+    "pino": "^9.6.0",
+    "pino-pretty": "^13.0.0",
+    "uuid": "^11.1.0",
+    "ws": "^8.18.0",
+    "zod-to-json-schema": "^3.25.0"
+  },
+  "optionalDependencies": {
+    "@ai-sdk/amazon-bedrock": "^3.0.73",
+    "@ai-sdk/anthropic": "^2.0.34",
+    "@ai-sdk/azure": "^2.0.54",
+    "@ai-sdk/cerebras": "^1.0.25",
+    "@ai-sdk/deepseek": "^1.0.23",
+    "@ai-sdk/google": "^2.0.53",
+    "@ai-sdk/google-vertex": "^3.0.70",
+    "@ai-sdk/groq": "^2.0.24",
+    "@ai-sdk/mistral": "^2.0.19",
+    "@ai-sdk/openai": "^2.0.53",
+    "@ai-sdk/perplexity": "^2.0.13",
+    "@ai-sdk/togetherai": "^1.0.23",
+    "@ai-sdk/xai": "^2.0.26",
+    "@langchain/core": "^0.3.40",
+    "bufferutil": "^4.0.9",
+    "chrome-launcher": "^1.2.0",
+    "ollama-ai-provider-v2": "^1.5.0",
+    "patchright-core": "^1.55.2",
+    "playwright": "^1.52.0",
+    "playwright-core": "^1.54.1",
+    "puppeteer-core": "^22.8.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.42.1",
+    "@types/adm-zip": "^0.5.7",
+    "@types/jsdom": "^27.0.0",
+    "@types/node": "^20.11.30",
+    "@types/ws": "^8.5.13",
+    "@vitest/coverage-v8": "^4.0.8",
+    "adm-zip": "^0.5.16",
+    "chalk": "^5.4.1",
+    "eslint": "10.0.2",
+    "jsdom": "^24.0.0",
+    "playwright": "^1.52.0",
+    "playwright-core": "^1.54.1",
+    "prettier": "^3.2.5",
+    "tsx": "*",
+    "vitest": "^4.0.8",
+    "zod": "^3.25.76 || ^4.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/browserbase/stagehand.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/browserbase/stagehand/issues"
+  },
+  "homepage": "https://stagehand.dev"
+}
diff --git a/packages/core/scripts/build-cjs.ts b/packages/core/scripts/build-cjs.ts
new file mode 100644
index 000000000..c5e048ce6
--- /dev/null
+++ b/packages/core/scripts/build-cjs.ts
@@ -0,0 +1,84 @@
+/**
+ * Build canonical dist/ (CJS) output for the core package (including tests).
+ *
+ * Prereqs: pnpm install; run gen-version + build-dom-scripts first (turbo handles).
+ * Args: none.
+ * Env: none.
+ * Example: pnpm run build:cjs
+ */
+import fs from "node:fs";
+import { spawnSync } from "node:child_process";
+import { getRepoRootDir } from "../lib/v3/runtimePaths.js";
+
+const repoRoot = getRepoRootDir();
+
+const runNodeScript = (scriptPath: string, args: string[]) => {
+  const result = spawnSync(process.execPath, [scriptPath, ...args], {
+    stdio: "inherit",
+    cwd: repoRoot,
+  });
+  if (result.error) {
+    console.error(`Failed to run node ${scriptPath} ${args.join(" ")}`);
+    console.error(result.error);
+    process.exit(1);
+  }
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
+  }
+};
+
+fs.rmSync(`${repoRoot}/packages/core/dist/cjs`, {
+  recursive: true,
+  force: true,
+});
+fs.mkdirSync(`${repoRoot}/packages/core/dist/cjs`, { recursive: true });
+
+runNodeScript(`${repoRoot}/node_modules/typescript/bin/tsc`, [
+  "-p",
+  "packages/core/tsconfig.json",
+  "--module",
+  "commonjs",
+  "--declaration",
+  "--outDir",
+  "packages/core/dist/cjs",
+]);
+
+fs.writeFileSync(
+  `${repoRoot}/packages/core/dist/cjs/index.js`,
+  `"use strict";
+module.exports = require("./lib/v3/index.js");
+`,
+);
+fs.writeFileSync(
+  `${repoRoot}/packages/core/dist/cjs/cli.js`,
+  `#!/usr/bin/env node
+"use strict";
+require("./lib/v3/cli.js");
+`,
+);
+fs.writeFileSync(
+  `${repoRoot}/packages/core/dist/cjs/index.d.ts`,
+  `export * from "./lib/v3/index";
+export { default } from "./lib/v3/index";
+`,
+);
+fs.writeFileSync(
+  `${repoRoot}/packages/core/dist/cjs/package.json`,
+  '{\n  "type": "commonjs"\n}\n',
+);
+
+fs.mkdirSync(`${repoRoot}/packages/core/dist/cjs/lib/v3/dom/build`, {
+  recursive: true,
+});
+if (fs.existsSync(`${repoRoot}/packages/core/lib/v3/dom/build`)) {
+  for (const file of fs.readdirSync(
+    `${repoRoot}/packages/core/lib/v3/dom/build`,
+  )) {
+    if (file.endsWith(".js")) {
+      fs.copyFileSync(
+        `${repoRoot}/packages/core/lib/v3/dom/build/${file}`,
+        `${repoRoot}/packages/core/dist/cjs/lib/v3/dom/build/${file}`,
+      );
+    }
+  }
+}
diff --git a/packages/core/scripts/build-esm.ts b/packages/core/scripts/build-esm.ts
new file mode 100644
index 000000000..2a0726c37
--- /dev/null
+++ b/packages/core/scripts/build-esm.ts
@@ -0,0 +1,77 @@
+/**
+ * Build canonical dist/esm output for the core package (including tests).
+ *
+ * Prereqs: pnpm install; run gen-version + build-dom-scripts first (turbo handles).
+ * Args: none.
+ * Env: none.
+ * Example: pnpm run build:esm
+ */
+import fs from "node:fs";
+import { spawnSync } from "node:child_process";
+import { getRepoRootDir } from "../lib/v3/runtimePaths.js";
+
+const repoRoot = getRepoRootDir();
+
+const runNodeScript = (scriptPath: string, args: string[]) => {
+  const result = spawnSync(process.execPath, [scriptPath, ...args], {
+    stdio: "inherit",
+    cwd: repoRoot,
+  });
+  if (result.error) {
+    console.error(`Failed to run node ${scriptPath} ${args.join(" ")}`);
+    console.error(result.error);
+    process.exit(1);
+  }
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
+  }
+};
+
+fs.rmSync(`${repoRoot}/packages/core/dist/esm`, {
+  recursive: true,
+  force: true,
+});
+
+// Core ESM emit includes generated lib/version.ts from gen-version (run in core build).
+runNodeScript(`${repoRoot}/node_modules/typescript/bin/tsc`, [
+  "-p",
+  "packages/core/tsconfig.json",
+  "--declaration",
+]);
+
+fs.mkdirSync(`${repoRoot}/packages/core/dist/esm`, { recursive: true });
+fs.writeFileSync(
+  `${repoRoot}/packages/core/dist/esm/package.json`,
+  '{\n  "type": "module"\n}\n',
+);
+fs.writeFileSync(
+  `${repoRoot}/packages/core/dist/esm/index.js`,
+  `export * from "./lib/v3/index.js";
+export { default } from "./lib/v3/index.js";
+`,
+);
+fs.writeFileSync(
+  `${repoRoot}/packages/core/dist/esm/index.d.ts`,
+  `export * from "./lib/v3/index.js";
+export { default } from "./lib/v3/index.js";
+`,
+);
+
+fs.mkdirSync(`${repoRoot}/packages/core/dist/esm/lib/v3/dom/build`, {
+  recursive: true,
+});
+// DOM script bundles are generated artifacts (not TS emit); copy into dist/esm for runtime.
+if (fs.existsSync(`${repoRoot}/packages/core/lib/v3/dom/build`)) {
+  for (const file of fs.readdirSync(
+    `${repoRoot}/packages/core/lib/v3/dom/build`,
+  )) {
+    if (file.endsWith(".js")) {
+      fs.copyFileSync(
+        `${repoRoot}/packages/core/lib/v3/dom/build/${file}`,
+        `${repoRoot}/packages/core/dist/esm/lib/v3/dom/build/${file}`,
+      );
+    }
+  }
+}
+
+// Note: evals + server test outputs are built by their respective packages.
diff --git a/packages/core/scripts/coverage.ts b/packages/core/scripts/coverage.ts
new file mode 100644
index 000000000..7b09dd69f
--- /dev/null
+++ b/packages/core/scripts/coverage.ts
@@ -0,0 +1,195 @@
+/**
+ * Coverage merge (V8 -> Istanbul).
+ *
+ * Prereqs: V8 coverage JSON files in `coverage/**` (from test scripts).
+ * Args: `merge` only.
+ * Env: none required.
+ * Example: pnpm run coverage:merge
+ */
+import fs from "node:fs";
+import { spawn, type ChildProcess } from "node:child_process";
+import normalizeV8Coverage from "./normalize-v8-coverage.js";
+import { getRepoRootDir } from "../lib/v3/runtimePaths.js";
+
+const repoRoot = getRepoRootDir();
+const command = process.argv[2];
+const terminationSignals: NodeJS.Signals[] = ["SIGINT", "SIGTERM"];
+const log = (message: string) => console.log(`[coverage:merge] ${message}`);
+
+let activeChild: ChildProcess | null = null;
+let isCancelling = false;
+
+const exitCodeForSignal = (signal: NodeJS.Signals): number =>
+  signal === "SIGINT" ? 130 : 143;
+
+const handleTermination = (signal: NodeJS.Signals) => {
+  isCancelling = true;
+  log(`received ${signal}, exiting`);
+  if (activeChild && activeChild.pid && !activeChild.killed) {
+    activeChild.kill(signal);
+  }
+  process.exit(exitCodeForSignal(signal));
+};
+
+terminationSignals.forEach((signal) => {
+  process.once(signal, () => handleTermination(signal));
+});
+
+const assertNotCancelling = () => {
+  if (isCancelling) {
+    throw new Error("Coverage merge cancelled");
+  }
+};
+
+if (!command || command !== "merge") {
+  console.error("Usage: coverage merge");
+  process.exit(1);
+}
+
+if (!process.env.V8_COVERAGE_SCAN_LIMIT) {
+  process.env.V8_COVERAGE_SCAN_LIMIT = "2000";
+}
+fs.rmSync(`${repoRoot}/coverage/merged`, { recursive: true, force: true });
+fs.rmSync(`${repoRoot}/coverage/.v8-tmp`, { recursive: true, force: true });
+log(`normalizing v8 coverage in ${repoRoot}/coverage`);
+log(`using V8_COVERAGE_SCAN_LIMIT=${process.env.V8_COVERAGE_SCAN_LIMIT}`);
+const normalizeStart = Date.now();
+await normalizeV8Coverage(`${repoRoot}/coverage`);
+log(`normalize completed in ${Date.now() - normalizeStart}ms`);
+const collectV8CoverageFiles = (dir: string): string[] => {
+  const results: string[] = [];
+  if (!fs.existsSync(dir)) return results;
+  const walk = (current: string) => {
+    assertNotCancelling();
+    const entries = fs.readdirSync(current, { withFileTypes: true });
+    for (const entry of entries) {
+      assertNotCancelling();
+      const fullPath = `${current}/${entry.name}`;
+      if (entry.isDirectory()) {
+        if (entry.name === ".v8-tmp" || entry.name === "merged") {
+          continue;
+        }
+        walk(fullPath);
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+      try {
+        const raw = fs.readFileSync(fullPath, "utf8");
+        if (!raw.trim()) continue;
+        const parsed = JSON.parse(raw) as { result?: unknown };
+        if (parsed?.result) results.push(fullPath);
+      } catch {
+        // ignore invalid JSON in coverage dir
+      }
+    }
+  };
+  walk(dir);
+  return results;
+};
+
+const v8CoverageFiles = collectV8CoverageFiles(`${repoRoot}/coverage`);
+if (v8CoverageFiles.length === 0) {
+  console.log("No V8 coverage files found.");
+  process.exit(0);
+}
+log(`found ${v8CoverageFiles.length} v8 coverage files`);
+
+fs.mkdirSync(`${repoRoot}/coverage/merged`, { recursive: true });
+fs.rmSync(`${repoRoot}/coverage/.v8-tmp`, { recursive: true, force: true });
+fs.mkdirSync(`${repoRoot}/coverage/.v8-tmp`, { recursive: true });
+v8CoverageFiles.forEach((file, index) => {
+  assertNotCancelling();
+  fs.copyFileSync(file, `${repoRoot}/coverage/.v8-tmp/coverage-${index}.json`);
+});
+log(`copied files to ${repoRoot}/coverage/.v8-tmp`);
+
+const runC8Report = async () => {
+  assertNotCancelling();
+  log("running c8 report merge");
+  const args = [
+    "exec",
+    "c8",
+    "report",
+    "--temp-directory",
+    `${repoRoot}/coverage/.v8-tmp`,
+    "--merge-async",
+    "--reporter=html",
+    "--reporter=lcov",
+    "--reporter=json",
+    "--reporter=text-summary",
+    "--reports-dir",
+    `${repoRoot}/coverage/merged`,
+    "--cwd",
+    repoRoot,
+    "--include",
+    "packages/**",
+    "--exclude",
+    "**/node_modules/**",
+    "--exclude",
+    "**/dist/**",
+    "--exclude",
+    "**/examples/**",
+    "--exclude",
+    "**/scripts/**",
+    "--exclude",
+    "packages/**/test/**",
+    "--exclude",
+    "packages/**/tests/**",
+    "--exclude",
+    "packages/**/examples/**",
+    "--exclude",
+    "packages/**/lib/**/tests/**",
+    "--exclude",
+    "packages/**/scripts/**",
+    "--exclude-after-remap",
+    "--exclude",
+    "**/*.d.ts",
+  ];
+  let stdout = "";
+
+  const status = await new Promise<number>((resolve, reject) => {
+    const child = spawn("pnpm", args, {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    activeChild = child;
+
+    child.stdout?.on("data", (chunk) => {
+      const text = String(chunk);
+      stdout += text;
+      process.stdout.write(text);
+    });
+    child.stderr?.on("data", (chunk) => {
+      process.stderr.write(String(chunk));
+    });
+
+    child.once("error", (error) => {
+      activeChild = null;
+      reject(error);
+    });
+    child.once("close", (code) => {
+      activeChild = null;
+      resolve(code ?? 1);
+    });
+  });
+
+  if (stdout) {
+    fs.writeFileSync(
+      `${repoRoot}/coverage/merged/coverage-summary.txt`,
+      stdout,
+    );
+  }
+  log(`c8 report completed with status ${status}`);
+  return status;
+};
+
+try {
+  const status = await runC8Report();
+  process.exit(status);
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (!isCancelling) {
+    console.error(`Failed to run c8 coverage report: ${message}`);
+  }
+  process.exit(1);
+}
diff --git a/packages/core/scripts/gen-version.ts b/packages/core/scripts/gen-version.ts
new file mode 100644
index 000000000..a8cc0fa9f
--- /dev/null
+++ b/packages/core/scripts/gen-version.ts
@@ -0,0 +1,19 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { getPackageRootDir } from "../lib/v3/runtimePaths.js";
+
+type PackageJson = { version: string };
+
+const packageRoot = getPackageRootDir();
+const pkgPath = `${packageRoot}/package.json`;
+const pkg: PackageJson = JSON.parse(readFileSync(pkgPath, "utf8"));
+
+const fullVersion: `${string}` = pkg.version;
+
+const banner = `/**
+ * AUTO-GENERATED — DO NOT EDIT BY HAND
+ *  Run \`pnpm run gen-version\` to refresh.
+ */
+export const STAGEHAND_VERSION = "${fullVersion}" as const;
+`;
+
+writeFileSync(`${packageRoot}/lib/version.ts`, banner);
diff --git a/packages/core/scripts/normalize-v8-coverage.ts b/packages/core/scripts/normalize-v8-coverage.ts
new file mode 100644
index 000000000..18fcd4710
--- /dev/null
+++ b/packages/core/scripts/normalize-v8-coverage.ts
@@ -0,0 +1,446 @@
+/**
+ * Normalize V8 coverage ranges using sourcemaps to avoid offset/1x floor issues.
+ *
+ * Prereqs: V8 coverage JSON files plus JS files with inline or external sourcemaps.
+ * Args: --coverage-dir <dir> (or NODE_V8_COVERAGE).
+ * Env: NODE_V8_COVERAGE, V8_COVERAGE_SCAN_LIMIT.
+ * Example: tsx packages/core/scripts/normalize-v8-coverage.ts --coverage-dir coverage/e2e-local
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  SourceMapConsumer,
+  type RawIndexMap,
+  type RawSourceMap,
+} from "source-map";
+import { getRepoRootDir, isMainModule } from "../lib/v3/runtimePaths.js";
+
+type CoverageRange = {
+  startOffset: number;
+  endOffset: number;
+  count: number;
+};
+
+type CoverageEntry = {
+  url?: string;
+  functions?: Array<{
+    ranges?: CoverageRange[];
+  }>;
+};
+
+type CoverageFile = {
+  result?: CoverageEntry[];
+};
+
+const toFilePath = (urlOrPath: string): string | null => {
+  if (!urlOrPath) return null;
+  if (urlOrPath.startsWith("node:")) return null;
+  if (urlOrPath.startsWith("file:")) {
+    try {
+      return fileURLToPath(urlOrPath);
+    } catch {
+      return null;
+    }
+  }
+  return path.isAbsolute(urlOrPath) ? urlOrPath : null;
+};
+
+type SourceMapPayload = RawSourceMap | RawIndexMap;
+
+const readSourceMap = (jsPath: string): SourceMapPayload | null => {
+  if (!fs.existsSync(jsPath)) return null;
+  const source = fs.readFileSync(jsPath, "utf8");
+  const inlineMatch = source.match(
+    /sourceMappingURL=data:application\/json;base64,([A-Za-z0-9+/=]+)/,
+  );
+  if (inlineMatch) {
+    return JSON.parse(
+      Buffer.from(inlineMatch[1], "base64").toString("utf8"),
+    ) as SourceMapPayload;
+  }
+  const mapMatch = source.match(/sourceMappingURL=([^\s]+)/);
+  if (!mapMatch) return null;
+  const mapFile = mapMatch[1].trim();
+  if (mapFile.startsWith("data:")) return null;
+  const mapPath = path.resolve(path.dirname(jsPath), mapFile);
+  if (!fs.existsSync(mapPath)) return null;
+  return JSON.parse(fs.readFileSync(mapPath, "utf8")) as SourceMapPayload;
+};
+
+const buildLineStarts = (source: string) => {
+  const lineStarts = [0];
+  for (let i = 0; i < source.length; i++) {
+    if (source[i] === "\n") lineStarts.push(i + 1);
+  }
+  return lineStarts;
+};
+
+const offsetToLineCol = (lineStarts: number[], offset: number) => {
+  let low = 0;
+  let high = lineStarts.length - 1;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const start = lineStarts[mid];
+    const next = mid + 1 < lineStarts.length ? lineStarts[mid + 1] : Infinity;
+    if (start <= offset && offset < next) {
+      return { line: mid + 1, column: offset - start };
+    }
+    if (start > offset) {
+      high = mid - 1;
+    } else {
+      low = mid + 1;
+    }
+  }
+  return { line: 1, column: 0 };
+};
+
+const lineColToOffset = (
+  lineStarts: number[],
+  line: number,
+  column: number,
+  sourceLength: number,
+) => {
+  const lineIndex = Math.max(0, line - 1);
+  const lineStart = lineStarts[lineIndex] ?? 0;
+  const lineEnd =
+    lineIndex + 1 < lineStarts.length
+      ? lineStarts[lineIndex + 1] - 1
+      : sourceLength;
+  const clampedColumn = Math.max(0, Math.min(column, lineEnd - lineStart));
+  return lineStart + clampedColumn;
+};
+type NormalizerOptions = {
+  coverageDir: string;
+  maxScan: number;
+};
+
+type SourceContext = {
+  lineStarts: number[];
+  sourceLength: number;
+  consumer: SourceMapConsumer;
+};
+
+type MappedPosition = {
+  source: string;
+  line: number;
+  column: number;
+};
+
+type OffsetMapping = {
+  mapped: MappedPosition;
+  offset: number;
+};
+
+const mapOriginalPosition = (
+  consumer: SourceMapConsumer,
+  line: number,
+  column: number,
+  bias: number,
+) =>
+  consumer.originalPositionFor({
+    line,
+    column,
+    bias,
+  });
+
+const findMappedStart = (
+  ctx: SourceContext,
+  startOffset: number,
+  endOffset: number,
+  options: NormalizerOptions,
+): OffsetMapping | null => {
+  const maxScan = Math.min(
+    options.maxScan,
+    Math.max(0, endOffset - startOffset),
+  );
+  const startPos = offsetToLineCol(ctx.lineStarts, startOffset);
+  let mapped = mapOriginalPosition(
+    ctx.consumer,
+    startPos.line,
+    startPos.column,
+    SourceMapConsumer.LEAST_UPPER_BOUND,
+  );
+  if (!mapped.source) {
+    mapped = mapOriginalPosition(
+      ctx.consumer,
+      startPos.line,
+      startPos.column,
+      SourceMapConsumer.GREATEST_LOWER_BOUND,
+    );
+  }
+  if (mapped.source) {
+    return {
+      mapped: {
+        source: mapped.source,
+        line: mapped.line ?? 1,
+        column: mapped.column ?? 0,
+      },
+      offset: startOffset,
+    };
+  }
+
+  const limit = Math.min(endOffset, startOffset + maxScan);
+  for (let off = startOffset + 1; off <= limit; off++) {
+    const pos = offsetToLineCol(ctx.lineStarts, off);
+    mapped = mapOriginalPosition(
+      ctx.consumer,
+      pos.line,
+      pos.column,
+      SourceMapConsumer.LEAST_UPPER_BOUND,
+    );
+    if (!mapped.source) {
+      mapped = mapOriginalPosition(
+        ctx.consumer,
+        pos.line,
+        pos.column,
+        SourceMapConsumer.GREATEST_LOWER_BOUND,
+      );
+    }
+    if (mapped.source) {
+      return {
+        mapped: {
+          source: mapped.source,
+          line: mapped.line ?? 1,
+          column: mapped.column ?? 0,
+        },
+        offset: off,
+      };
+    }
+  }
+
+  return null;
+};
+
+const findMappedEnd = (
+  ctx: SourceContext,
+  startOffset: number,
+  endOffset: number,
+  options: NormalizerOptions,
+  targetSource?: string,
+): OffsetMapping | null => {
+  const maxScan = Math.min(
+    options.maxScan,
+    Math.max(0, endOffset - startOffset),
+  );
+  const endPos = offsetToLineCol(ctx.lineStarts, endOffset);
+  let mapped = mapOriginalPosition(
+    ctx.consumer,
+    endPos.line,
+    endPos.column,
+    SourceMapConsumer.GREATEST_LOWER_BOUND,
+  );
+  if (!mapped.source || (targetSource && mapped.source !== targetSource)) {
+    mapped = mapOriginalPosition(
+      ctx.consumer,
+      endPos.line,
+      endPos.column,
+      SourceMapConsumer.LEAST_UPPER_BOUND,
+    );
+  }
+  if (mapped.source && (!targetSource || mapped.source === targetSource)) {
+    return {
+      mapped: {
+        source: mapped.source,
+        line: mapped.line ?? 1,
+        column: mapped.column ?? 0,
+      },
+      offset: endOffset,
+    };
+  }
+
+  const limit = Math.max(startOffset, endOffset - maxScan);
+  for (let off = endOffset - 1; off >= limit; off--) {
+    const pos = offsetToLineCol(ctx.lineStarts, off);
+    mapped = mapOriginalPosition(
+      ctx.consumer,
+      pos.line,
+      pos.column,
+      SourceMapConsumer.GREATEST_LOWER_BOUND,
+    );
+    if (!mapped.source || (targetSource && mapped.source !== targetSource)) {
+      mapped = mapOriginalPosition(
+        ctx.consumer,
+        pos.line,
+        pos.column,
+        SourceMapConsumer.LEAST_UPPER_BOUND,
+      );
+    }
+    if (mapped.source && (!targetSource || mapped.source === targetSource)) {
+      return {
+        mapped: {
+          source: mapped.source,
+          line: mapped.line ?? 1,
+          column: mapped.column ?? 0,
+        },
+        offset: off,
+      };
+    }
+  }
+
+  return null;
+};
+
+const normalizeRange = (
+  range: CoverageRange,
+  ctx: SourceContext,
+  options: NormalizerOptions,
+) => {
+  if (range.endOffset <= range.startOffset) return false;
+  const startMapping = findMappedStart(
+    ctx,
+    range.startOffset,
+    range.endOffset,
+    options,
+  );
+  if (!startMapping) return false;
+  const endMapping = findMappedEnd(
+    ctx,
+    range.startOffset,
+    range.endOffset,
+    options,
+    startMapping.mapped.source,
+  );
+  if (!endMapping) return false;
+
+  let startOffset = startMapping.offset;
+  let endOffset = endMapping.offset;
+
+  if (range.count === 0) {
+    const genStart = ctx.consumer.generatedPositionFor({
+      source: startMapping.mapped.source,
+      line: startMapping.mapped.line,
+      column: 0,
+      bias: SourceMapConsumer.LEAST_UPPER_BOUND,
+    });
+    const genEnd = ctx.consumer.generatedPositionFor({
+      source: startMapping.mapped.source,
+      line: endMapping.mapped.line ?? startMapping.mapped.line,
+      column: Number.MAX_SAFE_INTEGER,
+      bias: SourceMapConsumer.GREATEST_LOWER_BOUND,
+    });
+    if (genStart.line && genEnd.line) {
+      const expandedStart = lineColToOffset(
+        ctx.lineStarts,
+        genStart.line,
+        genStart.column ?? 0,
+        ctx.sourceLength,
+      );
+      const expandedEnd = lineColToOffset(
+        ctx.lineStarts,
+        genEnd.line,
+        genEnd.column ?? 0,
+        ctx.sourceLength,
+      );
+      startOffset = Math.min(startOffset, expandedStart);
+      endOffset = Math.max(endOffset, expandedEnd);
+    }
+  }
+
+  if (endOffset <= startOffset) return false;
+  if (startOffset !== range.startOffset || endOffset !== range.endOffset) {
+    range.startOffset = startOffset;
+    range.endOffset = endOffset;
+    return true;
+  }
+  return false;
+};
+
+const normalizeCoverageDir = async (options: NormalizerOptions) => {
+  if (!fs.existsSync(options.coverageDir)) return;
+  const jsonFiles: string[] = [];
+  const walk = (dir: string) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = `${dir}/${entry.name}`;
+      if (entry.isDirectory()) {
+        if (entry.name === ".v8-tmp" || entry.name === "merged") {
+          continue;
+        }
+        walk(full);
+      } else if (entry.isFile() && entry.name.endsWith(".json")) {
+        jsonFiles.push(full);
+      }
+    }
+  };
+  walk(options.coverageDir);
+  if (jsonFiles.length === 0) return;
+
+  const sourceCache = new Map<string, SourceContext | null>();
+  try {
+    for (const file of jsonFiles) {
+      const data = JSON.parse(fs.readFileSync(file, "utf8")) as CoverageFile;
+      if (!Array.isArray(data.result)) continue;
+      let updated = false;
+
+      for (const entry of data.result) {
+        const jsPath = entry.url ? toFilePath(entry.url) : null;
+        if (!jsPath) continue;
+        let ctx = sourceCache.get(jsPath);
+        if (ctx === undefined) {
+          const map = readSourceMap(jsPath);
+          if (!map) {
+            sourceCache.set(jsPath, null);
+            continue;
+          }
+          const source = fs.readFileSync(jsPath, "utf8");
+          ctx = {
+            lineStarts: buildLineStarts(source),
+            sourceLength: source.length,
+            consumer: await new SourceMapConsumer(map),
+          };
+          sourceCache.set(jsPath, ctx);
+        }
+        if (!ctx) continue;
+        if (!entry?.functions) continue;
+        for (const block of entry.functions) {
+          if (!block?.ranges) continue;
+          for (const range of block.ranges) {
+            if (normalizeRange(range, ctx, options)) {
+              updated = true;
+            }
+          }
+        }
+      }
+
+      if (updated) {
+        fs.writeFileSync(file, JSON.stringify(data));
+      }
+    }
+  } finally {
+    for (const ctx of sourceCache.values()) {
+      ctx?.consumer.destroy();
+    }
+  }
+};
+
+export const normalizeV8Coverage = async (coverageDir: string) => {
+  const repoRoot = getRepoRootDir();
+  const resolvedDir = path.isAbsolute(coverageDir)
+    ? coverageDir
+    : path.resolve(repoRoot, coverageDir);
+  const maxScan = Number(process.env.V8_COVERAGE_SCAN_LIMIT ?? 20000);
+  await normalizeCoverageDir({ coverageDir: resolvedDir, maxScan });
+};
+
+export default normalizeV8Coverage;
+
+const main = async () => {
+  const args = process.argv.slice(2);
+  const idx = args.indexOf("--coverage-dir");
+  const coverageDir =
+    (idx >= 0 ? args[idx + 1] : undefined) ?? process.env.NODE_V8_COVERAGE;
+  if (!coverageDir) {
+    console.error(
+      "Missing coverage dir (use --coverage-dir or NODE_V8_COVERAGE).",
+    );
+    process.exit(1);
+  }
+  await normalizeV8Coverage(coverageDir);
+};
+
+if (isMainModule()) {
+  main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}
diff --git a/packages/core/scripts/prepare.js b/packages/core/scripts/prepare.js
new file mode 100644
index 000000000..45449c6ba
--- /dev/null
+++ b/packages/core/scripts/prepare.js
@@ -0,0 +1,18 @@
+import { spawnSync } from "node:child_process";
+
+const isCi =
+  process.env.CI === "true" ||
+  process.env.CI === "1" ||
+  process.env.SKIP_PREPARE === "1";
+
+if (isCi) {
+  console.log("Skipping prepare script in CI.");
+  process.exit(0);
+}
+
+const result = spawnSync("pnpm", ["run", "build"], {
+  stdio: "inherit",
+  shell: process.platform === "win32",
+});
+
+process.exit(result.status ?? 1);
diff --git a/packages/core/scripts/test-core.ts b/packages/core/scripts/test-core.ts
new file mode 100644
index 000000000..019fcedfc
--- /dev/null
+++ b/packages/core/scripts/test-core.ts
@@ -0,0 +1,139 @@
+/**
+ * Core unit tests (Vitest) on dist/esm tests.
+ *
+ * Prereqs: pnpm run build:esm (packages/core/dist/esm/tests/unit present).
+ * Args: [test paths...] -- [vitest args...] | --list (prints JSON matrix)
+ * Env: NODE_V8_COVERAGE, NODE_OPTIONS, VITEST_CONSOLE_REPORTER;
+ *      writes CTRF to ctrf/vitest-core.xml by default.
+ * Example: pnpm run test:core -- packages/core/dist/esm/tests/unit/foo.test.js -- --reporter=junit
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import {
+  ensureParentDir,
+  parseListFlag,
+  splitArgs,
+  collectFiles,
+  toSafeName,
+  normalizeVitestArgs,
+  findJunitPath,
+  hasReporterName,
+  writeCtrfFromJunit,
+} from "./test-utils.js";
+import { getRepoRootDir } from "../lib/v3/runtimePaths.js";
+
+const repoRoot = getRepoRootDir();
+
+const sourceTestsDir = `${repoRoot}/packages/core/tests/unit`;
+const testsDir = `${repoRoot}/packages/core/dist/esm/tests/unit`;
+const defaultConfigPath = `${repoRoot}/packages/core/vitest.esm.config.mjs`;
+
+const resolveRepoRelative = (value: string) =>
+  path.isAbsolute(value) ? value : path.resolve(repoRoot, value);
+
+const hasConfigArg = (argsList: string[]) =>
+  argsList.some((arg, i) => {
+    if (arg.startsWith("--config=")) return true;
+    return arg === "--config" && Boolean(argsList[i + 1]);
+  });
+
+const toTestName = (testPath: string) => {
+  const abs = resolveRepoRelative(testPath);
+  const rel = path.relative(testsDir, abs).replaceAll("\\", "/");
+  if (!rel.startsWith("..")) {
+    return rel.replace(/\.test\.(ts|js)$/i, "");
+  }
+  return path.basename(abs).replace(/\.test\.(ts|js)$/i, "");
+};
+
+const listFlag = parseListFlag(process.argv.slice(2));
+const { paths, extra } = splitArgs(listFlag.args);
+
+if (listFlag.list) {
+  const tests = collectFiles(sourceTestsDir, ".test.ts");
+  const entries = tests.map((file) => {
+    const relSource = path.relative(sourceTestsDir, file).replaceAll("\\", "/");
+    const rel = relSource.replace(/\.test\.ts$/, "");
+    const distPath = `${testsDir}/${relSource.replace(/\.test\.ts$/, ".test.js")}`;
+    return {
+      path: path.relative(repoRoot, distPath).replaceAll("\\", "/"),
+      name: rel,
+      safe_name: toSafeName(rel),
+    };
+  });
+  console.log(JSON.stringify(entries));
+  process.exit(0);
+}
+
+if (!fs.existsSync(testsDir)) {
+  console.error(
+    "Missing packages/core/dist/esm/tests/unit. Run pnpm run build:esm first.",
+  );
+  process.exit(1);
+}
+
+const runtimePaths = paths.map(resolveRepoRelative);
+const hasUserConfig = hasConfigArg(extra);
+
+const baseNodeOptions = "--enable-source-maps";
+const nodeOptions = [process.env.NODE_OPTIONS, baseNodeOptions]
+  .filter(Boolean)
+  .join(" ");
+
+const relTestName = paths.length === 1 ? toTestName(paths[0]) : null;
+
+const coverageDir = resolveRepoRelative(
+  process.env.NODE_V8_COVERAGE ??
+    (relTestName
+      ? `${repoRoot}/coverage/core-unit/${relTestName}`
+      : `${repoRoot}/coverage/core-unit`),
+);
+fs.mkdirSync(coverageDir, { recursive: true });
+
+const normalizedExtra = normalizeVitestArgs(repoRoot, extra);
+const defaultJunitPath = (() => {
+  if (!relTestName) {
+    return `${repoRoot}/ctrf/core-unit/all.xml`;
+  }
+  return `${repoRoot}/ctrf/core-unit/${relTestName}.xml`;
+})();
+const hasOutput = Boolean(findJunitPath(normalizedExtra));
+const vitestArgs = [...normalizedExtra];
+const consoleReporter = process.env.VITEST_CONSOLE_REPORTER ?? "default";
+if (!hasReporterName(vitestArgs, consoleReporter)) {
+  vitestArgs.push(`--reporter=${consoleReporter}`);
+}
+if (!hasReporterName(vitestArgs, "junit")) {
+  vitestArgs.push("--reporter=junit");
+}
+if (!hasOutput) {
+  ensureParentDir(defaultJunitPath);
+  vitestArgs.push(`--outputFile.junit=${defaultJunitPath}`);
+}
+const junitPath = findJunitPath(vitestArgs) ?? defaultJunitPath;
+
+const env = {
+  ...process.env,
+  NODE_OPTIONS: nodeOptions,
+  NODE_V8_COVERAGE: coverageDir,
+};
+
+const result = spawnSync(
+  "pnpm",
+  [
+    "--filter",
+    "@browserbasehq/stagehand",
+    "exec",
+    "vitest",
+    "run",
+    ...(hasUserConfig ? [] : ["--config", defaultConfigPath]),
+    ...vitestArgs,
+    ...runtimePaths,
+  ],
+  { stdio: "inherit", env },
+);
+
+writeCtrfFromJunit(junitPath, "vitest");
+
+process.exit(result.status ?? 1);
diff --git a/packages/core/scripts/test-e2e.ts b/packages/core/scripts/test-e2e.ts
new file mode 100644
index 000000000..098003c5b
--- /dev/null
+++ b/packages/core/scripts/test-e2e.ts
@@ -0,0 +1,170 @@
+/**
+ * E2E tests (Playwright) on dist/esm tests.
+ *
+ * Prereqs: pnpm run build:esm (packages/core/dist/esm/tests/integration present).
+ * Args: [test paths...] -- [playwright args...] | --list (prints JSON matrix).
+ * Env: STAGEHAND_BROWSER_TARGET=local|browserbase, CHROME_PATH (local),
+ *      NODE_V8_COVERAGE, PLAYWRIGHT_CONSOLE_REPORTER;
+ *      writes CTRF to ctrf/playwright-*.xml by default.
+ * Example: STAGEHAND_BROWSER_TARGET=browserbase pnpm run test:e2e -- packages/core/dist/esm/tests/integration/foo.spec.js
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import {
+  ensureParentDir,
+  parseListFlag,
+  splitArgs,
+  collectFiles,
+  toSafeName,
+  writeCtrfFromJunit,
+} from "./test-utils.js";
+import {
+  createRequireFromCaller,
+  getRepoRootDir,
+} from "../lib/v3/runtimePaths.js";
+
+const repoRoot = getRepoRootDir();
+
+const sourceTestsDir = `${repoRoot}/packages/core/tests/integration`;
+const testsDir = `${repoRoot}/packages/core/dist/esm/tests/integration`;
+const defaultConfigPath = `${repoRoot}/packages/core/dist/esm/tests/integration/v3.playwright.config.js`;
+
+const resolveRepoRelative = (value: string) =>
+  path.isAbsolute(value) ? value : path.resolve(repoRoot, value);
+const require = createRequireFromCaller();
+const playwrightCliPath = require.resolve("@playwright/test/cli");
+
+const hasConfigArg = (argsList: string[]) =>
+  argsList.some((arg, i) => {
+    if (arg.startsWith("--config=")) return true;
+    return arg === "--config" && Boolean(argsList[i + 1]);
+  });
+
+const stripReporterArgs = (argsList: string[]) => {
+  const filtered: string[] = [];
+  let removed = false;
+  for (let i = 0; i < argsList.length; i++) {
+    const arg = argsList[i];
+    if (
+      arg === "--reporter" ||
+      arg === "-r" ||
+      arg.startsWith("--reporter=") ||
+      arg.startsWith("-r=")
+    ) {
+      removed = true;
+      if ((arg === "--reporter" || arg === "-r") && argsList[i + 1]) {
+        i += 1;
+      }
+      continue;
+    }
+    filtered.push(arg);
+  }
+  return { filtered, removed };
+};
+
+const toTestName = (testPath: string) => {
+  const abs = resolveRepoRelative(testPath);
+  const rel = path.relative(testsDir, abs).replaceAll("\\", "/");
+  if (!rel.startsWith("..")) {
+    return rel.replace(/\.spec\.(ts|js)$/i, "");
+  }
+  return path.basename(abs).replace(/\.spec\.(ts|js)$/i, "");
+};
+
+const toPlaywrightPath = (testPath: string) => {
+  const abs = resolveRepoRelative(testPath);
+  const rel = path.relative(testsDir, abs).replaceAll("\\", "/");
+  const value = rel.startsWith("..") ? abs : rel;
+  return value.replace(/(\.spec|\.test)\.(ts|js)$/i, "$1");
+};
+
+const listFlag = parseListFlag(process.argv.slice(2));
+const { paths, extra } = splitArgs(listFlag.args);
+
+if (listFlag.list) {
+  const tests = collectFiles(sourceTestsDir, ".spec.ts");
+  const entries = tests.map((file) => {
+    const relSource = path.relative(sourceTestsDir, file).replaceAll("\\", "/");
+    const rel = relSource.replace(/\.spec\.ts$/, "");
+    const distPath = `${testsDir}/${relSource.replace(/\.spec\.ts$/, ".spec.js")}`;
+    return {
+      path: path.relative(repoRoot, distPath).replaceAll("\\", "/"),
+      name: rel,
+      safe_name: toSafeName(rel),
+    };
+  });
+  console.log(JSON.stringify(entries));
+  process.exit(0);
+}
+
+if (!fs.existsSync(testsDir)) {
+  console.error(
+    "Missing packages/core/dist/esm/tests/integration. Run pnpm run build:esm first.",
+  );
+  process.exit(1);
+}
+
+const { filtered: extraArgs, removed: removedReporterOverride } =
+  stripReporterArgs(extra);
+if (removedReporterOverride) {
+  console.warn(
+    "Ignoring Playwright --reporter override to preserve console + JUnit output.",
+  );
+}
+
+const hasUserConfig = hasConfigArg(extraArgs);
+if (!hasUserConfig && !fs.existsSync(defaultConfigPath)) {
+  console.error(`Missing Playwright config at ${defaultConfigPath}.`);
+  process.exit(1);
+}
+
+const playwrightPaths = paths.map(toPlaywrightPath);
+
+const target = (process.env.STAGEHAND_BROWSER_TARGET ?? "local").toLowerCase();
+const useBrowserbase = target === "browserbase";
+const relTestName = paths.length === 1 ? toTestName(paths[0]) : null;
+
+const coverageDir = resolveRepoRelative(
+  process.env.NODE_V8_COVERAGE ??
+    (relTestName
+      ? `${repoRoot}/coverage/${useBrowserbase ? "e2e-bb" : "e2e-local"}/${relTestName}`
+      : `${repoRoot}/coverage/${useBrowserbase ? "e2e-bb" : "e2e-local"}`),
+);
+fs.mkdirSync(coverageDir, { recursive: true });
+
+const defaultJunitPath = relTestName
+  ? `${repoRoot}/ctrf/${useBrowserbase ? "e2e-bb" : "e2e-local"}/${relTestName}.xml`
+  : `${repoRoot}/ctrf/${useBrowserbase ? "e2e-bb" : "e2e-local"}/all.xml`;
+const ctrfPath = process.env.CTRF_JUNIT_PATH
+  ? resolveRepoRelative(process.env.CTRF_JUNIT_PATH)
+  : defaultJunitPath;
+ensureParentDir(ctrfPath);
+
+const baseNodeOptions = "--enable-source-maps";
+const nodeOptions = [process.env.NODE_OPTIONS, baseNodeOptions]
+  .filter(Boolean)
+  .join(" ");
+
+const env = {
+  ...process.env,
+  NODE_OPTIONS: nodeOptions,
+  NODE_V8_COVERAGE: coverageDir,
+  CTRF_JUNIT_PATH: ctrfPath,
+};
+
+const result = spawnSync(
+  process.execPath,
+  [
+    playwrightCliPath,
+    "test",
+    ...(hasUserConfig ? [] : ["--config", defaultConfigPath]),
+    ...extraArgs,
+    ...playwrightPaths,
+  ],
+  { stdio: "inherit", env, cwd: repoRoot },
+);
+
+writeCtrfFromJunit(ctrfPath, "playwright");
+
+process.exit(result.status ?? 1);
diff --git a/packages/core/scripts/test-utils.ts b/packages/core/scripts/test-utils.ts
new file mode 100644
index 000000000..8a981429f
--- /dev/null
+++ b/packages/core/scripts/test-utils.ts
@@ -0,0 +1,174 @@
+/**
+ * Shared helpers for scripts (not a runnable script).
+ *
+ * Prereqs: none.
+ * Args: n/a.
+ * Env: n/a.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { getRepoRootDir } from "../lib/v3/runtimePaths.js";
+
+const workspaceRoot = getRepoRootDir();
+
+export const ensureParentDir = (filePath: string) => {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+};
+
+export const splitArgs = (args: string[]) => {
+  const tokens = [...args];
+  while (tokens[0] === "--") {
+    tokens.shift();
+  }
+
+  const leadingExtra: string[] = [];
+  while (tokens.length > 0 && tokens[0].startsWith("-")) {
+    const arg = tokens.shift();
+    if (!arg) break;
+    if (arg === "--") break;
+    leadingExtra.push(arg);
+    if (
+      !arg.includes("=") &&
+      tokens[0] &&
+      tokens[0] !== "--" &&
+      !tokens[0].startsWith("-")
+    ) {
+      leadingExtra.push(tokens.shift() as string);
+    }
+  }
+
+  while (tokens[0] === "--") {
+    tokens.shift();
+  }
+
+  const separatorIndex = tokens.indexOf("--");
+  return {
+    paths: separatorIndex === -1 ? tokens : tokens.slice(0, separatorIndex),
+    extra: [
+      ...leadingExtra,
+      ...(separatorIndex === -1 ? [] : tokens.slice(separatorIndex + 1)),
+    ],
+  };
+};
+
+export const parseListFlag = (args: string[]) => {
+  const remaining: string[] = [];
+  let value: string | null = null;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--list") {
+      const next = args[i + 1];
+      if (next && !next.startsWith("--")) {
+        value = next;
+        i += 1;
+      } else {
+        value = "";
+      }
+      continue;
+    }
+    if (arg.startsWith("--list=")) {
+      value = arg.slice("--list=".length);
+      continue;
+    }
+    remaining.push(arg);
+  }
+  return { list: value !== null, value: value ?? "", args: remaining };
+};
+
+export const toSafeName = (name: string) => name.replace(/[\\/]/g, "-");
+
+export const collectFiles = (dir: string, suffix: string) => {
+  const results: string[] = [];
+  const walk = (current: string) => {
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const full = `${current}/${entry.name}`;
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile() && entry.name.endsWith(suffix)) {
+        results.push(full);
+      }
+    }
+  };
+  if (fs.existsSync(dir)) walk(dir);
+  return results.sort();
+};
+
+export const normalizeVitestArgs = (repoRoot: string, argsList: string[]) => {
+  const normalized = [...argsList];
+  const prefix = "--outputFile.junit=";
+  for (let i = 0; i < normalized.length; i++) {
+    const arg = normalized[i];
+    if (arg.startsWith(prefix)) {
+      const value = arg.slice(prefix.length);
+      const resolved = path.isAbsolute(value)
+        ? value
+        : path.resolve(repoRoot, value);
+      ensureParentDir(resolved);
+      normalized[i] = `${prefix}${resolved}`;
+      continue;
+    }
+    if (arg === "--outputFile.junit" && normalized[i + 1]) {
+      const resolved = path.isAbsolute(normalized[i + 1])
+        ? normalized[i + 1]
+        : path.resolve(repoRoot, normalized[i + 1]);
+      ensureParentDir(resolved);
+      normalized[i + 1] = resolved;
+      i += 1;
+    }
+  }
+  return normalized;
+};
+
+export const findJunitPath = (argsList: string[]) => {
+  const prefix = "--outputFile.junit=";
+  for (let i = 0; i < argsList.length; i++) {
+    const arg = argsList[i];
+    if (arg.startsWith(prefix)) {
+      return arg.slice(prefix.length);
+    }
+    if (arg === "--outputFile.junit" && argsList[i + 1]) {
+      return argsList[i + 1];
+    }
+  }
+  return null;
+};
+
+const parseReporters = (argsList: string[]) => {
+  const reporters: string[] = [];
+  for (let i = 0; i < argsList.length; i++) {
+    const arg = argsList[i];
+    if (arg.startsWith("--reporter=")) {
+      reporters.push(arg.slice("--reporter=".length));
+      continue;
+    }
+    if (arg === "--reporter" && argsList[i + 1]) {
+      reporters.push(argsList[i + 1]);
+      i += 1;
+    }
+  }
+  return reporters
+    .flatMap((value) => value.split(","))
+    .map((value) => value.trim())
+    .filter(Boolean);
+};
+
+export const hasReporterName = (argsList: string[], reporter: string) =>
+  parseReporters(argsList).some((value) => value === reporter);
+
+export const writeCtrfFromJunit = (junitPath: string, tool: string) => {
+  if (!fs.existsSync(junitPath)) return;
+  const stat = fs.statSync(junitPath);
+  if (stat.size === 0) return;
+  const ctrfPath = junitPath.match(/\.xml$/i)
+    ? junitPath.replace(/\.xml$/i, ".json")
+    : `${junitPath}.json`;
+  const result = spawnSync(
+    "pnpm",
+    ["exec", "junit-to-ctrf", junitPath, "-o", ctrfPath, "-t", tool],
+    { stdio: "inherit", cwd: workspaceRoot },
+  );
+  if (result.status !== 0) {
+    console.warn(`CTRF conversion failed for ${junitPath}.`);
+  }
+};
diff --git a/packages/core/tests/cache-variables.test.ts b/packages/core/tests/cache-variables.test.ts
new file mode 100644
index 000000000..fc63abbaf
--- /dev/null
+++ b/packages/core/tests/cache-variables.test.ts
@@ -0,0 +1,292 @@
+import { describe, expect, it, vi } from "vitest";
+import { ActCache } from "../lib/v3/cache/ActCache";
+import type { CacheStorage } from "../lib/v3/cache/CacheStorage";
+import type { ActHandler } from "../lib/v3/handlers/actHandler";
+import type { LLMClient } from "../lib/v3/llm/LLMClient";
+import type { Page } from "../lib/v3/understudy/page";
+import type { ActCacheContext, CachedActEntry } from "../lib/v3/types/private";
+import type { Action } from "../lib/v3/types/public";
+
+function createFakeStorage<T>(entry: T): CacheStorage {
+  return {
+    enabled: true,
+    readJson: vi.fn().mockResolvedValue({ value: entry }),
+    writeJson: vi.fn().mockResolvedValue({}),
+    directory: "/tmp/cache",
+  } as unknown as CacheStorage;
+}
+
+describe("ActCache variable handling", () => {
+  it("cache key includes variable keys but not values", async () => {
+    const storage = {
+      enabled: true,
+      readJson: vi.fn(),
+      writeJson: vi.fn().mockResolvedValue({}),
+      directory: "/tmp/cache",
+    } as unknown as CacheStorage;
+
+    const cache = new ActCache({
+      storage,
+      logger: vi.fn(),
+      getActHandler: () => null as unknown as ActHandler,
+      getDefaultLlmClient: () => ({}) as LLMClient,
+      domSettleTimeoutMs: undefined,
+    });
+
+    const fakePage = {
+      url: vi.fn().mockResolvedValue("https://example.com"),
+    } as unknown as Page;
+
+    // First context with username="user1@example.com"
+    const context1 = await cache.prepareContext(
+      "type %username% into the email field",
+      fakePage,
+      { username: "user1@example.com" },
+    );
+
+    // Second context with username="user2@example.com"
+    const context2 = await cache.prepareContext(
+      "type %username% into the email field",
+      fakePage,
+      { username: "user2@example.com" },
+    );
+
+    // Third context with different variable key name
+    const context3 = await cache.prepareContext(
+      "type %email% into the email field",
+      fakePage,
+      { email: "user3@example.com" },
+    );
+
+    // Same instruction + same variable keys = same cache key
+    expect(context1?.cacheKey).toBe(context2?.cacheKey);
+
+    // Different variable keys = different cache key
+    expect(context1?.cacheKey).not.toBe(context3?.cacheKey);
+
+    // Verify variable keys are sorted and stored
+    expect(context1?.variableKeys).toEqual(["username"]);
+    expect(context2?.variableKeys).toEqual(["username"]);
+    expect(context3?.variableKeys).toEqual(["email"]);
+
+    // Verify variable values are preserved in context
+    expect(context1?.variables).toEqual({ username: "user1@example.com" });
+    expect(context2?.variables).toEqual({ username: "user2@example.com" });
+  });
+
+  it("replays cached actions with variable substitution", async () => {
+    // Cached action contains variable placeholder %username%
+    const action: Action = {
+      selector: "xpath=/html/body/input[@type='email']",
+      description: "type username into email field",
+      method: "type",
+      arguments: ["%username%"], // Variable placeholder
+    };
+
+    const entry: CachedActEntry = {
+      version: 1,
+      instruction: "type %username% into the email field",
+      url: "https://example.com",
+      variableKeys: ["username"],
+      actions: [action],
+      actionDescription: "type username",
+      message: "done",
+    };
+
+    const storage = createFakeStorage(entry);
+
+    // Track what variables are passed to takeDeterministicAction
+    const capturedVariables: Record<string, string>[] = [];
+    const handler = {
+      takeDeterministicAction: vi
+        .fn()
+        .mockImplementation(
+          async (_action, _page, _timeout, _client, _ensure, variables) => {
+            capturedVariables.push(variables || {});
+            return {
+              success: true,
+              message: "ok",
+              actionDescription: "type username",
+              actions: [action],
+            };
+          },
+        ),
+    } as unknown as ActHandler;
+
+    const defaultClient = {} as LLMClient;
+
+    const cache = new ActCache({
+      storage,
+      logger: vi.fn(),
+      getActHandler: () => handler,
+      getDefaultLlmClient: () => defaultClient,
+      domSettleTimeoutMs: undefined,
+    });
+
+    // First replay with username="user1@example.com"
+    const context1: ActCacheContext = {
+      instruction: "type %username% into the email field",
+      cacheKey: "test-key",
+      pageUrl: "https://example.com",
+      variableKeys: ["username"],
+      variables: { username: "user1@example.com" },
+    };
+
+    const result1 = await cache.tryReplay(context1, {} as Page);
+
+    expect(result1?.success).toBe(true);
+    expect(handler.takeDeterministicAction).toHaveBeenCalledTimes(1);
+    expect(capturedVariables[0]).toEqual({ username: "user1@example.com" });
+
+    // Reset
+    vi.clearAllMocks();
+    capturedVariables.length = 0;
+
+    // Second replay with username="user2@example.com"
+    const context2: ActCacheContext = {
+      instruction: "type %username% into the email field",
+      cacheKey: "test-key", // Same cache key!
+      pageUrl: "https://example.com",
+      variableKeys: ["username"],
+      variables: { username: "user2@example.com" },
+    };
+
+    const result2 = await cache.tryReplay(context2, {} as Page);
+
+    expect(result2?.success).toBe(true);
+    expect(handler.takeDeterministicAction).toHaveBeenCalledTimes(1);
+    expect(capturedVariables[0]).toEqual({ username: "user2@example.com" });
+  });
+
+  it("cache miss when variable keys don't match", async () => {
+    const action: Action = {
+      selector: "xpath=/html/body/input",
+      description: "type username",
+      method: "type",
+      arguments: ["%username%"],
+    };
+
+    // Cached entry expects "username" variable
+    const entry: CachedActEntry = {
+      version: 1,
+      instruction: "type %username% into the field",
+      url: "https://example.com",
+      variableKeys: ["username"],
+      actions: [action],
+    };
+
+    const storage = createFakeStorage(entry);
+    const cache = new ActCache({
+      storage,
+      logger: vi.fn(),
+      getActHandler: () => null as unknown as ActHandler,
+      getDefaultLlmClient: () => ({}) as LLMClient,
+      domSettleTimeoutMs: undefined,
+    });
+
+    // Context has different variable key "email"
+    const context: ActCacheContext = {
+      instruction: "type %email% into the field",
+      cacheKey: "test-key",
+      pageUrl: "https://example.com",
+      variableKeys: ["email"],
+      variables: { email: "test@example.com" },
+    };
+
+    const result = await cache.tryReplay(context, {} as Page);
+
+    // Should return null (cache miss) due to variable key mismatch
+    expect(result).toBeNull();
+  });
+
+  it("cache miss when required variables are missing", async () => {
+    const action: Action = {
+      selector: "xpath=/html/body/input",
+      description: "type username",
+      method: "type",
+      arguments: ["%username%"],
+    };
+
+    const entry: CachedActEntry = {
+      version: 1,
+      instruction: "type %username% into the field",
+      url: "https://example.com",
+      variableKeys: ["username"],
+      actions: [action],
+    };
+
+    const storage = createFakeStorage(entry);
+    const logger = vi.fn();
+    const cache = new ActCache({
+      storage,
+      logger,
+      getActHandler: () => null as unknown as ActHandler,
+      getDefaultLlmClient: () => ({}) as LLMClient,
+      domSettleTimeoutMs: undefined,
+    });
+
+    // Context missing the username variable value
+    const context: ActCacheContext = {
+      instruction: "type %username% into the field",
+      cacheKey: "test-key",
+      pageUrl: "https://example.com",
+      variableKeys: ["username"],
+      variables: {}, // Missing username value!
+    };
+
+    const result = await cache.tryReplay(context, {} as Page);
+
+    // Should return null (cache miss)
+    expect(result).toBeNull();
+
+    // Should log the miss reason
+    expect(logger).toHaveBeenCalledWith(
+      expect.objectContaining({
+        category: "cache",
+        message: "act cache miss: missing variables for replay",
+        level: 2,
+      }),
+    );
+  });
+
+  it("handles multiple variables correctly", async () => {
+    const storage = {
+      enabled: true,
+      readJson: vi.fn(),
+      writeJson: vi.fn().mockResolvedValue({}),
+      directory: "/tmp/cache",
+    } as unknown as CacheStorage;
+
+    const cache = new ActCache({
+      storage,
+      logger: vi.fn(),
+      getActHandler: () => null as unknown as ActHandler,
+      getDefaultLlmClient: () => ({}) as LLMClient,
+      domSettleTimeoutMs: undefined,
+    });
+
+    const fakePage = {
+      url: vi.fn().mockResolvedValue("https://example.com"),
+    } as unknown as Page;
+
+    // Context with multiple variables
+    const context1 = await cache.prepareContext(
+      "fill %username% and %password%",
+      fakePage,
+      { username: "user1", password: "pass1" },
+    );
+
+    const context2 = await cache.prepareContext(
+      "fill %username% and %password%",
+      fakePage,
+      { username: "user2", password: "pass2" },
+    );
+
+    // Same cache key despite different values
+    expect(context1?.cacheKey).toBe(context2?.cacheKey);
+
+    // Variable keys should be sorted
+    expect(context1?.variableKeys).toEqual(["password", "username"]);
+    expect(context2?.variableKeys).toEqual(["password", "username"]);
+  });
+});
diff --git a/packages/core/tests/integration/agent-abort-signal.spec.ts b/packages/core/tests/integration/agent-abort-signal.spec.ts
new file mode 100644
index 000000000..cec9c9b08
--- /dev/null
+++ b/packages/core/tests/integration/agent-abort-signal.spec.ts
@@ -0,0 +1,163 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+import { AgentAbortError } from "../../lib/v3/types/public/sdkErrors.js";
+
+test.describe("Stagehand agent abort signal", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3({
+      ...v3TestConfig,
+      experimental: true,
+    });
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test("non-streaming: abort signal stops execution and throws AgentAbortError", async () => {
+    test.setTimeout(60000);
+
+    const agent = v3.agent({
+      model: "anthropic/claude-haiku-4-5-20251001",
+    });
+
+    const page = v3.context.pages()[0];
+    await page.goto("https://example.com");
+
+    const controller = new AbortController();
+
+    // Abort after 500ms - should be enough for the LLM to start but not finish
+    setTimeout(() => controller.abort(), 500);
+
+    await expect(
+      agent.execute({
+        instruction:
+          "Describe every visual element on this page in extreme detail. Describe at least 100 different elements.",
+        maxSteps: 50,
+        signal: controller.signal,
+      }),
+    ).rejects.toThrow(AgentAbortError);
+  });
+
+  test("streaming: abort signal stops stream and rejects result with AgentAbortError", async () => {
+    test.setTimeout(60000);
+
+    const agent = v3.agent({
+      stream: true,
+      model: "anthropic/claude-haiku-4-5-20251001",
+    });
+
+    const page = v3.context.pages()[0];
+    await page.goto("https://example.com");
+
+    const controller = new AbortController();
+
+    // Abort after 500ms
+    setTimeout(() => controller.abort(), 500);
+
+    const streamResult = await agent.execute({
+      instruction:
+        "Describe every visual element on this page in extreme detail. Describe at least 100 different elements.",
+      maxSteps: 50,
+      signal: controller.signal,
+    });
+
+    // Handle both stream consumption and result promise together
+    // The result promise will reject with AgentAbortError when aborted
+    const consumeStream = async () => {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      for await (const _ of streamResult.textStream) {
+        // Just consume chunks until stream ends
+      }
+    };
+
+    // Both should complete - stream ends and result rejects
+    const [, resultError] = await Promise.allSettled([
+      consumeStream(),
+      streamResult.result,
+    ]);
+
+    // The result should have rejected with AgentAbortError
+    expect(resultError.status).toBe("rejected");
+    expect((resultError as PromiseRejectedResult).reason).toBeInstanceOf(
+      AgentAbortError,
+    );
+  });
+
+  test("non-streaming: already aborted signal throws AgentAbortError immediately", async () => {
+    test.setTimeout(20000);
+
+    const agent = v3.agent({
+      model: "anthropic/claude-haiku-4-5-20251001",
+    });
+
+    const page = v3.context.pages()[0];
+    await page.goto("https://example.com");
+
+    // Create an already aborted controller
+    const controller = new AbortController();
+    controller.abort();
+
+    await expect(
+      agent.execute({
+        instruction: "This should not run.",
+        maxSteps: 3,
+        signal: controller.signal,
+      }),
+    ).rejects.toThrow(AgentAbortError);
+  });
+
+  test("non-streaming: execution completes normally without abort signal", async () => {
+    test.setTimeout(60000);
+
+    const agent = v3.agent({
+      model: "anthropic/claude-haiku-4-5-20251001",
+    });
+
+    const page = v3.context.pages()[0];
+    await page.goto("https://example.com");
+
+    // No signal provided - should complete normally
+    const result = await agent.execute({
+      instruction: "Describe this page briefly.",
+      maxSteps: 3,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.completed).toBe(true);
+  });
+
+  test("streaming: execution completes normally without abort signal", async () => {
+    test.setTimeout(60000);
+
+    const agent = v3.agent({
+      stream: true,
+      model: "anthropic/claude-haiku-4-5-20251001",
+    });
+
+    const page = v3.context.pages()[0];
+    await page.goto("https://example.com");
+
+    // No signal provided - should complete normally
+    const streamResult = await agent.execute({
+      instruction: "Describe this page briefly.",
+      maxSteps: 3,
+    });
+
+    // Consume the stream first
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    for await (const _ of streamResult.textStream) {
+      // Just consume
+    }
+
+    // Now get the final result
+    const result = await streamResult.result;
+
+    expect(result.success).toBe(true);
+    expect(result.completed).toBe(true);
+  });
+});
diff --git a/packages/core/tests/integration/agent-cache-self-heal.spec.ts b/packages/core/tests/integration/agent-cache-self-heal.spec.ts
new file mode 100644
index 000000000..2c20c273f
--- /dev/null
+++ b/packages/core/tests/integration/agent-cache-self-heal.spec.ts
@@ -0,0 +1,104 @@
+import { test, expect } from "@playwright/test";
+import fs from "fs/promises";
+import path from "path";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+import type {
+  AgentReplayActStep,
+  AgentReplayFillFormStep,
+  CachedAgentEntry,
+} from "../../lib/v3/types/private/cache.js";
+
+test.describe("Agent cache self-heal (e2e)", () => {
+  let v3: V3;
+  let cacheDir: string;
+
+  // eslint-disable-next-line no-empty-pattern
+  test.beforeEach(async ({}, testInfo) => {
+    await fs.mkdir(testInfo.outputDir, { recursive: true });
+    cacheDir = await fs.mkdtemp(path.join(testInfo.outputDir, "agent-cache-"));
+    v3 = new V3({
+      ...v3TestConfig,
+      cacheDir,
+      selfHeal: true,
+    });
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test("replays heal corrupted selectors", async () => {
+    test.setTimeout(120_000);
+
+    const agent = v3.agent({
+      model: "anthropic/claude-haiku-4-5-20251001",
+    });
+    const page = v3.context.pages()[0];
+    const url =
+      "https://browserbase.github.io/stagehand-eval-sites/sites/shadow-dom/";
+    const instruction = "click the button";
+
+    await page.goto(url, { waitUntil: "networkidle" });
+    const firstResult = await agent.execute({ instruction, maxSteps: 20 });
+    expect(firstResult.success).toBe(true);
+
+    const cachePath = await locateAgentCacheFile(cacheDir);
+    const originalEntry = await readCacheEntry(cachePath);
+    const originalActionStep = findFirstActionStep(originalEntry);
+    expect(originalActionStep).toBeDefined();
+    const originalSelector = originalActionStep?.actions?.[0]?.selector;
+    expect(typeof originalSelector).toBe("string");
+
+    // Corrupt the cached selector so the replay needs to self-heal.
+    if (originalActionStep?.actions?.[0]) {
+      originalActionStep.actions[0].selector = "xpath=/yeee";
+    }
+    await fs.writeFile(
+      cachePath,
+      JSON.stringify(originalEntry, null, 2),
+      "utf8",
+    );
+
+    // Second run should replay from cache, self-heal, and update the file.
+    await page.goto(url, { waitUntil: "networkidle" });
+    const replayResult = await agent.execute({ instruction, maxSteps: 20 });
+    expect(replayResult.success).toBe(true);
+
+    const healedEntry = await readCacheEntry(cachePath);
+    const healedActionStep = findFirstActionStep(healedEntry);
+    expect(healedActionStep?.actions?.[0]?.selector).toBe(originalSelector);
+    expect(healedActionStep?.actions?.[0]?.selector).not.toBe("xpath=/yeee");
+    expect(healedEntry.timestamp).not.toBe(originalEntry.timestamp);
+  });
+});
+
+async function locateAgentCacheFile(cacheDir: string): Promise<string> {
+  const deadline = Date.now() + 10_000;
+  while (Date.now() < deadline) {
+    const entries = await fs.readdir(cacheDir);
+    const agentFiles = entries.filter((file) => file.startsWith("agent-"));
+    if (agentFiles.length > 0) {
+      return path.join(cacheDir, agentFiles[0]!);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+  throw new Error("Timed out waiting for agent cache entry to be written");
+}
+
+async function readCacheEntry(cachePath: string): Promise<CachedAgentEntry> {
+  const raw = await fs.readFile(cachePath, "utf8");
+  return JSON.parse(raw) as CachedAgentEntry;
+}
+
+type StepWithActions = AgentReplayActStep | AgentReplayFillFormStep;
+
+function findFirstActionStep(
+  entry: CachedAgentEntry,
+): StepWithActions | undefined {
+  return entry.steps.find((step) => {
+    const actions = (step as StepWithActions).actions;
+    return Array.isArray(actions) && actions.length > 0;
+  }) as StepWithActions | undefined;
+}
diff --git a/packages/core/tests/integration/agent-callbacks.spec.ts b/packages/core/tests/integration/agent-callbacks.spec.ts
new file mode 100644
index 000000000..b79943433
--- /dev/null
+++ b/packages/core/tests/integration/agent-callbacks.spec.ts
@@ -0,0 +1,477 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+import type { StepResult, ToolSet } from "ai";
+import { StreamingCallbacksInNonStreamingModeError } from "../../lib/v3/types/public/sdkErrors.js";
+
+test.describe("Stagehand agent callbacks behavior", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3({
+      ...v3TestConfig,
+      experimental: true, // Required for callbacks and streaming
+    });
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test.describe("Non-streaming callbacks (stream: false)", () => {
+    test("onStepFinish callback is called for each step", async () => {
+      test.setTimeout(60000);
+
+      const stepFinishEvents: StepResult<ToolSet>[] = [];
+
+      const agent = v3.agent({
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      await agent.execute({
+        instruction:
+          "What is the title of this page? Mark the task as complete after answering.",
+        maxSteps: 5,
+        callbacks: {
+          onStepFinish: async (event) => {
+            stepFinishEvents.push(event);
+          },
+        },
+      });
+
+      // Should have at least one step finish event
+      expect(stepFinishEvents.length).toBeGreaterThan(0);
+
+      // Each event should have expected properties
+      for (const event of stepFinishEvents) {
+        expect(event).toHaveProperty("finishReason");
+        expect(event).toHaveProperty("text");
+      }
+    });
+
+    test("prepareStep callback is called before each step", async () => {
+      test.setTimeout(60000);
+
+      let prepareStepCallCount = 0;
+
+      const agent = v3.agent({
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      await agent.execute({
+        instruction: "Simply describe the page briefly.",
+        maxSteps: 3,
+        callbacks: {
+          prepareStep: async (stepContext) => {
+            prepareStepCallCount++;
+            return stepContext;
+          },
+        },
+      });
+
+      // prepareStep should have been called at least once
+      expect(prepareStepCallCount).toBeGreaterThan(0);
+    });
+
+    test("callbacks receive tool call information", async () => {
+      test.setTimeout(60000);
+
+      const toolCalls: Array<{ toolName: string; input: unknown }> = [];
+
+      const agent = v3.agent({
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      await agent.execute({
+        instruction:
+          "Take a screenshot and describe what you see briefly. Then mark the task as complete.",
+        maxSteps: 3,
+        callbacks: {
+          onStepFinish: async (event) => {
+            if (event.toolCalls) {
+              for (const tc of event.toolCalls) {
+                toolCalls.push({
+                  toolName: tc.toolName,
+                  input: tc.input,
+                });
+              }
+            }
+          },
+        },
+      });
+
+      // Should have captured at least one tool call (e.g. screenshot)
+      expect(toolCalls.length).toBeGreaterThan(0);
+      expect(
+        toolCalls.some(
+          (tc) => tc.toolName === "screenshot" || tc.toolName === "ariaTree",
+        ),
+      ).toBe(true);
+    });
+  });
+
+  test.describe("Streaming callbacks (stream: true)", () => {
+    test("onStepFinish callback is called for each step in stream mode", async () => {
+      test.setTimeout(60000);
+
+      const stepFinishEvents: StepResult<ToolSet>[] = [];
+
+      const agent = v3.agent({
+        stream: true,
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      const streamResult = await agent.execute({
+        instruction: "What is this page? Describe it briefly.",
+        maxSteps: 5,
+        callbacks: {
+          onStepFinish: async (event) => {
+            stepFinishEvents.push(event);
+          },
+        },
+      });
+
+      // Consume the stream
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      for await (const _ of streamResult.textStream) {
+        // Just consume
+      }
+
+      // Wait for result to complete
+      await streamResult.result;
+
+      // Should have at least one step finish event
+      expect(stepFinishEvents.length).toBeGreaterThan(0);
+    });
+
+    test("onChunk callback is called for each chunk", async () => {
+      test.setTimeout(60000);
+
+      let chunkCount = 0;
+
+      const agent = v3.agent({
+        stream: true,
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      const streamResult = await agent.execute({
+        instruction: "Say hello briefly and describe the page.",
+        maxSteps: 3,
+        callbacks: {
+          onChunk: async () => {
+            chunkCount++;
+          },
+        },
+      });
+
+      // Consume the stream
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      for await (const _ of streamResult.textStream) {
+        // Just consume
+      }
+
+      await streamResult.result;
+
+      // Should have received chunks
+      expect(chunkCount).toBeGreaterThan(0);
+    });
+
+    test("onFinish callback is called when stream completes", async () => {
+      test.setTimeout(60000);
+
+      let finishCalled = false;
+      let finishEvent: unknown = null;
+
+      const agent = v3.agent({
+        stream: true,
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      const streamResult = await agent.execute({
+        instruction: "Simply describe the page briefly.",
+        maxSteps: 3,
+        callbacks: {
+          onFinish: (event) => {
+            finishCalled = true;
+            finishEvent = event;
+          },
+        },
+      });
+
+      // Consume the stream
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      for await (const _ of streamResult.textStream) {
+        // Just consume
+      }
+
+      await streamResult.result;
+
+      // onFinish should have been called
+      expect(finishCalled).toBe(true);
+      expect(finishEvent).not.toBeNull();
+    });
+
+    test("prepareStep callback works in stream mode", async () => {
+      test.setTimeout(60000);
+
+      let prepareStepCallCount = 0;
+
+      const agent = v3.agent({
+        stream: true,
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      const streamResult = await agent.execute({
+        instruction: "Simply describe the page briefly.",
+        maxSteps: 3,
+        callbacks: {
+          prepareStep: async (stepContext) => {
+            prepareStepCallCount++;
+            return stepContext;
+          },
+        },
+      });
+
+      // Consume the stream
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      for await (const _ of streamResult.textStream) {
+        // Just consume
+      }
+
+      await streamResult.result;
+
+      // prepareStep should have been called at least once
+      expect(prepareStepCallCount).toBeGreaterThan(0);
+    });
+  });
+
+  test.describe("Streaming-only callbacks runtime validation", () => {
+    test("throws StreamingCallbacksInNonStreamingModeError when onChunk is used", async () => {
+      const agent = v3.agent({
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      try {
+        await agent.execute({
+          instruction: "test",
+          callbacks: {
+            onChunk: (() => {}) as never,
+          },
+        });
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(StreamingCallbacksInNonStreamingModeError);
+        expect(
+          (error as StreamingCallbacksInNonStreamingModeError).invalidCallbacks,
+        ).toEqual(["onChunk"]);
+      }
+    });
+
+    test("throws StreamingCallbacksInNonStreamingModeError when onFinish is used", async () => {
+      const agent = v3.agent({
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      try {
+        await agent.execute({
+          instruction: "test",
+          callbacks: {
+            onFinish: (() => {}) as never,
+          },
+        });
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(StreamingCallbacksInNonStreamingModeError);
+        expect(
+          (error as StreamingCallbacksInNonStreamingModeError).invalidCallbacks,
+        ).toEqual(["onFinish"]);
+      }
+    });
+
+    test("throws StreamingCallbacksInNonStreamingModeError when onError is used", async () => {
+      const agent = v3.agent({
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      try {
+        await agent.execute({
+          instruction: "test",
+          callbacks: {
+            onError: (() => {}) as never,
+          },
+        });
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(StreamingCallbacksInNonStreamingModeError);
+        expect(
+          (error as StreamingCallbacksInNonStreamingModeError).invalidCallbacks,
+        ).toEqual(["onError"]);
+      }
+    });
+
+    test("throws StreamingCallbacksInNonStreamingModeError when onAbort is used", async () => {
+      const agent = v3.agent({
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      try {
+        await agent.execute({
+          instruction: "test",
+          callbacks: {
+            onAbort: (() => {}) as never,
+          },
+        });
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(StreamingCallbacksInNonStreamingModeError);
+        expect(
+          (error as StreamingCallbacksInNonStreamingModeError).invalidCallbacks,
+        ).toEqual(["onAbort"]);
+      }
+    });
+
+    test("error includes all invalid callbacks when multiple are used", async () => {
+      const agent = v3.agent({
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      try {
+        await agent.execute({
+          instruction: "test",
+          callbacks: {
+            onChunk: (() => {}) as never,
+            onFinish: (() => {}) as never,
+          },
+        });
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(StreamingCallbacksInNonStreamingModeError);
+        expect(
+          (error as StreamingCallbacksInNonStreamingModeError).invalidCallbacks,
+        ).toEqual(["onChunk", "onFinish"]);
+      }
+    });
+  });
+
+  test.describe("Combined callbacks", () => {
+    test("multiple callbacks can be used together", async () => {
+      test.setTimeout(60000);
+
+      let prepareStepCount = 0;
+      let stepFinishCount = 0;
+
+      const agent = v3.agent({
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      await agent.execute({
+        instruction: "Simply describe the page briefly.",
+        maxSteps: 3,
+        callbacks: {
+          prepareStep: async (stepContext) => {
+            prepareStepCount++;
+            return stepContext;
+          },
+          onStepFinish: async () => {
+            stepFinishCount++;
+          },
+        },
+      });
+
+      // Both callbacks should have been called
+      expect(prepareStepCount).toBeGreaterThan(0);
+      expect(stepFinishCount).toBeGreaterThan(0);
+    });
+
+    test("streaming with multiple callbacks", async () => {
+      test.setTimeout(60000);
+
+      let prepareStepCount = 0;
+      let stepFinishCount = 0;
+      let chunkCount = 0;
+      let finishCalled = false;
+
+      const agent = v3.agent({
+        stream: true,
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      const streamResult = await agent.execute({
+        instruction: "Say hello briefly and describe the page.",
+        maxSteps: 3,
+        callbacks: {
+          prepareStep: async (stepContext) => {
+            prepareStepCount++;
+            return stepContext;
+          },
+          onStepFinish: async () => {
+            stepFinishCount++;
+          },
+          onChunk: async () => {
+            chunkCount++;
+          },
+          onFinish: () => {
+            finishCalled = true;
+          },
+        },
+      });
+
+      // Consume the stream
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      for await (const _ of streamResult.textStream) {
+        // Just consume
+      }
+
+      await streamResult.result;
+
+      // All callbacks should have been called
+      expect(prepareStepCount).toBeGreaterThan(0);
+      expect(stepFinishCount).toBeGreaterThan(0);
+      expect(chunkCount).toBeGreaterThan(0);
+      expect(finishCalled).toBe(true);
+    });
+  });
+});
diff --git a/packages/core/tests/integration/agent-experimental-validation.spec.ts b/packages/core/tests/integration/agent-experimental-validation.spec.ts
new file mode 100644
index 000000000..fdf4c7864
--- /dev/null
+++ b/packages/core/tests/integration/agent-experimental-validation.spec.ts
@@ -0,0 +1,402 @@
+import { test, expect } from "@playwright/test";
+import { z } from "zod";
+import { tool } from "ai";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+import {
+  ExperimentalNotConfiguredError,
+  StagehandInvalidArgumentError,
+} from "../../lib/v3/types/public/sdkErrors.js";
+
+// Define a mock custom tool for testing
+const mockCustomTool = tool({
+  description: "A mock tool for testing",
+  inputSchema: z.object({
+    input: z.string().describe("The input string"),
+  }),
+  execute: async ({ input }) => {
+    return `Processed: ${input}`;
+  },
+});
+
+test.describe("Stagehand agent experimental feature validation", () => {
+  test.describe("Invalid argument errors", () => {
+    let v3: V3;
+
+    test.beforeEach(async () => {
+      v3 = new V3({
+        ...v3TestConfig,
+        experimental: false,
+      });
+      await v3.init();
+    });
+
+    test.afterEach(async () => {
+      await v3?.close?.().catch(() => {});
+    });
+
+    test("throws StagehandInvalidArgumentError when CUA and streaming are both enabled", async () => {
+      try {
+        v3.agent({
+          cua: true,
+          stream: true,
+          model: "anthropic/claude-sonnet-4-20250514",
+        });
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(StagehandInvalidArgumentError);
+        expect((error as Error).message).toContain("streaming");
+        expect((error as Error).message).toContain("not supported with CUA");
+      }
+    });
+
+    test("throws StagehandInvalidArgumentError for CUA + streaming even with experimental: true", async () => {
+      // Close the non-experimental instance
+      await v3.close();
+
+      // Create an experimental instance
+      const v3Experimental = new V3({
+        ...v3TestConfig,
+        experimental: true,
+      });
+      await v3Experimental.init();
+
+      try {
+        v3Experimental.agent({
+          cua: true,
+          stream: true,
+          model: "anthropic/claude-sonnet-4-20250514",
+        });
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(StagehandInvalidArgumentError);
+        expect((error as Error).message).toContain("streaming");
+        expect((error as Error).message).toContain("not supported with CUA");
+      } finally {
+        await v3Experimental.close();
+      }
+    });
+  });
+
+  test.describe("Experimental feature errors without experimental: true", () => {
+    let v3: V3;
+
+    test.beforeEach(async () => {
+      v3 = new V3({
+        ...v3TestConfig,
+        experimental: false,
+      });
+      await v3.init();
+    });
+
+    test.afterEach(async () => {
+      await v3?.close?.().catch(() => {});
+    });
+
+    test("throws ExperimentalNotConfiguredError for MCP integrations", async () => {
+      const agent = v3.agent({
+        model: "anthropic/claude-sonnet-4-20250514",
+        integrations: ["https://mcp.example.com"],
+      });
+
+      try {
+        await agent.execute("test");
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(ExperimentalNotConfiguredError);
+        expect((error as Error).message).toContain(
+          "MCP integrations and custom tools",
+        );
+      }
+    });
+
+    test("throws ExperimentalNotConfiguredError for custom tools", async () => {
+      const agent = v3.agent({
+        model: "anthropic/claude-sonnet-4-20250514",
+        tools: {
+          mockCustomTool,
+        },
+      });
+
+      try {
+        await agent.execute("test");
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(ExperimentalNotConfiguredError);
+        expect((error as Error).message).toContain(
+          "MCP integrations and custom tools",
+        );
+      }
+    });
+
+    test("throws ExperimentalNotConfiguredError for streaming mode", async () => {
+      try {
+        const agent = v3.agent({
+          stream: true,
+          model: "anthropic/claude-sonnet-4-20250514",
+        });
+        await agent.execute("test instruction");
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(ExperimentalNotConfiguredError);
+        expect((error as Error).message).toContain("streaming");
+      }
+    });
+
+    test("throws ExperimentalNotConfiguredError for callbacks", async () => {
+      const agent = v3.agent({
+        model: "anthropic/claude-sonnet-4-20250514",
+      });
+
+      try {
+        await agent.execute({
+          instruction: "test",
+          callbacks: {
+            onStepFinish: async () => {},
+          },
+        });
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(ExperimentalNotConfiguredError);
+        expect((error as Error).message).toContain("callbacks");
+      }
+    });
+
+    test("throws ExperimentalNotConfiguredError for abort signal", async () => {
+      const agent = v3.agent({
+        model: "anthropic/claude-sonnet-4-20250514",
+      });
+
+      const controller = new AbortController();
+      try {
+        await agent.execute({
+          instruction: "test",
+          signal: controller.signal,
+        });
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(ExperimentalNotConfiguredError);
+        expect((error as Error).message).toContain("abort signal");
+      }
+    });
+
+    test("throws ExperimentalNotConfiguredError for message continuation", async () => {
+      const agent = v3.agent({
+        model: "anthropic/claude-sonnet-4-20250514",
+      });
+
+      try {
+        await agent.execute({
+          instruction: "test",
+          messages: [{ role: "user", content: "previous message" }],
+        });
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(ExperimentalNotConfiguredError);
+        expect((error as Error).message).toContain("message continuation");
+      }
+    });
+
+    test("throws ExperimentalNotConfiguredError listing multiple features", async () => {
+      const agent = v3.agent({
+        model: "anthropic/claude-sonnet-4-20250514",
+      });
+
+      const controller = new AbortController();
+      try {
+        await agent.execute({
+          instruction: "test",
+          callbacks: { onStepFinish: async () => {} },
+          signal: controller.signal,
+          messages: [{ role: "user", content: "previous" }],
+        });
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(ExperimentalNotConfiguredError);
+        const message = (error as Error).message;
+        expect(message).toContain("callbacks");
+        expect(message).toContain("abort signal");
+        expect(message).toContain("message continuation");
+      }
+    });
+  });
+
+  test.describe("CUA agent unsupported features", () => {
+    let v3: V3;
+
+    test.beforeEach(async () => {
+      v3 = new V3({
+        ...v3TestConfig,
+        experimental: false,
+      });
+      await v3.init();
+    });
+
+    test.afterEach(async () => {
+      await v3?.close?.().catch(() => {});
+    });
+
+    test("throws ExperimentalNotConfiguredError for CUA with integrations", async () => {
+      // MCP integrations are still an experimental feature check (not unsupported)
+      try {
+        v3.agent({
+          cua: true,
+          model: "anthropic/claude-sonnet-4-20250514",
+          integrations: ["https://mcp.example.com"],
+        });
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(ExperimentalNotConfiguredError);
+        expect((error as Error).message).toContain(
+          "MCP integrations and custom tools",
+        );
+      }
+    });
+
+    test("throws StagehandInvalidArgumentError for CUA with abort signal (not supported)", async () => {
+      const agent = v3.agent({
+        cua: true,
+        model: "anthropic/claude-sonnet-4-20250514",
+      });
+
+      const controller = new AbortController();
+      try {
+        await agent.execute({
+          instruction: "test",
+          signal: controller.signal,
+        });
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(StagehandInvalidArgumentError);
+        expect((error as Error).message).toContain("abort signal");
+        expect((error as Error).message).toContain("not supported with CUA");
+      }
+    });
+
+    test("throws StagehandInvalidArgumentError for CUA with message continuation (not supported)", async () => {
+      const agent = v3.agent({
+        cua: true,
+        model: "anthropic/claude-sonnet-4-20250514",
+      });
+
+      try {
+        await agent.execute({
+          instruction: "test",
+          messages: [{ role: "user", content: "previous message" }],
+        });
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(StagehandInvalidArgumentError);
+        expect((error as Error).message).toContain("message continuation");
+        expect((error as Error).message).toContain("not supported with CUA");
+      }
+    });
+
+    test("throws StagehandInvalidArgumentError for CUA with multiple unsupported features", async () => {
+      const agent = v3.agent({
+        cua: true,
+        model: "anthropic/claude-sonnet-4-20250514",
+      });
+
+      const controller = new AbortController();
+      try {
+        await agent.execute({
+          instruction: "test",
+          signal: controller.signal,
+          messages: [{ role: "user", content: "previous message" }],
+        });
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(StagehandInvalidArgumentError);
+        const message = (error as Error).message;
+        expect(message).toContain("abort signal");
+        expect(message).toContain("message continuation");
+        expect(message).toContain("are not supported with CUA");
+      }
+    });
+
+    test("throws StagehandInvalidArgumentError for CUA unsupported features even with experimental: true", async () => {
+      // Close the non-experimental instance
+      await v3.close();
+
+      // Create an experimental instance
+      const v3Experimental = new V3({
+        ...v3TestConfig,
+        experimental: true,
+      });
+      await v3Experimental.init();
+
+      const agent = v3Experimental.agent({
+        cua: true,
+        model: "anthropic/claude-sonnet-4-20250514",
+      });
+
+      const controller = new AbortController();
+      try {
+        await agent.execute({
+          instruction: "test",
+          signal: controller.signal,
+        });
+        throw new Error("Expected error to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(StagehandInvalidArgumentError);
+        expect((error as Error).message).toContain("not supported with CUA");
+      } finally {
+        await v3Experimental.close();
+      }
+    });
+  });
+
+  test.describe("Valid configurations with experimental: true", () => {
+    let v3: V3;
+
+    test.beforeEach(async () => {
+      v3 = new V3({
+        ...v3TestConfig,
+        experimental: true,
+      });
+      await v3.init();
+    });
+
+    test.afterEach(async () => {
+      await v3?.close?.().catch(() => {});
+    });
+
+    test("allows CUA without streaming", () => {
+      expect(() =>
+        v3.agent({
+          cua: true,
+          model: "anthropic/claude-sonnet-4-20250514",
+        }),
+      ).not.toThrow();
+    });
+
+    test("allows streaming mode", () => {
+      expect(() =>
+        v3.agent({
+          stream: true,
+          model: "anthropic/claude-sonnet-4-20250514",
+        }),
+      ).not.toThrow();
+    });
+
+    test("allows basic agent without experimental features", async () => {
+      const v3NonExperimental = new V3({
+        ...v3TestConfig,
+        experimental: false,
+      });
+      await v3NonExperimental.init();
+
+      try {
+        // This should work - just creating a basic agent with no experimental features
+        expect(() =>
+          v3NonExperimental.agent({
+            model: "anthropic/claude-sonnet-4-20250514",
+          }),
+        ).not.toThrow();
+      } finally {
+        await v3NonExperimental.close();
+      }
+    });
+  });
+});
diff --git a/packages/core/tests/integration/agent-hybrid-mode.spec.ts b/packages/core/tests/integration/agent-hybrid-mode.spec.ts
new file mode 100644
index 000000000..f0a0d4b3e
--- /dev/null
+++ b/packages/core/tests/integration/agent-hybrid-mode.spec.ts
@@ -0,0 +1,318 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+import { createAgentTools } from "../../lib/v3/agent/tools/index.js";
+import { buildAgentSystemPrompt } from "../../lib/v3/agent/prompts/agentSystemPrompt.js";
+import type { StepResult, ToolSet } from "ai";
+
+test.describe("Stagehand agent hybrid mode", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3({
+      ...v3TestConfig,
+      experimental: true,
+    });
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test.describe("Tool filtering by mode", () => {
+    test("DOM mode includes DOM-based tools and excludes coordinate-based tools", () => {
+      const tools = createAgentTools(v3, { mode: "dom" });
+
+      // DOM mode should have these tools
+      expect(tools).toHaveProperty("act");
+      expect(tools).toHaveProperty("fillForm");
+      expect(tools).toHaveProperty("ariaTree");
+      expect(tools).toHaveProperty("screenshot");
+      expect(tools).toHaveProperty("extract");
+      expect(tools).toHaveProperty("goto");
+      expect(tools).toHaveProperty("scroll");
+      expect(tools).toHaveProperty("wait");
+      expect(tools).toHaveProperty("navback");
+      expect(tools).toHaveProperty("keys");
+      expect(tools).toHaveProperty("think");
+
+      // DOM mode should NOT have coordinate-based tools
+      expect(tools).not.toHaveProperty("click");
+      expect(tools).not.toHaveProperty("type");
+      expect(tools).not.toHaveProperty("dragAndDrop");
+      expect(tools).not.toHaveProperty("clickAndHold");
+      expect(tools).not.toHaveProperty("fillFormVision");
+    });
+
+    test("Hybrid mode includes coordinate-based tools and excludes DOM fillForm", () => {
+      const tools = createAgentTools(v3, { mode: "hybrid" });
+
+      // Hybrid mode should have coordinate-based tools
+      expect(tools).toHaveProperty("click");
+      expect(tools).toHaveProperty("type");
+      expect(tools).toHaveProperty("dragAndDrop");
+      expect(tools).toHaveProperty("clickAndHold");
+      expect(tools).toHaveProperty("fillFormVision");
+
+      // Hybrid mode should also have common tools
+      expect(tools).toHaveProperty("act");
+      expect(tools).toHaveProperty("ariaTree");
+      expect(tools).toHaveProperty("screenshot");
+      expect(tools).toHaveProperty("extract");
+      expect(tools).toHaveProperty("goto");
+      expect(tools).toHaveProperty("scroll");
+      expect(tools).toHaveProperty("wait");
+      expect(tools).toHaveProperty("navback");
+      expect(tools).toHaveProperty("keys");
+      expect(tools).toHaveProperty("think");
+
+      // Hybrid mode should NOT have DOM-based fillForm
+      expect(tools).not.toHaveProperty("fillForm");
+    });
+
+    test("Default mode is DOM when not specified", () => {
+      const tools = createAgentTools(v3, {});
+
+      // Should behave like DOM mode
+      expect(tools).toHaveProperty("fillForm");
+      expect(tools).not.toHaveProperty("click");
+      expect(tools).not.toHaveProperty("type");
+    });
+  });
+
+  test.describe("System prompt generation", () => {
+    test("DOM mode system prompt emphasizes ariaTree and act tool", () => {
+      const prompt = buildAgentSystemPrompt({
+        url: "https://example.com",
+        executionInstruction: "Test instruction",
+        mode: "dom",
+      });
+
+      // DOM mode should prioritize ariaTree
+      expect(prompt).toContain("ariaTree");
+      expect(prompt).toContain("act");
+      expect(prompt).toContain("fillForm");
+
+      // Should have DOM-specific strategy
+      expect(prompt).toContain("Use act tool for all clicking and typing");
+      expect(prompt).toContain("Always check ariaTree first");
+    });
+
+    test("Hybrid mode system prompt emphasizes screenshot and coordinate tools", () => {
+      const prompt = buildAgentSystemPrompt({
+        url: "https://example.com",
+        executionInstruction: "Test instruction",
+        mode: "hybrid",
+      });
+
+      // Hybrid mode should have coordinate-based tools mentioned
+      expect(prompt).toContain("click");
+      expect(prompt).toContain("type");
+      expect(prompt).toContain("fillFormVision");
+      expect(prompt).toContain("dragAndDrop");
+
+      // Should have hybrid-specific strategy
+      expect(prompt).toContain(
+        "Use specific tools (click, type) when elements are visible",
+      );
+      expect(prompt).toContain("Always use screenshot");
+    });
+
+    test("System prompt includes custom instructions when provided", () => {
+      const customInstructions = "Always be polite and thorough";
+      const prompt = buildAgentSystemPrompt({
+        url: "https://example.com",
+        executionInstruction: "Test instruction",
+        mode: "dom",
+        systemInstructions: customInstructions,
+      });
+
+      expect(prompt).toContain("customInstructions");
+      expect(prompt).toContain(customInstructions);
+    });
+
+    test("System prompt includes Browserbase captcha message when isBrowserbase is true", () => {
+      const prompt = buildAgentSystemPrompt({
+        url: "https://example.com",
+        executionInstruction: "Test instruction",
+        mode: "dom",
+        isBrowserbase: true,
+      });
+
+      expect(prompt).toContain("captcha");
+      expect(prompt).toContain("automatically be solved");
+    });
+
+    test("System prompt does not include captcha message when isBrowserbase is false", () => {
+      const prompt = buildAgentSystemPrompt({
+        url: "https://example.com",
+        executionInstruction: "Test instruction",
+        mode: "dom",
+        isBrowserbase: false,
+      });
+
+      expect(prompt).not.toContain("automatically be solved");
+    });
+  });
+
+  test.describe("Agent creation with mode", () => {
+    test("agent({ mode: 'dom' }) creates DOM-mode agent", () => {
+      const agent = v3.agent({
+        mode: "dom",
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      expect(agent).toHaveProperty("execute");
+    });
+
+    test("agent({ mode: 'hybrid' }) creates hybrid-mode agent", () => {
+      const agent = v3.agent({
+        mode: "hybrid",
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      expect(agent).toHaveProperty("execute");
+    });
+
+    test("agent without mode defaults to DOM mode", () => {
+      const agent = v3.agent({
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      expect(agent).toHaveProperty("execute");
+    });
+
+    test("hybrid mode can be combined with streaming", () => {
+      const agent = v3.agent({
+        mode: "hybrid",
+        stream: true,
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      expect(agent).toHaveProperty("execute");
+    });
+  });
+
+  test.describe("Hybrid mode execution", () => {
+    test("hybrid mode agent uses coordinate-based tools when available", async () => {
+      test.setTimeout(90000);
+
+      const toolCalls: Array<{ toolName: string; input: unknown }> = [];
+
+      const agent = v3.agent({
+        mode: "hybrid",
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      await agent.execute({
+        instruction:
+          "Take a screenshot to see the page, then describe what you see briefly and mark the task as complete.",
+        maxSteps: 5,
+        callbacks: {
+          onStepFinish: async (event: StepResult<ToolSet>) => {
+            if (event.toolCalls) {
+              for (const tc of event.toolCalls) {
+                toolCalls.push({
+                  toolName: tc.toolName,
+                  input: tc.input,
+                });
+              }
+            }
+          },
+        },
+      });
+
+      // Should have captured tool calls
+      expect(toolCalls.length).toBeGreaterThan(0);
+
+      const toolNames = toolCalls.map((tc) => tc.toolName);
+      // Should include screenshot (hybrid mode emphasizes visual)
+      expect(toolNames).toContain("screenshot");
+    });
+
+    test("DOM mode agent uses DOM-based tools", async () => {
+      test.setTimeout(90000);
+
+      const toolCalls: Array<{ toolName: string; input: unknown }> = [];
+
+      const agent = v3.agent({
+        mode: "dom",
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      await agent.execute({
+        instruction:
+          "Use the ariaTree to understand the page, then provide the final requested output or a summary of the page.",
+        maxSteps: 5,
+        callbacks: {
+          onStepFinish: async (event: StepResult<ToolSet>) => {
+            if (event.toolCalls) {
+              for (const tc of event.toolCalls) {
+                toolCalls.push({
+                  toolName: tc.toolName,
+                  input: tc.input,
+                });
+              }
+            }
+          },
+        },
+      });
+
+      // Should have captured tool calls
+      expect(toolCalls.length).toBeGreaterThan(0);
+
+      // Should include ariaTree (DOM mode emphasizes aria-based interaction)
+      const toolNames = toolCalls.map((tc) => tc.toolName);
+      expect(toolNames).toContain("ariaTree");
+    });
+  });
+
+  test.describe("Scroll tool variants by mode", () => {
+    test("DOM mode uses simple scroll tool without coordinates", () => {
+      const tools = createAgentTools(v3, { mode: "dom" });
+
+      expect(tools).toHaveProperty("scroll");
+      // The DOM scroll tool should exist
+      expect(typeof tools.scroll).toBe("object");
+    });
+
+    test("Hybrid mode uses vision scroll tool with optional coordinates", () => {
+      const tools = createAgentTools(v3, { mode: "hybrid" });
+
+      expect(tools).toHaveProperty("scroll");
+      // The hybrid scroll tool should exist
+      expect(typeof tools.scroll).toBe("object");
+    });
+  });
+
+  test.describe("Keys tool availability in both modes", () => {
+    test("Keys tool is available in DOM mode", () => {
+      const tools = createAgentTools(v3, { mode: "dom" });
+      expect(tools).toHaveProperty("keys");
+    });
+
+    test("Keys tool is available in hybrid mode", () => {
+      const tools = createAgentTools(v3, { mode: "hybrid" });
+      expect(tools).toHaveProperty("keys");
+    });
+  });
+
+  test.describe("Think tool availability", () => {
+    test("Think tool is available in DOM mode", () => {
+      const tools = createAgentTools(v3, { mode: "dom" });
+      expect(tools).toHaveProperty("think");
+    });
+
+    test("Think tool is available in hybrid mode", () => {
+      const tools = createAgentTools(v3, { mode: "hybrid" });
+      expect(tools).toHaveProperty("think");
+    });
+  });
+});
diff --git a/packages/core/tests/integration/agent-message-continuation.spec.ts b/packages/core/tests/integration/agent-message-continuation.spec.ts
new file mode 100644
index 000000000..fa24925fd
--- /dev/null
+++ b/packages/core/tests/integration/agent-message-continuation.spec.ts
@@ -0,0 +1,149 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+import type { ModelMessage } from "ai";
+
+test.describe("Stagehand agent message continuation", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3({
+      ...v3TestConfig,
+      experimental: true,
+    });
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test("execute returns messages in the result", async () => {
+    test.setTimeout(60000);
+
+    const agent = v3.agent({
+      model: "anthropic/claude-haiku-4-5-20251001",
+    });
+
+    const page = v3.context.pages()[0];
+    await page.goto("https://example.com");
+
+    const result = await agent.execute({
+      instruction: "What is the title of this page? Describe it briefly.",
+      maxSteps: 5,
+    });
+
+    // Result should contain messages
+    expect(result.messages).toBeDefined();
+    expect(Array.isArray(result.messages)).toBe(true);
+    expect(result.messages!.length).toBeGreaterThan(0);
+
+    // First message should be the user instruction
+    const firstMessage = result.messages![0];
+    expect(firstMessage.role).toBe("user");
+  });
+
+  test("can continue conversation with previous messages", async () => {
+    test.setTimeout(120000);
+
+    const agent = v3.agent({
+      model: "anthropic/claude-haiku-4-5-20251001",
+    });
+
+    const page = v3.context.pages()[0];
+    await page.goto("https://example.com");
+
+    // First execution
+    const result1 = await agent.execute({
+      instruction: "What is the title of this page? Describe it briefly.",
+      maxSteps: 5,
+    });
+
+    expect(result1.messages).toBeDefined();
+    expect(result1.messages!.length).toBeGreaterThan(0);
+
+    // Second execution continuing from first
+    const result2 = await agent.execute({
+      instruction:
+        "Based on what you just told me, is this a simple or complex website? Answer briefly.",
+      maxSteps: 5,
+      messages: result1.messages,
+    });
+
+    expect(result2.messages).toBeDefined();
+    // Second result should have more messages (includes first conversation)
+    expect(result2.messages!.length).toBeGreaterThan(result1.messages!.length);
+  });
+
+  test("messages include tool calls and results", async () => {
+    test.setTimeout(60000);
+
+    const agent = v3.agent({
+      model: "anthropic/claude-haiku-4-5-20251001",
+    });
+
+    const page = v3.context.pages()[0];
+    await page.goto("https://example.com");
+
+    const result = await agent.execute({
+      instruction:
+        "Use the ariaTree tool to see the page, then describe what you found briefly.",
+      maxSteps: 5,
+    });
+
+    expect(result.messages).toBeDefined();
+
+    // Verify there are assistant messages
+    const assistantMessages = result.messages!.filter(
+      (m: ModelMessage) => m.role === "assistant",
+    );
+    expect(assistantMessages.length).toBeGreaterThan(0);
+
+    // Verify at least one assistant message contains tool calls
+    const hasToolCalls = assistantMessages.some((m: ModelMessage) => {
+      if (Array.isArray(m.content)) {
+        return m.content.some(
+          (part) => typeof part === "object" && part.type === "tool-call",
+        );
+      }
+      return false;
+    });
+    expect(hasToolCalls).toBe(true);
+
+    // Verify there are tool result messages
+    const hasToolResults = result.messages!.some(
+      (m: ModelMessage) => m.role === "tool",
+    );
+    expect(hasToolResults).toBe(true);
+  });
+
+  test("streaming mode also returns messages", async () => {
+    test.setTimeout(60000);
+
+    const agent = v3.agent({
+      stream: true,
+      model: "anthropic/claude-haiku-4-5-20251001",
+    });
+
+    const page = v3.context.pages()[0];
+    await page.goto("https://example.com");
+
+    const streamResult = await agent.execute({
+      instruction: "What is this page? Describe it briefly.",
+      maxSteps: 5,
+    });
+
+    // Consume the stream
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    for await (const _ of streamResult.textStream) {
+      // Just consume
+    }
+
+    const result = await streamResult.result;
+
+    // Result should contain messages
+    expect(result.messages).toBeDefined();
+    expect(Array.isArray(result.messages)).toBe(true);
+    expect(result.messages!.length).toBeGreaterThan(0);
+  });
+});
diff --git a/packages/core/tests/integration/agent-streaming.spec.ts b/packages/core/tests/integration/agent-streaming.spec.ts
new file mode 100644
index 000000000..549bfed09
--- /dev/null
+++ b/packages/core/tests/integration/agent-streaming.spec.ts
@@ -0,0 +1,173 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+import type { AgentResult } from "../../lib/v3/types/public/agent.js";
+
+test.describe("Stagehand agent streaming behavior", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3({
+      ...v3TestConfig,
+      experimental: true, // Required for streaming
+    });
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test.describe("agent({ stream: true })", () => {
+    test("AgentStreamResult has textStream as async iterable", async () => {
+      test.setTimeout(60000);
+
+      const agent = v3.agent({
+        stream: true,
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      // Navigate to a simple page first
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      const streamResult = await agent.execute({
+        instruction: "What is the title of this page? Describe it briefly.",
+        maxSteps: 3,
+      });
+
+      // Verify it's an AgentStreamResult with streaming capabilities
+      expect(streamResult).toHaveProperty("textStream");
+      expect(streamResult).toHaveProperty("result");
+
+      // textStream should be async iterable
+      expect(typeof streamResult.textStream[Symbol.asyncIterator]).toBe(
+        "function",
+      );
+
+      // result should be a promise
+      expect(streamResult.result).toBeInstanceOf(Promise);
+    });
+
+    test("textStream yields chunks incrementally", async () => {
+      test.setTimeout(60000);
+
+      const agent = v3.agent({
+        stream: true,
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      const streamResult = await agent.execute({
+        instruction: "Say hello briefly.",
+        maxSteps: 3,
+      });
+
+      // Collect chunks from the stream
+      const chunks: string[] = [];
+      for await (const chunk of streamResult.textStream) {
+        chunks.push(chunk);
+      }
+
+      // Should have received at least some chunks (streaming behavior)
+      // The exact content depends on the LLM response
+      expect(Array.isArray(chunks)).toBe(true);
+      expect(chunks.length).toBeGreaterThan(0);
+    });
+
+    test("result promise resolves to AgentResult after stream completes", async () => {
+      test.setTimeout(60000);
+
+      const agent = v3.agent({
+        stream: true,
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      const streamResult = await agent.execute({
+        instruction: "What is this page about? Describe it briefly.",
+        maxSteps: 5,
+      });
+
+      // Consume the stream first
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      for await (const _ of streamResult.textStream) {
+        // Just consume
+      }
+
+      // Now get the final result
+      const finalResult: AgentResult = await streamResult.result;
+
+      // Verify it's a proper AgentResult
+      expect(finalResult).toHaveProperty("success");
+      expect(finalResult).toHaveProperty("message");
+      expect(finalResult).toHaveProperty("actions");
+      expect(finalResult).toHaveProperty("completed");
+      expect(typeof finalResult.success).toBe("boolean");
+      expect(typeof finalResult.message).toBe("string");
+      expect(Array.isArray(finalResult.actions)).toBe(true);
+    });
+  });
+
+  test.describe("agent({ stream: false }) or agent()", () => {
+    test("execute returns AgentResult without streaming properties", async () => {
+      test.setTimeout(60000);
+
+      const agent = v3.agent({
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      const page = v3.context.pages()[0];
+      await page.goto("https://example.com");
+
+      const result = await agent.execute({
+        instruction: "What is this page? Describe it briefly.",
+        maxSteps: 3,
+      });
+      // Should be AgentResult, not AgentStreamResult
+      expect(result).toHaveProperty("success");
+      expect(result).toHaveProperty("message");
+      expect(result).toHaveProperty("actions");
+      expect(result).toHaveProperty("completed");
+
+      // Should NOT have streaming properties
+      expect(result).not.toHaveProperty("textStream");
+    });
+  });
+
+  test.describe("CUA disables streaming", () => {
+    test("throws StagehandInvalidArgumentError when cua: true and stream: true", () => {
+      expect(() => {
+        v3.agent({
+          cua: true,
+          stream: true,
+          model: "anthropic/claude-haiku-4-5-20251001",
+        });
+      }).toThrow("streaming is not supported with CUA");
+    });
+
+    test("allows cua: true without stream", () => {
+      // Should not throw
+      const agent = v3.agent({
+        cua: true,
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      expect(agent).toHaveProperty("execute");
+    });
+
+    test("allows stream: true without cua", () => {
+      // Should not throw
+      const agent = v3.agent({
+        stream: true,
+        model: "anthropic/claude-haiku-4-5-20251001",
+      });
+
+      expect(agent).toHaveProperty("execute");
+    });
+  });
+});
diff --git a/packages/core/tests/integration/cdp-close-api-region.spec.ts b/packages/core/tests/integration/cdp-close-api-region.spec.ts
new file mode 100644
index 000000000..6587095e1
--- /dev/null
+++ b/packages/core/tests/integration/cdp-close-api-region.spec.ts
@@ -0,0 +1,53 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { getV3TestConfig } from "./v3.config.js";
+import { raceTimeout } from "./testUtils.js";
+
+/**
+ * Full production trigger chain:
+ *
+ *   v3.close()
+ *     → apiClient.end()           (tells hosted API to kill the BB session)
+ *     → hosted API terminates BB   (CDP WebSocket closes from server side)
+ *     → ctx.close() → conn.close() (awaits "close" on already-CLOSED WS → hangs)
+ *
+ * Requires:
+ *   - BROWSERBASE_API_KEY / BROWSERBASE_PROJECT_ID
+ *   - The Stagehand hosted API to be reachable
+ *   - A non-us-west-2 region (higher latency makes the race reliably trigger)
+ */
+test.describe("v3.close() with Stagehand API + non-default region", () => {
+  test("close resolves instead of hanging", async () => {
+    const apiKey = process.env.BROWSERBASE_API_KEY;
+    const projectId = process.env.BROWSERBASE_PROJECT_ID;
+
+    test.skip(
+      !apiKey || !projectId,
+      "BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID are required",
+    );
+
+    const v3 = new V3(
+      getV3TestConfig({
+        disableAPI: false,
+        browserbaseSessionCreateParams: { region: "ap-southeast-1" },
+      }),
+    );
+
+    await v3.init();
+
+    // Verify the instance is functional.
+    const page = v3.context.pages()[0];
+    await page.goto("data:text/html,<html><body>api-region-test</body></html>");
+
+    // Call v3.close() — the normal production shutdown path.
+    // Internally: apiClient.end() → hosted API kills BB session →
+    // CDP WebSocket closes → conn.close() tries to close already-closed WS.
+    // Without the fix this hangs forever.
+    const result = await raceTimeout(
+      v3.close().then(() => "resolved" as const),
+      30_000,
+    );
+
+    expect(result).toBe("resolved");
+  });
+});
diff --git a/packages/core/tests/integration/cdp-connection-close.spec.ts b/packages/core/tests/integration/cdp-connection-close.spec.ts
new file mode 100644
index 000000000..1d1e1b308
--- /dev/null
+++ b/packages/core/tests/integration/cdp-connection-close.spec.ts
@@ -0,0 +1,97 @@
+import { test, expect } from "@playwright/test";
+import WebSocket from "ws";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+import { raceTimeout } from "./testUtils.js";
+
+test.describe("CdpConnection.close() after external WebSocket close", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    // Best-effort teardown – don't let a hung close block the suite.
+    try {
+      await raceTimeout(v3?.close?.(), 5_000);
+    } catch {
+      // ignore
+    }
+  });
+
+  test("v3.close() resolves after the CDP WebSocket is already closed", async () => {
+    // Verify the V3 instance is functional.
+    const page = v3.context.pages()[0];
+    await page.goto("data:text/html,<html><body>close-test</body></html>");
+
+    const conn = v3.context.conn;
+
+    // Unhook the V3-level _onCdpClosed handler so it doesn't trigger
+    // _immediateShutdown in the background (we want to isolate the
+    // CdpConnection.close() hang).
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const onCdpClosed = (v3 as any)._onCdpClosed;
+    if (onCdpClosed) {
+      conn.offTransportClosed(onCdpClosed);
+    }
+
+    // Wait for the transport-close event to be fully processed.
+    const transportClosed = new Promise<void>((resolve) => {
+      conn.onTransportClosed(() => resolve());
+    });
+
+    // Terminate the underlying WebSocket – simulates the hosted API
+    // killing the Browserbase session, which closes the CDP socket
+    // from the server side.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const ws: WebSocket = (conn as any).ws;
+    ws.terminate();
+
+    await transportClosed;
+
+    // Now call v3.close(). Internally this calls ctx.close() →
+    // conn.close(), which awaits a "close" event on an already-CLOSED
+    // WebSocket. Without the fix this promise never resolves.
+    const result = await raceTimeout(
+      v3.close().then(() => "resolved" as const),
+      5_000,
+    );
+
+    expect(result).toBe("resolved");
+  });
+
+  test("inflight CDP calls reject when the WebSocket is terminated", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto("data:text/html,<html><body>inflight-test</body></html>");
+
+    const conn = v3.context.conn;
+
+    // Unhook the V3-level handler as above.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const onCdpClosed = (v3 as any)._onCdpClosed;
+    if (onCdpClosed) {
+      conn.offTransportClosed(onCdpClosed);
+    }
+
+    // Send a long-running CDP call that the server will never answer.
+    const pending = conn.send("Runtime.evaluate", {
+      expression: "new Promise(r => setTimeout(() => r('done'), 60000))",
+      awaitPromise: true,
+    });
+
+    // Terminate the WebSocket while the call is inflight.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const ws: WebSocket = (conn as any).ws;
+    ws.terminate();
+
+    // The pending promise must reject – not hang forever.
+    const result = await raceTimeout(
+      pending.then(() => "resolved" as const).catch(() => "rejected" as const),
+      5_000,
+    );
+
+    expect(result).toBe("rejected");
+  });
+});
diff --git a/packages/core/tests/integration/cdp-session-detached.spec.ts b/packages/core/tests/integration/cdp-session-detached.spec.ts
new file mode 100644
index 000000000..05db8554c
--- /dev/null
+++ b/packages/core/tests/integration/cdp-session-detached.spec.ts
@@ -0,0 +1,57 @@
+import { test, expect } from "@playwright/test";
+import { chromium as playwrightChromium } from "playwright";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+
+test.describe("CDP session detach handling", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test("rejects inflight CDP calls when a target is closed", async () => {
+    const unhandled: unknown[] = [];
+    const onUnhandled = (reason: unknown) => {
+      unhandled.push(reason);
+    };
+
+    process.on("unhandledRejection", onUnhandled);
+
+    let pwBrowser: Awaited<
+      ReturnType<typeof playwrightChromium.connectOverCDP>
+    > | null = null;
+
+    try {
+      pwBrowser = await playwrightChromium.connectOverCDP(v3.connectURL());
+      const pwContext = pwBrowser.contexts()[0];
+      const pwPage = pwContext.pages()[0];
+
+      const v3Page = v3.context.pages()[0];
+      await v3Page.goto("data:text/html,<html><body>cdp</body></html>");
+
+      const pending = v3Page.sendCDP("Runtime.evaluate", {
+        expression: "new Promise(r => setTimeout(() => r('done'), 5000))",
+        awaitPromise: true,
+        returnByValue: true,
+      });
+
+      await pwPage.close();
+
+      await expect(pending).rejects.toThrow(
+        /No Page found for target closed before CDP response/,
+      );
+
+      await new Promise((r) => setTimeout(r, 50));
+      expect(unhandled).toHaveLength(0);
+    } finally {
+      process.off("unhandledRejection", onUnhandled);
+      await pwBrowser?.close().catch(() => {});
+    }
+  });
+});
diff --git a/packages/core/tests/integration/click-count.spec.ts b/packages/core/tests/integration/click-count.spec.ts
new file mode 100644
index 000000000..f4690d127
--- /dev/null
+++ b/packages/core/tests/integration/click-count.spec.ts
@@ -0,0 +1,207 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+
+// Keep double-click verification event-based and deterministic.
+// Time-delta counters (Date.now() between mousedowns) are flaky at ms boundaries
+// and can miss valid double-clicks when synthetic input lands in the same millisecond.
+const doubleClickFixtureUrl = `data:text/html,${encodeURIComponent(`<!DOCTYPE html>
+<html>
+  <body>
+    <div id="target" style="width: 240px; height: 120px; border: 1px solid #000;">target</div>
+    <input id="clickCount" value="0" readonly />
+    <input id="dblClickCount" value="0" readonly />
+    <input id="lastClickDetail" value="0" readonly />
+    <input id="lastDblClickDetail" value="0" readonly />
+    <script>
+      const target = document.getElementById("target");
+      const clickCount = document.getElementById("clickCount");
+      const dblClickCount = document.getElementById("dblClickCount");
+      const lastClickDetail = document.getElementById("lastClickDetail");
+      const lastDblClickDetail = document.getElementById("lastDblClickDetail");
+      let clicks = 0;
+      let dblClicks = 0;
+
+      target.addEventListener("click", (event) => {
+        clicks += 1;
+        clickCount.value = String(clicks);
+        lastClickDetail.value = String(event.detail);
+      });
+
+      target.addEventListener("dblclick", (event) => {
+        dblClicks += 1;
+        dblClickCount.value = String(dblClicks);
+        lastDblClickDetail.value = String(event.detail);
+      });
+    </script>
+  </body>
+</html>`)}`;
+
+test.describe("Locator and Page click methods", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test("locator.click() performs single click by default", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/click-test/",
+    );
+
+    // Wait for page to be fully loaded
+    await page.waitForLoadState("domcontentloaded");
+
+    // Get initial count
+    const countDisplay = page.locator("#count");
+    const initialCount = await countDisplay.inputValue();
+    expect(initialCount).toBe("0");
+
+    // Perform single click on the textarea (the clickable area)
+    const clickArea = page.locator("#textarea");
+    await clickArea.click();
+
+    // Verify count incremented by 1
+    const newCount = await countDisplay.inputValue();
+    expect(newCount).toBe("1");
+  });
+
+  test("locator.click() with clickCount: 2 performs double-click", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto(doubleClickFixtureUrl);
+    await page.waitForLoadState("domcontentloaded");
+
+    const countDisplay = page.locator("#clickCount");
+    const dcCountDisplay = page.locator("#dblClickCount");
+    const clickDetailDisplay = page.locator("#lastClickDetail");
+    const dblClickDetailDisplay = page.locator("#lastDblClickDetail");
+
+    const initialCount = await countDisplay.inputValue();
+    const initialDcCount = await dcCountDisplay.inputValue();
+    expect(initialCount).toBe("0");
+    expect(initialDcCount).toBe("0");
+
+    const clickArea = page.locator("#target");
+    await clickArea.click({ clickCount: 2 });
+
+    const newCount = await countDisplay.inputValue();
+    expect(newCount).toBe("2");
+
+    const newDcCount = await dcCountDisplay.inputValue();
+    expect(newDcCount).toBe("1");
+    // `dblclick` is the browser-level contract for double-click behavior.
+    // Verifying `detail=2` ensures the click sequence is recognized as a true multi-click.
+    expect(await clickDetailDisplay.inputValue()).toBe("2");
+    expect(await dblClickDetailDisplay.inputValue()).toBe("2");
+  });
+
+  test("locator.click() with clickCount: 3 performs triple-click", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/click-test/",
+    );
+
+    // Wait for page to be fully loaded
+    await page.waitForLoadState("domcontentloaded");
+
+    const countDisplay = page.locator("#count");
+    const initialCount = await countDisplay.inputValue();
+    expect(initialCount).toBe("0");
+
+    // Perform triple-click on the textarea
+    const clickArea = page.locator("#textarea");
+    await clickArea.click({ clickCount: 3 });
+
+    // Verify count incremented by 3
+    const newCount = await countDisplay.inputValue();
+    expect(newCount).toBe("3");
+  });
+
+  test("page.click() performs single click with coordinates", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/click-test/",
+    );
+
+    // Wait for page to be fully loaded
+    await page.waitForLoadState("domcontentloaded");
+
+    // Get initial count
+    const countDisplay = page.locator("#count");
+    const initialCount = await countDisplay.inputValue();
+    expect(initialCount).toBe("0");
+
+    // Get the centroid of the textarea to click
+    const clickArea = page.locator("#textarea");
+    const { x, y } = await clickArea.centroid();
+
+    // Perform single click using page.click() with coordinates
+    await page.click(x, y);
+
+    // Verify count incremented by 1
+    const newCount = await countDisplay.inputValue();
+    expect(newCount).toBe("1");
+  });
+
+  test("page.click() with clickCount: 2 performs double-click", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto(doubleClickFixtureUrl);
+    await page.waitForLoadState("domcontentloaded");
+
+    const countDisplay = page.locator("#clickCount");
+    const dcCountDisplay = page.locator("#dblClickCount");
+    const clickDetailDisplay = page.locator("#lastClickDetail");
+    const dblClickDetailDisplay = page.locator("#lastDblClickDetail");
+
+    const initialCount = await countDisplay.inputValue();
+    const initialDcCount = await dcCountDisplay.inputValue();
+    expect(initialCount).toBe("0");
+    expect(initialDcCount).toBe("0");
+
+    const clickArea = page.locator("#target");
+    const { x, y } = await clickArea.centroid();
+
+    await page.click(x, y, { clickCount: 2 });
+
+    const newCount = await countDisplay.inputValue();
+    expect(newCount).toBe("2");
+
+    const newDcCount = await dcCountDisplay.inputValue();
+    expect(newDcCount).toBe("1");
+    // `dblclick` is the browser-level contract for double-click behavior.
+    // Verifying `detail=2` ensures the click sequence is recognized as a true multi-click.
+    expect(await clickDetailDisplay.inputValue()).toBe("2");
+    expect(await dblClickDetailDisplay.inputValue()).toBe("2");
+  });
+
+  test("page.click() with clickCount: 3 performs triple-click", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/click-test/",
+    );
+
+    // Wait for page to be fully loaded
+    await page.waitForLoadState("domcontentloaded");
+
+    const countDisplay = page.locator("#count");
+    const initialCount = await countDisplay.inputValue();
+    expect(initialCount).toBe("0");
+
+    // Get the centroid of the textarea to click
+    const clickArea = page.locator("#textarea");
+    const { x, y } = await clickArea.centroid();
+
+    // Perform triple-click using page.click() with coordinates
+    await page.click(x, y, { clickCount: 3 });
+
+    // Verify count incremented by 3
+    const newCount = await countDisplay.inputValue();
+    expect(newCount).toBe("3");
+  });
+});
diff --git a/packages/core/tests/integration/connect-to-existing-browser.spec.ts b/packages/core/tests/integration/connect-to-existing-browser.spec.ts
new file mode 100644
index 000000000..37a143a5a
--- /dev/null
+++ b/packages/core/tests/integration/connect-to-existing-browser.spec.ts
@@ -0,0 +1,120 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3DynamicTestConfig } from "./v3.dynamic.config.js";
+import { closeV3 } from "./testUtils.js";
+
+const PAGE_TARGET_COUNT = 5;
+
+test.describe("connect to existing Browserbase session", () => {
+  test("new Stagehand instance reuses an existing Browserbase session", async () => {
+    const browserTarget = (
+      process.env.STAGEHAND_BROWSER_TARGET ?? "local"
+    ).toLowerCase();
+    const isBrowserbase = browserTarget === "browserbase";
+    test.skip(!isBrowserbase, "Requires STAGEHAND_BROWSER_TARGET=browserbase");
+    test.skip(
+      !process.env.BROWSERBASE_API_KEY || !process.env.BROWSERBASE_PROJECT_ID,
+      "BROWSERBASE credentials are required",
+    );
+
+    const initialStagehand = new V3({
+      ...v3DynamicTestConfig,
+      disableAPI: true,
+    });
+    await initialStagehand.init();
+
+    let resumedStagehand: V3 | null = null;
+
+    try {
+      const ctx = initialStagehand.context;
+      const initialPage = ctx.pages()[0];
+      expect(initialPage).toBeDefined();
+
+      for (let i = 0; i < PAGE_TARGET_COUNT; i++) {
+        await ctx.newPage(`https://example.com/?tab=${i}`);
+      }
+
+      await initialPage?.close();
+      await expect
+        .poll(() => ctx.pages().length, { timeout: 15_000 })
+        .toBe(PAGE_TARGET_COUNT);
+
+      const sessionUrl = initialStagehand.connectURL();
+      expect(sessionUrl).toBeTruthy();
+
+      resumedStagehand = new V3({
+        env: "LOCAL",
+        verbose: 0,
+        disablePino: true,
+        disableAPI: true,
+        logger: v3DynamicTestConfig.logger,
+        localBrowserLaunchOptions: {
+          cdpUrl: sessionUrl,
+        },
+      });
+      await resumedStagehand.init();
+
+      await expect
+        .poll(() => resumedStagehand!.context.pages().length, {
+          timeout: 15_000,
+        })
+        .toBe(PAGE_TARGET_COUNT);
+
+      const resumedPagesCount = resumedStagehand.context.pages().length;
+      expect(resumedPagesCount).toBe(PAGE_TARGET_COUNT);
+    } finally {
+      await closeV3(resumedStagehand);
+      await closeV3(initialStagehand);
+    }
+  });
+
+  test("new Stagehand instance initializes when existing browser has zero pages", async () => {
+    const browserTarget = (
+      process.env.STAGEHAND_BROWSER_TARGET ?? "local"
+    ).toLowerCase();
+    const isLocal = browserTarget !== "browserbase";
+    test.skip(!isLocal, "Requires STAGEHAND_BROWSER_TARGET=local");
+
+    const initialStagehand = new V3({
+      ...v3DynamicTestConfig,
+      disableAPI: true,
+      env: "LOCAL",
+    });
+    await initialStagehand.init();
+
+    let resumedStagehand: V3 | null = null;
+
+    try {
+      const ctx = initialStagehand.context;
+      const pages = ctx.pages();
+      for (const page of pages) {
+        await page.close();
+      }
+
+      await expect.poll(() => ctx.pages().length, { timeout: 15_000 }).toBe(0);
+
+      const sessionUrl = initialStagehand.connectURL();
+      resumedStagehand = new V3({
+        env: "LOCAL",
+        verbose: 0,
+        disablePino: true,
+        disableAPI: true,
+        logger: v3DynamicTestConfig.logger,
+        localBrowserLaunchOptions: {
+          cdpUrl: sessionUrl,
+        },
+      });
+
+      await resumedStagehand.init();
+
+      await expect
+        .poll(() => resumedStagehand!.context.pages().length, {
+          timeout: 15_000,
+        })
+        .toBeGreaterThan(0);
+    } finally {
+      await closeV3(resumedStagehand);
+      await closeV3(initialStagehand);
+    }
+  });
+});
diff --git a/packages/core/tests/integration/context-addInitScript.spec.ts b/packages/core/tests/integration/context-addInitScript.spec.ts
new file mode 100644
index 000000000..dc453615e
--- /dev/null
+++ b/packages/core/tests/integration/context-addInitScript.spec.ts
@@ -0,0 +1,335 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+import { V3Context } from "../../lib/v3/understudy/context.js";
+import type { Page as V3Page } from "../../lib/v3/understudy/page.js";
+
+const POPUP_TIMEOUT_MS = 20_000;
+
+const toDataUrl = (html: string): string =>
+  `data:text/html,${encodeURIComponent(html)}`;
+
+const waitForPopupPage = async (
+  ctx: V3Context,
+  knownTargetIds: Set<string>,
+  timeoutMs = POPUP_TIMEOUT_MS,
+): Promise<V3Page> => {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const popup = ctx
+      .pages()
+      .find((page) => !knownTargetIds.has(page.targetId()));
+    if (popup) return popup;
+    try {
+      const active = await ctx.awaitActivePage(500);
+      if (!knownTargetIds.has(active.targetId())) return active;
+    } catch {
+      // keep polling
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  throw new Error("Popup page was not created");
+};
+
+test.describe("context.addInitScript", () => {
+  let v3: V3;
+  let ctx: V3Context;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+    ctx = v3.context;
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test("runs before inline document scripts on navigation", async () => {
+    const page = await ctx.awaitActivePage();
+
+    await ctx.addInitScript(() => {
+      (window as unknown as { __fromContextInit?: string }).__fromContextInit =
+        "injected-value";
+    });
+
+    const html = `<!DOCTYPE html>
+      <html>
+        <body>
+          <script>
+            var value = (window && window.__fromContextInit) || 'missing';
+            document.body.dataset.initWitness = value;
+          </script>
+        </body>
+      </html>`;
+
+    await page.goto(toDataUrl(html), { waitUntil: "load" });
+
+    const observed = await page.evaluate(() => {
+      return document.body.dataset.initWitness;
+    });
+    expect(observed).toBe("injected-value");
+  });
+
+  test("re-applies the script on every navigation for the same page", async () => {
+    const page = await ctx.awaitActivePage();
+
+    await ctx.addInitScript(`
+      (function () {
+        function markVisit() {
+          var root = document.documentElement;
+          if (!root) return;
+          var current = Number(window.name || "0");
+          var next = current + 1;
+          window.name = String(next);
+          root.dataset.visitCount = String(next);
+        }
+        if (document.readyState === "loading") {
+          document.addEventListener("DOMContentLoaded", markVisit, {
+            once: true,
+          });
+        } else {
+          markVisit();
+        }
+      })();
+    `);
+
+    await page.goto(toDataUrl("<html><body>first</body></html>"), {
+      waitUntil: "load",
+    });
+    const first = await page.evaluate(() => {
+      return Number(document.documentElement.dataset.visitCount ?? "0");
+    });
+    expect(first).toBe(1);
+
+    await page.goto(toDataUrl("<html><body>second</body></html>"), {
+      waitUntil: "load",
+    });
+    const second = await page.evaluate(() => {
+      return Number(document.documentElement.dataset.visitCount ?? "0");
+    });
+    expect(second).toBe(2);
+  });
+
+  test("applies script (with args) to newly created pages", async () => {
+    const payload = { greeting: "hi", nested: { count: 2 } };
+
+    const initPayload = ((arg) => {
+      function setPayload() {
+        const root = document.documentElement;
+        if (!root) return;
+        root.dataset.initPayload = JSON.stringify(arg);
+      }
+      if (document.readyState === "loading") {
+        document.addEventListener("DOMContentLoaded", setPayload, {
+          once: true,
+        });
+      } else {
+        setPayload();
+      }
+    }) as (arg: typeof payload) => void;
+    await ctx.addInitScript(initPayload, payload);
+
+    const newPage = await ctx.newPage();
+    await newPage.goto(toDataUrl("<html><body>child</body></html>"), {
+      waitUntil: "load",
+    });
+
+    const observed = await newPage.evaluate(() => {
+      const raw = document.documentElement.dataset.initPayload;
+      return raw ? JSON.parse(raw) : undefined;
+    });
+    expect(observed).toEqual(payload);
+  });
+
+  test("applies script to newPage(url) on initial document", async () => {
+    const payload = { marker: "newPageUrl" };
+
+    await ctx.addInitScript((arg) => {
+      function setPayload(): void {
+        const root = document.documentElement;
+        if (!root) return;
+        root.dataset.initPayload = JSON.stringify(arg);
+      }
+      if (document.readyState === "loading") {
+        document.addEventListener("DOMContentLoaded", setPayload, {
+          once: true,
+        });
+      } else {
+        setPayload();
+      }
+    }, payload);
+
+    const newPage = await ctx.newPage(
+      toDataUrl("<html><body>new page</body></html>"),
+    );
+    await newPage.waitForLoadState("load");
+
+    const observed = await newPage.evaluate(() => {
+      const raw = document.documentElement.dataset.initPayload;
+      return raw ? JSON.parse(raw) : undefined;
+    });
+    expect(observed).toEqual(payload);
+  });
+
+  test("applies script to pages opened via link clicks", async () => {
+    const payload = { marker: "linkClick" };
+
+    await ctx.addInitScript((arg) => {
+      function setPayload(): void {
+        const root = document.documentElement;
+        if (!root) return;
+        root.dataset.initPayload = JSON.stringify(arg);
+      }
+      if (document.readyState === "loading") {
+        document.addEventListener("DOMContentLoaded", setPayload, {
+          once: true,
+        });
+      } else {
+        setPayload();
+      }
+    }, payload);
+
+    const popupUrl = "https://example.com/";
+    const openerHtml =
+      "<!DOCTYPE html>" +
+      "<html><body>" +
+      '<a id="open" target="_blank" href="' +
+      popupUrl +
+      '">open</a>' +
+      "</body></html>";
+
+    const opener = await ctx.awaitActivePage();
+    await opener.goto(toDataUrl(openerHtml), { waitUntil: "load" });
+    const knownTargetIds = new Set(ctx.pages().map((p) => p.targetId()));
+    await opener.locator("#open").click();
+
+    const popup = await waitForPopupPage(ctx, knownTargetIds);
+
+    await popup.waitForLoadState("load");
+
+    const observed = await popup.evaluate(() => {
+      const raw = document.documentElement.dataset.initPayload;
+      return raw ? JSON.parse(raw) : undefined;
+    });
+    expect(observed).toEqual(payload);
+
+    await popup.reload({ waitUntil: "load" });
+    const observedAfterReload = await popup.evaluate(() => {
+      const raw = document.documentElement.dataset.initPayload;
+      return raw ? JSON.parse(raw) : undefined;
+    });
+    expect(observedAfterReload).toEqual(payload);
+  });
+
+  test("applies script to in-process popup", async () => {
+    await ctx.addInitScript(() => {
+      (window as unknown as { __injected?: number }).__injected = 123;
+    });
+
+    const opener = await ctx.awaitActivePage();
+    const openerHtml =
+      "<!DOCTYPE html>" +
+      "<html><body>" +
+      '<a id="open" target="_blank" href="about:blank">open</a>' +
+      "</body></html>";
+    await opener.goto(toDataUrl(openerHtml), { waitUntil: "load" });
+    const knownTargetIds = new Set(ctx.pages().map((p) => p.targetId()));
+    await opener.locator("#open").click();
+
+    const popup = await waitForPopupPage(ctx, knownTargetIds);
+    await popup.waitForLoadState("load");
+    const injected = await popup.evaluate(() => {
+      return (window as unknown as { __injected?: number }).__injected;
+    });
+    expect(injected).toBe(123);
+  });
+
+  test("applies script to cross-process popup and survives reload", async () => {
+    await ctx.addInitScript(() => {
+      (window as unknown as { __injected?: number }).__injected = 123;
+    });
+
+    const opener = await ctx.awaitActivePage();
+    const openerHtml =
+      "<!DOCTYPE html>" +
+      "<html><body>" +
+      '<a id="open" target="_blank" href="https://example.com/">open</a>' +
+      "</body></html>";
+    await opener.goto(toDataUrl(openerHtml), {
+      waitUntil: "load",
+    });
+    const knownTargetIds = new Set(ctx.pages().map((p) => p.targetId()));
+    await opener.locator("#open").click();
+
+    const popup = await waitForPopupPage(ctx, knownTargetIds);
+    await popup.waitForLoadState("load");
+
+    const injected = await popup.evaluate(() => {
+      return (window as unknown as { __injected?: number }).__injected;
+    });
+    expect(injected).toBe(123);
+
+    await popup.reload({ waitUntil: "load" });
+    const injectedAfterReload = await popup.evaluate(() => {
+      return (window as unknown as { __injected?: number }).__injected;
+    });
+    expect(injectedAfterReload).toBe(123);
+  });
+
+  test("applies script to cross-process popup opened via window.open and survives reload", async () => {
+    await ctx.addInitScript(() => {
+      (window as unknown as { __injected?: number }).__injected = 789;
+    });
+
+    const opener = await ctx.awaitActivePage();
+    await opener.goto("about:blank", { waitUntil: "load" });
+    await opener.mainFrame().evaluate(() => {
+      const button = document.createElement("button");
+      button.id = "open-via-window-open";
+      button.textContent = "open popup";
+      button.addEventListener("click", () => {
+        window.open("https://example.com/", "_blank");
+      });
+      document.body.appendChild(button);
+    });
+
+    const knownTargetIds = new Set(ctx.pages().map((p) => p.targetId()));
+    await opener.locator("#open-via-window-open").click();
+
+    const popup = await waitForPopupPage(ctx, knownTargetIds);
+    await popup.waitForLoadState("load");
+
+    const injected = await popup.evaluate(() => {
+      return (window as unknown as { __injected?: number }).__injected;
+    });
+    expect(injected).toBe(789);
+
+    await popup.reload({ waitUntil: "load" });
+    const injectedAfterReload = await popup.evaluate(() => {
+      return (window as unknown as { __injected?: number }).__injected;
+    });
+    expect(injectedAfterReload).toBe(789);
+  });
+
+  test("context.addInitScript installs a function callable from page.evaluate", async () => {
+    const page = await ctx.awaitActivePage();
+
+    await ctx.addInitScript(() => {
+      // installed before any navigation
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-expect-error
+      window.sayHelloFromStagehand = () => "hello from stagehand";
+    });
+
+    await page.goto("https://example.com", { waitUntil: "domcontentloaded" });
+
+    const result = await page.evaluate(() => {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-expect-error
+      return window.sayHelloFromStagehand();
+    });
+
+    expect(result).toBe("hello from stagehand");
+  });
+});
diff --git a/packages/core/tests/integration/context-extra-http-headers.spec.ts b/packages/core/tests/integration/context-extra-http-headers.spec.ts
new file mode 100644
index 000000000..b58bafff8
--- /dev/null
+++ b/packages/core/tests/integration/context-extra-http-headers.spec.ts
@@ -0,0 +1,70 @@
+import { test, expect } from "@playwright/test";
+import type { Protocol } from "devtools-protocol";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+import { closeV3 } from "./testUtils.js";
+
+const TEST_URL =
+  "https://browserbase.github.io/stagehand-eval-sites/sites/example/";
+
+test.describe("context.setExtraHTTPHeaders", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await closeV3(v3);
+  });
+
+  test("applies headers to navigation requests", async () => {
+    const ctx = v3.context;
+    const page = await ctx.awaitActivePage();
+
+    await ctx.setExtraHTTPHeaders({ "x-stagehand-test": "yes" });
+
+    const internal = page as unknown as {
+      mainSession: {
+        send: (method: string, params?: unknown) => Promise<unknown>;
+        on: (event: string, handler: (params: unknown) => void) => void;
+        off: (event: string, handler: (params: unknown) => void) => void;
+      };
+    };
+
+    await internal.mainSession.send("Network.enable");
+
+    const requestPromise = new Promise<Protocol.Network.RequestWillBeSentEvent>(
+      (resolve, reject) => {
+        const timeout = setTimeout(() => {
+          internal.mainSession.off("Network.requestWillBeSent", handler);
+          reject(new Error("Timed out waiting for request"));
+        }, 5000);
+
+        const handler = (evt: Protocol.Network.RequestWillBeSentEvent) => {
+          if (evt.type !== "Document") return;
+          const url = String(evt.request?.url ?? "");
+          if (!url.startsWith(TEST_URL)) return;
+          clearTimeout(timeout);
+          internal.mainSession.off("Network.requestWillBeSent", handler);
+          resolve(evt);
+        };
+
+        internal.mainSession.on("Network.requestWillBeSent", handler);
+      },
+    );
+
+    await page.goto(TEST_URL, { waitUntil: "domcontentloaded" });
+
+    const request = await requestPromise;
+    const headers = Object.fromEntries(
+      Object.entries(request.request.headers ?? {}).map(([key, value]) => [
+        key.toLowerCase(),
+        String(value),
+      ]),
+    );
+
+    expect(headers["x-stagehand-test"]).toBe("yes");
+  });
+});
diff --git a/packages/core/tests/integration/cookies.spec.ts b/packages/core/tests/integration/cookies.spec.ts
new file mode 100644
index 000000000..3b34157c3
--- /dev/null
+++ b/packages/core/tests/integration/cookies.spec.ts
@@ -0,0 +1,231 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3DynamicTestConfig } from "./v3.dynamic.config.js";
+import { closeV3 } from "./testUtils.js";
+
+const BASE_URL =
+  "https://browserbase.github.io/stagehand-eval-sites/sites/example/";
+
+test.describe("cookies", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3DynamicTestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await closeV3(v3);
+  });
+
+  test("addCookies sets a cookie visible to the page", async () => {
+    const ctx = v3.context;
+    const page = ctx.pages()[0];
+    expect(page).toBeDefined();
+
+    await page!.goto(BASE_URL);
+
+    const name = `stagehand_cookie_${Date.now()}`;
+    await ctx.addCookies([
+      {
+        name,
+        value: "1",
+        url: BASE_URL,
+        httpOnly: false,
+      },
+    ]);
+
+    await page!.reload();
+
+    const cookieString = await page!.evaluate(() => document.cookie);
+    expect(cookieString).toContain(`${name}=1`);
+
+    const cookies = await ctx.cookies(BASE_URL);
+    expect(cookies.some((c) => c.name === name && c.value === "1")).toBe(true);
+  });
+
+  test("cookies() with no URL returns all cookies", async () => {
+    const ctx = v3.context;
+    const page = ctx.pages()[0]!;
+    await page.goto(BASE_URL);
+
+    const name = `stagehand_all_${Date.now()}`;
+    await ctx.addCookies([
+      { name, value: "all", url: BASE_URL, httpOnly: false },
+    ]);
+
+    const all = await ctx.cookies();
+    expect(all.some((c) => c.name === name)).toBe(true);
+  });
+
+  test("clearCookies() removes all cookies", async () => {
+    const ctx = v3.context;
+    const page = ctx.pages()[0]!;
+    await page.goto(BASE_URL);
+
+    await ctx.addCookies([
+      { name: "to_clear_a", value: "1", url: BASE_URL, httpOnly: false },
+      { name: "to_clear_b", value: "2", url: BASE_URL, httpOnly: false },
+    ]);
+
+    // Verify cookies were set
+    let cookies = await ctx.cookies(BASE_URL);
+    expect(cookies.some((c) => c.name === "to_clear_a")).toBe(true);
+    expect(cookies.some((c) => c.name === "to_clear_b")).toBe(true);
+
+    await ctx.clearCookies();
+
+    cookies = await ctx.cookies(BASE_URL);
+    expect(cookies.some((c) => c.name === "to_clear_a")).toBe(false);
+    expect(cookies.some((c) => c.name === "to_clear_b")).toBe(false);
+  });
+
+  test("clearCookies() with name filter removes only matching cookies", async () => {
+    const ctx = v3.context;
+    const page = ctx.pages()[0]!;
+    await page.goto(BASE_URL);
+
+    await ctx.addCookies([
+      { name: "keep_me", value: "1", url: BASE_URL, httpOnly: false },
+      { name: "remove_me", value: "2", url: BASE_URL, httpOnly: false },
+    ]);
+
+    await ctx.clearCookies({ name: "remove_me" });
+
+    const cookies = await ctx.cookies(BASE_URL);
+    expect(cookies.some((c) => c.name === "keep_me")).toBe(true);
+    expect(cookies.some((c) => c.name === "remove_me")).toBe(false);
+  });
+
+  test("clearCookies() with regex filter removes matching cookies", async () => {
+    const ctx = v3.context;
+    const page = ctx.pages()[0]!;
+    await page.goto(BASE_URL);
+
+    await ctx.addCookies([
+      { name: "_ga_ABC", value: "1", url: BASE_URL, httpOnly: false },
+      { name: "_ga_DEF", value: "2", url: BASE_URL, httpOnly: false },
+      { name: "session", value: "3", url: BASE_URL, httpOnly: false },
+    ]);
+
+    await ctx.clearCookies({ name: /^_ga/ });
+
+    const cookies = await ctx.cookies(BASE_URL);
+    expect(cookies.some((c) => c.name === "session")).toBe(true);
+    expect(cookies.some((c) => c.name === "_ga_ABC")).toBe(false);
+    expect(cookies.some((c) => c.name === "_ga_DEF")).toBe(false);
+  });
+
+  test("cookies are visible from a second page on the same domain", async () => {
+    const ctx = v3.context;
+    const page1 = ctx.pages()[0]!;
+    await page1.goto(BASE_URL);
+
+    const name = `stagehand_multi_${Date.now()}`;
+    await ctx.addCookies([
+      { name, value: "shared", url: BASE_URL, httpOnly: false },
+    ]);
+
+    const page2 = await ctx.newPage();
+    await page2.goto(BASE_URL);
+
+    const cookieString = await page2.evaluate(() => document.cookie);
+    expect(cookieString).toContain(`${name}=shared`);
+  });
+
+  test("cookies persist across navigation to a different path", async () => {
+    const ctx = v3.context;
+    const page = ctx.pages()[0]!;
+    await page.goto(BASE_URL);
+
+    const name = `stagehand_nav_${Date.now()}`;
+    await ctx.addCookies([
+      {
+        name,
+        value: "persisted",
+        domain: "browserbase.github.io",
+        path: "/",
+        httpOnly: false,
+      },
+    ]);
+
+    // Navigate to a different path on the same domain
+    await page.goto("https://browserbase.github.io/stagehand-eval-sites/");
+
+    const cookieString = await page.evaluate(() => document.cookie);
+    expect(cookieString).toContain(`${name}=persisted`);
+  });
+
+  test("httpOnly cookie is hidden from document.cookie but returned by cookies()", async () => {
+    const ctx = v3.context;
+    const page = ctx.pages()[0]!;
+    await page.goto(BASE_URL);
+
+    const name = `stagehand_http_${Date.now()}`;
+    await ctx.addCookies([
+      { name, value: "secret", url: BASE_URL, httpOnly: true },
+    ]);
+
+    await page.reload();
+
+    // document.cookie must NOT include httpOnly cookies
+    const cookieString = await page.evaluate(() => document.cookie);
+    expect(cookieString).not.toContain(name);
+
+    // But the context API should still return it
+    const cookies = await ctx.cookies(BASE_URL);
+    const match = cookies.find((c) => c.name === name);
+    expect(match).toBeDefined();
+    expect(match!.value).toBe("secret");
+    expect(match!.httpOnly).toBe(true);
+  });
+
+  test("cookies() returns correct shape for a fully-specified cookie", async () => {
+    const ctx = v3.context;
+    const page = ctx.pages()[0]!;
+    await page.goto(BASE_URL);
+
+    const name = `stagehand_shape_${Date.now()}`;
+    const expires = Math.floor(Date.now() / 1000) + 3600; // 1 hour from now
+    await ctx.addCookies([
+      {
+        name,
+        value: "full",
+        domain: "browserbase.github.io",
+        path: "/",
+        expires,
+        httpOnly: true,
+        secure: true,
+        sameSite: "Lax",
+      },
+    ]);
+
+    const cookies = await ctx.cookies(BASE_URL);
+    const match = cookies.find((c) => c.name === name);
+    expect(match).toBeDefined();
+
+    // Validate every field on the returned Cookie object
+    expect(match!.value).toBe("full");
+    expect(match!.domain).toMatch(/browserbase\.github\.io/);
+    expect(match!.path).toBe("/");
+    expect(match!.expires).toBeGreaterThan(0);
+    expect(match!.httpOnly).toBe(true);
+    expect(match!.secure).toBe(true);
+    expect(match!.sameSite).toBe("Lax");
+
+    // Ensure no extra fields leak through from CDP
+    const keys = Object.keys(match!);
+    expect(keys.sort()).toEqual(
+      [
+        "name",
+        "value",
+        "domain",
+        "path",
+        "expires",
+        "httpOnly",
+        "secure",
+        "sameSite",
+      ].sort(),
+    );
+  });
+});
diff --git a/packages/core/tests/integration/default-page-tracking.spec.ts b/packages/core/tests/integration/default-page-tracking.spec.ts
new file mode 100644
index 000000000..e4d358948
--- /dev/null
+++ b/packages/core/tests/integration/default-page-tracking.spec.ts
@@ -0,0 +1,69 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3DynamicTestConfig } from "./v3.dynamic.config.js";
+import { closeV3 } from "./testUtils.js";
+
+test.describe.configure({ mode: "parallel" });
+test.describe("V3 default page tracking", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3DynamicTestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await closeV3(v3);
+  });
+
+  test("activePage points to initial page", async () => {
+    const ctx = v3.context;
+    // Should have at least one top-level page
+    const pages = ctx.pages();
+    expect(pages.length).toBeGreaterThanOrEqual(1);
+    const active = ctx.activePage();
+    expect(active).toBeTruthy();
+    // mainFrameId should be a non-empty string
+    expect(active!.mainFrameId().length).toBeGreaterThan(0);
+  });
+
+  test("activePage switches to most recent top-level page and reverts on close", async () => {
+    const ctx = v3.context;
+    const newPage = await ctx.newPage("https://example.com/");
+
+    const activeAfterCreate = await ctx.awaitActivePage();
+    expect(activeAfterCreate.url()).toContain(newPage.url());
+  });
+
+  test("popup default-page flow via five-tab site", async () => {
+    const ctx = v3.context;
+
+    // 1) Navigate the default page to the site
+    const root = await ctx.awaitActivePage();
+    await root!.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/five-tab/",
+      { waitUntil: "load", timeoutMs: 15000 },
+    );
+    // 2) Click button on the page to open a new tab → page2.html
+    await root.locator("xpath=/html/body/button").click();
+    const page2 = await ctx.awaitActivePage();
+    expect(page2!.url()).toBe(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/five-tab/page2.html",
+    );
+
+    // 3) On the default page (now page2), click its button → open page3 popup
+
+    await page2.locator("xpath=/html/body/button").click();
+    const page3 = await ctx.awaitActivePage();
+    expect(page3!.url()).toBe(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/five-tab/page3.html",
+    );
+
+    // 4) Close the current page (page3) and ensure the default page reverts to page2
+    await page3!.close();
+    const backToPage2 = await ctx.awaitActivePage();
+    expect(backToPage2!.url()).toBe(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/five-tab/page2.html",
+    );
+  });
+});
diff --git a/packages/core/tests/integration/downloads.spec.ts b/packages/core/tests/integration/downloads.spec.ts
new file mode 100644
index 000000000..39c8e6279
--- /dev/null
+++ b/packages/core/tests/integration/downloads.spec.ts
@@ -0,0 +1,72 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import Browserbase from "@browserbasehq/sdk";
+import AdmZip from "adm-zip";
+import { v3DynamicTestConfig } from "./v3.dynamic.config.js";
+import { closeV3 } from "./testUtils.js";
+
+const pdfRe = /sample-(\d{13})+\.pdf/;
+test.describe("downloads on browserbase", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3DynamicTestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await closeV3(v3);
+  });
+
+  test("downloaded pdf is available via downloads api", async () => {
+    const browserTarget = (
+      process.env.STAGEHAND_BROWSER_TARGET ?? "local"
+    ).toLowerCase();
+    const isBrowserbase = browserTarget === "browserbase";
+    // Skip this test in LOCAL mode as it requires Browserbase session
+    test.skip(
+      !isBrowserbase,
+      "Skipping Browserbase-only downloads test in LOCAL mode",
+    );
+
+    // Skip if BROWSERBASE_API_KEY is not set
+    test.skip(
+      !process.env.BROWSERBASE_API_KEY,
+      "Skipping test: BROWSERBASE_API_KEY not set",
+    );
+
+    // Tiny timeout to force the race to hit the timeout branch
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/download-on-click/",
+    );
+    await page.locator("/html/body/button").click();
+
+    await expect(async () => {
+      const bb = new Browserbase();
+      const zipBuffer = await bb.sessions.downloads.list(
+        v3.browserbaseSessionId,
+      );
+      if (!zipBuffer) {
+        throw new Error(
+          `Download buffer is empty for session ${v3.browserbaseSessionId}`,
+        );
+      }
+
+      const zip = new AdmZip(Buffer.from(await zipBuffer.arrayBuffer()));
+      const zipEntries = zip.getEntries();
+      const pdfEntry = zipEntries.find((entry) => pdfRe.test(entry.entryName));
+
+      if (!pdfEntry) {
+        throw new Error(
+          `Session ${v3.browserbaseSessionId} is missing a file matching "${pdfRe.toString()}" in its zip entries: ${JSON.stringify(zipEntries.map((entry) => entry.entryName))}`,
+        );
+      }
+
+      const expectedFileSize = 13264;
+      expect(pdfEntry.header.size).toBe(expectedFileSize);
+    }).toPass({
+      timeout: 30_000,
+    });
+  });
+});
diff --git a/packages/core/tests/integration/frame-get-location-and-click.spec.ts b/packages/core/tests/integration/frame-get-location-and-click.spec.ts
new file mode 100644
index 000000000..ce653e087
--- /dev/null
+++ b/packages/core/tests/integration/frame-get-location-and-click.spec.ts
@@ -0,0 +1,68 @@
+import { expect, test } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+
+test.describe("Coordinate-based clicking", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test("clicking by coordinates toggles a button state", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <button id="btn" onclick="this.dataset.clicked = (this.dataset.clicked==='1'?'0':'1')">Click</button>
+            <div id="out"></div>
+            <script>
+              const btn = document.getElementById('btn');
+              const out = document.getElementById('out');
+              const update = () => { out.textContent = btn.dataset.clicked === '1' ? 'clicked' : 'idle'; };
+              update();
+              btn.addEventListener('click', update);
+            </script>
+          </body></html>`,
+        ),
+    );
+
+    // Initial state should be idle
+    let state = await page.mainFrame().evaluate(() => {
+      const out = document.getElementById("out");
+      return out?.textContent || "";
+    });
+    expect(state).toBe("idle");
+
+    // Compute button location via Frame.getLocationForSelector
+    const { x, y, width, height } = await page
+      .mainFrame()
+      .getLocationForSelector("#btn");
+
+    // Click near the center of the button using Page.click coordinates
+    const cx = Math.round(x + width / 2);
+    const cy = Math.round(y + height / 2);
+    await page.click(cx, cy);
+
+    state = await page.mainFrame().evaluate(() => {
+      const out = document.getElementById("out");
+      return out?.textContent || "";
+    });
+    expect(state).toBe("clicked");
+
+    // Click again to toggle back to idle
+    await page.click(cx, cy);
+    state = await page.mainFrame().evaluate(() => {
+      const out = document.getElementById("out");
+      return out?.textContent || "";
+    });
+    expect(state).toBe("idle");
+  });
+});
diff --git a/packages/core/tests/integration/iframe-ctx-addInitScript-race.spec.ts b/packages/core/tests/integration/iframe-ctx-addInitScript-race.spec.ts
new file mode 100644
index 000000000..555540c0a
--- /dev/null
+++ b/packages/core/tests/integration/iframe-ctx-addInitScript-race.spec.ts
@@ -0,0 +1,302 @@
+import { expect, test } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+import type { V3Context } from "../../lib/v3/understudy/context.js";
+import type { Page } from "../../lib/v3/understudy/page.js";
+
+const DEFAULT_INIT_SCRIPT_DELAY_MS = 250;
+const INIT_SCRIPT_DELAY_MS = (() => {
+  const rawValue = process.env.IFRAME_INIT_SCRIPT_SEND_DELAY_MS;
+  if (rawValue === undefined) return DEFAULT_INIT_SCRIPT_DELAY_MS;
+  const parsed = Number(rawValue);
+  if (!Number.isFinite(parsed) || parsed <= 0)
+    return DEFAULT_INIT_SCRIPT_DELAY_MS;
+  return parsed;
+})();
+
+const POPUP_TIMEOUT_MS = 20_000;
+const RACE_INIT_SCRIPT_SENTINEL = "__stagehand_init_script_race_sentinel__";
+const INIT_SCRIPT_MARKER_KEY = "__stagehand_init_script_loaded__";
+const POPUP_URL = "https://example.com/";
+const POPUP_IFRAME_URL = "https://example.org/";
+
+const INIT_SCRIPT_SOURCE = `
+(() => {
+  /* ${RACE_INIT_SCRIPT_SENTINEL} */
+  window["${INIT_SCRIPT_MARKER_KEY}"] = true;
+})();
+`;
+
+type PatchedConn = {
+  _sendViaSession: (
+    sessionId: string,
+    method: string,
+    params?: object,
+  ) => Promise<unknown>;
+};
+
+type SessionCommandRecord = {
+  sequence: number;
+  sessionId: string;
+  method: string;
+  isRaceInitScript: boolean;
+};
+
+type PopupTriggerCase = {
+  name: string;
+  prepare: (opener: Page) => Promise<void>;
+};
+
+async function closeAllPages(ctx: V3Context): Promise<void> {
+  const pages = ctx.pages();
+  await Promise.allSettled(pages.map((page) => page.close()));
+}
+
+async function waitForPopupPage(
+  ctx: V3Context,
+  knownTargetIds: Set<string>,
+  timeoutMs = POPUP_TIMEOUT_MS,
+): Promise<Page> {
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() < deadline) {
+    const popup = ctx
+      .pages()
+      .find((candidate) => !knownTargetIds.has(candidate.targetId()));
+    if (popup) return popup;
+    try {
+      const active = await ctx.awaitActivePage(500);
+      if (!knownTargetIds.has(active.targetId())) return active;
+    } catch {
+      // keep polling
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+
+  throw new Error("Timed out waiting for popup page");
+}
+
+async function waitForChildFrame(
+  page: Page,
+  expectedUrl: string,
+  timeoutMs = POPUP_TIMEOUT_MS,
+): Promise<ReturnType<Page["frames"]>[number]> {
+  const mainFrameId = page.mainFrame().frameId;
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() < deadline) {
+    for (const frame of page.frames()) {
+      if (frame.frameId === mainFrameId) continue;
+      try {
+        const href = await frame.evaluate(() => window.location.href);
+        if (href === expectedUrl) return frame;
+      } catch {
+        // frame context may not be ready yet
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+
+  throw new Error("Timed out waiting for child frame");
+}
+
+async function prepareTargetBlankPopupOpener(opener: Page): Promise<void> {
+  await opener.goto("about:blank", { waitUntil: "domcontentloaded" });
+  await opener.mainFrame().evaluate((popupUrl) => {
+    const link = document.createElement("a");
+    link.id = "open-popup";
+    link.target = "_blank";
+    link.href = popupUrl;
+    link.textContent = "open popup";
+    document.body.appendChild(link);
+  }, POPUP_URL);
+}
+
+async function prepareWindowOpenPopupOpener(opener: Page): Promise<void> {
+  await opener.goto("about:blank", { waitUntil: "domcontentloaded" });
+  await opener.mainFrame().evaluate((popupUrl) => {
+    const button = document.createElement("button");
+    button.id = "open-popup";
+    button.textContent = "open popup";
+    button.addEventListener("click", () => {
+      window.open(popupUrl, "_blank");
+    });
+    document.body.appendChild(button);
+  }, POPUP_URL);
+}
+
+const POPUP_TRIGGER_CASES: PopupTriggerCase[] = [
+  {
+    name: 'target="_blank" link click',
+    prepare: prepareTargetBlankPopupOpener,
+  },
+  {
+    name: "window.open from click handler",
+    prepare: prepareWindowOpenPopupOpener,
+  },
+];
+
+test.describe("repro: popup iframe addInitScript race under delayed CDP send", () => {
+  test.describe.configure({ mode: "serial" });
+
+  let restoreSend: (() => void) | undefined;
+  let v3: V3 | undefined;
+  let ctx: V3Context | undefined;
+  let sequence = 0;
+  let records: SessionCommandRecord[] = [];
+
+  test.beforeAll(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+    ctx = v3.context;
+
+    const conn = (ctx as unknown as { conn?: PatchedConn }).conn;
+    if (!conn || typeof conn._sendViaSession !== "function") {
+      throw new Error("Unable to access CDP connection for race repro patch");
+    }
+
+    const originalSendViaSession = conn._sendViaSession.bind(conn);
+    conn._sendViaSession = function patchedSendViaSession(
+      sessionId: string,
+      method: string,
+      params?: object,
+    ) {
+      const source =
+        typeof (params as { source?: unknown } | undefined)?.source === "string"
+          ? (params as { source: string }).source
+          : "";
+      const isRaceInitScript =
+        method === "Page.addScriptToEvaluateOnNewDocument" &&
+        source.includes(RACE_INIT_SCRIPT_SENTINEL);
+
+      const sendNow = () => {
+        records.push({
+          sequence: ++sequence,
+          sessionId,
+          method,
+          isRaceInitScript,
+        });
+        return originalSendViaSession(sessionId, method, params);
+      };
+
+      if (isRaceInitScript && INIT_SCRIPT_DELAY_MS > 0) {
+        return new Promise((resolve, reject) => {
+          setTimeout(() => {
+            sendNow().then(resolve, reject);
+          }, INIT_SCRIPT_DELAY_MS);
+        });
+      }
+
+      return sendNow();
+    };
+
+    restoreSend = () => {
+      conn._sendViaSession = originalSendViaSession;
+    };
+
+    await ctx.addInitScript(INIT_SCRIPT_SOURCE);
+  });
+
+  test.afterAll(async () => {
+    restoreSend?.();
+    await v3?.close?.().catch(() => {});
+  });
+
+  test.beforeEach(async () => {
+    records = [];
+    sequence = 0;
+    if (!ctx) return;
+    await closeAllPages(ctx);
+  });
+
+  test.afterEach(async () => {
+    if (!ctx) return;
+    await closeAllPages(ctx);
+  });
+
+  for (const popupCase of POPUP_TRIGGER_CASES) {
+    test(`should send addScript before resume for popup targets via ${popupCase.name}`, async () => {
+      if (!ctx) throw new Error("Context not initialized");
+
+      const opener = await ctx.newPage();
+      await popupCase.prepare(opener);
+
+      const knownTargetIds = new Set(ctx.pages().map((p) => p.targetId()));
+      const knownSessionIds = new Set(
+        records.map((record) => record.sessionId),
+      );
+
+      await opener.locator("#open-popup").click();
+
+      const popup = await waitForPopupPage(ctx, knownTargetIds);
+      await popup.waitForLoadState("load", POPUP_TIMEOUT_MS);
+      await popup.mainFrame().evaluate((iframeUrl) => {
+        const iframe = document.createElement("iframe");
+        iframe.id = "race-child-iframe";
+        iframe.src = iframeUrl;
+        document.body.appendChild(iframe);
+      }, POPUP_IFRAME_URL);
+      const iframe = await waitForChildFrame(
+        popup,
+        POPUP_IFRAME_URL,
+        POPUP_TIMEOUT_MS,
+      );
+
+      const popupInitScriptMarker = await popup.mainFrame().evaluate((key) => {
+        return Boolean(Reflect.get(window, key));
+      }, INIT_SCRIPT_MARKER_KEY);
+      const iframeInitScriptMarker = await iframe.evaluate((key) => {
+        return Boolean(Reflect.get(window, key));
+      }, INIT_SCRIPT_MARKER_KEY);
+
+      const perSession = new Map<
+        string,
+        {
+          raceInitScriptSequence?: number;
+          resumeSequence?: number;
+        }
+      >();
+
+      for (const record of records) {
+        if (knownSessionIds.has(record.sessionId)) continue;
+        const entry = perSession.get(record.sessionId) ?? {};
+        if (
+          record.isRaceInitScript &&
+          entry.raceInitScriptSequence === undefined
+        ) {
+          entry.raceInitScriptSequence = record.sequence;
+        }
+        if (
+          record.method === "Runtime.runIfWaitingForDebugger" &&
+          entry.resumeSequence === undefined
+        ) {
+          entry.resumeSequence = record.sequence;
+        }
+        perSession.set(record.sessionId, entry);
+      }
+
+      const comparableSessions = [...perSession.entries()]
+        .map(([sessionId, entry]) => ({ sessionId, ...entry }))
+        .filter(
+          (entry) =>
+            entry.raceInitScriptSequence !== undefined &&
+            entry.resumeSequence !== undefined,
+        );
+      expect(comparableSessions.length).toBeGreaterThan(0);
+
+      const orderingViolations = comparableSessions.filter((entry) => {
+        return (
+          (entry.raceInitScriptSequence as number) >
+          (entry.resumeSequence as number)
+        );
+      });
+
+      expect(
+        orderingViolations,
+        `Expected addScript before resume for ${popupCase.name}. initScriptDelayMs=${INIT_SCRIPT_DELAY_MS}; comparableSessions=${JSON.stringify(comparableSessions)}`,
+      ).toEqual([]);
+      expect(popupInitScriptMarker).toBe(true);
+      expect(iframeInitScriptMarker).toBe(true);
+    });
+  }
+});
diff --git a/packages/core/tests/integration/iframe-ctx-addInitScript.spec.ts b/packages/core/tests/integration/iframe-ctx-addInitScript.spec.ts
new file mode 100644
index 000000000..7ae9c8be0
--- /dev/null
+++ b/packages/core/tests/integration/iframe-ctx-addInitScript.spec.ts
@@ -0,0 +1,640 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+import { V3Context } from "../../lib/v3/understudy/context.js";
+import type { Page } from "../../lib/v3/understudy/page.js";
+
+const isBrowserbase =
+  (process.env.STAGEHAND_BROWSER_TARGET ?? "local").toLowerCase() ===
+  "browserbase";
+const MIN_TIMEOUT_MS = 3_000;
+const MAX_TIMEOUT_MS = 120_000;
+
+const parseBoundedTimeoutMs = (
+  value: string | undefined,
+  fallbackMs: number,
+): number => {
+  const parsed = Number(value ?? fallbackMs);
+  if (!Number.isFinite(parsed)) return fallbackMs;
+  return Math.max(MIN_TIMEOUT_MS, Math.min(MAX_TIMEOUT_MS, parsed));
+};
+
+const CHILD_FRAME_TIMEOUT_MS = parseBoundedTimeoutMs(
+  process.env.IFRAME_CHILD_FRAME_TIMEOUT_MS,
+  isBrowserbase ? 80_000 : 40_000,
+);
+const POPUP_TIMEOUT_MS = parseBoundedTimeoutMs(
+  process.env.IFRAME_POPUP_TIMEOUT_MS,
+  isBrowserbase ? 60_000 : 40_000,
+);
+const POPUP_URL_TIMEOUT_MS = parseBoundedTimeoutMs(
+  process.env.IFRAME_POPUP_URL_TIMEOUT_MS,
+  isBrowserbase ? 80_000 : 40_000,
+);
+const DEBUG_INTERVAL_MS = 5_000;
+const iframeDebugEnabled = isBrowserbase || process.env.IFRAME_DEBUG === "1";
+const TEST_VIEWPORT = { width: 1288, height: 711 };
+
+type FrameTreeNode = {
+  frame: { id: string; parentId?: string; url?: string };
+  childFrames?: FrameTreeNode[];
+};
+type ChildFrame = ReturnType<Page["frames"]>[number];
+type ChildFrameProbe = {
+  child: ChildFrame;
+  href?: string;
+  readyState?: DocumentReadyState;
+  error?: string;
+};
+
+const formatError = (error: unknown): string => {
+  if (error instanceof Error) return error.message;
+  return String(error);
+};
+
+const flattenFrameTree = (
+  node: FrameTreeNode,
+  out: Array<{ id: string; parentId: string | null; url: string }> = [],
+): Array<{ id: string; parentId: string | null; url: string }> => {
+  out.push({
+    id: node.frame.id,
+    parentId: node.frame.parentId ?? null,
+    url: node.frame.url ?? "",
+  });
+  for (const child of node.childFrames ?? []) {
+    flattenFrameTree(child, out);
+  }
+  return out;
+};
+
+function debugLog(
+  step: string,
+  payload?: Record<string, unknown> | string,
+): void {
+  if (!iframeDebugEnabled) return;
+  if (payload === undefined) {
+    console.log(`[iframe-debug] ${step}`);
+    return;
+  }
+  if (typeof payload === "string") {
+    console.log(`[iframe-debug] ${step}: ${payload}`);
+    return;
+  }
+  try {
+    console.log(`[iframe-debug] ${step}: ${JSON.stringify(payload)}`);
+  } catch {
+    console.log(`[iframe-debug] ${step}: <unserializable payload>`);
+  }
+}
+
+async function collectFrameSnapshot(
+  page: Page,
+): Promise<Array<Record<string, unknown>>> {
+  const known = new Map<string, ReturnType<Page["frames"]>[number]>();
+  known.set(page.mainFrame().frameId, page.mainFrame());
+  for (const frame of page.frames()) known.set(frame.frameId, frame);
+
+  return Promise.all(
+    [...known.values()].map(async (frame) => {
+      try {
+        const state = await frame.evaluate(() => {
+          return {
+            href: location.href,
+            readyState: document.readyState,
+            visibilityState: document.visibilityState,
+            iframeCount: document.querySelectorAll("iframe").length,
+            hasShadowHost: Boolean(document.querySelector("shadow-host")),
+          };
+        });
+        return {
+          frameId: frame.frameId,
+          sessionId: frame.sessionId ?? "root",
+          ...state,
+        };
+      } catch (error) {
+        return {
+          frameId: frame.frameId,
+          sessionId: frame.sessionId ?? "root",
+          error: formatError(error),
+        };
+      }
+    }),
+  );
+}
+
+async function logPageDiagnostics(
+  page: Page,
+  reason: string,
+  markerSelector?: string,
+): Promise<void> {
+  if (!iframeDebugEnabled) return;
+  const diagnostics: Record<string, unknown> = {
+    reason,
+    pageUrl: page.url(),
+    mainFrameId: page.mainFrame().frameId,
+    knownFrameCount: page.frames().length,
+  };
+
+  try {
+    const domState = await page.mainFrame().evaluate((marker) => {
+      const el = marker ? document.querySelector(marker) : null;
+      const rect =
+        el instanceof Element ? el.getBoundingClientRect().toJSON() : null;
+      return {
+        href: location.href,
+        readyState: document.readyState,
+        visibilityState: document.visibilityState,
+        hidden: document.hidden,
+        hasFocus: document.hasFocus(),
+        innerWidth: window.innerWidth,
+        innerHeight: window.innerHeight,
+        devicePixelRatio: window.devicePixelRatio,
+        markerSelector: marker,
+        markerPresent: Boolean(el),
+        markerRect: rect,
+        iframeCount: document.querySelectorAll("iframe").length,
+      };
+    }, markerSelector);
+    diagnostics.domState = domState;
+  } catch (error) {
+    diagnostics.domStateError = formatError(error);
+  }
+
+  try {
+    const frameTreeResponse = (await page.sendCDP("Page.getFrameTree")) as {
+      frameTree?: FrameTreeNode;
+    };
+    if (frameTreeResponse.frameTree) {
+      diagnostics.cdpFrameTree = flattenFrameTree(frameTreeResponse.frameTree);
+    }
+  } catch (error) {
+    diagnostics.cdpFrameTreeError = formatError(error);
+  }
+
+  diagnostics.frameSnapshot = await collectFrameSnapshot(page);
+  debugLog("page-diagnostics", diagnostics);
+}
+
+async function closeAllPages(ctx: V3Context): Promise<void> {
+  const pages = ctx.pages();
+  await Promise.allSettled(pages.map((page) => page.close()));
+}
+
+/**
+ * Poll until a child frame (non-main) appears on `page` and its document
+ * has finished loading.  Returns the child frame.
+ */
+async function waitForChildFrame(
+  page: Page,
+  expectedChildUrl: string,
+  timeoutMs = CHILD_FRAME_TIMEOUT_MS,
+): Promise<ChildFrame> {
+  const mainFrameId = page.mainFrame().frameId;
+  const deadline = Date.now() + timeoutMs;
+  let observedFrameCount = 0;
+  const observedChildFrameIds = new Set<string>();
+  let lastUrl = "";
+  let lastLogAt = Date.now();
+
+  while (Date.now() < deadline) {
+    const frames = page.frames();
+    observedFrameCount = Math.max(observedFrameCount, frames.length);
+    lastUrl = page.url();
+    const childIds = frames
+      .filter((f) => f.frameId !== mainFrameId)
+      .map((f) => f.frameId);
+    if (iframeDebugEnabled && Date.now() - lastLogAt >= DEBUG_INTERVAL_MS) {
+      debugLog("waitForChildFrame:progress", {
+        url: lastUrl,
+        mainFrameId,
+        observedFrameCount,
+        childIds,
+        expectedChildUrl,
+      });
+      lastLogAt = Date.now();
+    }
+    for (const childId of childIds) observedChildFrameIds.add(childId);
+
+    const childFrames = frames
+      .filter((f) => f.frameId !== mainFrameId)
+      // Prefer recently-discovered frames first; stale swapped frame ids
+      // can remain visible in the registry while the live OOPIF is ready.
+      .reverse();
+
+    if (childFrames.length) {
+      const probes = await Promise.all(
+        childFrames.map(async (child): Promise<ChildFrameProbe> => {
+          try {
+            const state = await child.evaluate(
+              (): { href: string; readyState: DocumentReadyState } => ({
+                href: location.href,
+                readyState: document.readyState,
+              }),
+            );
+            return {
+              child,
+              href: state.href,
+              readyState: state.readyState,
+            };
+          } catch (error) {
+            const failedProbe: ChildFrameProbe = {
+              child,
+              href: undefined,
+              readyState: undefined,
+              error: formatError(error),
+            };
+            return failedProbe;
+          }
+        }),
+      );
+
+      const ready = probes.find(
+        (probe) =>
+          probe.readyState === "complete" && probe.href === expectedChildUrl,
+      );
+      if (ready) {
+        debugLog("waitForChildFrame:ready", {
+          childFrameId: ready.child.frameId,
+          childSessionId: ready.child.sessionId ?? "root",
+          childUrl: ready.href ?? "<unknown>",
+          expectedChildUrl,
+          url: lastUrl,
+        });
+        return ready.child;
+      }
+
+      if (iframeDebugEnabled && Date.now() - lastLogAt >= DEBUG_INTERVAL_MS) {
+        debugLog("waitForChildFrame:not-ready", {
+          url: lastUrl,
+          mainFrameId,
+          expectedChildUrl,
+          probes: probes.map((probe) => ({
+            frameId: probe.child.frameId,
+            sessionId: probe.child.sessionId ?? "root",
+            readyState: probe.readyState ?? "<unknown>",
+            href: probe.href ?? "<unknown>",
+            error: probe.error ?? "<none>",
+          })),
+        });
+        lastLogAt = Date.now();
+      }
+    }
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  await logPageDiagnostics(page, "waitForChildFrame timeout");
+  throw new Error(
+    `Timed out waiting for child frame to load (timeout=${timeoutMs}ms, mainFrameId=${mainFrameId}, expectedChildUrl=${expectedChildUrl}, maxObservedFrames=${observedFrameCount}, observedChildFrameIds=[${[...observedChildFrameIds].join(",")}], url=${lastUrl || "<unknown>"})`,
+  );
+}
+
+async function waitForPageUrl(
+  page: Page,
+  expectedUrlSubstring: string,
+  timeoutMs = POPUP_URL_TIMEOUT_MS,
+): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  let lastUrl = "";
+  let lastLogAt = Date.now();
+  while (Date.now() < deadline) {
+    lastUrl = page.url();
+    if (iframeDebugEnabled && Date.now() - lastLogAt >= DEBUG_INTERVAL_MS) {
+      debugLog("waitForPageUrl:progress", {
+        expectedUrlSubstring,
+        lastUrl,
+      });
+      lastLogAt = Date.now();
+    }
+    if (lastUrl.includes(expectedUrlSubstring)) {
+      debugLog("waitForPageUrl:ready", {
+        expectedUrlSubstring,
+        lastUrl,
+      });
+      return;
+    }
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  await logPageDiagnostics(
+    page,
+    `waitForPageUrl timeout for ${expectedUrlSubstring}`,
+  );
+  throw new Error(
+    `Timed out waiting for popup URL to include "${expectedUrlSubstring}" (timeout=${timeoutMs}ms, lastUrl=${lastUrl || "<unknown>"})`,
+  );
+}
+
+async function preparePopupForFrameAttach(
+  page: Page,
+  markerSelector: string,
+  timeoutMs = CHILD_FRAME_TIMEOUT_MS,
+): Promise<void> {
+  debugLog("preparePopupForFrameAttach:start", {
+    markerSelector,
+    timeoutMs,
+    url: page.url(),
+  });
+  await page.waitForLoadState("domcontentloaded", timeoutMs);
+  await page.waitForSelector(markerSelector, {
+    state: "attached",
+    timeout: timeoutMs,
+  });
+  await page.mainFrame().evaluate(() => {
+    const host = document.querySelector("shadow-host");
+    if (host instanceof HTMLElement) {
+      host.scrollIntoView({ block: "center", inline: "center" });
+    } else {
+      window.scrollTo(0, document.body.scrollHeight);
+      window.scrollTo(0, 0);
+    }
+    window.dispatchEvent(new Event("scroll"));
+  });
+  await logPageDiagnostics(
+    page,
+    "preparePopupForFrameAttach:ready",
+    markerSelector,
+  );
+}
+
+async function ensurePopupViewport(page: Page): Promise<void> {
+  await page.setViewportSize(TEST_VIEWPORT.width, TEST_VIEWPORT.height);
+  await logPageDiagnostics(page, "ensurePopupViewport");
+}
+
+async function waitForPopupPage(
+  ctx: V3Context,
+  opener: Page,
+  timeoutMs = POPUP_TIMEOUT_MS,
+): Promise<Page> {
+  const openerMainFrameId = opener.mainFrame().frameId;
+  const deadline = Date.now() + timeoutMs;
+  let lastLogAt = Date.now();
+
+  while (Date.now() < deadline) {
+    const pages = ctx.pages();
+    const popup = pages.find((candidate) => {
+      return candidate.mainFrame().frameId !== openerMainFrameId;
+    });
+    if (popup) {
+      debugLog("waitForPopupPage:found", {
+        openerMainFrameId,
+        popupMainFrameId: popup.mainFrame().frameId,
+        popupUrl: popup.url(),
+      });
+      return popup;
+    }
+
+    if (iframeDebugEnabled && Date.now() - lastLogAt >= DEBUG_INTERVAL_MS) {
+      debugLog("waitForPopupPage:progress", {
+        openerMainFrameId,
+        observedPageIds: pages.map((p) => p.mainFrame().frameId),
+      });
+      lastLogAt = Date.now();
+    }
+
+    try {
+      const active = await ctx.awaitActivePage(500);
+      if (active.mainFrame().frameId !== openerMainFrameId) {
+        debugLog("waitForPopupPage:active-non-opener", {
+          openerMainFrameId,
+          activeMainFrameId: active.mainFrame().frameId,
+          activeUrl: active.url(),
+        });
+        return active;
+      }
+    } catch {
+      // keep polling until timeout
+    }
+
+    await new Promise((r) => setTimeout(r, 100));
+  }
+
+  const pageIds = ctx
+    .pages()
+    .map((p) => p.mainFrame().frameId)
+    .join(", ");
+  throw new Error(
+    `Timed out waiting for popup page (timeout=${timeoutMs}ms, openerMainFrameId=${openerMainFrameId}, observedPages=[${pageIds}])`,
+  );
+}
+
+test.describe("context.addInitScript with iframes", () => {
+  const OOPIF_CHILD_URL =
+    "https://seanmcguire12.github.io/stagehand-oopif-sites/sites/form-filling/";
+  const SPIF_CHILD_URL =
+    "https://browserbase.github.io/stagehand-eval-sites/sites/spif-in-closed-shadow-dom/iframe.html";
+  const POPUP_SPIF_CHILD_URL =
+    "https://browserbase.github.io/stagehand-eval-sites/sites/closed-shadow-dom-in-spif/embedded.html";
+
+  if (isBrowserbase) {
+    test.describe.configure({ mode: "serial" });
+  }
+
+  let v3: V3;
+  let ctx: V3Context;
+
+  test.beforeAll(async () => {
+    debugLog("beforeAll:config", {
+      browserTarget: process.env.STAGEHAND_BROWSER_TARGET ?? "local",
+      childFrameTimeoutMs: CHILD_FRAME_TIMEOUT_MS,
+      popupTimeoutMs: POPUP_TIMEOUT_MS,
+      popupUrlTimeoutMs: POPUP_URL_TIMEOUT_MS,
+    });
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+    ctx = v3.context;
+
+    // Add init script that sets background to red
+    await ctx.addInitScript(`
+      (() => {
+        document.addEventListener('DOMContentLoaded', () => {
+          document.documentElement.style.backgroundColor = 'red';
+        });
+      })();
+    `);
+  });
+
+  test.beforeEach(async () => {
+    await closeAllPages(ctx);
+  });
+
+  test.afterEach(async () => {
+    await closeAllPages(ctx);
+  });
+
+  test.afterAll(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test.describe("direct navigation", () => {
+    test("with OOPIF - sets background red in main page and iframe", async () => {
+      const page = await ctx.newPage();
+
+      await page.goto(
+        "https://browserbase.github.io/stagehand-eval-sites/sites/oopif-in-closed-shadow-dom/",
+        { waitUntil: "networkidle" },
+      );
+
+      const iframe = await waitForChildFrame(page, OOPIF_CHILD_URL);
+
+      // Check main page background
+      const mainBgColor = await page.mainFrame().evaluate(() => {
+        return getComputedStyle(document.documentElement).backgroundColor;
+      });
+      expect(mainBgColor).toBe("rgb(255, 0, 0)");
+
+      const iframeBgColor = await iframe.evaluate(() => {
+        return getComputedStyle(document.documentElement).backgroundColor;
+      });
+      expect(iframeBgColor).toBe("rgb(255, 0, 0)");
+    });
+
+    test("with SPIF - sets background red in main page and iframe", async () => {
+      const page = await ctx.newPage();
+
+      await page.goto(
+        "https://browserbase.github.io/stagehand-eval-sites/sites/spif-in-closed-shadow-dom/",
+        { waitUntil: "networkidle" },
+      );
+
+      const iframe = await waitForChildFrame(page, SPIF_CHILD_URL);
+
+      // Check main page background
+      const mainBgColor = await page.mainFrame().evaluate(() => {
+        return getComputedStyle(document.documentElement).backgroundColor;
+      });
+      expect(mainBgColor).toBe("rgb(255, 0, 0)");
+
+      const iframeBgColor = await iframe.evaluate(() => {
+        return getComputedStyle(document.documentElement).backgroundColor;
+      });
+      expect(iframeBgColor).toBe("rgb(255, 0, 0)");
+    });
+  });
+
+  test.describe("via newPage", () => {
+    test("with OOPIF - sets background red in main page and iframe", async () => {
+      const page = await ctx.newPage();
+
+      await page.goto(
+        "https://browserbase.github.io/stagehand-eval-sites/sites/oopif-in-closed-shadow-dom/",
+        { waitUntil: "networkidle" },
+      );
+
+      const iframe = await waitForChildFrame(page, OOPIF_CHILD_URL);
+
+      // Check main page background
+      const mainBgColor = await page.mainFrame().evaluate(() => {
+        return getComputedStyle(document.documentElement).backgroundColor;
+      });
+      expect(mainBgColor).toBe("rgb(255, 0, 0)");
+
+      const iframeBgColor = await iframe.evaluate(() => {
+        return getComputedStyle(document.documentElement).backgroundColor;
+      });
+      expect(iframeBgColor).toBe("rgb(255, 0, 0)");
+    });
+
+    test("with SPIF - sets background red in main page and iframe", async () => {
+      const page = await ctx.newPage();
+
+      await page.goto(
+        "https://browserbase.github.io/stagehand-eval-sites/sites/spif-in-closed-shadow-dom/",
+        { waitUntil: "networkidle" },
+      );
+
+      const iframe = await waitForChildFrame(page, SPIF_CHILD_URL);
+
+      // Check main page background
+      const mainBgColor = await page.mainFrame().evaluate(() => {
+        return getComputedStyle(document.documentElement).backgroundColor;
+      });
+      expect(mainBgColor).toBe("rgb(255, 0, 0)");
+
+      const iframeBgColor = await iframe.evaluate(() => {
+        return getComputedStyle(document.documentElement).backgroundColor;
+      });
+      expect(iframeBgColor).toBe("rgb(255, 0, 0)");
+    });
+  });
+
+  test.describe("via popup", () => {
+    test("with OOPIF - sets background red in main page and iframe", async () => {
+      const page = await ctx.newPage();
+
+      await page.goto(
+        "https://browserbase.github.io/stagehand-eval-sites/sites/ctx-add-init-script-oopif/",
+        { waitUntil: "networkidle" },
+      );
+
+      // Click link to open popup
+      await page.locator("a").click();
+      debugLog("popup-oopif:clicked-link", { openerUrl: page.url() });
+
+      // Wait for popup to open and become active
+      const popup = await waitForPopupPage(ctx, page);
+      ctx.setActivePage(popup);
+      await ensurePopupViewport(popup);
+      await waitForPageUrl(
+        popup,
+        "/stagehand-eval-sites/sites/oopif-in-closed-shadow-dom/",
+      );
+      debugLog("popup-oopif:refresh-navigation", { url: popup.url() });
+      await popup.goto(
+        "https://browserbase.github.io/stagehand-eval-sites/sites/oopif-in-closed-shadow-dom/",
+        { waitUntil: "networkidle" },
+      );
+      await logPageDiagnostics(
+        popup,
+        "popup-oopif:after-refresh",
+        "shadow-host",
+      );
+      await preparePopupForFrameAttach(popup, "shadow-host");
+      const iframe = await waitForChildFrame(popup, OOPIF_CHILD_URL);
+
+      // Check popup main page background
+      const mainBgColor = await popup.mainFrame().evaluate(() => {
+        return getComputedStyle(document.documentElement).backgroundColor;
+      });
+      expect(mainBgColor).toBe("rgb(255, 0, 0)");
+
+      const iframeBgColor = await iframe.evaluate(() => {
+        return getComputedStyle(document.documentElement).backgroundColor;
+      });
+      expect(iframeBgColor).toBe("rgb(255, 0, 0)");
+    });
+
+    test("with SPIF - sets background red in main page and iframe", async () => {
+      const page = await ctx.newPage();
+
+      await page.goto(
+        "https://browserbase.github.io/stagehand-eval-sites/sites/ctx-add-init-script-spif/",
+        { waitUntil: "networkidle" },
+      );
+
+      // Click link to open popup
+      await page.locator("a").click();
+      debugLog("popup-spif:clicked-link", { openerUrl: page.url() });
+
+      // Wait for popup to open and become active
+      const popup = await waitForPopupPage(ctx, page);
+      ctx.setActivePage(popup);
+      await ensurePopupViewport(popup);
+      await waitForPageUrl(
+        popup,
+        "/stagehand-eval-sites/sites/closed-shadow-dom-in-spif/",
+      );
+      await preparePopupForFrameAttach(popup, "iframe");
+      const iframe = await waitForChildFrame(popup, POPUP_SPIF_CHILD_URL);
+
+      // Check popup main page background
+      const mainBgColor = await popup.mainFrame().evaluate(() => {
+        return getComputedStyle(document.documentElement).backgroundColor;
+      });
+      expect(mainBgColor).toBe("rgb(255, 0, 0)");
+
+      const iframeBgColor = await iframe.evaluate(() => {
+        return getComputedStyle(document.documentElement).backgroundColor;
+      });
+      expect(iframeBgColor).toBe("rgb(255, 0, 0)");
+    });
+  });
+});
diff --git a/packages/core/tests/integration/keep-alive.child.ts b/packages/core/tests/integration/keep-alive.child.ts
new file mode 100644
index 000000000..7e1e572b4
--- /dev/null
+++ b/packages/core/tests/integration/keep-alive.child.ts
@@ -0,0 +1,117 @@
+import { V3 } from "../../lib/v3/v3.js";
+
+async function main(): Promise<void> {
+  const encoded = process.argv.find((arg) => arg.startsWith("cfg:"));
+  if (!encoded) {
+    throw new Error("Missing child config payload.");
+  }
+  const raw = Buffer.from(encoded.slice(4), "base64").toString("utf8");
+  const cfg = JSON.parse(raw) as {
+    env: "LOCAL" | "BROWSERBASE";
+    keepAlive: boolean;
+    disableAPI: boolean;
+    scenario: string;
+    apiKey?: string;
+    projectId?: string;
+    debug?: boolean;
+    viewMs?: number;
+  };
+  const {
+    env,
+    keepAlive,
+    disableAPI,
+    scenario,
+    apiKey,
+    projectId,
+    debug = false,
+    viewMs = 0,
+  } = cfg;
+
+  const log = (message: string): void => {
+    if (debug) {
+      console.log(message);
+    }
+  };
+
+  if (env !== "LOCAL" && env !== "BROWSERBASE") {
+    throw new Error("KEEP_ALIVE_ENV must be LOCAL or BROWSERBASE");
+  }
+  if (!scenario) {
+    throw new Error("KEEP_ALIVE_SCENARIO is required");
+  }
+
+  log(
+    `[keep-alive-child] env=${env} keepAlive=${keepAlive} disableAPI=${disableAPI} ` +
+      `scenario=${scenario} apiKey=${apiKey ? "set" : "missing"} ` +
+      `projectId=${projectId ? "set" : "missing"}`,
+  );
+
+  const showBrowser = viewMs > 0;
+  const v3 = new V3({
+    env,
+    keepAlive,
+    disableAPI,
+    apiKey,
+    projectId,
+    browserbaseSessionCreateParams: undefined,
+    localBrowserLaunchOptions:
+      env === "LOCAL"
+        ? {
+            executablePath: process.env.CHROME_PATH,
+            args: process.env.CI ? ["--no-sandbox"] : undefined,
+            headless: !showBrowser,
+            viewport: { width: 1288, height: 711 },
+          }
+        : undefined,
+    verbose: debug ? 2 : 0,
+    disablePino: true,
+    logger: debug ? (line) => console.log(line) : undefined,
+  });
+
+  await v3.init();
+
+  const info = {
+    connectURL: v3.connectURL(),
+    sessionId: v3.browserbaseSessionId ?? null,
+  };
+  await new Promise<void>((resolve, reject) => {
+    process.stdout.write(`__KEEPALIVE__${JSON.stringify(info)}\n`, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+
+  if (env === "LOCAL" && viewMs > 0) {
+    await new Promise((r) => setTimeout(r, viewMs));
+  }
+
+  if (scenario === "close") {
+    await v3.close().catch(() => {});
+    process.exit(0);
+  }
+
+  if (scenario === "sigterm") {
+    return;
+  }
+
+  if (scenario === "sigint") {
+    return;
+  }
+
+  if (scenario === "unhandled") {
+    setTimeout(() => {
+      void Promise.reject(new Error("keepAlive unhandled rejection"));
+    }, 0);
+    return;
+  }
+
+  throw new Error(`Unknown scenario: ${scenario}`);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
diff --git a/packages/core/tests/integration/keep-alive.spec.ts b/packages/core/tests/integration/keep-alive.spec.ts
new file mode 100644
index 000000000..174f4fe7b
--- /dev/null
+++ b/packages/core/tests/integration/keep-alive.spec.ts
@@ -0,0 +1,675 @@
+import { test } from "@playwright/test";
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import Browserbase from "@browserbasehq/sdk";
+import WebSocket from "ws";
+import { v3DynamicTestConfig } from "./v3.dynamic.config.js";
+import { getPackageRootDir } from "../../lib/v3/runtimePaths.js";
+
+export type EnvKind = "LOCAL" | "BROWSERBASE";
+export type ScenarioKind = "unhandled" | "close" | "sigterm" | "sigint";
+
+export type KeepAliveCase = {
+  title: string;
+  env: EnvKind;
+  envLabel: string;
+  keepAlive: boolean;
+  disableAPI: boolean;
+  kind: ScenarioKind;
+  requiresBrowserbase: boolean;
+};
+
+type ScenarioConfig = {
+  env: EnvKind;
+  keepAlive: boolean;
+  disableAPI: boolean;
+  kind: ScenarioKind;
+  debug: boolean;
+  viewMs: number;
+  apiKey?: string;
+  projectId?: string;
+};
+
+type ChildInfo = {
+  connectURL: string;
+  sessionId: string | null;
+};
+
+type ChildLogs = {
+  stdout: string[];
+  stderr: string[];
+};
+
+type CheckResult = {
+  alive: boolean;
+  status?: string;
+};
+
+type Outcome = {
+  expected: "open" | "closed";
+  actual: "open" | "closed";
+  durationMs: number;
+  lastStatus?: string;
+};
+
+const coreDir = getPackageRootDir();
+
+const resolveChildRunner = (): { command: string; args: string[] } | null => {
+  const distJsPath = `${coreDir}/dist/esm/tests/integration/keep-alive.child.js`;
+  if (fs.existsSync(distJsPath)) {
+    return { command: process.execPath, args: [distJsPath] };
+  }
+
+  return null;
+};
+
+const childRunner = resolveChildRunner();
+
+const DEBUG = process.env.KEEP_ALIVE_DEBUG === "1";
+const VIEW_MS = Number(process.env.KEEP_ALIVE_VIEW_MS ?? "0");
+const LOCAL_TIMEOUT_MS = Number(
+  process.env.KEEP_ALIVE_LOCAL_TIMEOUT_MS ?? "8000",
+);
+const BB_TIMEOUT_MS = Number(process.env.KEEP_ALIVE_BB_TIMEOUT_MS ?? "30000");
+const STAY_OPEN_MS = Number(process.env.KEEP_ALIVE_STAY_OPEN_MS ?? "6000");
+const ACTION_EXIT_TIMEOUT_MS = Number(
+  process.env.KEEP_ALIVE_ACTION_EXIT_TIMEOUT_MS ?? "3000",
+);
+const LOCAL_INFO_TIMEOUT_MS = Number(
+  process.env.KEEP_ALIVE_LOCAL_INFO_TIMEOUT_MS ?? "15000",
+);
+const BB_INFO_TIMEOUT_MS = Number(
+  process.env.KEEP_ALIVE_BB_INFO_TIMEOUT_MS ??
+    (process.env.CI ? "45000" : "30000"),
+);
+
+const getInfoTimeoutMs = (env: EnvKind): number =>
+  env === "BROWSERBASE" ? BB_INFO_TIMEOUT_MS : LOCAL_INFO_TIMEOUT_MS;
+
+function debugLog(message: string): void {
+  if (DEBUG) {
+    console.log(message);
+  }
+}
+
+function parseChildInfo(line: string): ChildInfo | null {
+  const prefix = "__KEEPALIVE__";
+  if (!line.startsWith(prefix)) return null;
+  try {
+    return JSON.parse(line.slice(prefix.length)) as ChildInfo;
+  } catch {
+    return null;
+  }
+}
+
+async function runScenario(config: ScenarioConfig): Promise<{
+  info: ChildInfo;
+  child: ReturnType<typeof spawn>;
+  logs: ChildLogs;
+}> {
+  const payload = {
+    env: config.env,
+    keepAlive: config.keepAlive,
+    disableAPI: config.disableAPI,
+    scenario: config.kind,
+    apiKey: config.apiKey,
+    projectId: config.projectId,
+    debug: config.debug,
+    viewMs: config.viewMs,
+  };
+  const encoded = `cfg:${Buffer.from(JSON.stringify(payload)).toString("base64")}`;
+
+  if (!childRunner) {
+    throw new Error(
+      "keep-alive child script not found at dist/esm/tests/integration/keep-alive.child.js",
+    );
+  }
+
+  const child = spawn(childRunner.command, [...childRunner.args, encoded], {
+    cwd: coreDir,
+    env: { ...process.env },
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  const logs: ChildLogs = { stdout: [], stderr: [] };
+  let buffer = "";
+  let stderr = "";
+  let resolved = false;
+  const infoTimeoutMs = getInfoTimeoutMs(config.env);
+
+  const infoPromise = new Promise<ChildInfo>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      child.kill("SIGKILL");
+      const stdoutDetails =
+        logs.stdout.length > 0
+          ? `\nChild stdout:\n${logs.stdout.join("\n")}`
+          : "";
+      const details = stderr.trim();
+      const suffix = details
+        ? `\nChild stderr:\n${details}`
+        : "\nChild did not emit keepAlive info.";
+      reject(
+        new Error(
+          `Child timed out waiting for info after ${infoTimeoutMs}ms (env=${config.env}, keepAlive=${config.keepAlive}, disableAPI=${config.disableAPI}, scenario=${config.kind}).${suffix}${stdoutDetails}`,
+        ),
+      );
+    }, infoTimeoutMs);
+
+    child.stdout.on("data", (chunk) => {
+      buffer += chunk.toString();
+      let idx = buffer.indexOf("\n");
+      while (idx !== -1) {
+        const line = buffer.slice(0, idx).trim();
+        buffer = buffer.slice(idx + 1);
+        const parsed = parseChildInfo(line);
+        if (parsed && !resolved) {
+          resolved = true;
+          clearTimeout(timeout);
+          resolve(parsed);
+        } else if (line.length > 0) {
+          logs.stdout.push(line);
+          debugLog(`[keep-alive-child] ${line}`);
+        }
+        idx = buffer.indexOf("\n");
+      }
+    });
+
+    child.on("exit", (code, signal) => {
+      if (resolved) return;
+      clearTimeout(timeout);
+      const stdoutDetails =
+        logs.stdout.length > 0
+          ? `\nChild stdout:\n${logs.stdout.join("\n")}`
+          : "";
+      const details = stderr.trim();
+      const suffix = details
+        ? `\nChild stderr:\n${details}`
+        : "\nChild exited without emitting keepAlive info.";
+      reject(
+        new Error(
+          `Child exited (code=${code ?? "null"}, signal=${signal ?? "null"}) before emitting keepAlive info (env=${config.env}, keepAlive=${config.keepAlive}, disableAPI=${config.disableAPI}, scenario=${config.kind}).${suffix}${stdoutDetails}`,
+        ),
+      );
+    });
+
+    child.on("error", (error) => {
+      if (resolved) return;
+      clearTimeout(timeout);
+      reject(error);
+    });
+  });
+
+  child.stderr.on("data", (chunk) => {
+    const text = chunk.toString();
+    stderr += text;
+    const trimmed = text.trim();
+    if (trimmed.length > 0) {
+      logs.stderr.push(trimmed);
+      debugLog(`[keep-alive-child] ${trimmed}`);
+    }
+  });
+
+  const info = await infoPromise;
+  return { info, child, logs };
+}
+
+async function stopChild(child: ReturnType<typeof spawn>): Promise<void> {
+  if (child.exitCode !== null) return;
+  try {
+    child.kill("SIGKILL");
+  } catch {
+    return;
+  }
+  await new Promise<void>((resolve) => {
+    const timer = setTimeout(() => resolve(), 2000);
+    child.once("exit", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
+
+async function waitForChildExit(
+  child: ReturnType<typeof spawn>,
+  timeoutMs: number,
+): Promise<void> {
+  if (child.exitCode !== null) return;
+  await new Promise<void>((resolve) => {
+    const timer = setTimeout(() => resolve(), timeoutMs);
+    child.once("exit", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
+
+async function checkLocalAlive(connectURL: string): Promise<CheckResult> {
+  let port: string;
+  try {
+    port = new URL(connectURL).port;
+  } catch {
+    return { alive: false, status: "INVALID_URL" };
+  }
+  if (!port) return { alive: false, status: "MISSING_PORT" };
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 1500);
+  try {
+    const resp = await fetch(`http://127.0.0.1:${port}/json/version`, {
+      signal: controller.signal,
+    });
+    if (!resp.ok) {
+      return { alive: false, status: `HTTP_${resp.status}` };
+    }
+    const json = (await resp.json()) as { webSocketDebuggerUrl?: string };
+    const ws = json?.webSocketDebuggerUrl;
+    if (!ws) {
+      return { alive: false, status: "MISSING_WS" };
+    }
+    if (ws !== connectURL) {
+      return { alive: false, status: "WS_MISMATCH" };
+    }
+    return { alive: true, status: "MATCH" };
+  } catch {
+    return { alive: false, status: "FETCH_ERROR" };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function closeLocalBrowser(connectURL: string): Promise<void> {
+  await new Promise<void>((resolve) => {
+    const ws = new WebSocket(connectURL);
+    const timer = setTimeout(() => {
+      ws.terminate();
+      resolve();
+    }, 2000);
+    ws.on("open", () => {
+      ws.send(JSON.stringify({ id: 1, method: "Browser.close" }));
+    });
+    ws.on("error", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+    ws.on("close", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
+
+async function checkBrowserbaseAlive(
+  sessionId: string,
+  apiKey?: string,
+): Promise<CheckResult> {
+  if (!apiKey) return { alive: false, status: "NO_API_KEY" };
+
+  const bb = new Browserbase({ apiKey });
+  try {
+    const snapshot = (await bb.sessions.retrieve(sessionId)) as {
+      status?: string;
+    };
+    if (DEBUG) {
+      const status = snapshot?.status ?? "<missing>";
+      debugLog(`[keep-alive] session ${sessionId} status=${status}`);
+    }
+    const status = snapshot?.status;
+    return { alive: status === "RUNNING", status };
+  } catch (error) {
+    debugLog(
+      `[keep-alive] session ${sessionId} retrieve failed: ${String(error)}`,
+    );
+    return { alive: false, status: "RETRIEVE_FAILED" };
+  }
+}
+
+async function endBrowserbaseSession(
+  sessionId: string,
+  apiKey?: string,
+  projectId?: string,
+): Promise<void> {
+  if (!apiKey || !projectId) return;
+  const bb = new Browserbase({ apiKey });
+  try {
+    await bb.sessions.update(sessionId, {
+      status: "REQUEST_RELEASE",
+      projectId,
+    });
+  } catch {
+    // best-effort cleanup
+  }
+}
+
+async function assertStaysOpen(
+  check: () => Promise<CheckResult>,
+  durationMs: number,
+  intervalMs = 500,
+): Promise<{ durationMs: number; lastStatus?: string }> {
+  const start = Date.now();
+  const deadline = start + durationMs;
+  let lastStatus: string | undefined;
+  while (Date.now() < deadline) {
+    const result = await check();
+    lastStatus = result.status ?? lastStatus;
+    if (!result.alive) {
+      const elapsed = Date.now() - start;
+      const status = lastStatus ? ` (last status ${lastStatus})` : "";
+      throw new Error(
+        `Browser closed after ${elapsed}ms (expected ${durationMs}ms)${status}.`,
+      );
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  return { durationMs: Date.now() - start, lastStatus };
+}
+
+async function waitForClosed(
+  check: () => Promise<CheckResult>,
+  timeoutMs: number,
+  intervalMs = 500,
+): Promise<{ durationMs: number; lastStatus?: string }> {
+  const start = Date.now();
+  let lastStatus: string | undefined;
+  while (Date.now() - start < timeoutMs) {
+    const result = await check();
+    lastStatus = result.status ?? lastStatus;
+    if (!result.alive) {
+      return { durationMs: Date.now() - start, lastStatus };
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  const status = lastStatus ? ` (last status ${lastStatus})` : "";
+  throw new Error(`Browser still alive after ${timeoutMs}ms${status}.`);
+}
+
+async function assertBrowserState(
+  env: EnvKind,
+  info: ChildInfo,
+  shouldStayOpen: boolean,
+  apiKey?: string,
+  projectId?: string,
+): Promise<Outcome> {
+  const expected: Outcome["expected"] = shouldStayOpen ? "open" : "closed";
+  if (env === "LOCAL") {
+    if (shouldStayOpen) {
+      const result = await assertStaysOpen(
+        () => checkLocalAlive(info.connectURL),
+        STAY_OPEN_MS,
+      );
+      const outcome: Outcome = {
+        expected,
+        actual: "open",
+        durationMs: result.durationMs,
+        lastStatus: result.lastStatus,
+      };
+      await closeLocalBrowser(info.connectURL);
+      return outcome;
+    }
+
+    const result = await waitForClosed(
+      () => checkLocalAlive(info.connectURL),
+      LOCAL_TIMEOUT_MS,
+    );
+    return {
+      expected,
+      actual: "closed",
+      durationMs: result.durationMs,
+      lastStatus: result.lastStatus,
+    };
+  }
+
+  if (!info.sessionId) {
+    throw new Error("Browserbase sessionId missing");
+  }
+
+  if (shouldStayOpen) {
+    const result = await assertStaysOpen(
+      () => checkBrowserbaseAlive(info.sessionId!, apiKey),
+      STAY_OPEN_MS,
+      1000,
+    );
+    const outcome: Outcome = {
+      expected,
+      actual: "open",
+      durationMs: result.durationMs,
+      lastStatus: result.lastStatus,
+    };
+    await endBrowserbaseSession(info.sessionId, apiKey, projectId);
+    return outcome;
+  }
+
+  const result = await waitForClosed(
+    () => checkBrowserbaseAlive(info.sessionId!, apiKey),
+    BB_TIMEOUT_MS,
+    1000,
+  );
+  return {
+    expected,
+    actual: "closed",
+    durationMs: result.durationMs,
+    lastStatus: result.lastStatus,
+  };
+}
+
+function dumpLogs(logs: ChildLogs): void {
+  if (logs.stdout.length > 0) {
+    console.log("[keep-alive] child stdout:");
+    for (const line of logs.stdout) {
+      console.log(`  ${line}`);
+    }
+  }
+  if (logs.stderr.length > 0) {
+    console.log("[keep-alive] child stderr:");
+    for (const line of logs.stderr) {
+      console.log(`  ${line}`);
+    }
+  }
+}
+
+function logCaseResult(
+  label: string,
+  envLabel: string,
+  keepAlive: boolean,
+  outcome?: Outcome,
+  error?: Error,
+): void {
+  const prefix = `[keep-alive] ${envLabel} keepAlive=${keepAlive} ${label}`;
+  if (error) {
+    console.log(`${prefix} FAIL: ${error.message}`);
+    return;
+  }
+  if (!outcome) {
+    console.log(`${prefix} FAIL: missing outcome`);
+    return;
+  }
+  const status =
+    outcome.lastStatus !== undefined
+      ? ` (last status ${outcome.lastStatus})`
+      : "";
+  if (outcome.actual === "open") {
+    console.log(
+      `${prefix} PASS: stayed open for ${outcome.durationMs}ms${status}`,
+    );
+  } else {
+    console.log(
+      `${prefix} PASS: closed after ${outcome.durationMs}ms${status}`,
+    );
+  }
+}
+
+export function getKeepAliveEnvConfig(): {
+  testEnv: EnvKind;
+  apiKey?: string;
+  projectId?: string;
+  hasBrowserbaseCreds: boolean;
+} {
+  const testEnv = v3DynamicTestConfig.env;
+  const apiKey =
+    testEnv === "BROWSERBASE"
+      ? (v3DynamicTestConfig.apiKey as string | undefined)
+      : undefined;
+  const projectId =
+    testEnv === "BROWSERBASE"
+      ? (v3DynamicTestConfig.projectId as string | undefined)
+      : undefined;
+  const hasBrowserbaseCreds = Boolean(apiKey && projectId);
+  return { testEnv, apiKey, projectId, hasBrowserbaseCreds };
+}
+
+export function buildKeepAliveCases(testEnv: EnvKind): KeepAliveCase[] {
+  const scenarios: Array<{ kind: ScenarioKind; label: string }> = [
+    { kind: "unhandled", label: "unhandled rejection" },
+    { kind: "close", label: "stagehand.close()" },
+    { kind: "sigterm", label: "SIGTERM" },
+    { kind: "sigint", label: "SIGINT" },
+  ];
+
+  const environments: Array<{
+    env: EnvKind;
+    label: string;
+    disableAPI: boolean;
+    requiresBrowserbase: boolean;
+  }> =
+    testEnv === "BROWSERBASE"
+      ? [
+          {
+            env: "BROWSERBASE",
+            label: "bb direct ws",
+            disableAPI: true,
+            requiresBrowserbase: true,
+          },
+          {
+            env: "BROWSERBASE",
+            label: "bb via api",
+            disableAPI: false,
+            requiresBrowserbase: true,
+          },
+        ]
+      : [
+          {
+            env: "LOCAL",
+            label: "local",
+            disableAPI: false,
+            requiresBrowserbase: false,
+          },
+        ];
+
+  const cases: KeepAliveCase[] = [];
+  for (const keepAlive of [true, false]) {
+    for (const envConfig of environments) {
+      for (const scenario of scenarios) {
+        const expectation = keepAlive ? "expect open" : "expect closed";
+        cases.push({
+          title: `${envConfig.label} keepAlive=${keepAlive} ${scenario.label} (${expectation})`,
+          env: envConfig.env,
+          envLabel: envConfig.label,
+          keepAlive,
+          disableAPI: envConfig.disableAPI,
+          kind: scenario.kind,
+          requiresBrowserbase: envConfig.requiresBrowserbase,
+        });
+      }
+    }
+  }
+  return cases;
+}
+
+export async function runKeepAliveCase(
+  testCase: KeepAliveCase,
+  envConfig: {
+    apiKey?: string;
+    projectId?: string;
+  },
+): Promise<void> {
+  let info: ChildInfo | undefined;
+  let child: ReturnType<typeof spawn> | undefined;
+  let logs: ChildLogs | undefined;
+  try {
+    ({ info, child, logs } = await runScenario({
+      env: testCase.env,
+      keepAlive: testCase.keepAlive,
+      disableAPI: testCase.disableAPI,
+      kind: testCase.kind,
+      debug: DEBUG,
+      viewMs: VIEW_MS,
+      apiKey: envConfig.apiKey,
+      projectId: envConfig.projectId,
+    }));
+  } catch (error) {
+    logCaseResult(
+      testCase.title,
+      testCase.envLabel,
+      testCase.keepAlive,
+      undefined,
+      error as Error,
+    );
+    throw error;
+  }
+
+  if (testCase.kind === "sigterm") {
+    child.kill("SIGTERM");
+  } else if (testCase.kind === "sigint") {
+    child.kill("SIGINT");
+  }
+
+  let outcome: Outcome | undefined;
+  let failure: Error | undefined;
+  try {
+    if (
+      testCase.kind === "close" ||
+      testCase.kind === "unhandled" ||
+      testCase.kind === "sigterm" ||
+      testCase.kind === "sigint"
+    ) {
+      await waitForChildExit(child, ACTION_EXIT_TIMEOUT_MS);
+    }
+    outcome = await assertBrowserState(
+      testCase.env,
+      info,
+      testCase.keepAlive,
+      envConfig.apiKey,
+      envConfig.projectId,
+    );
+  } catch (error) {
+    failure = error as Error;
+    if (logs) {
+      dumpLogs(logs);
+    }
+    throw error;
+  } finally {
+    logCaseResult(
+      testCase.title,
+      testCase.envLabel,
+      testCase.keepAlive,
+      outcome,
+      failure,
+    );
+    await stopChild(child);
+    if (testCase.env === "LOCAL" && info.connectURL) {
+      await closeLocalBrowser(info.connectURL);
+    }
+    if (testCase.env === "BROWSERBASE" && info.sessionId) {
+      await endBrowserbaseSession(
+        info.sessionId,
+        envConfig.apiKey,
+        envConfig.projectId,
+      );
+    }
+  }
+}
+
+test.describe.parallel("keepAlive behavior", () => {
+  const { testEnv, apiKey, projectId, hasBrowserbaseCreds } =
+    getKeepAliveEnvConfig();
+  const cases = buildKeepAliveCases(testEnv);
+
+  for (const testCase of cases) {
+    test(testCase.title, async () => {
+      if (testCase.requiresBrowserbase) {
+        test.skip(!hasBrowserbaseCreds, "Browserbase credentials required");
+      }
+
+      await runKeepAliveCase(testCase, { apiKey, projectId });
+    });
+  }
+});
diff --git a/packages/core/tests/integration/keyboard.spec.ts b/packages/core/tests/integration/keyboard.spec.ts
new file mode 100644
index 000000000..630c7207a
--- /dev/null
+++ b/packages/core/tests/integration/keyboard.spec.ts
@@ -0,0 +1,343 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3DynamicTestConfig } from "./v3.dynamic.config.js";
+import { closeV3 } from "./testUtils.js";
+
+function dataUrl(html: string): string {
+  return "data:text/html;charset=utf-8," + encodeURIComponent(html);
+}
+
+test.describe("V3 keyboard shortcuts and typing", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3DynamicTestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await closeV3(v3);
+  });
+
+  test("typing, select-all + delete clears input (Cmd maps cross-OS)", async () => {
+    const html = `<!doctype html>
+      <input id="i1" autofocus />`;
+    const page = await v3.context.awaitActivePage();
+    await page.goto(dataUrl(html), {
+      waitUntil: "domcontentloaded",
+      timeoutMs: 15000,
+    });
+
+    await page.locator("#i1").click();
+    await page.type("Hello World");
+
+    await page.keyPress("Cmd+A");
+    await page.keyPress("Delete");
+
+    const value = await page.evaluate(
+      (sel) => (document.querySelector(sel) as HTMLInputElement)!.value,
+      "#i1",
+    );
+    expect(value).toBe("");
+  });
+
+  test("accelerator does not inject printable text (Cmd+B does not type 'b')", async () => {
+    const html = `<!doctype html>
+      <input id="i" />`;
+    const page = await v3.context.awaitActivePage();
+    await page.goto(dataUrl(html), {
+      waitUntil: "domcontentloaded",
+      timeoutMs: 15000,
+    });
+
+    await page.locator("#i").click();
+    await page.type("xyz");
+
+    await page.keyPress("Cmd+B");
+
+    const value = await page.evaluate(
+      (sel) => (document.querySelector(sel) as HTMLInputElement)!.value,
+      "#i",
+    );
+    expect(value).toBe("xyz");
+  });
+
+  test("Tab and Shift+Tab move focus", async () => {
+    const html = `<!doctype html>
+      <input id="a" />
+      <input id="b" />`;
+    const page = await v3.context.awaitActivePage();
+    await page.goto(dataUrl(html), {
+      waitUntil: "domcontentloaded",
+      timeoutMs: 15000,
+    });
+
+    await page.locator("#a").click();
+    await page.keyPress("Tab");
+    const active1 = await page.evaluate(
+      () => (document.activeElement as HTMLElement)?.id || "",
+    );
+    expect(active1).toBe("b");
+
+    await page.keyPress("Shift+Tab");
+    const active2 = await page.evaluate(
+      () => (document.activeElement as HTMLElement)?.id || "",
+    );
+    expect(active2).toBe("a");
+  });
+
+  test("cut clears the field (Cmd+X)", async () => {
+    const html = `<!doctype html>
+      <input id="t" />`;
+    const page = await v3.context.awaitActivePage();
+    await page.goto(dataUrl(html), {
+      waitUntil: "domcontentloaded",
+      timeoutMs: 15000,
+    });
+
+    await page.locator("#t").click();
+    await page.type("cut-me");
+    await page.keyPress("Cmd+A");
+    await page.keyPress("Cmd+X");
+
+    const value = await page.evaluate(
+      (sel) => (document.querySelector(sel) as HTMLInputElement)!.value,
+      "#t",
+    );
+    expect(value).toBe("");
+  });
+
+  test("single printable via keyPress types characters (a, Shift+A, space)", async () => {
+    const html = `<!doctype html>
+      <input id="t" autofocus />`;
+    const page = await v3.context.awaitActivePage();
+    await page.goto(dataUrl(html), {
+      waitUntil: "domcontentloaded",
+      timeoutMs: 15000,
+    });
+
+    await page.locator("#t").click();
+    await page.keyPress("a");
+    await page.keyPress("Shift+A");
+    await page.keyPress(" ");
+
+    const value = await page.evaluate(
+      (sel) => (document.querySelector(sel) as HTMLInputElement)!.value,
+      "#t",
+    );
+    expect(value).toBe("aA ");
+  });
+
+  test("Backspace removes last char", async () => {
+    const html = `<!doctype html>
+      <input id="t" />`;
+    const page = await v3.context.awaitActivePage();
+    await page.goto(dataUrl(html), {
+      waitUntil: "domcontentloaded",
+      timeoutMs: 15000,
+    });
+
+    await page.locator("#t").click();
+    await page.type("ab");
+    await page.keyPress("Backspace");
+    const value = await page.evaluate(
+      (sel) => (document.querySelector(sel) as HTMLInputElement)!.value,
+      "#t",
+    );
+    expect(value).toBe("a");
+  });
+
+  test("Delete removes next char at caret", async () => {
+    const html = `<!doctype html>
+      <input id="t" />`;
+    const page = await v3.context.awaitActivePage();
+    await page.goto(dataUrl(html), {
+      waitUntil: "domcontentloaded",
+      timeoutMs: 15000,
+    });
+
+    await page.locator("#t").click();
+    await page.type("abc");
+    // place caret between a|bc
+    await page.evaluate(() => {
+      const el = document.getElementById("t") as HTMLInputElement;
+      el.focus();
+      el.setSelectionRange(1, 1);
+    });
+    await page.keyPress("Delete");
+    const value = await page.evaluate(
+      (sel) => (document.querySelector(sel) as HTMLInputElement)!.value,
+      "#t",
+    );
+    expect(value).toBe("ac");
+  });
+
+  test("ArrowLeft moves caret and typing inserts in middle", async () => {
+    const html = `<!doctype html>
+      <input id="t" />`;
+    const page = await v3.context.awaitActivePage();
+    await page.goto(dataUrl(html), {
+      waitUntil: "domcontentloaded",
+      timeoutMs: 15000,
+    });
+
+    await page.locator("#t").click();
+    await page.type("ac");
+    await page.keyPress("ArrowLeft");
+    await page.keyPress("b");
+    const value = await page.evaluate(
+      (sel) => (document.querySelector(sel) as HTMLInputElement)!.value,
+      "#t",
+    );
+    expect(value).toBe("abc");
+  });
+
+  test("Enter inserts newline in textarea", async () => {
+    const html = `<!doctype html>
+      <textarea id="ta"></textarea>`;
+    const page = await v3.context.awaitActivePage();
+    await page.goto(dataUrl(html), {
+      waitUntil: "domcontentloaded",
+      timeoutMs: 15000,
+    });
+
+    await page.locator("#ta").click();
+    await page.keyPress("a");
+    await page.keyPress("Enter");
+    await page.keyPress("b");
+    const value = await page.evaluate(
+      (sel) => (document.querySelector(sel) as HTMLTextAreaElement)!.value,
+      "#ta",
+    );
+    expect(value).toBe("a\nb");
+  });
+
+  test("Insert key (no-op for value)", async () => {
+    const html = `<!doctype html>
+      <input id="t" />`;
+    const page = await v3.context.awaitActivePage();
+    await page.goto(dataUrl(html), {
+      waitUntil: "domcontentloaded",
+      timeoutMs: 15000,
+    });
+
+    await page.locator("#t").click();
+    await page.type("abc");
+    await page.keyPress("Insert");
+    const value = await page.evaluate(
+      (sel) => (document.querySelector(sel) as HTMLInputElement)!.value,
+      "#t",
+    );
+    expect(value).toBe("abc");
+  });
+
+  test("Enter submits form from text input", async () => {
+    const html = `<!doctype html>
+      <form id="f">
+        <input id="name" />
+        <button id="submit">Go</button>
+        <input id="submitted" />
+      </form>
+      <script>
+        document.getElementById('f').addEventListener('submit', (e) => {
+          e.preventDefault();
+          document.getElementById('submitted').value = 'yes';
+        });
+      </script>`;
+    const page = await v3.context.awaitActivePage();
+    await page.goto(dataUrl(html), {
+      waitUntil: "domcontentloaded",
+      timeoutMs: 15000,
+    });
+
+    await page.locator("#name").click();
+    await page.type("foo");
+    await page.keyPress("Enter");
+
+    const submitted = await page.evaluate(
+      () =>
+        (document.getElementById("submitted") as HTMLInputElement)?.value || "",
+    );
+    expect(submitted).toBe("yes");
+  });
+
+  test("Enter in textarea does not submit form (inserts newline)", async () => {
+    const html = `<!doctype html>
+      <form id="f">
+        <textarea id="ta"></textarea>
+        <button id="submit">Go</button>
+        <input id="submitted" />
+      </form>
+      <script>
+        document.getElementById('f').addEventListener('submit', (e) => {
+          e.preventDefault();
+          document.getElementById('submitted').value = 'yes';
+        });
+      </script>`;
+    const page = await v3.context.awaitActivePage();
+    await page.goto(dataUrl(html), {
+      waitUntil: "domcontentloaded",
+      timeoutMs: 15000,
+    });
+
+    await page.locator("#ta").click();
+    await page.keyPress("a");
+    await page.keyPress("Enter");
+    await page.keyPress("b");
+
+    const submitted = await page.evaluate(
+      () =>
+        (document.getElementById("submitted") as HTMLInputElement)?.value || "",
+    );
+    const value = await page.evaluate(
+      (sel) => (document.querySelector(sel) as HTMLTextAreaElement)!.value,
+      "#ta",
+    );
+    expect(submitted).toBe("");
+    expect(value).toBe("a\nb");
+  });
+
+  test('pressing "+" key types plus sign', async () => {
+    const html = `<!doctype html>
+      <input id="t" />`;
+    const page = await v3.context.awaitActivePage();
+    await page.goto(dataUrl(html), {
+      waitUntil: "domcontentloaded",
+      timeoutMs: 15000,
+    });
+
+    await page.locator("#t").click();
+    await page.keyPress("+");
+    const value = await page.evaluate(
+      (sel) => (document.querySelector(sel) as HTMLInputElement)!.value,
+      "#t",
+    );
+    expect(value).toBe("+");
+  });
+
+  test("modifier state clears on keyPress error", async () => {
+    const html = `<!doctype html>
+      <input id="t" />`;
+    const page = await v3.context.awaitActivePage();
+    await page.goto(dataUrl(html), {
+      waitUntil: "domcontentloaded",
+      timeoutMs: 15000,
+    });
+
+    await page.locator("#t").click();
+    // Try invalid key that might throw
+    try {
+      await page.keyPress("Cmd+InvalidKey123");
+    } catch {
+      // Expected to fail
+    }
+
+    // Now try normal typing - should work if modifiers were cleared
+    await page.type("ok");
+    const value = await page.evaluate(
+      (sel) => (document.querySelector(sel) as HTMLInputElement)!.value,
+      "#t",
+    );
+    expect(value).toBe("ok");
+  });
+});
diff --git a/packages/core/tests/integration/locator-backend-node-id.spec.ts b/packages/core/tests/integration/locator-backend-node-id.spec.ts
new file mode 100644
index 000000000..e18628c80
--- /dev/null
+++ b/packages/core/tests/integration/locator-backend-node-id.spec.ts
@@ -0,0 +1,216 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+
+test.describe("Locator.backendNodeId() - CDP DOM node ID", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test("returns a valid backend node ID for an element", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <button id="btn">Click me</button>
+          </body></html>`,
+        ),
+    );
+
+    const locator = page.locator("button#btn");
+    const nodeId = await locator.backendNodeId();
+
+    // Backend node ID should be a valid number
+    expect(typeof nodeId).toBe("number");
+    expect(nodeId).toBeGreaterThan(0);
+  });
+
+  test("returns different node IDs for different elements", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <div id="div1">First</div>
+            <div id="div2">Second</div>
+            <p id="p1">Third</p>
+          </body></html>`,
+        ),
+    );
+
+    const nodeId1 = await page.locator("div#div1").backendNodeId();
+    const nodeId2 = await page.locator("div#div2").backendNodeId();
+    const nodeId3 = await page.locator("p#p1").backendNodeId();
+
+    // All node IDs should be unique
+    expect(nodeId1).not.toBe(nodeId2);
+    expect(nodeId2).not.toBe(nodeId3);
+    expect(nodeId1).not.toBe(nodeId3);
+  });
+
+  test("returns consistent node ID for the same element", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <input type="text" id="input" />
+          </body></html>`,
+        ),
+    );
+
+    const locator = page.locator("input#input");
+
+    // Call multiple times on the same element
+    const nodeId1 = await locator.backendNodeId();
+    const nodeId2 = await locator.backendNodeId();
+
+    // Should return the same ID (same element)
+    expect(nodeId1).toBe(nodeId2);
+  });
+
+  test("returns node ID for nested elements", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <div id="outer">
+              <div id="middle">
+                <span id="inner">Deep</span>
+              </div>
+            </div>
+          </body></html>`,
+        ),
+    );
+
+    const outerNodeId = await page.locator("div#outer").backendNodeId();
+    const middleNodeId = await page.locator("div#middle").backendNodeId();
+    const innerNodeId = await page.locator("span#inner").backendNodeId();
+
+    // All should be valid and unique
+    expect(outerNodeId).toBeGreaterThan(0);
+    expect(middleNodeId).toBeGreaterThan(0);
+    expect(innerNodeId).toBeGreaterThan(0);
+    expect(new Set([outerNodeId, middleNodeId, innerNodeId]).size).toBe(3);
+  });
+
+  test("returns node ID for elements with various attributes", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <button class="btn primary" data-test="submit" aria-label="Submit form">Save</button>
+          </body></html>`,
+        ),
+    );
+
+    const locator = page.locator("button");
+    const nodeId = await locator.backendNodeId();
+
+    // Should work with complex elements
+    expect(typeof nodeId).toBe("number");
+    expect(nodeId).toBeGreaterThan(0);
+  });
+
+  test("returns node ID for form elements", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <form>
+              <input type="email" id="email" placeholder="Email" />
+              <textarea id="message"></textarea>
+              <select id="country">
+                <option value="us">USA</option>
+                <option value="ca">Canada</option>
+              </select>
+              <button type="submit">Submit</button>
+            </form>
+          </body></html>`,
+        ),
+    );
+
+    const emailNodeId = await page.locator("input#email").backendNodeId();
+    const textareaNodeId = await page
+      .locator("textarea#message")
+      .backendNodeId();
+    const selectNodeId = await page.locator("select#country").backendNodeId();
+    const submitNodeId = await page
+      .locator("button[type='submit']")
+      .backendNodeId();
+
+    // All form elements should have valid node IDs
+    expect(emailNodeId).toBeGreaterThan(0);
+    expect(textareaNodeId).toBeGreaterThan(0);
+    expect(selectNodeId).toBeGreaterThan(0);
+    expect(submitNodeId).toBeGreaterThan(0);
+
+    // All should be unique
+    const nodeIds = [emailNodeId, textareaNodeId, selectNodeId, submitNodeId];
+    expect(new Set(nodeIds).size).toBe(4);
+  });
+
+  test("returns node ID for dynamically created elements", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <div id="container"></div>
+            <script>
+              const container = document.getElementById('container');
+              const newBtn = document.createElement('button');
+              newBtn.id = 'dynamic-btn';
+              newBtn.textContent = 'Dynamically created';
+              container.appendChild(newBtn);
+            </script>
+          </body></html>`,
+        ),
+    );
+
+    const locator = page.locator("button#dynamic-btn");
+    const nodeId = await locator.backendNodeId();
+
+    // Should work with dynamically created elements
+    expect(typeof nodeId).toBe("number");
+    expect(nodeId).toBeGreaterThan(0);
+  });
+
+  test("returns node ID for elements with text selectors", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <button>Submit Form</button>
+          </body></html>`,
+        ),
+    );
+
+    const locator = page.locator("text=Submit Form");
+    const nodeId = await locator.backendNodeId();
+
+    // Should work with text-based selectors
+    expect(typeof nodeId).toBe("number");
+    expect(nodeId).toBeGreaterThan(0);
+  });
+});
diff --git a/packages/core/tests/integration/locator-content-methods.spec.ts b/packages/core/tests/integration/locator-content-methods.spec.ts
new file mode 100644
index 000000000..80f2abb24
--- /dev/null
+++ b/packages/core/tests/integration/locator-content-methods.spec.ts
@@ -0,0 +1,255 @@
+import { expect, test } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+
+test.describe("Locator content methods (textContent, innerHtml, innerText, inputValue)", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch((e) => {
+      void e;
+    });
+  });
+
+  test("Locator.textContent() returns raw text including hidden content", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <div id="content">
+              Hello
+              <span style="display:none">Hidden</span>
+              World
+            </div>
+          </body></html>`,
+        ),
+    );
+
+    const content = await page.mainFrame().locator("#content").textContent();
+    // textContent includes all text nodes, even hidden ones
+    expect(content).toContain("Hello");
+    expect(content).toContain("Hidden");
+    expect(content).toContain("World");
+  });
+
+  test("Locator.innerText() returns visible text only", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <div id="content">
+              Visible
+              <span style="display:none">Hidden</span>
+              Text
+            </div>
+          </body></html>`,
+        ),
+    );
+
+    const text = await page.mainFrame().locator("#content").innerText();
+    // innerText is layout-aware and excludes hidden elements
+    expect(text).toContain("Visible");
+    expect(text).toContain("Text");
+    expect(text).not.toContain("Hidden");
+  });
+
+  test("Locator.innerHtml() returns HTML markup", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <div id="container">
+              <p class="para">Hello</p>
+              <strong>World</strong>
+            </div>
+          </body></html>`,
+        ),
+    );
+
+    const html = await page.mainFrame().locator("#container").innerHtml();
+    expect(html).toContain('<p class="para">Hello</p>');
+    expect(html).toContain("<strong>World</strong>");
+  });
+
+  test("Locator.inputValue() reads value from input elements", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <input id="text-input" type="text" value="hello world" />
+            <textarea id="textarea">multi
+line
+text</textarea>
+            <input id="number-input" type="number" value="42" />
+          </body></html>`,
+        ),
+    );
+
+    const textValue = await page
+      .mainFrame()
+      .locator("#text-input")
+      .inputValue();
+    expect(textValue).toBe("hello world");
+
+    const taValue = await page.mainFrame().locator("#textarea").inputValue();
+    expect(taValue).toBe("multi\nline\ntext");
+
+    const numValue = await page
+      .mainFrame()
+      .locator("#number-input")
+      .inputValue();
+    expect(numValue).toBe("42");
+  });
+
+  test("Locator.textContent() on empty elements returns empty string", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <div id="empty"></div>
+            <span id="whitespace">   </span>
+          </body></html>`,
+        ),
+    );
+
+    const empty = await page.mainFrame().locator("#empty").textContent();
+    expect(empty).toBe("");
+
+    const whitespace = await page
+      .mainFrame()
+      .locator("#whitespace")
+      .textContent();
+    expect(whitespace.trim()).toBe("");
+  });
+
+  test("Locator.innerText() with nested elements and formatting", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <div id="formatted">
+              <p>Line 1</p>
+              <p>Line 2</p>
+              <ul>
+                <li>Item 1</li>
+                <li>Item 2</li>
+              </ul>
+            </div>
+          </body></html>`,
+        ),
+    );
+
+    const text = await page.mainFrame().locator("#formatted").innerText();
+    expect(text).toContain("Line 1");
+    expect(text).toContain("Line 2");
+    expect(text).toContain("Item 1");
+    expect(text).toContain("Item 2");
+  });
+
+  test("Locator.inputValue() on contenteditable elements", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <div id="editable" contenteditable="true">Editable content</div>
+          </body></html>`,
+        ),
+    );
+
+    const value = await page.mainFrame().locator("#editable").inputValue();
+    expect(value).toBe("Editable content");
+  });
+
+  test("Locator.innerHtml() preserves attributes and structure", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <div id="complex">
+              <a href="/link" class="link-class">Link</a>
+              <img src="image.png" alt="test" />
+            </div>
+          </body></html>`,
+        ),
+    );
+
+    const html = await page.mainFrame().locator("#complex").innerHtml();
+    expect(html).toContain('href="/link"');
+    expect(html).toContain('class="link-class"');
+    expect(html).toContain('src="image.png"');
+    expect(html).toContain('alt="test"');
+  });
+
+  test("Locator.textContent() vs innerText() with script/style tags", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <div id="mixed">
+              Visible text
+              <script>console.log('script');</script>
+              <style>body { color: red; }</style>
+              More visible
+            </div>
+          </body></html>`,
+        ),
+    );
+
+    const textContent = await page.mainFrame().locator("#mixed").textContent();
+    // textContent includes script content
+    expect(textContent).toContain("Visible text");
+    expect(textContent).toContain("More visible");
+
+    const innerText = await page.mainFrame().locator("#mixed").innerText();
+    // innerText excludes script/style
+    expect(innerText).toContain("Visible text");
+    expect(innerText).toContain("More visible");
+    expect(innerText).not.toContain("console.log");
+  });
+
+  test("Locator.inputValue() returns empty string for non-input elements", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <div id="div">Not an input</div>
+            <input id="empty-input" type="text" value="" />
+          </body></html>`,
+        ),
+    );
+
+    const divValue = await page.mainFrame().locator("#div").inputValue();
+    expect(divValue).toBe("");
+
+    const emptyInput = await page
+      .mainFrame()
+      .locator("#empty-input")
+      .inputValue();
+    expect(emptyInput).toBe("");
+  });
+});
diff --git a/packages/core/tests/integration/locator-count-iframe.spec.ts b/packages/core/tests/integration/locator-count-iframe.spec.ts
new file mode 100644
index 000000000..2f5d2422b
--- /dev/null
+++ b/packages/core/tests/integration/locator-count-iframe.spec.ts
@@ -0,0 +1,160 @@
+import { expect, test } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3DynamicTestConfig } from "./v3.dynamic.config.js";
+import { closeV3 } from "./testUtils.js";
+
+test.describe("Locator count() method with iframes", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3DynamicTestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await closeV3(v3);
+  });
+
+  test("count() does not search inside iframes by default", async () => {
+    const page = v3.context.pages()[0];
+
+    // Create a page with buttons in main frame and iframe
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(`
+        <button>Main Frame Button 1</button>
+        <button>Main Frame Button 2</button>
+        <iframe id="test-iframe" srcdoc="
+          <button>Iframe Button 1</button>
+          <button>Iframe Button 2</button>
+          <button>Iframe Button 3</button>
+        "></iframe>
+      `),
+    );
+
+    // Wait for iframe to load
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // Count buttons in main frame only
+    const mainFrameCount = await page.mainFrame().locator("button").count();
+    expect(mainFrameCount).toBe(2); // Should only find buttons in main frame
+  });
+
+  test("count() works with frameLocator for iframe content", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(`
+        <button>Main Frame Button</button>
+        <iframe id="test-iframe" srcdoc="
+          <button>Iframe Button 1</button>
+          <button>Iframe Button 2</button>
+          <button>Iframe Button 3</button>
+        "></iframe>
+      `),
+    );
+
+    // Wait for iframe to load
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // Count buttons in iframe using frameLocator
+    const iframeLocator = page.frameLocator("#test-iframe");
+    const iframeCount = await iframeLocator.locator("button").count();
+    expect(iframeCount).toBe(3); // Should find 3 buttons in iframe
+  });
+
+  test("count() with nested iframes", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(`
+        <div class="level-0">Main Frame</div>
+        <iframe id="frame1" srcdoc="
+          <div class='level-1'>Frame 1</div>
+          <iframe id='frame2' srcdoc='
+            <div class=&quot;level-2&quot;>Frame 2</div>
+            <div class=&quot;level-2&quot;>Frame 2</div>
+          '></iframe>
+        "></iframe>
+      `),
+    );
+
+    // Wait for all iframes to load
+    await new Promise((resolve) => setTimeout(resolve, 800));
+
+    // Count at each level
+    const mainCount = await page.mainFrame().locator(".level-0").count();
+    expect(mainCount).toBe(1);
+
+    const frame1Count = await page
+      .frameLocator("#frame1")
+      .locator(".level-1")
+      .count();
+    expect(frame1Count).toBe(1);
+
+    const frame2Count = await page
+      .frameLocator("#frame1")
+      .frameLocator("#frame2")
+      .locator(".level-2")
+      .count();
+    expect(frame2Count).toBe(2);
+  });
+
+  test("count() with same selector in multiple contexts", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(`
+        <span class="item">Main 1</span>
+        <span class="item">Main 2</span>
+        <iframe id="frame1" srcdoc="
+          <span class='item'>Frame1 Item</span>
+        "></iframe>
+        <iframe id="frame2" srcdoc="
+          <span class='item'>Frame2 Item 1</span>
+          <span class='item'>Frame2 Item 2</span>
+          <span class='item'>Frame2 Item 3</span>
+        "></iframe>
+      `),
+    );
+
+    // Wait for iframes to load
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // Count in each context
+    const mainCount = await page.mainFrame().locator(".item").count();
+    const frame1Count = await page
+      .frameLocator("#frame1")
+      .locator(".item")
+      .count();
+    const frame2Count = await page
+      .frameLocator("#frame2")
+      .locator(".item")
+      .count();
+
+    expect(mainCount).toBe(2); // Main frame items only
+    expect(frame1Count).toBe(1); // Frame 1 items only
+    expect(frame2Count).toBe(3); // Frame 2 items only
+  });
+
+  test("count() returns 0 for non-existent iframe", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto("data:text/html,<div>No iframes here</div>");
+
+    try {
+      const frameLocator = page.frameLocator("#non-existent");
+      await frameLocator.locator("button").count();
+      // If we get here, the test should fail
+      expect(true).toBe(false);
+    } catch (error) {
+      // Expected behavior - frameLocator should throw when iframe doesn't exist
+      expect(error.message).toContain(
+        "Could not find an element for the given xPath(s):",
+      );
+    }
+  });
+});
diff --git a/packages/core/tests/integration/locator-count.spec.ts b/packages/core/tests/integration/locator-count.spec.ts
new file mode 100644
index 000000000..b619ef4f1
--- /dev/null
+++ b/packages/core/tests/integration/locator-count.spec.ts
@@ -0,0 +1,106 @@
+import { expect, test } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3DynamicTestConfig } from "./v3.dynamic.config.js";
+import { closeV3 } from "./testUtils.js";
+
+test.describe("Locator count() method tests", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3DynamicTestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await closeV3(v3);
+  });
+
+  test("count() returns correct number for CSS selectors", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html,<div class='test'>1</div><div class='test'>2</div><div class='test'>3</div><span>4</span>",
+    );
+
+    const locator = page.mainFrame().locator(".test");
+    const count = await locator.count();
+
+    expect(count).toBe(3);
+  });
+
+  test("count() returns 0 for non-matching selectors", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto("data:text/html,<div>Test</div>");
+
+    const locator = page.mainFrame().locator(".non-existent");
+    const count = await locator.count();
+
+    expect(count).toBe(0);
+  });
+
+  test("count() works with XPath selectors", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html,<button>Button 1</button><button>Button 2</button><button>Button 3</button>",
+    );
+
+    const locator = page.mainFrame().locator("//button");
+    const count = await locator.count();
+
+    expect(count).toBe(3);
+  });
+
+  test("count() works with text selectors", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html,<div>Click me</div><button>Click me</button><span>Don't click me</span>",
+    );
+
+    const locator = page.mainFrame().locator("text=Click me");
+    const count = await locator.count();
+
+    // Case-insensitive substring match: also matches "Don't click me"
+    expect(count).toBe(3);
+  });
+
+  test("count() handles shadow DOM elements", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          '<div id="host"></div>' +
+            "<script>" +
+            'const host = document.getElementById("host");' +
+            'const shadow = host.attachShadow({mode: "open"});' +
+            'shadow.innerHTML = "<button>1</button><button>2</button>";' +
+            "</script>",
+        ),
+      { waitUntil: "load", timeoutMs: 30000 },
+    );
+
+    // Wait a bit for shadow DOM to be attached
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    const locator = page.mainFrame().locator("button");
+    const count = await locator.count();
+
+    expect(count).toBe(2);
+  });
+
+  test("count() works with complex CSS selectors", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html,<div class='container'><span class='item'>1</span><span class='item'>2</span></div><div><span class='item'>3</span></div>",
+    );
+
+    const locator = page.mainFrame().locator(".container .item");
+    const count = await locator.count();
+
+    expect(count).toBe(2);
+  });
+});
diff --git a/packages/core/tests/integration/locator-fill.spec.ts b/packages/core/tests/integration/locator-fill.spec.ts
new file mode 100644
index 000000000..1d02d9ba4
--- /dev/null
+++ b/packages/core/tests/integration/locator-fill.spec.ts
@@ -0,0 +1,147 @@
+import { expect, test } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { StagehandLocatorError } from "../../lib/v3/types/public/sdkErrors.js";
+import { v3TestConfig } from "./v3.config.js";
+
+test.describe("Locator.fill()", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch((e) => {
+      void e;
+    });
+  });
+
+  test("fills date inputs via value setter even when beforeinput blocks insertText", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <input id="date" type="date" />
+            <script>
+              const input = document.getElementById('date');
+              input.addEventListener('beforeinput', (e) => {
+                if (e && e.inputType === 'insertText') e.preventDefault();
+              });
+            </script>
+          </body></html>`,
+        ),
+    );
+
+    const dateInput = page.mainFrame().locator("xpath=/html/body/input");
+    await dateInput.fill("2026-01-01");
+
+    const value = await dateInput.inputValue();
+    expect(value).toBe("2026-01-01");
+  });
+
+  test("xpath case: throws StagehandLocatorError when fill encounters an exception", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <input id="date" type="date" />
+          </body></html>`,
+        ),
+    );
+
+    await page.waitForSelector("xpath=/html/body/input");
+
+    await page.evaluate(() => {
+      const input = document.querySelector("input");
+      Object.defineProperty(input, "isConnected", {
+        get() {
+          throw new Error("boom");
+        },
+      });
+    });
+
+    const dateInput = page.mainFrame().locator("xpath=/html/body/input");
+    let error: unknown;
+    try {
+      await dateInput.fill("2026-01-01");
+    } catch (err) {
+      error = err;
+    }
+
+    expect(error).toBeInstanceOf(StagehandLocatorError);
+    if (error instanceof Error) {
+      // Log the message so it's visible in test output.
+      expect(error.message).toContain("Error Filling Element");
+      expect(error.message).toContain("selector: xpath=/html/body/input");
+      expect(error.message).toContain("boom");
+    }
+  });
+
+  test("css selector case: throws StagehandLocatorError when fill encounters an exception", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <input id="date" type="date" />
+          </body></html>`,
+        ),
+    );
+
+    await page.waitForSelector("#date");
+
+    // Override in main world
+    await page.evaluate(() => {
+      const input = document.querySelector("input");
+      Object.defineProperty(input, "isConnected", {
+        get() {
+          throw new Error("boom");
+        },
+        configurable: true,
+      });
+    });
+
+    // Also override in the isolated world that CSS selectors use
+    const frameId = page.mainFrameId();
+    const { executionContextId } = await page.sendCDP<{
+      executionContextId: number;
+    }>("Page.createIsolatedWorld", {
+      frameId,
+      worldName: "v3-world",
+    });
+
+    await page.sendCDP("Runtime.evaluate", {
+      expression: `(() => {
+        const input = document.querySelector('input');
+        if (input) {
+          Object.defineProperty(input, 'isConnected', {
+            get() { throw new Error("boom"); },
+            configurable: true
+          });
+        }
+      })()`,
+      contextId: executionContextId,
+    });
+
+    const dateInput = page.mainFrame().locator("#date");
+    let error: unknown;
+    try {
+      await dateInput.fill("2026-01-01");
+    } catch (err) {
+      error = err;
+    }
+
+    expect(error).toBeInstanceOf(StagehandLocatorError);
+    if (error instanceof Error) {
+      expect(error.message).toContain("Error Filling Element");
+      expect(error.message).toContain("selector: #date");
+      expect(error.message).toContain("boom");
+    }
+  });
+});
diff --git a/packages/core/tests/integration/locator-input-methods.spec.ts b/packages/core/tests/integration/locator-input-methods.spec.ts
new file mode 100644
index 000000000..5e6753a01
--- /dev/null
+++ b/packages/core/tests/integration/locator-input-methods.spec.ts
@@ -0,0 +1,190 @@
+import { expect, test } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+
+test.describe("Locator input methods (fill, type, hover, isVisible, isChecked)", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch((e) => {
+      void e;
+    });
+  });
+
+  test("Locator.fill() sets input value directly", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <input id="name" type="text" />
+            <div id="out"></div>
+          </body></html>`,
+        ),
+    );
+
+    const input = page.mainFrame().locator("#name");
+    await input.fill("Hello World");
+
+    const value = await input.inputValue();
+    expect(value).toBe("Hello World");
+  });
+
+  test("Locator.type() types text character by character", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <input id="search" type="text" />
+          </body></html>`,
+        ),
+    );
+
+    const input = page.mainFrame().locator("#search");
+    await input.type("test123", { delay: 10 });
+
+    const value = await input.inputValue();
+    expect(value).toBe("test123");
+  });
+
+  test("Locator.hover() moves mouse to element center", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <button id="btn" onmouseover="this.dataset.hovered='true'" onmouseout="this.dataset.hovered='false'">Hover Me</button>
+          </body></html>`,
+        ),
+    );
+
+    const btn = page.mainFrame().locator("#btn");
+    await btn.hover();
+
+    const hovered = await page.mainFrame().evaluate(() => {
+      const b = document.getElementById("btn") as HTMLButtonElement | null;
+      return b?.dataset.hovered === "true";
+    });
+
+    expect(hovered).toBe(true);
+  });
+
+  test("Locator.isVisible() returns true for visible elements", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <div id="visible">I am visible</div>
+            <div id="hidden" style="display:none">I am hidden</div>
+            <div id="invisible" style="visibility:hidden">I am invisible</div>
+            <div id="transparent" style="opacity:0">I am transparent</div>
+            <div id="zero-size" style="width:0;height:0">Zero size</div>
+          </body></html>`,
+        ),
+    );
+
+    const visible = await page.mainFrame().locator("#visible").isVisible();
+    expect(visible).toBe(true);
+
+    const hidden = await page.mainFrame().locator("#hidden").isVisible();
+    expect(hidden).toBe(false);
+
+    const invisible = await page.mainFrame().locator("#invisible").isVisible();
+    expect(invisible).toBe(false);
+
+    const transparent = await page
+      .mainFrame()
+      .locator("#transparent")
+      .isVisible();
+    expect(transparent).toBe(false);
+
+    const zeroSize = await page.mainFrame().locator("#zero-size").isVisible();
+    expect(zeroSize).toBe(false);
+  });
+
+  test("Locator.isChecked() detects checkbox state", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <input id="checked" type="checkbox" checked />
+            <input id="unchecked" type="checkbox" />
+            <input id="radio-selected" type="radio" name="opt" checked />
+            <input id="radio-unselected" type="radio" name="opt" />
+          </body></html>`,
+        ),
+    );
+
+    const checked = await page.mainFrame().locator("#checked").isChecked();
+    expect(checked).toBe(true);
+
+    const unchecked = await page.mainFrame().locator("#unchecked").isChecked();
+    expect(unchecked).toBe(false);
+
+    const radioSelected = await page
+      .mainFrame()
+      .locator("#radio-selected")
+      .isChecked();
+    expect(radioSelected).toBe(true);
+
+    const radioUnselected = await page
+      .mainFrame()
+      .locator("#radio-unselected")
+      .isChecked();
+    expect(radioUnselected).toBe(false);
+  });
+
+  test("Locator.fill() on textarea", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <textarea id="ta"></textarea>
+          </body></html>`,
+        ),
+    );
+
+    const ta = page.mainFrame().locator("#ta");
+    await ta.fill("Multi\nline\ntext");
+
+    const value = await ta.inputValue();
+    expect(value).toBe("Multi\nline\ntext");
+  });
+
+  test("Locator.fill() clears and sets new value", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <input id="inp" type="text" value="initial" />
+          </body></html>`,
+        ),
+    );
+
+    const inp = page.mainFrame().locator("#inp");
+
+    let value = await inp.inputValue();
+    expect(value).toBe("initial");
+
+    await inp.fill("replaced");
+    value = await inp.inputValue();
+    expect(value).toBe("replaced");
+  });
+});
diff --git a/packages/core/tests/integration/locator-nth.spec.ts b/packages/core/tests/integration/locator-nth.spec.ts
new file mode 100644
index 000000000..4898af962
--- /dev/null
+++ b/packages/core/tests/integration/locator-nth.spec.ts
@@ -0,0 +1,254 @@
+import { expect, test } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3DynamicTestConfig } from "./v3.dynamic.config.js";
+import { closeV3 } from "./testUtils.js";
+
+test.describe("Locator nth() method tests", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3DynamicTestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await closeV3(v3);
+  });
+
+  test("nth() returns correct element for CSS selectors", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          '<div class="test" id="first">1</div>' +
+            '<div class="test" id="second">2</div>' +
+            '<div class="test" id="third">3</div>' +
+            '<span id="other">4</span>',
+        ),
+    );
+
+    // Test nth() with CSS selectors
+    const locator0 = page.mainFrame().locator(".test").nth(0);
+    const text0 = await locator0.textContent();
+    expect(text0).toBe("1");
+
+    const locator1 = page.mainFrame().locator(".test").nth(1);
+    const text1 = await locator1.textContent();
+    expect(text1).toBe("2");
+
+    const locator2 = page.mainFrame().locator(".test").nth(2);
+    const text2 = await locator2.textContent();
+    expect(text2).toBe("3");
+  });
+
+  test("nth() returns correct element for XPath selectors", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          '<button id="btn1">Button 1</button>' +
+            '<button id="btn2">Button 2</button>' +
+            '<button id="btn3">Button 3</button>',
+        ),
+    );
+
+    // Test nth() with XPath selectors
+    const locator0 = page.mainFrame().locator("//button").nth(0);
+    const text0 = await locator0.textContent();
+    expect(text0).toBe("Button 1");
+
+    const locator1 = page.mainFrame().locator("//button").nth(1);
+    const text1 = await locator1.textContent();
+    expect(text1).toBe("Button 2");
+
+    const locator2 = page.mainFrame().locator("//button").nth(2);
+    const text2 = await locator2.textContent();
+    expect(text2).toBe("Button 3");
+  });
+
+  test("nth() returns correct element for text selectors", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          '<div id="d1">Click me</div>' +
+            '<button id="b1">Click me</button>' +
+            '<span id="s1">Click me</span>',
+        ),
+    );
+
+    // Test nth() with text selectors
+    const locator0 = page.mainFrame().locator("text=Click me").nth(0);
+    const text0 = await locator0.textContent();
+    expect(text0).toBe("Click me");
+
+    const locator1 = page.mainFrame().locator("text=Click me").nth(1);
+    const text1 = await locator1.textContent();
+    expect(text1).toBe("Click me");
+
+    const locator2 = page.mainFrame().locator("text=Click me").nth(2);
+    const text2 = await locator2.textContent();
+    expect(text2).toBe("Click me");
+  });
+
+  test("nth() with shadow DOM", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          '<div id="host"></div>' +
+            "<script>" +
+            'const host = document.getElementById("host");' +
+            'const shadow = host.attachShadow({mode: "open"});' +
+            'shadow.innerHTML = "<button>Shadow Button 1</button><button>Shadow Button 2</button><button>Shadow Button 3</button>";' +
+            "</script>",
+        ),
+      { waitUntil: "load", timeoutMs: 30000 },
+    );
+
+    // Wait a bit for shadow DOM to be attached
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // Test nth() with shadow DOM elements
+    const locator0 = page.mainFrame().locator("button").nth(0);
+    const text0 = await locator0.textContent();
+    expect(text0).toBe("Shadow Button 1");
+
+    const locator1 = page.mainFrame().locator("button").nth(1);
+    const text1 = await locator1.textContent();
+    expect(text1).toBe("Shadow Button 2");
+
+    const locator2 = page.mainFrame().locator("button").nth(2);
+    const text2 = await locator2.textContent();
+    expect(text2).toBe("Shadow Button 3");
+  });
+
+  test("nth() with out of bounds index throws error", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          '<div class="test">1</div>' + '<div class="test">2</div>',
+        ),
+    );
+
+    // Test with out of bounds index - should throw an error
+    const locator = page.mainFrame().locator(".test").nth(5);
+    let error = null;
+    try {
+      await locator.textContent();
+    } catch (e) {
+      error = e;
+    }
+
+    expect(error).not.toBeNull();
+  });
+
+  test("nth() works with complex CSS selectors", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          '<div class="container">' +
+            '<span class="item">1</span>' +
+            '<span class="item">2</span>' +
+            "</div>" +
+            "<div>" +
+            '<span class="item">3</span>' +
+            "</div>",
+        ),
+    );
+
+    // Test nth() with complex CSS selectors
+    const locator0 = page.mainFrame().locator(".container .item").nth(0);
+    const text0 = await locator0.textContent();
+    expect(text0).toBe("1");
+
+    const locator1 = page.mainFrame().locator(".container .item").nth(1);
+    const text1 = await locator1.textContent();
+    expect(text1).toBe("2");
+  });
+
+  test("nth() can be chained with other locator methods", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          '<div class="test">First</div>' +
+            '<div class="test">Second</div>' +
+            '<div class="test">Third</div>',
+        ),
+    );
+
+    // Test that nth() returns a Locator that can be used for other actions
+    const locator = page.mainFrame().locator(".test").nth(1);
+    const text = await locator.textContent();
+    expect(text).toBe("Second");
+
+    // Verify it's visible
+    const isVisible = await locator.isVisible();
+    expect(isVisible).toBe(true);
+  });
+
+  test("nth(0) is equivalent to first()", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          '<div class="test">First</div>' +
+            '<div class="test">Second</div>' +
+            '<div class="test">Third</div>',
+        ),
+    );
+
+    // Verify nth(0) returns the same element as first()
+    const nthLocator = page.mainFrame().locator(".test").nth(0);
+    const nthText = await nthLocator.textContent();
+
+    const firstLocator = page.mainFrame().locator(".test").first();
+    const firstText = await firstLocator.textContent();
+
+    expect(nthText).toBe(firstText);
+    expect(nthText).toBe("First");
+  });
+
+  test("nth() works correctly with iframe selectors", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          '<button id="main1">Main Button 1</button>' +
+            '<button id="main2">Main Button 2</button>' +
+            '<iframe id="frame1"></iframe>' +
+            "<script>" +
+            'const frame = document.getElementById("frame1");' +
+            "const doc = frame.contentDocument;" +
+            "doc.open();" +
+            'doc.write("<button>Frame Button 1</button><button>Frame Button 2</button>");' +
+            "doc.close();" +
+            "</script>",
+        ),
+    );
+
+    // Wait for iframe to load
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // Test that nth() works correctly with buttons in the main frame
+    const mainLocator0 = page.mainFrame().locator("button").nth(0);
+    const mainText0 = await mainLocator0.textContent();
+    expect(mainText0).toBe("Main Button 1");
+
+    const mainLocator1 = page.mainFrame().locator("button").nth(1);
+    const mainText1 = await mainLocator1.textContent();
+    expect(mainText1).toBe("Main Button 2");
+  });
+});
diff --git a/packages/core/tests/integration/locator-select-option.spec.ts b/packages/core/tests/integration/locator-select-option.spec.ts
new file mode 100644
index 000000000..26eebc404
--- /dev/null
+++ b/packages/core/tests/integration/locator-select-option.spec.ts
@@ -0,0 +1,301 @@
+import { expect, test } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+
+test.describe("Locator.selectOption() method", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch((e) => {
+      void e; // ignore cleanup errors
+    });
+  });
+
+  test("selectOption() selects single option by value", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <select id="fruit">
+              <option value="">-- Choose --</option>
+              <option value="apple">Apple</option>
+              <option value="banana">Banana</option>
+              <option value="cherry">Cherry</option>
+            </select>
+          </body></html>`,
+        ),
+    );
+
+    const select = page.mainFrame().locator("#fruit");
+    const selected = await select.selectOption("banana");
+
+    expect(selected).toEqual(["banana"]);
+
+    const value = await page.mainFrame().evaluate(() => {
+      const s = document.getElementById("fruit") as HTMLSelectElement | null;
+      return s?.value;
+    });
+    expect(value).toBe("banana");
+  });
+
+  test("selectOption() selects option by label/text", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <select id="country">
+              <option value="us">United States</option>
+              <option value="uk">United Kingdom</option>
+              <option value="ca">Canada</option>
+            </select>
+          </body></html>`,
+        ),
+    );
+
+    const select = page.mainFrame().locator("#country");
+    const selected = await select.selectOption("United Kingdom");
+
+    expect(selected).toEqual(["uk"]);
+  });
+
+  test("selectOption() selects multiple options in multiple select", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <select id="colors" multiple>
+              <option value="red">Red</option>
+              <option value="green">Green</option>
+              <option value="blue">Blue</option>
+              <option value="yellow">Yellow</option>
+            </select>
+          </body></html>`,
+        ),
+    );
+
+    const select = page.mainFrame().locator("#colors");
+    const selected = await select.selectOption(["red", "blue"]);
+
+    expect(selected.sort()).toEqual(["blue", "red"]);
+
+    const values = await page.mainFrame().evaluate(() => {
+      const s = document.getElementById("colors") as HTMLSelectElement | null;
+      return Array.from(s?.selectedOptions ?? []).map((o) => o.value);
+    });
+    expect(values.sort()).toEqual(["blue", "red"]);
+  });
+
+  test("selectOption() deselects previous option on single select", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <select id="size">
+              <option value="s">Small</option>
+              <option value="m" selected>Medium</option>
+              <option value="l">Large</option>
+            </select>
+          </body></html>`,
+        ),
+    );
+
+    const select = page.mainFrame().locator("#size");
+
+    let value = await page.mainFrame().evaluate(() => {
+      const s = document.getElementById("size") as HTMLSelectElement | null;
+      return s?.value;
+    });
+    expect(value).toBe("m");
+
+    await select.selectOption("l");
+
+    value = await page.mainFrame().evaluate(() => {
+      const s = document.getElementById("size") as HTMLSelectElement | null;
+      return s?.value;
+    });
+    expect(value).toBe("l");
+  });
+
+  test("selectOption() triggers change event", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <select id="opt">
+              <option value="a">Option A</option>
+              <option value="b">Option B</option>
+            </select>
+            <div id="out"></div>
+            <script>
+              const select = document.getElementById('opt');
+              const out = document.getElementById('out');
+              select.addEventListener('change', () => {
+                out.textContent = 'changed-' + select.value;
+              });
+            </script>
+          </body></html>`,
+        ),
+    );
+
+    const select = page.mainFrame().locator("#opt");
+    await select.selectOption("b");
+
+    const output = await page.mainFrame().evaluate(() => {
+      const out = document.getElementById("out");
+      return out?.textContent;
+    });
+    expect(output).toBe("changed-b");
+  });
+
+  test("selectOption() with optgroup structure", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <select id="grouped">
+              <optgroup label="Fruits">
+                <option value="apple">Apple</option>
+                <option value="orange">Orange</option>
+              </optgroup>
+              <optgroup label="Vegetables">
+                <option value="carrot">Carrot</option>
+                <option value="celery">Celery</option>
+              </optgroup>
+            </select>
+          </body></html>`,
+        ),
+    );
+
+    const select = page.mainFrame().locator("#grouped");
+    await select.selectOption("celery");
+
+    const value = await page.mainFrame().evaluate(() => {
+      const s = document.getElementById("grouped") as HTMLSelectElement | null;
+      return s?.value;
+    });
+    expect(value).toBe("celery");
+  });
+
+  test("selectOption() returns array of selected values", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <select id="multi" multiple>
+              <option value="1">One</option>
+              <option value="2">Two</option>
+              <option value="3">Three</option>
+            </select>
+          </body></html>`,
+        ),
+    );
+
+    const select = page.mainFrame().locator("#multi");
+    const selected = await select.selectOption(["1", "3"]);
+
+    expect(selected).toContain("1");
+    expect(selected).toContain("3");
+    expect(selected.length).toBe(2);
+  });
+
+  test("selectOption() with empty string value", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <select id="opt">
+              <option value="">None</option>
+              <option value="yes">Yes</option>
+              <option value="no">No</option>
+            </select>
+          </body></html>`,
+        ),
+    );
+
+    const select = page.mainFrame().locator("#opt");
+    const selected = await select.selectOption("");
+
+    expect(selected).toEqual([""]);
+
+    const value = await page.mainFrame().evaluate(() => {
+      const s = document.getElementById("opt") as HTMLSelectElement | null;
+      return s?.value;
+    });
+    expect(value).toBe("");
+  });
+
+  test("selectOption() with numeric values", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <select id="nums">
+              <option value="1">One</option>
+              <option value="2">Two</option>
+              <option value="10">Ten</option>
+              <option value="100">Hundred</option>
+            </select>
+          </body></html>`,
+        ),
+    );
+
+    const select = page.mainFrame().locator("#nums");
+    await select.selectOption("10");
+
+    const value = await page.mainFrame().evaluate(() => {
+      const s = document.getElementById("nums") as HTMLSelectElement | null;
+      return s?.value;
+    });
+    expect(value).toBe("10");
+  });
+
+  test("selectOption() with disabled option", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body>
+            <select id="mixed">
+              <option value="a">Available</option>
+              <option value="b" disabled>Unavailable</option>
+              <option value="c">Available</option>
+            </select>
+          </body></html>`,
+        ),
+    );
+
+    const select = page.mainFrame().locator("#mixed");
+    // Should still select disabled option if explicitly requested
+    await select.selectOption("b");
+
+    const value = await page.mainFrame().evaluate(() => {
+      const s = document.getElementById("mixed") as HTMLSelectElement | null;
+      return s?.value;
+    });
+    expect(value).toBe("b");
+  });
+});
diff --git a/packages/core/tests/integration/logger-initialization.spec.ts b/packages/core/tests/integration/logger-initialization.spec.ts
new file mode 100644
index 000000000..a46e08351
--- /dev/null
+++ b/packages/core/tests/integration/logger-initialization.spec.ts
@@ -0,0 +1,687 @@
+import { test, expect } from "@playwright/test";
+import {
+  bindInstanceLogger,
+  unbindInstanceLogger,
+  withInstanceLogContext,
+  v3Logger,
+} from "../../lib/v3/logger.js";
+import type { LogLine } from "../../lib/v3/types/public/logs.js";
+
+test.describe("V3 Logger Instance Routing", () => {
+  test.afterEach(() => {
+    // Clean up is handled by unbindInstanceLogger calls in tests
+  });
+
+  test("bindInstanceLogger routes logs to correct instance", () => {
+    const instanceId = "test-instance-001";
+    const capturedLogs: LogLine[] = [];
+
+    bindInstanceLogger(instanceId, (line) => {
+      capturedLogs.push(line);
+    });
+
+    try {
+      // Log within context
+      withInstanceLogContext(instanceId, () => {
+        v3Logger({
+          category: "test",
+          message: "Test message for instance",
+          level: 1,
+        });
+      });
+
+      // Should have captured the log
+      expect(capturedLogs.length).toBe(1);
+      expect(capturedLogs[0].message).toBe("Test message for instance");
+    } finally {
+      unbindInstanceLogger(instanceId);
+    }
+  });
+
+  test("unbindInstanceLogger stops routing", () => {
+    const instanceId = "test-instance-002";
+    const capturedLogs: LogLine[] = [];
+    const consoleOutput: string[] = [];
+    const originalConsoleLog = console.log;
+
+    try {
+      console.log = (msg: string) => {
+        consoleOutput.push(msg);
+      };
+
+      bindInstanceLogger(instanceId, (line) => {
+        capturedLogs.push(line);
+      });
+
+      // Unbind immediately
+      unbindInstanceLogger(instanceId);
+
+      // Log - should fall back to console
+      withInstanceLogContext(instanceId, () => {
+        v3Logger({
+          category: "test",
+          message: "After unbind",
+          level: 1,
+        });
+      });
+
+      // Should not have captured via instance logger
+      expect(capturedLogs.length).toBe(0);
+      // But should have logged to console
+      expect(consoleOutput.length).toBeGreaterThan(0);
+    } finally {
+      console.log = originalConsoleLog;
+      unbindInstanceLogger(instanceId);
+    }
+  });
+
+  test("multiple instances have isolated log routing", () => {
+    const instance1Id = "test-instance-1";
+    const instance2Id = "test-instance-2";
+    const instance1Logs: LogLine[] = [];
+    const instance2Logs: LogLine[] = [];
+
+    bindInstanceLogger(instance1Id, (line) => instance1Logs.push(line));
+    bindInstanceLogger(instance2Id, (line) => instance2Logs.push(line));
+
+    try {
+      // Log from instance 1
+      withInstanceLogContext(instance1Id, () => {
+        v3Logger({
+          category: "test",
+          message: "From instance 1",
+          level: 1,
+        });
+      });
+
+      // Log from instance 2
+      withInstanceLogContext(instance2Id, () => {
+        v3Logger({
+          category: "test",
+          message: "From instance 2",
+          level: 1,
+        });
+      });
+
+      // Each instance should have only its own log
+      expect(instance1Logs.length).toBe(1);
+      expect(instance2Logs.length).toBe(1);
+      expect(instance1Logs[0].message).toBe("From instance 1");
+      expect(instance2Logs[0].message).toBe("From instance 2");
+    } finally {
+      unbindInstanceLogger(instance1Id);
+      unbindInstanceLogger(instance2Id);
+    }
+  });
+
+  test("v3Logger falls back to console when no instance context", () => {
+    const capturedLogs: string[] = [];
+    const originalConsoleLog = console.log;
+
+    try {
+      console.log = (msg: string) => {
+        capturedLogs.push(msg);
+      };
+
+      // Log without any instance context
+      v3Logger({
+        category: "test",
+        message: "Console fallback log",
+        level: 1,
+      });
+
+      // Should have used console logger
+      expect(capturedLogs.length).toBeGreaterThan(0);
+      const logOutput = capturedLogs.join("\n");
+      expect(logOutput).toContain("Console fallback log");
+    } finally {
+      console.log = originalConsoleLog;
+    }
+  });
+
+  test("v3Logger falls back to console when instance logger throws", () => {
+    const instanceId = "failing-instance";
+    const capturedConsoleLogs: string[] = [];
+    const originalConsoleLog = console.log;
+
+    try {
+      console.log = (msg: string) => {
+        capturedConsoleLogs.push(msg);
+      };
+
+      // Bind a logger that throws
+      bindInstanceLogger(instanceId, () => {
+        throw new Error("Instance logger failed");
+      });
+
+      // Should fall back to console without throwing
+      withInstanceLogContext(instanceId, () => {
+        expect(() => {
+          v3Logger({
+            category: "test",
+            message: "Test with failing instance logger",
+            level: 1,
+          });
+        }).not.toThrow();
+      });
+
+      // Console should have received the log as fallback
+      expect(capturedConsoleLogs.length).toBeGreaterThan(0);
+      const logOutput = capturedConsoleLogs.join("\n");
+      expect(logOutput).toContain("Test with failing instance logger");
+    } finally {
+      console.log = originalConsoleLog;
+      unbindInstanceLogger(instanceId);
+    }
+  });
+
+  test("withInstanceLogContext nests properly", () => {
+    const outerInstanceId = "outer-instance";
+    const innerInstanceId = "inner-instance";
+    const outerLogs: LogLine[] = [];
+    const innerLogs: LogLine[] = [];
+
+    bindInstanceLogger(outerInstanceId, (line) => outerLogs.push(line));
+    bindInstanceLogger(innerInstanceId, (line) => innerLogs.push(line));
+
+    try {
+      withInstanceLogContext(outerInstanceId, () => {
+        v3Logger({
+          category: "test",
+          message: "Outer context",
+          level: 1,
+        });
+
+        withInstanceLogContext(innerInstanceId, () => {
+          v3Logger({
+            category: "test",
+            message: "Inner context",
+            level: 1,
+          });
+        });
+
+        v3Logger({
+          category: "test",
+          message: "Back to outer context",
+          level: 1,
+        });
+      });
+
+      // Outer instance should have 2 logs
+      expect(outerLogs.length).toBe(2);
+      expect(outerLogs[0].message).toBe("Outer context");
+      expect(outerLogs[1].message).toBe("Back to outer context");
+
+      // Inner instance should have 1 log
+      expect(innerLogs.length).toBe(1);
+      expect(innerLogs[0].message).toBe("Inner context");
+    } finally {
+      unbindInstanceLogger(outerInstanceId);
+      unbindInstanceLogger(innerInstanceId);
+    }
+  });
+
+  test("withInstanceLogContext returns function result", () => {
+    const instanceId = "return-test-instance";
+    bindInstanceLogger(instanceId, () => {});
+
+    try {
+      const result = withInstanceLogContext(instanceId, () => {
+        return { success: true, value: 42 };
+      });
+
+      expect(result).toEqual({ success: true, value: 42 });
+    } finally {
+      unbindInstanceLogger(instanceId);
+    }
+  });
+
+  test("withInstanceLogContext works with async functions", async () => {
+    const instanceId = "async-test-instance";
+    const capturedLogs: LogLine[] = [];
+
+    bindInstanceLogger(instanceId, (line) => capturedLogs.push(line));
+
+    try {
+      const asyncResult = await withInstanceLogContext(instanceId, async () => {
+        v3Logger({
+          category: "test",
+          message: "Log from async context",
+          level: 1,
+        });
+
+        await new Promise((resolve) => setTimeout(resolve, 10));
+
+        v3Logger({
+          category: "test",
+          message: "Log after await",
+          level: 1,
+        });
+
+        return "async result";
+      });
+
+      expect(asyncResult).toBe("async result");
+      expect(capturedLogs.length).toBe(2);
+      expect(capturedLogs[0].message).toBe("Log from async context");
+      expect(capturedLogs[1].message).toBe("Log after await");
+    } finally {
+      unbindInstanceLogger(instanceId);
+    }
+  });
+
+  test("console fallback formats different log levels correctly", () => {
+    const consoleOutput: { level: string; msg: string }[] = [];
+    const originalConsoleLog = console.log;
+    const originalConsoleError = console.error;
+    const originalConsoleDebug = console.debug;
+
+    try {
+      console.log = (msg: string) => {
+        consoleOutput.push({ level: "log", msg });
+      };
+      console.error = (msg: string) => {
+        consoleOutput.push({ level: "error", msg });
+      };
+      console.debug = (msg: string) => {
+        consoleOutput.push({ level: "debug", msg });
+      };
+
+      // Test error level (0)
+      v3Logger({
+        category: "test",
+        message: "Error message",
+        level: 0,
+      });
+
+      // Test info level (1)
+      v3Logger({
+        category: "test",
+        message: "Info message",
+        level: 1,
+      });
+
+      // Test debug level (2)
+      v3Logger({
+        category: "test",
+        message: "Debug message",
+        level: 2,
+      });
+
+      expect(consoleOutput.length).toBe(3);
+      expect(consoleOutput[0].level).toBe("error");
+      expect(consoleOutput[0].msg).toContain("ERROR");
+      expect(consoleOutput[0].msg).toContain("Error message");
+
+      expect(consoleOutput[1].level).toBe("log");
+      expect(consoleOutput[1].msg).toContain("INFO");
+      expect(consoleOutput[1].msg).toContain("Info message");
+
+      expect(consoleOutput[2].level).toBe("debug");
+      expect(consoleOutput[2].msg).toContain("DEBUG");
+      expect(consoleOutput[2].msg).toContain("Debug message");
+    } finally {
+      console.log = originalConsoleLog;
+      console.error = originalConsoleError;
+      console.debug = originalConsoleDebug;
+    }
+  });
+
+  test("console fallback formats auxiliary data", () => {
+    const consoleOutput: string[] = [];
+    const originalConsoleLog = console.log;
+
+    try {
+      console.log = (msg: string) => {
+        consoleOutput.push(msg);
+      };
+
+      v3Logger({
+        category: "test",
+        message: "Message with auxiliary",
+        level: 1,
+        auxiliary: {
+          stringValue: { value: "test", type: "string" },
+          integerValue: { value: "42", type: "integer" },
+          objectValue: {
+            value: JSON.stringify({ nested: "data" }),
+            type: "object",
+          },
+        },
+      });
+
+      expect(consoleOutput.length).toBe(1);
+      const output = consoleOutput[0];
+      expect(output).toContain("Message with auxiliary");
+      expect(output).toContain("stringValue");
+      expect(output).toContain("integerValue");
+      expect(output).toContain("objectValue");
+    } finally {
+      console.log = originalConsoleLog;
+    }
+  });
+
+  test("concurrent instances don't interfere", () => {
+    const instances = Array.from({ length: 10 }, (_, i) => `instance-${i}`);
+    const logsByInstance = new Map<string, LogLine[]>();
+
+    // Bind all instances
+    instances.forEach((id) => {
+      const logs: LogLine[] = [];
+      logsByInstance.set(id, logs);
+      bindInstanceLogger(id, (line) => logs.push(line));
+    });
+
+    try {
+      // Log from each instance
+      instances.forEach((id, index) => {
+        withInstanceLogContext(id, () => {
+          v3Logger({
+            category: "test",
+            message: `Message from ${id}`,
+            level: 1,
+            auxiliary: {
+              index: { value: String(index), type: "integer" },
+            },
+          });
+        });
+      });
+
+      // Verify each instance received only its own log
+      instances.forEach((id) => {
+        const logs = logsByInstance.get(id)!;
+        expect(logs.length).toBe(1);
+        expect(logs[0].message).toBe(`Message from ${id}`);
+      });
+    } finally {
+      instances.forEach((id) => unbindInstanceLogger(id));
+    }
+  });
+});
+
+test.describe("V3 Logger with External Logger (Production Pattern)", () => {
+  test.afterEach(() => {
+    // Clean up instance loggers
+  });
+
+  test("external logger receives all logs from v3Logger", () => {
+    const instanceId = "v3-instance-with-external";
+    const externalLogs: LogLine[] = [];
+
+    // Simulate V3 constructor behavior with external logger
+    const externalLogger = (line: LogLine) => {
+      externalLogs.push(line);
+    };
+
+    bindInstanceLogger(instanceId, externalLogger);
+
+    try {
+      withInstanceLogContext(instanceId, () => {
+        v3Logger({
+          category: "a11y/snapshot",
+          message: "Capturing hybrid snapshot",
+          level: 0,
+        });
+
+        v3Logger({
+          category: "handlers/act",
+          message: "Executing action",
+          level: 1,
+          auxiliary: {
+            action: { value: "click", type: "string" },
+          },
+        });
+
+        v3Logger({
+          category: "debug",
+          message: "Debug details",
+          level: 2,
+        });
+      });
+
+      // All logs should be captured by external logger
+      expect(externalLogs.length).toBe(3);
+      expect(externalLogs[0].message).toBe("Capturing hybrid snapshot");
+      expect(externalLogs[1].message).toBe("Executing action");
+      expect(externalLogs[2].message).toBe("Debug details");
+    } finally {
+      unbindInstanceLogger(instanceId);
+    }
+  });
+
+  test("StagehandLogger wrapper forwards to external logger", () => {
+    const instanceId = "v3-with-stagehand-wrapper";
+    const externalLogs: LogLine[] = [];
+
+    // Simulate V3's stagehandLogger.log() wrapping pattern
+    const mockStagehandLogger = {
+      log: (line: LogLine) => {
+        // This simulates StagehandLogger.log() which internally calls externalLogger
+        externalLogs.push(line);
+      },
+    };
+
+    bindInstanceLogger(instanceId, (line) => mockStagehandLogger.log(line));
+
+    try {
+      withInstanceLogContext(instanceId, () => {
+        v3Logger({
+          category: "test",
+          message: "Log through StagehandLogger wrapper",
+          level: 1,
+        });
+      });
+
+      expect(externalLogs.length).toBe(1);
+      expect(externalLogs[0].message).toBe(
+        "Log through StagehandLogger wrapper",
+      );
+    } finally {
+      unbindInstanceLogger(instanceId);
+    }
+  });
+
+  test("multiple V3 instances with different external loggers", () => {
+    const instance1Id = "v3-instance-1";
+    const instance2Id = "v3-instance-2";
+    const external1Logs: LogLine[] = [];
+    const external2Logs: LogLine[] = [];
+
+    // Simulate two V3 instances with different external loggers
+    bindInstanceLogger(instance1Id, (line) => external1Logs.push(line));
+    bindInstanceLogger(instance2Id, (line) => external2Logs.push(line));
+
+    try {
+      // Instance 1 logs
+      withInstanceLogContext(instance1Id, () => {
+        v3Logger({
+          category: "instance1",
+          message: "Instance 1 activity",
+          level: 1,
+        });
+      });
+
+      // Instance 2 logs
+      withInstanceLogContext(instance2Id, () => {
+        v3Logger({
+          category: "instance2",
+          message: "Instance 2 activity",
+          level: 1,
+        });
+      });
+
+      // Each external logger should only have its instance's logs
+      expect(external1Logs.length).toBe(1);
+      expect(external2Logs.length).toBe(1);
+      expect(external1Logs[0].message).toBe("Instance 1 activity");
+      expect(external2Logs[0].message).toBe("Instance 2 activity");
+    } finally {
+      unbindInstanceLogger(instance1Id);
+      unbindInstanceLogger(instance2Id);
+    }
+  });
+
+  test("external logger receives logs with auxiliary data preserved", () => {
+    const instanceId = "v3-with-auxiliary";
+    const externalLogs: LogLine[] = [];
+
+    bindInstanceLogger(instanceId, (line) => externalLogs.push(line));
+
+    try {
+      withInstanceLogContext(instanceId, () => {
+        v3Logger({
+          category: "extract",
+          message: "Extracting data",
+          level: 1,
+          auxiliary: {
+            selector: { value: "xpath=/html/body", type: "string" },
+            timeout: { value: "5000", type: "integer" },
+            retries: { value: "3", type: "integer" },
+            metadata: {
+              value: JSON.stringify({ key: "value" }),
+              type: "object",
+            },
+          },
+        });
+      });
+
+      expect(externalLogs.length).toBe(1);
+      const log = externalLogs[0];
+      expect(log.auxiliary).toBeDefined();
+      expect(log.auxiliary?.selector?.value).toBe("xpath=/html/body");
+      expect(log.auxiliary?.timeout?.value).toBe("5000");
+      expect(log.auxiliary?.retries?.value).toBe("3");
+      expect(log.auxiliary?.metadata?.type).toBe("object");
+    } finally {
+      unbindInstanceLogger(instanceId);
+    }
+  });
+
+  test("external logger handles rapid concurrent logs", () => {
+    const instanceId = "v3-rapid-logs";
+    const externalLogs: LogLine[] = [];
+
+    bindInstanceLogger(instanceId, (line) => externalLogs.push(line));
+
+    try {
+      withInstanceLogContext(instanceId, () => {
+        // Simulate rapid logging like during snapshot capture
+        for (let i = 0; i < 50; i++) {
+          v3Logger({
+            category: "perf",
+            message: `Operation ${i}`,
+            level: 2,
+            auxiliary: {
+              iteration: { value: String(i), type: "integer" },
+            },
+          });
+        }
+      });
+
+      // All logs should be captured
+      expect(externalLogs.length).toBe(50);
+      expect(externalLogs[0].message).toBe("Operation 0");
+      expect(externalLogs[49].message).toBe("Operation 49");
+    } finally {
+      unbindInstanceLogger(instanceId);
+    }
+  });
+
+  test("external logger can filter by log level", () => {
+    const instanceId = "v3-with-filtering";
+    const errorLogs: LogLine[] = [];
+
+    // External logger that only captures errors
+    const filteringLogger = (line: LogLine) => {
+      if (line.level === 0) {
+        errorLogs.push(line);
+      }
+    };
+
+    bindInstanceLogger(instanceId, filteringLogger);
+
+    try {
+      withInstanceLogContext(instanceId, () => {
+        v3Logger({
+          category: "test",
+          message: "Info message",
+          level: 1,
+        });
+
+        v3Logger({
+          category: "test",
+          message: "Error message",
+          level: 0,
+        });
+
+        v3Logger({
+          category: "test",
+          message: "Debug message",
+          level: 2,
+        });
+
+        v3Logger({
+          category: "test",
+          message: "Another error",
+          level: 0,
+        });
+      });
+
+      // Only error logs should be captured
+      expect(errorLogs.length).toBe(2);
+      expect(errorLogs[0].message).toBe("Error message");
+      expect(errorLogs[1].message).toBe("Another error");
+    } finally {
+      unbindInstanceLogger(instanceId);
+    }
+  });
+
+  test("external logger persists across async operations", async () => {
+    const instanceId = "v3-async-ops";
+    const externalLogs: LogLine[] = [];
+
+    bindInstanceLogger(instanceId, (line) => externalLogs.push(line));
+
+    try {
+      await withInstanceLogContext(instanceId, async () => {
+        v3Logger({
+          category: "async",
+          message: "Before async operation",
+          level: 1,
+        });
+
+        await new Promise((resolve) => setTimeout(resolve, 50));
+
+        v3Logger({
+          category: "async",
+          message: "After async operation",
+          level: 1,
+        });
+
+        await Promise.all([
+          Promise.resolve().then(() =>
+            v3Logger({
+              category: "async",
+              message: "Parallel operation 1",
+              level: 1,
+            }),
+          ),
+          Promise.resolve().then(() =>
+            v3Logger({
+              category: "async",
+              message: "Parallel operation 2",
+              level: 1,
+            }),
+          ),
+        ]);
+      });
+
+      // All logs should be captured despite async boundaries
+      expect(externalLogs.length).toBe(4);
+      expect(externalLogs[0].message).toBe("Before async operation");
+      expect(externalLogs[1].message).toBe("After async operation");
+    } finally {
+      unbindInstanceLogger(instanceId);
+    }
+  });
+});
diff --git a/packages/core/tests/integration/multi-instance-logger.spec.ts b/packages/core/tests/integration/multi-instance-logger.spec.ts
new file mode 100644
index 000000000..96a77b9d4
--- /dev/null
+++ b/packages/core/tests/integration/multi-instance-logger.spec.ts
@@ -0,0 +1,365 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { getV3DynamicTestConfig } from "./v3.dynamic.config.js";
+import type { LogLine } from "../../lib/v3/types/public/logs.js";
+import { closeV3 } from "./testUtils.js";
+
+test.describe("V3 Multi-Instance Logger Isolation", () => {
+  // Run tests serially to avoid resource exhaustion from creating many Chrome instances
+  test.describe.configure({ mode: "serial" });
+  // Increase timeout for stress tests that create/destroy multiple instances
+  test.setTimeout(120_000);
+
+  test("multiple V3 instances can be created concurrently without logger conflicts", async () => {
+    const instanceCount = 5;
+    const instances: V3[] = [];
+    const instanceLogs: Map<number, LogLine[]> = new Map();
+
+    try {
+      // Create multiple instances with individual loggers
+      const creationPromises = Array.from({ length: instanceCount }, (_, i) => {
+        const logs: LogLine[] = [];
+        instanceLogs.set(i, logs);
+
+        const config = getV3DynamicTestConfig({
+          verbose: 2,
+          disablePino: true,
+          logger: (line: LogLine) => {
+            logs.push({
+              ...line,
+              auxiliary: {
+                ...line.auxiliary,
+                index: { value: String(i), type: "integer" },
+              },
+            });
+          },
+        });
+
+        const v3 = new V3(config);
+        instances.push(v3);
+        return v3.init();
+      });
+
+      // All instances should initialize successfully
+      await Promise.all(creationPromises);
+
+      // Each instance should be initialized
+      expect(instances.length).toBe(instanceCount);
+      for (const instance of instances) {
+        expect(instance.context).toBeDefined();
+      }
+
+      // Perform operations that generate logs
+      await Promise.all(
+        instances.map(async (instance) => {
+          const page = await instance.context.awaitActivePage();
+          await page.goto("about:blank");
+        }),
+      );
+
+      // Each instance should have logged to its own logger
+      for (let i = 0; i < instanceCount; i++) {
+        const logs = instanceLogs.get(i)!;
+        // Each instance should have some logs
+        expect(logs.length).toBeGreaterThan(0);
+
+        // Logs should not contain data from other instances
+        // (though this is harder to verify without more specific markers)
+        const hasOwnLogs = logs.some(
+          (log) =>
+            log.auxiliary?.index?.value === String(i) ||
+            log.category === "init",
+        );
+        expect(hasOwnLogs).toBe(true);
+      }
+    } finally {
+      // Clean up all instances
+      await Promise.all(instances.map((instance) => closeV3(instance)));
+    }
+  });
+
+  test("V3 instances with external loggers don't leak logs to each other", async () => {
+    const instance1Logs: LogLine[] = [];
+    const instance2Logs: LogLine[] = [];
+
+    const v3Instance1 = new V3(
+      getV3DynamicTestConfig({
+        verbose: 2,
+        disablePino: true,
+        logger: (line: LogLine) => instance1Logs.push(line),
+      }),
+    );
+
+    const v3Instance2 = new V3(
+      getV3DynamicTestConfig({
+        verbose: 2,
+        disablePino: true,
+        logger: (line: LogLine) => instance2Logs.push(line),
+      }),
+    );
+
+    try {
+      // Initialize both instances
+      await Promise.all([v3Instance1.init(), v3Instance2.init()]);
+
+      // Perform operations on each instance
+      const page1 = await v3Instance1.context.awaitActivePage();
+      await page1.goto("about:blank");
+
+      const page2 = await v3Instance2.context.awaitActivePage();
+      await page2.goto("data:text/html,<h1>Instance 2</h1>");
+
+      // Both instances should have logs
+      expect(instance1Logs.length).toBeGreaterThan(0);
+      expect(instance2Logs.length).toBeGreaterThan(0);
+
+      // Logs should be distinct (no exact duplicates)
+      // This is a weak check, but verifies basic isolation
+      const instance1Messages = new Set(instance1Logs.map((l) => l.message));
+      const instance2Messages = new Set(instance2Logs.map((l) => l.message));
+
+      // At least some messages should be unique to each instance
+      // (This might not always be true for very generic messages like "init",
+      // but serves as a smoke test)
+      const allMessages = new Set([...instance1Messages, ...instance2Messages]);
+      expect(allMessages.size).toBeGreaterThanOrEqual(
+        Math.max(instance1Messages.size, instance2Messages.size),
+      );
+    } finally {
+      await Promise.all([closeV3(v3Instance1), closeV3(v3Instance2)]);
+    }
+  });
+
+  test("V3 instances without external loggers use shared global logger", async () => {
+    // Create instances without external loggers
+    const v3Instance1 = new V3(
+      getV3DynamicTestConfig({
+        verbose: 1,
+        disablePino: true,
+      }),
+    );
+
+    const v3Instance2 = new V3(
+      getV3DynamicTestConfig({
+        verbose: 1,
+        disablePino: true,
+      }),
+    );
+
+    try {
+      // Initialize both instances concurrently
+      await Promise.all([v3Instance1.init(), v3Instance2.init()]);
+
+      // Both should work fine
+      expect(v3Instance1.context).toBeDefined();
+      expect(v3Instance2.context).toBeDefined();
+
+      // Perform basic operations to ensure logging doesn't cause issues
+      const page1 = await v3Instance1.context.awaitActivePage();
+      const page2 = await v3Instance2.context.awaitActivePage();
+
+      await Promise.all([page1.goto("about:blank"), page2.goto("about:blank")]);
+
+      // Both should still be operational
+      expect(page1.url()).toContain("about:blank");
+      expect(page2.url()).toContain("about:blank");
+    } finally {
+      await Promise.all([closeV3(v3Instance1), closeV3(v3Instance2)]);
+    }
+  });
+
+  test("rapidly creating and destroying instances doesn't cause logger issues", async () => {
+    const iterations = 5;
+    const results: boolean[] = [];
+
+    for (let i = 0; i < iterations; i++) {
+      const logs: LogLine[] = [];
+      const v3 = new V3(
+        getV3DynamicTestConfig({
+          verbose: 1, // Capture INFO logs for verification
+          disablePino: true,
+          logger: (line: LogLine) => logs.push(line),
+        }),
+      );
+
+      try {
+        await v3.init();
+        const page = await v3.context.awaitActivePage();
+        await page.goto("about:blank");
+        results.push(true);
+
+        // Verify some logs were captured
+        expect(logs.length).toBeGreaterThan(0);
+      } finally {
+        await closeV3(v3);
+      }
+    }
+
+    // All iterations should succeed
+    expect(results.length).toBe(iterations);
+    expect(results.every((r) => r === true)).toBe(true);
+  });
+
+  test("concurrent instance creation with mixed logger configurations", async () => {
+    const instances: V3[] = [];
+    const configs = [
+      // With Pino disabled
+      getV3DynamicTestConfig({ verbose: 1, disablePino: true }),
+      // With external logger
+      getV3DynamicTestConfig({
+        verbose: 2,
+        disablePino: true,
+        //eslint-disable-next-line @typescript-eslint/no-unused-vars
+        logger: (_line: LogLine) => {
+          // External logger
+        },
+      }),
+      // Without external logger
+      getV3DynamicTestConfig({ verbose: 0, disablePino: true }),
+      // High verbosity
+      getV3DynamicTestConfig({ verbose: 2, disablePino: true }),
+    ];
+
+    try {
+      // Create all instances concurrently
+      const creationPromises = configs.map((config) => {
+        const v3 = new V3(config);
+        instances.push(v3);
+        return v3.init();
+      });
+
+      await Promise.all(creationPromises);
+
+      // All should be initialized successfully
+      expect(instances.length).toBe(configs.length);
+      for (const instance of instances) {
+        expect(instance.context).toBeDefined();
+      }
+
+      // All should be able to perform operations
+      await Promise.all(
+        instances.map(async (instance) => {
+          const page = await instance.context.awaitActivePage();
+          await page.goto("about:blank");
+          expect(page.url()).toContain("about:blank");
+        }),
+      );
+    } finally {
+      await Promise.all(instances.map((instance) => closeV3(instance)));
+    }
+  });
+
+  test("V3 instance logger is properly cleaned up on close", async () => {
+    const logs: LogLine[] = [];
+    const v3 = new V3(
+      getV3DynamicTestConfig({
+        verbose: 2,
+        disablePino: true,
+        logger: (line: LogLine) => logs.push(line),
+      }),
+    );
+
+    await v3.init();
+    const initialLogCount = logs.length;
+    expect(initialLogCount).toBeGreaterThan(0);
+
+    await closeV3(v3);
+
+    // After close, the instance should not generate new logs
+    // (This is hard to test directly, but we can verify the instance is closed)
+    expect(v3["state"].kind).toBe("UNINITIALIZED");
+  });
+
+  test("logger works correctly across instance lifecycle", async () => {
+    const logs: LogLine[] = [];
+    const v3 = new V3(
+      getV3DynamicTestConfig({
+        verbose: 2,
+        disablePino: true,
+        logger: (line: LogLine) => logs.push(line),
+      }),
+    );
+
+    try {
+      // Before init
+      expect(logs.length).toBe(0);
+
+      // After init
+      await v3.init();
+      const afterInitCount = logs.length;
+      expect(afterInitCount).toBeGreaterThan(0);
+
+      // During operation
+      const page = await v3.context.awaitActivePage();
+      await page.goto("data:text/html,<h1>Test</h1>");
+      const afterOperationCount = logs.length;
+      expect(afterOperationCount).toBeGreaterThanOrEqual(afterInitCount);
+
+      // Verify log structure
+      const initLogs = logs.filter((log) => log.category === "init");
+      expect(initLogs.length).toBeGreaterThan(0);
+
+      // All logs should have required fields
+      for (const log of logs) {
+        expect(log.category).toBeDefined();
+        expect(log.message).toBeDefined();
+        expect(typeof log.level).toBe("number");
+      }
+    } finally {
+      await closeV3(v3);
+    }
+  });
+
+  test("multiple instances can navigate concurrently without logger interference", async () => {
+    const instanceCount = 3;
+    const instances: V3[] = [];
+    const instanceLogs: Map<number, LogLine[]> = new Map();
+
+    try {
+      // Create instances
+      for (let i = 0; i < instanceCount; i++) {
+        const logs: LogLine[] = [];
+        instanceLogs.set(i, logs);
+
+        const v3 = new V3(
+          getV3DynamicTestConfig({
+            verbose: 1,
+            disablePino: true,
+            logger: (line: LogLine) => logs.push(line),
+          }),
+        );
+
+        instances.push(v3);
+        await v3.init();
+      }
+
+      // Navigate all instances concurrently to different URLs
+      const urls = [
+        "data:text/html,<h1>Page 1</h1>",
+        "data:text/html,<h1>Page 2</h1>",
+        "data:text/html,<h1>Page 3</h1>",
+      ];
+
+      await Promise.all(
+        instances.map(async (instance, i) => {
+          const page = await instance.context.awaitActivePage();
+          await page.goto(urls[i]);
+        }),
+      );
+
+      // Verify each instance navigated to the correct URL
+      for (let i = 0; i < instanceCount; i++) {
+        const page = await instances[i].context.awaitActivePage();
+        expect(page.url()).toContain(`Page ${i + 1}`);
+      }
+
+      // Each instance should have its own logs
+      for (let i = 0; i < instanceCount; i++) {
+        const logs = instanceLogs.get(i)!;
+        expect(logs.length).toBeGreaterThan(0);
+      }
+    } finally {
+      await Promise.all(instances.map((instance) => closeV3(instance)));
+    }
+  });
+});
diff --git a/packages/core/tests/integration/nested-div.spec.ts b/packages/core/tests/integration/nested-div.spec.ts
new file mode 100644
index 000000000..e8f6b9051
--- /dev/null
+++ b/packages/core/tests/integration/nested-div.spec.ts
@@ -0,0 +1,27 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { captureHybridSnapshot } from "../../lib/v3/understudy/a11y/snapshot/index.js";
+import { v3TestConfig } from "./v3.config.js";
+
+test.describe("tests captureHybridSnapshot() does not break due to -32000 Failed to convert response to JSON: CBOR: stack limit exceeded", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test("captureHybridSnapshot does not throw", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/nested-div/",
+    );
+
+    await expect(captureHybridSnapshot(page)).resolves.toBeDefined();
+  });
+});
diff --git a/packages/core/tests/integration/page-addInitScript.spec.ts b/packages/core/tests/integration/page-addInitScript.spec.ts
new file mode 100644
index 000000000..2eb932f81
--- /dev/null
+++ b/packages/core/tests/integration/page-addInitScript.spec.ts
@@ -0,0 +1,110 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+import { V3Context } from "../../lib/v3/understudy/context.js";
+
+const EXAMPLE_URL = "https://example.com";
+
+test.describe("page.addInitScript", () => {
+  let v3: V3;
+  let ctx: V3Context;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+    ctx = v3.context;
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test("runs scripts on real network navigations", async () => {
+    const page = await ctx.awaitActivePage();
+
+    await page.addInitScript(() => {
+      (window as unknown as { __fromPageInit?: string }).__fromPageInit =
+        "page-level";
+    });
+
+    await page.goto(EXAMPLE_URL, { waitUntil: "domcontentloaded" });
+
+    const observed = await page.evaluate(() => {
+      return (window as unknown as { __fromPageInit?: string }).__fromPageInit;
+    });
+
+    expect(observed).toBe("page-level");
+  });
+
+  test("scopes scripts to the page only", async () => {
+    const first = await ctx.awaitActivePage();
+
+    await first.addInitScript(`
+      (function () {
+        function markScope() {
+          var root = document.documentElement;
+          if (!root) return;
+          root.dataset.scopeWitness = "page-one";
+        }
+        if (document.readyState === "loading") {
+          document.addEventListener("DOMContentLoaded", markScope, {
+            once: true,
+          });
+        } else {
+          markScope();
+        }
+      })();
+    `);
+
+    await first.goto(`${EXAMPLE_URL}/?page=one`, {
+      waitUntil: "domcontentloaded",
+    });
+
+    const second = await ctx.newPage();
+    await second.goto(`${EXAMPLE_URL}/?page=two`, {
+      waitUntil: "domcontentloaded",
+    });
+
+    const firstValue = await first.evaluate(() => {
+      return document.documentElement.dataset.scopeWitness ?? "missing";
+    });
+    const secondValue = await second.evaluate(() => {
+      return document.documentElement.dataset.scopeWitness ?? "missing";
+    });
+
+    expect(firstValue).toBe("page-one");
+    expect(secondValue).toBe("missing");
+  });
+
+  test("supports passing arguments to function sources", async () => {
+    const page = await ctx.awaitActivePage();
+    const payload = { greeting: "hi", nested: { count: 1 } };
+
+    const initPayload = ((arg) => {
+      function setPayload() {
+        const root = document.documentElement;
+        if (!root) return;
+        root.dataset.pageInitPayload = JSON.stringify(arg);
+      }
+      if (document.readyState === "loading") {
+        document.addEventListener("DOMContentLoaded", setPayload, {
+          once: true,
+        });
+      } else {
+        setPayload();
+      }
+    }) as (arg: typeof payload) => void;
+    await page.addInitScript(initPayload, payload);
+
+    await page.goto(`${EXAMPLE_URL}/?page=payload`, {
+      waitUntil: "domcontentloaded",
+    });
+
+    const observed = await page.evaluate(() => {
+      const raw = document.documentElement.dataset.pageInitPayload;
+      return raw ? JSON.parse(raw) : undefined;
+    });
+
+    expect(observed).toEqual(payload);
+  });
+});
diff --git a/packages/core/tests/integration/page-console.spec.ts b/packages/core/tests/integration/page-console.spec.ts
new file mode 100644
index 000000000..27ba8e1f4
--- /dev/null
+++ b/packages/core/tests/integration/page-console.spec.ts
@@ -0,0 +1,71 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+
+test.describe("Page console events", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test("captures console messages emitted by the page", async () => {
+    const browserTarget = (
+      process.env.STAGEHAND_BROWSER_TARGET ?? "local"
+    ).toLowerCase();
+    const isBrowserbase = browserTarget === "browserbase";
+    if (isBrowserbase) {
+      console.warn(
+        "[page-console] TODO: re-enable once BB cloud browsers support Runtime.consoleAPICalled events again. See https://browserbase.slack.com/archives/C06U6CM7YS1/p1769483322836589",
+      );
+      test.skip(
+        true,
+        "TODO: re-enable once BB cloud browsers support Runtime.consoleAPICalled events again.",
+      );
+    }
+    const page = v3.context.pages()[0];
+    const received: Array<{ type: string; text: string }> = [];
+
+    page.on("console", (message) => {
+      received.push({ type: message.type(), text: message.text() });
+    });
+
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/iframe-hn/",
+    );
+
+    await page.evaluate(() => {
+      console.log("stagehand console", { ok: true });
+      console.error("stagehand console error");
+    });
+
+    const waitForConsole = async (
+      predicate: () => boolean,
+      timeoutMs = 2000,
+    ) => {
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        if (predicate()) return;
+        await new Promise((resolve) => setTimeout(resolve, 50));
+      }
+    };
+
+    await waitForConsole(
+      () =>
+        received.some((m) => m.type === "log") &&
+        received.some((m) => m.type === "error" && m.text.includes("error")),
+      5000,
+    );
+
+    expect(received.length).toBeGreaterThanOrEqual(2);
+    expect(received.some((m) => m.type === "log")).toBeTruthy();
+    expect(
+      received.some((m) => m.type === "error" && m.text.includes("error")),
+    ).toBeTruthy();
+  });
+});
diff --git a/packages/core/tests/integration/page-drag-and-drop.spec.ts b/packages/core/tests/integration/page-drag-and-drop.spec.ts
new file mode 100644
index 000000000..c84970ded
--- /dev/null
+++ b/packages/core/tests/integration/page-drag-and-drop.spec.ts
@@ -0,0 +1,521 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+
+test.describe("Page.dragAndDrop() - dragging elements", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test("drags and drops element to target zone", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(`
+          <!doctype html>
+          <html>
+          <head>
+            <style>
+              body { font-family: Arial; margin: 0; padding: 20px; }
+              .container { display: flex; gap: 20px; }
+              .source-box {
+                width: 150px;
+                height: 100px;
+                background: lightblue;
+                border: 2px solid blue;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                cursor: move;
+                user-select: none;
+              }
+              .drop-zone {
+                width: 200px;
+                height: 150px;
+                background: lightyellow;
+                border: 2px dashed orange;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+              }
+              .result { margin-top: 20px; font-weight: bold; }
+            </style>
+          </head>
+          <body>
+            <div class="container">
+              <div id="source" class="source-box" draggable="true">Drag Me</div>
+              <div id="dropZone" class="drop-zone">Drop Here</div>
+            </div>
+            <div id="result" class="result">Status: Waiting</div>
+            <script>
+              const source = document.getElementById('source');
+              const dropZone = document.getElementById('dropZone');
+              const result = document.getElementById('result');
+              
+              source.addEventListener('dragstart', (e) => {
+                e.dataTransfer.effectAllowed = 'move';
+                e.dataTransfer.setData('text/plain', 'Dragged Element');
+              });
+              
+              dropZone.addEventListener('dragover', (e) => {
+                e.preventDefault();
+                e.dataTransfer.dropEffect = 'move';
+                dropZone.style.background = 'lightgreen';
+              });
+              
+              dropZone.addEventListener('dragleave', () => {
+                dropZone.style.background = 'lightyellow';
+              });
+              
+              dropZone.addEventListener('drop', (e) => {
+                e.preventDefault();
+                result.textContent = 'Status: DROP SUCCESSFUL';
+                result.style.color = 'green';
+                dropZone.style.background = 'lightgreen';
+              });
+            </script>
+          </body>
+          </html>
+        `),
+    );
+
+    // Get coordinates for drag and drop
+    const sourceLocation = await page
+      .frames()[0]
+      .getLocationForSelector("#source");
+    const dropZoneLocation = await page
+      .frames()[0]
+      .getLocationForSelector("#dropZone");
+
+    const fromX = sourceLocation.x + sourceLocation.width / 2;
+    const fromY = sourceLocation.y + sourceLocation.height / 2;
+    const toX = dropZoneLocation.x + dropZoneLocation.width / 2;
+    const toY = dropZoneLocation.y + dropZoneLocation.height / 2;
+
+    // Perform drag and drop
+    await page.dragAndDrop(fromX, fromY, toX, toY);
+
+    // Wait for events to be processed
+    await page.evaluate(() => new Promise((r) => setTimeout(r, 100)));
+
+    // Verify visual result
+    const resultText = await page.evaluate(
+      () => document.getElementById("result").textContent,
+    );
+    expect(resultText).toContain("DROP SUCCESSFUL");
+  });
+
+  test("drag and drop with steps parameter", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(`
+          <!doctype html>
+          <html>
+          <head>
+            <style>
+              body { margin: 0; padding: 20px; }
+              .box {
+                width: 100px;
+                height: 100px;
+                background: lightblue;
+                margin: 20px;
+                cursor: move;
+              }
+              .target {
+                width: 200px;
+                height: 200px;
+                background: lightyellow;
+                margin: 20px;
+                border: 2px dashed orange;
+              }
+            </style>
+          </head>
+          <body>
+            <div id="box" class="box" draggable="true"></div>
+            <div id="target" class="target"></div>
+            <div id="status">Not dropped</div>
+            <script>
+              document.getElementById('box').addEventListener('dragstart', (e) => {
+                e.dataTransfer.effectAllowed = 'move';
+              });
+              document.getElementById('target').addEventListener('drop', (e) => {
+                e.preventDefault();
+                document.getElementById('status').textContent = 'Dropped with steps';
+              });
+              document.getElementById('target').addEventListener('dragover', (e) => {
+                e.preventDefault();
+              });
+            </script>
+          </body>
+          </html>
+        `),
+    );
+
+    const boxLocation = await page.frames()[0].getLocationForSelector("#box");
+    const targetLocation = await page
+      .frames()[0]
+      .getLocationForSelector("#target");
+
+    const fromX = boxLocation.x + boxLocation.width / 2;
+    const fromY = boxLocation.y + boxLocation.height / 2;
+    const toX = targetLocation.x + targetLocation.width / 2;
+    const toY = targetLocation.y + targetLocation.height / 2;
+
+    // Drag with multiple steps for smoother motion
+    await page.dragAndDrop(fromX, fromY, toX, toY, { steps: 5 });
+
+    // Wait for events to be processed
+    await page.evaluate(() => new Promise((r) => setTimeout(r, 100)));
+
+    const status = await page.evaluate(
+      () => document.getElementById("status").textContent,
+    );
+    expect(status).toContain("Dropped");
+  });
+
+  test("drag and drop with delay between steps", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(`
+          <!doctype html>
+          <html>
+          <head>
+            <style>
+              body { margin: 0; padding: 20px; }
+              #dragItem { width: 80px; height: 80px; background: lightcoral; cursor: move; }
+              #dropArea { width: 150px; height: 150px; background: lightgray; margin-top: 20px; }
+            </style>
+          </head>
+          <body>
+            <div id="dragItem" draggable="true"></div>
+            <div id="dropArea"></div>
+            <div id="complete">false</div>
+            <script>
+              const item = document.getElementById('dragItem');
+              const area = document.getElementById('dropArea');
+              const complete = document.getElementById('complete');
+              
+              item.addEventListener('dragstart', (e) => {
+                e.dataTransfer.effectAllowed = 'move';
+              });
+              
+              area.addEventListener('drop', (e) => {
+                e.preventDefault();
+                complete.textContent = 'true';
+              });
+              
+              area.addEventListener('dragover', (e) => {
+                e.preventDefault();
+              });
+            </script>
+          </body>
+          </html>
+        `),
+    );
+
+    const itemLocation = await page
+      .frames()[0]
+      .getLocationForSelector("#dragItem");
+    const areaLocation = await page
+      .frames()[0]
+      .getLocationForSelector("#dropArea");
+
+    const fromX = itemLocation.x + itemLocation.width / 2;
+    const fromY = itemLocation.y + itemLocation.height / 2;
+    const toX = areaLocation.x + areaLocation.width / 2;
+    const toY = areaLocation.y + areaLocation.height / 2;
+
+    // Drag with delay between steps
+    await page.dragAndDrop(fromX, fromY, toX, toY, { steps: 3, delay: 50 });
+
+    // Wait for events to be processed
+    await page.evaluate(() => new Promise((r) => setTimeout(r, 100)));
+
+    const isComplete = await page.evaluate(
+      () => document.getElementById("complete").textContent === "true",
+    );
+    expect(isComplete).toBe(true);
+  });
+
+  test("drag and drop returns xpath when requested", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(`
+          <!doctype html>
+          <html>
+          <head>
+            <style>
+              body { margin: 20px; }
+              #source { width: 100px; height: 100px; background: blue; cursor: move; }
+              #target { width: 150px; height: 150px; background: green; margin-top: 20px; }
+            </style>
+          </head>
+          <body>
+            <div id="source" draggable="true"></div>
+            <div id="target"></div>
+            <script>
+              document.getElementById('source').addEventListener('dragstart', (e) => {
+                e.dataTransfer.effectAllowed = 'move';
+              });
+              document.getElementById('target').addEventListener('drop', (e) => {
+                e.preventDefault();
+              });
+              document.getElementById('target').addEventListener('dragover', (e) => {
+                e.preventDefault();
+              });
+            </script>
+          </body>
+          </html>
+        `),
+    );
+
+    const sourceLocation = await page
+      .frames()[0]
+      .getLocationForSelector("#source");
+    const targetLocation = await page
+      .frames()[0]
+      .getLocationForSelector("#target");
+
+    const fromX = sourceLocation.x + sourceLocation.width / 2;
+    const fromY = sourceLocation.y + sourceLocation.height / 2;
+    const toX = targetLocation.x + targetLocation.width / 2;
+    const toY = targetLocation.y + targetLocation.height / 2;
+
+    const [fromXpath, toXpath] = await page.dragAndDrop(
+      fromX,
+      fromY,
+      toX,
+      toY,
+      {
+        returnXpath: true,
+      },
+    );
+
+    // Should return xpaths for both start and end positions
+    expect(typeof fromXpath).toBe("string");
+    expect(typeof toXpath).toBe("string");
+    expect(fromXpath.length).toBeGreaterThan(0);
+    expect(toXpath.length).toBeGreaterThan(0);
+  });
+
+  test("drag and drop without returnXpath returns empty strings", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(`
+          <!doctype html>
+          <html>
+          <head>
+            <style>
+              body { margin: 20px; }
+              #item1 { width: 80px; height: 80px; background: red; cursor: move; }
+              #item2 { width: 100px; height: 100px; background: yellow; margin-top: 20px; }
+            </style>
+          </head>
+          <body>
+            <div id="item1" draggable="true"></div>
+            <div id="item2"></div>
+            <script>
+              document.getElementById('item1').addEventListener('dragstart', (e) => {
+                e.dataTransfer.effectAllowed = 'move';
+              });
+              document.getElementById('item2').addEventListener('drop', (e) => {
+                e.preventDefault();
+              });
+              document.getElementById('item2').addEventListener('dragover', (e) => {
+                e.preventDefault();
+              });
+            </script>
+          </body>
+          </html>
+        `),
+    );
+
+    const item1Location = await page
+      .frames()[0]
+      .getLocationForSelector("#item1");
+    const item2Location = await page
+      .frames()[0]
+      .getLocationForSelector("#item2");
+
+    const fromX = item1Location.x + item1Location.width / 2;
+    const fromY = item1Location.y + item1Location.height / 2;
+    const toX = item2Location.x + item2Location.width / 2;
+    const toY = item2Location.y + item2Location.height / 2;
+
+    const [fromXpath, toXpath] = await page.dragAndDrop(fromX, fromY, toX, toY);
+
+    // Should return empty strings when returnXpath is not set
+    expect(fromXpath).toBe("");
+    expect(toXpath).toBe("");
+  });
+
+  test("drag and drop with different mouse buttons", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(`
+          <!doctype html>
+          <html>
+          <head>
+            <style>
+              body { margin: 20px; }
+              .draggable { width: 100px; height: 100px; background: lightblue; cursor: move; }
+              .drop-area { width: 200px; height: 200px; background: lightgray; margin-top: 20px; }
+            </style>
+          </head>
+          <body>
+            <div id="source" class="draggable" draggable="true"></div>
+            <div id="target" class="drop-area"></div>
+            <div id="buttonUsed">none</div>
+            <script>
+              document.getElementById('source').addEventListener('dragstart', (e) => {
+                e.dataTransfer.effectAllowed = 'move';
+              });
+              document.getElementById('target').addEventListener('drop', (e) => {
+                e.preventDefault();
+                document.getElementById('buttonUsed').textContent = 'left';
+              });
+              document.getElementById('target').addEventListener('dragover', (e) => {
+                e.preventDefault();
+              });
+            </script>
+          </body>
+          </html>
+        `),
+    );
+
+    const sourceLocation = await page
+      .frames()[0]
+      .getLocationForSelector("#source");
+    const targetLocation = await page
+      .frames()[0]
+      .getLocationForSelector("#target");
+
+    const fromX = sourceLocation.x + sourceLocation.width / 2;
+    const fromY = sourceLocation.y + sourceLocation.height / 2;
+    const toX = targetLocation.x + targetLocation.width / 2;
+    const toY = targetLocation.y + targetLocation.height / 2;
+
+    // Test with left button (default)
+    await page.dragAndDrop(fromX, fromY, toX, toY, { button: "left" });
+
+    // Wait for events to be processed
+    await page.evaluate(() => new Promise((r) => setTimeout(r, 100)));
+
+    const buttonUsed = await page.evaluate(
+      () => document.getElementById("buttonUsed").textContent,
+    );
+    expect(buttonUsed).toBe("left");
+  });
+
+  test("multiple sequential drag and drops", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(`
+          <!doctype html>
+          <html>
+          <head>
+            <style>
+              body { margin: 20px; font-family: Arial; }
+              .item { width: 80px; height: 80px; background: lightblue; margin: 10px; cursor: move; display: inline-block; }
+              .zone { width: 150px; height: 150px; background: lightyellow; margin: 10px; display: inline-block; border: 2px dashed orange; }
+              #log { margin-top: 20px; }
+            </style>
+          </head>
+          <body>
+            <div id="item1" class="item" draggable="true">Item 1</div>
+            <div id="zone1" class="zone"></div>
+            <div id="item2" class="item" draggable="true">Item 2</div>
+            <div id="zone2" class="zone"></div>
+            <div id="log">Drops: 0</div>
+            <script>
+              let dropCount = 0;
+              const items = ['item1', 'item2'];
+              const zones = ['zone1', 'zone2'];
+              
+              items.forEach(id => {
+                document.getElementById(id).addEventListener('dragstart', (e) => {
+                  e.dataTransfer.effectAllowed = 'move';
+                });
+              });
+              
+              zones.forEach(id => {
+                const zone = document.getElementById(id);
+                zone.addEventListener('drop', (e) => {
+                  e.preventDefault();
+                  dropCount++;
+                  document.getElementById('log').textContent = 'Drops: ' + dropCount;
+                });
+                zone.addEventListener('dragover', (e) => {
+                  e.preventDefault();
+                });
+              });
+            </script>
+          </body>
+          </html>
+        `),
+    );
+
+    const item1Location = await page
+      .frames()[0]
+      .getLocationForSelector("#item1");
+    const zone1Location = await page
+      .frames()[0]
+      .getLocationForSelector("#zone1");
+
+    const from1X = item1Location.x + item1Location.width / 2;
+    const from1Y = item1Location.y + item1Location.height / 2;
+    const to1X = zone1Location.x + zone1Location.width / 2;
+    const to1Y = zone1Location.y + zone1Location.height / 2;
+
+    await page.dragAndDrop(from1X, from1Y, to1X, to1Y);
+
+    await page.evaluate(() => new Promise((r) => setTimeout(r, 100)));
+
+    let dropCountText = await page.evaluate(
+      () => document.getElementById("log").textContent,
+    );
+    expect(dropCountText).toContain("Drops: 1");
+
+    const item2Location = await page
+      .frames()[0]
+      .getLocationForSelector("#item2");
+    const zone2Location = await page
+      .frames()[0]
+      .getLocationForSelector("#zone2");
+
+    const from2X = item2Location.x + item2Location.width / 2;
+    const from2Y = item2Location.y + item2Location.height / 2;
+    const to2X = zone2Location.x + zone2Location.width / 2;
+    const to2Y = zone2Location.y + zone2Location.height / 2;
+
+    await page.dragAndDrop(from2X, from2Y, to2X, to2Y);
+
+    // Wait for events to be processed
+    await page.evaluate(() => new Promise((r) => setTimeout(r, 100)));
+
+    dropCountText = await page.evaluate(
+      () => document.getElementById("log").textContent,
+    );
+    expect(dropCountText).toContain("Drops: 2");
+  });
+});
diff --git a/packages/core/tests/integration/page-extra-http-headers.spec.ts b/packages/core/tests/integration/page-extra-http-headers.spec.ts
new file mode 100644
index 000000000..36bae755c
--- /dev/null
+++ b/packages/core/tests/integration/page-extra-http-headers.spec.ts
@@ -0,0 +1,125 @@
+import { test, expect } from "@playwright/test";
+import type { Protocol } from "devtools-protocol";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+import { closeV3 } from "./testUtils.js";
+
+const TEST_URL =
+  "https://browserbase.github.io/stagehand-eval-sites/sites/example/";
+
+test.describe("page.setExtraHTTPHeaders", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await closeV3(v3);
+  });
+
+  test("applies headers to navigation requests", async () => {
+    const ctx = v3.context;
+    const page = await ctx.awaitActivePage();
+
+    await page.setExtraHTTPHeaders({ "x-page-header": "from-page" });
+
+    const internal = page as unknown as {
+      mainSession: {
+        send: (method: string, params?: unknown) => Promise<unknown>;
+        on: (event: string, handler: (params: unknown) => void) => void;
+        off: (event: string, handler: (params: unknown) => void) => void;
+      };
+    };
+
+    await internal.mainSession.send("Network.enable");
+
+    const requestPromise = new Promise<Protocol.Network.RequestWillBeSentEvent>(
+      (resolve, reject) => {
+        const timeout = setTimeout(() => {
+          internal.mainSession.off("Network.requestWillBeSent", handler);
+          reject(new Error("Timed out waiting for request"));
+        }, 5000);
+
+        const handler = (evt: Protocol.Network.RequestWillBeSentEvent) => {
+          if (evt.type !== "Document") return;
+          const url = String(evt.request?.url ?? "");
+          if (!url.startsWith(TEST_URL)) return;
+          clearTimeout(timeout);
+          internal.mainSession.off("Network.requestWillBeSent", handler);
+          resolve(evt);
+        };
+
+        internal.mainSession.on("Network.requestWillBeSent", handler);
+      },
+    );
+
+    await page.goto(TEST_URL, { waitUntil: "domcontentloaded" });
+
+    const request = await requestPromise;
+    const headers = Object.fromEntries(
+      Object.entries(request.request.headers ?? {}).map(([key, value]) => [
+        key.toLowerCase(),
+        String(value),
+      ]),
+    );
+
+    expect(headers["x-page-header"]).toBe("from-page");
+  });
+
+  test("updated headers replace previous ones", async () => {
+    const ctx = v3.context;
+    const page = await ctx.awaitActivePage();
+
+    const internal = page as unknown as {
+      mainSession: {
+        send: (method: string, params?: unknown) => Promise<unknown>;
+        on: (event: string, handler: (params: unknown) => void) => void;
+        off: (event: string, handler: (params: unknown) => void) => void;
+      };
+    };
+
+    await internal.mainSession.send("Network.enable");
+
+    // Set initial headers and navigate
+    await page.setExtraHTTPHeaders({ "x-first": "yes" });
+    await page.goto(TEST_URL, { waitUntil: "domcontentloaded" });
+
+    // Update headers
+    await page.setExtraHTTPHeaders({ "x-second": "yes" });
+
+    const requestPromise = new Promise<Protocol.Network.RequestWillBeSentEvent>(
+      (resolve, reject) => {
+        const timeout = setTimeout(() => {
+          internal.mainSession.off("Network.requestWillBeSent", handler);
+          reject(new Error("Timed out waiting for request"));
+        }, 5000);
+
+        const handler = (evt: Protocol.Network.RequestWillBeSentEvent) => {
+          if (evt.type !== "Document") return;
+          const url = String(evt.request?.url ?? "");
+          if (!url.startsWith(TEST_URL)) return;
+          clearTimeout(timeout);
+          internal.mainSession.off("Network.requestWillBeSent", handler);
+          resolve(evt);
+        };
+
+        internal.mainSession.on("Network.requestWillBeSent", handler);
+      },
+    );
+
+    await page.goto(TEST_URL, { waitUntil: "domcontentloaded" });
+
+    const request = await requestPromise;
+    const headers = Object.fromEntries(
+      Object.entries(request.request.headers ?? {}).map(([key, value]) => [
+        key.toLowerCase(),
+        String(value),
+      ]),
+    );
+
+    expect(headers["x-second"]).toBe("yes");
+    expect(headers["x-first"]).toBeUndefined();
+  });
+});
diff --git a/packages/core/tests/integration/page-goto-response.spec.ts b/packages/core/tests/integration/page-goto-response.spec.ts
new file mode 100644
index 000000000..b17e2b152
--- /dev/null
+++ b/packages/core/tests/integration/page-goto-response.spec.ts
@@ -0,0 +1,45 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+
+test.describe("Page.goto() response surface", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test("returns a response object for network navigations", async () => {
+    const page = v3.context.pages()[0];
+
+    const response = await page.goto("https://example.com");
+
+    expect(response).not.toBeNull();
+    expect(response!.status()).toBe(200);
+    expect(response!.ok()).toBeTruthy();
+
+    const headers = await response.headersArray();
+    expect(headers.length).toBeGreaterThan(0);
+
+    const body = await response.text();
+    expect(body).toContain("Example Domain");
+
+    const finished = await response.finished();
+    expect(finished).toBeNull();
+  });
+
+  test("falls back to null for data URLs", async () => {
+    const page = v3.context.pages()[0];
+
+    const response = await page.goto(
+      "data:text/html,<html><body data-testid='fallback'>inline</body></html>",
+    );
+
+    expect(response).toBeNull();
+  });
+});
diff --git a/packages/core/tests/integration/page-hover.spec.ts b/packages/core/tests/integration/page-hover.spec.ts
new file mode 100644
index 000000000..b6098c4ec
--- /dev/null
+++ b/packages/core/tests/integration/page-hover.spec.ts
@@ -0,0 +1,220 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+
+test.describe("Page.hover() - mouse hover at coordinates", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test("hover triggers mouseover event at coordinates", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body style="margin: 0; padding: 0;">
+            <div id="target" 
+                 style="position: absolute; top: 100px; left: 100px; width: 200px; height: 200px; background: lightblue;"
+                 onmouseover="this.dataset.hovered='true'"
+                 onmouseout="this.dataset.hovered='false'">
+              Hover Me
+            </div>
+          </body></html>`,
+        ),
+    );
+
+    // Check initial state
+    let hovered = await page.evaluate(() => {
+      const el = document.getElementById("target");
+      return el?.dataset.hovered === "true";
+    });
+    expect(hovered).toBe(false);
+
+    // Hover at coordinates within the target element (200, 200 is center of the div)
+    await page.hover(200, 200);
+
+    // Verify mouseover was triggered
+    hovered = await page.evaluate(() => {
+      const el = document.getElementById("target");
+      return el?.dataset.hovered === "true";
+    });
+    expect(hovered).toBe(true);
+  });
+
+  test("hover moves mouse without clicking", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body style="margin: 0; padding: 0;">
+            <button id="btn" 
+                    style="position: absolute; top: 100px; left: 100px; width: 200px; height: 100px;"
+                    onclick="this.dataset.clicked='true'"
+                    onmouseover="this.dataset.hovered='true'">
+              Click Me
+            </button>
+          </body></html>`,
+        ),
+    );
+
+    // Hover over the button
+    await page.hover(200, 150);
+
+    // Check that hover happened but click did not
+    const state = await page.evaluate(() => {
+      const btn = document.getElementById("btn");
+      return {
+        hovered: btn?.dataset.hovered === "true",
+        clicked: btn?.dataset.clicked === "true",
+      };
+    });
+
+    expect(state.hovered).toBe(true);
+    expect(state.clicked).toBe(false);
+  });
+
+  test("hover returns xpath when requested", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body style="margin: 0; padding: 0;">
+            <div id="target" style="position: absolute; top: 0px; left: 400px; width: 300px; height: 100px; background: blue;">
+              Target element
+            </div>
+            <p style="position: absolute; top: 200px; left: 0px;">Content below</p>
+          </body></html>`,
+        ),
+    );
+
+    // Hover at coordinate (550, 50) which should be directly over the target div
+    const xpath = await page.hover(550, 50, { returnXpath: true });
+
+    // Should return a non-empty xpath string for the element at that coordinate
+    expect(typeof xpath).toBe("string");
+    expect(xpath.length).toBeGreaterThan(0);
+    // Xpath should reference the div
+    expect(xpath.toLowerCase()).toMatch(/div|target/);
+  });
+
+  test("hover without returnXpath returns empty string", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body style="margin: 0; padding: 0;">
+            <div style="width: 100px; height: 100px; background: lightblue;">Content</div>
+          </body></html>`,
+        ),
+    );
+
+    // Hover without returnXpath
+    const result = await page.hover(50, 50);
+
+    // Should return empty string
+    expect(result).toBe("");
+  });
+
+  test("hover triggers CSS :hover styles", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html>
+          <head>
+            <style>
+              #hoverable {
+                position: absolute;
+                top: 100px;
+                left: 100px;
+                width: 200px;
+                height: 200px;
+                background: red;
+              }
+              #hoverable:hover {
+                background: green;
+              }
+            </style>
+          </head>
+          <body style="margin: 0; padding: 0;">
+            <div id="hoverable">Hover to change color</div>
+          </body></html>`,
+        ),
+    );
+
+    // Get initial background color
+    let bgColor = await page.evaluate(() => {
+      const el = document.getElementById("hoverable");
+      return getComputedStyle(el!).backgroundColor;
+    });
+    expect(bgColor).toBe("rgb(255, 0, 0)"); // red
+
+    // Hover over the element
+    await page.hover(200, 200);
+
+    // Check that CSS :hover state is applied
+    bgColor = await page.evaluate(() => {
+      const el = document.getElementById("hoverable");
+      return getComputedStyle(el!).backgroundColor;
+    });
+    expect(bgColor).toBe("rgb(0, 128, 0)"); // green
+  });
+
+  test("multiple hovers move the mouse correctly", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body style="margin: 0; padding: 0;">
+            <div id="box1" 
+                 style="position: absolute; top: 0; left: 0; width: 100px; height: 100px; background: red;"
+                 onmouseover="this.dataset.hovered='true'"
+                 onmouseout="this.dataset.hovered='false'">
+              Box 1
+            </div>
+            <div id="box2" 
+                 style="position: absolute; top: 0; left: 200px; width: 100px; height: 100px; background: blue;"
+                 onmouseover="this.dataset.hovered='true'"
+                 onmouseout="this.dataset.hovered='false'">
+              Box 2
+            </div>
+          </body></html>`,
+        ),
+    );
+
+    // Hover over box1
+    await page.hover(50, 50);
+
+    let state = await page.evaluate(() => ({
+      box1: document.getElementById("box1")?.dataset.hovered === "true",
+      box2: document.getElementById("box2")?.dataset.hovered === "true",
+    }));
+
+    expect(state.box1).toBe(true);
+    expect(state.box2).toBe(false);
+
+    // Move hover to box2
+    await page.hover(250, 50);
+
+    state = await page.evaluate(() => ({
+      box1: document.getElementById("box1")?.dataset.hovered === "true",
+      box2: document.getElementById("box2")?.dataset.hovered === "true",
+    }));
+
+    expect(state.box1).toBe(false);
+    expect(state.box2).toBe(true);
+  });
+});
diff --git a/packages/core/tests/integration/page-screenshot.spec.ts b/packages/core/tests/integration/page-screenshot.spec.ts
new file mode 100644
index 000000000..b6a70fa28
--- /dev/null
+++ b/packages/core/tests/integration/page-screenshot.spec.ts
@@ -0,0 +1,348 @@
+import { test, expect } from "@playwright/test";
+import { promises as fs } from "fs";
+import * as os from "os";
+import * as path from "path";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+import { Frame } from "../../lib/v3/understudy/frame.js";
+
+const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+test.describe("Page.screenshot options", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test("rejects clip combined with fullPage", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto("data:text/html,<html><body>test</body></html>");
+
+    await expect(
+      page.screenshot({
+        fullPage: true,
+        clip: { x: 0, y: 0, width: 100, height: 100 },
+      }),
+    ).rejects.toThrow(/clip and fullPage/);
+  });
+
+  test("rejects unsupported image type", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto("data:text/html,<html><body>noop</body></html>");
+
+    await expect(
+      page.screenshot({
+        // @ts-expect-error intentional invalid type for runtime validation
+        type: "webp",
+      }),
+    ).rejects.toThrow(/unsupported image type/);
+  });
+
+  test("rejects jpeg quality for png screenshots", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto("data:text/html,<html><body>noop</body></html>");
+
+    await expect(page.screenshot({ type: "png", quality: 50 })).rejects.toThrow(
+      /quality option is only valid/,
+    );
+  });
+
+  test("honours timeout option", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto("data:text/html,<html><body>noop</body></html>");
+
+    const mainFrame = page.mainFrame();
+    const originalScreenshot = mainFrame.screenshot.bind(mainFrame);
+
+    (
+      mainFrame as typeof mainFrame & {
+        screenshot: typeof mainFrame.screenshot;
+      }
+    ).screenshot = async () => {
+      await wait(50);
+      return Buffer.from("late");
+    };
+
+    try {
+      await expect(page.screenshot({ timeout: 10 })).rejects.toThrow(
+        /timed out|timeout/i,
+      );
+    } finally {
+      (
+        mainFrame as typeof mainFrame & {
+          screenshot: typeof mainFrame.screenshot;
+        }
+      ).screenshot = originalScreenshot;
+    }
+  });
+
+  test("applies advanced options and cleans up overlays", async () => {
+    const page = v3.context.pages()[0];
+    const screenshotTimeout = process.env.CI ? 15000 : 5000;
+    const testStart = Date.now();
+    console.log(
+      `[screenshot-test] start ${new Date(testStart).toISOString()} timeout=${screenshotTimeout}`,
+    );
+
+    const html = `
+      <!doctype html>
+      <html>
+        <head>
+          <meta charset="utf-8" />
+          <style>
+            body { background: #aaccee; margin: 0; height: 100vh; display: flex; flex-direction: column; align-items: flex-start; }
+            .mask-target { width: 80px; height: 80px; margin: 40px; background: rgb(0, 180, 60); animation: pulse 1s infinite alternate; }
+            @keyframes pulse { from { transform: scale(1); } to { transform: scale(1.2); } }
+          </style>
+        </head>
+        <body>
+          <div class="mask-target"></div>
+          <div class="mask-target"></div>
+          <input id="focus-me" value="focus" />
+          <script>document.getElementById('focus-me').focus();</script>
+        </body>
+      </html>
+    `;
+
+    await page.goto("data:text/html," + encodeURIComponent(html));
+    console.log(`[screenshot-test] page loaded in ${Date.now() - testStart}ms`);
+
+    const maskLocator = page.locator(".mask-target");
+    const tempPath = path.join(
+      os.tmpdir(),
+      `stagehand-screenshot-${Date.now()}-${Math.random().toString(36).slice(2)}.jpeg`,
+    );
+    console.log(`[screenshot-test] tempPath=${tempPath}`);
+
+    const targetId = page.targetId();
+    const screenshotCalls: Array<{
+      frameId: string;
+      options: Parameters<Frame["screenshot"]>[0];
+    }> = [];
+    const evaluateCalls: Array<{ frameId: string; arg: unknown }> = [];
+    const originalScreenshot = Frame.prototype.screenshot;
+    const originalEvaluate = Frame.prototype.evaluate;
+
+    // Hook Frame.screenshot so we can assert which options reach CDP without writing real data.
+    Frame.prototype.screenshot = async function screenshotSpy(options) {
+      const frame = this as Frame;
+      if (frame.pageId === targetId) {
+        screenshotCalls.push({ frameId: frame.frameId, options });
+        return Buffer.from("stub-image");
+      }
+      return originalScreenshot.call(this, options);
+    };
+
+    // Spy on Frame.evaluate to capture the arguments used to inject CSS/masks.
+    Frame.prototype.evaluate = async function evaluateSpy(expression, arg?) {
+      const frame = this as Frame;
+      if (frame.pageId === targetId) {
+        evaluateCalls.push({ frameId: frame.frameId, arg });
+      }
+      return originalEvaluate.call(this, expression as never, arg);
+    } as Frame["evaluate"];
+
+    const internalPage = page as unknown as {
+      mainSession: {
+        send: (method: string, params?: unknown) => Promise<unknown>;
+      };
+    };
+    const sendCalls: Array<{ method: string; params: unknown }> = [];
+    const originalSend = internalPage.mainSession.send.bind(
+      internalPage.mainSession,
+    ) as (method: string, params?: unknown) => Promise<unknown>;
+    // Capture background overrides so we can confirm omitBackground toggles on/off.
+    internalPage.mainSession.send = async (
+      method: string,
+      params?: unknown,
+    ) => {
+      sendCalls.push({ method, params });
+      return originalSend(method, params);
+    };
+
+    try {
+      const maskCount = await maskLocator.count();
+      console.log(`[screenshot-test] maskLocator.count=${maskCount}`);
+
+      const buffer = await page.screenshot({
+        animations: "disabled",
+        caret: "hide",
+        clip: { x: 0, y: 0, width: 200, height: 200 },
+        mask: [maskLocator],
+        maskColor: "rgba(255, 0, 0, 0.4)",
+        omitBackground: true,
+        path: tempPath,
+        quality: 80,
+        scale: "css",
+        style: "body { border: 3px solid black; }",
+        timeout: screenshotTimeout,
+        type: "jpeg",
+      });
+      console.log(
+        `[screenshot-test] screenshot returned bytes=${buffer.length} elapsed=${Date.now() - testStart}ms`,
+      );
+
+      expect(Buffer.isBuffer(buffer)).toBeTruthy();
+      expect(screenshotCalls.length).toBeGreaterThanOrEqual(1);
+      console.log(
+        `[screenshot-test] screenshotCalls=${screenshotCalls.length} evaluateCalls=${evaluateCalls.length} sendCalls=${sendCalls.length}`,
+      );
+      const recorded = screenshotCalls[0]?.options ?? {};
+      expect(recorded).toMatchObject({ type: "jpeg", quality: 80 });
+      expect(recorded?.clip).toMatchObject({
+        x: 0,
+        y: 0,
+        width: 200,
+        height: 200,
+      });
+      if (typeof recorded?.scale === "number") {
+        expect(recorded.scale).toBeGreaterThan(0);
+        expect(recorded.scale).toBeLessThanOrEqual(2);
+      }
+
+      await fs.stat(tempPath);
+
+      const maskNodes = await page.evaluate(
+        () => document.querySelectorAll("[data-stagehand-mask]").length,
+      );
+      expect(maskNodes).toBe(0);
+
+      const styleNodes = await page.evaluate(
+        () => document.querySelectorAll("[data-stagehand-style]").length,
+      );
+      expect(styleNodes).toBe(0);
+
+      const backgroundCalls = sendCalls.filter(
+        (call) => call.method === "Emulation.setDefaultBackgroundColorOverride",
+      );
+      expect(backgroundCalls.length).toBeGreaterThan(1);
+      expect(
+        backgroundCalls.some(
+          (call) =>
+            call.params &&
+            typeof call.params === "object" &&
+            "color" in (call.params as Record<string, unknown>),
+        ),
+      ).toBeTruthy();
+      expect(
+        backgroundCalls.some(
+          (call) =>
+            !call.params ||
+            Object.keys(call.params as Record<string, unknown>).length === 0,
+        ),
+      ).toBeTruthy();
+
+      const cssArgs = evaluateCalls
+        .map((entry) => {
+          const value = entry.arg as { css?: string } | undefined;
+          return value?.css ?? null;
+        })
+        .filter((css): css is string => typeof css === "string");
+
+      const tokens = evaluateCalls
+        .map((entry) => {
+          const arg = entry.arg as { token?: string } | undefined;
+          return arg?.token ?? null;
+        })
+        .filter((token): token is string => typeof token === "string");
+
+      // Tokens include which helper injected the style (animations/caret/custom).
+      expect(tokens.some((token) => token.includes("animations"))).toBeTruthy();
+      expect(tokens.some((token) => token.includes("caret"))).toBeTruthy();
+      expect(tokens.some((token) => token.includes("custom"))).toBeTruthy();
+      // Custom style should bubble through so we check the actual CSS text.
+      expect(
+        cssArgs.some((css) => css.includes("border: 3px solid black")),
+      ).toBeTruthy();
+
+      const maskCalls = evaluateCalls.filter((entry) => {
+        const arg = entry.arg;
+        return (
+          arg &&
+          typeof arg === "object" &&
+          "rects" in (arg as Record<string, unknown>)
+        );
+      });
+      expect(maskCalls.length).toBeGreaterThan(0);
+      const rects = (maskCalls[0]?.arg as { rects?: unknown } | undefined)
+        ?.rects;
+      expect(Array.isArray(rects)).toBeTruthy();
+      expect((rects as unknown[]).length).toBe(2);
+    } finally {
+      Frame.prototype.screenshot = originalScreenshot;
+      Frame.prototype.evaluate = originalEvaluate;
+      internalPage.mainSession.send = originalSend;
+      await fs.unlink(tempPath).catch(() => {});
+    }
+  });
+
+  test("masks elements inside dialog top layer", async () => {
+    const page = v3.context.pages()[0];
+
+    const html = `
+      <!doctype html>
+      <html>
+        <head>
+          <meta charset="utf-8" />
+          <style>
+            dialog { padding: 16px; border: 2px solid #444; }
+            #dialog-input { display: block; width: 160px; height: 32px; }
+          </style>
+        </head>
+        <body>
+          <dialog id="dialog">
+            <label>Secret <input id="dialog-input" value="top-layer" /></label>
+          </dialog>
+          <script>
+            const dialog = document.getElementById("dialog");
+            if (dialog) {
+              if (typeof dialog.showModal === "function") {
+                try {
+                  dialog.showModal();
+                } catch {
+                  dialog.setAttribute("open", "");
+                }
+              } else {
+                dialog.setAttribute("open", "");
+              }
+            }
+          </script>
+        </body>
+      </html>
+    `;
+
+    await page.goto("data:text/html," + encodeURIComponent(html));
+
+    const targetId = page.targetId();
+    const originalScreenshot = Frame.prototype.screenshot;
+    let dialogMaskCount = 0;
+
+    Frame.prototype.screenshot = async function screenshotSpy(options) {
+      const frame = this as Frame;
+      if (frame.pageId === targetId) {
+        dialogMaskCount = await frame.evaluate(() => {
+          const dialog = document.querySelector("dialog[open]");
+          if (!dialog) return 0;
+          return dialog.querySelectorAll("[data-stagehand-mask]").length;
+        });
+        return Buffer.from("stub-image");
+      }
+      return originalScreenshot.call(this, options);
+    };
+
+    try {
+      await page.screenshot({
+        mask: [page.locator("#dialog-input")],
+      });
+      expect(dialogMaskCount).toBeGreaterThan(0);
+    } finally {
+      Frame.prototype.screenshot = originalScreenshot;
+    }
+  });
+});
diff --git a/packages/core/tests/integration/page-scroll.spec.ts b/packages/core/tests/integration/page-scroll.spec.ts
new file mode 100644
index 000000000..a63cf9a0e
--- /dev/null
+++ b/packages/core/tests/integration/page-scroll.spec.ts
@@ -0,0 +1,268 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+
+test.describe("Page.scroll() - mouse wheel scrolling", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test("scrolls page vertically with positive deltaY", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body style="height: 2000px;">
+            <div style="height: 400px; background: lightblue;">Section 1</div>
+            <div style="height: 400px; background: lightgreen;">Section 2</div>
+            <div style="height: 400px; background: lightyellow;">Section 3</div>
+            <div style="height: 400px; background: lightcoral;">Section 4</div>
+            <div style="height: 400px; background: lightgray;">Section 5</div>
+          </body></html>`,
+        ),
+    );
+
+    // Get initial scroll position
+    let scrollY = await page.evaluate(() => window.scrollY);
+    expect(scrollY).toBe(0);
+
+    // Scroll down (positive deltaY)
+    await page.scroll(640, 400, 0, 300);
+
+    // Wait for scroll to complete
+    await page.evaluate(() => new Promise((r) => setTimeout(r, 200)));
+
+    // Check that we've scrolled down
+    scrollY = await page.evaluate(() => window.scrollY);
+    expect(scrollY).toBeGreaterThan(0);
+  });
+
+  test("scrolls page horizontally with positive deltaX", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body style="width: 2000px; height: 600px;">
+            <div style="display: inline-block; width: 400px; height: 100%; background: lightblue;">Section 1</div>
+            <div style="display: inline-block; width: 400px; height: 100%; background: lightgreen;">Section 2</div>
+            <div style="display: inline-block; width: 400px; height: 100%; background: lightyellow;">Section 3</div>
+            <div style="display: inline-block; width: 400px; height: 100%; background: lightcoral;">Section 4</div>
+            <div style="display: inline-block; width: 400px; height: 100%; background: lightgray;">Section 5</div>
+          </body></html>`,
+        ),
+    );
+
+    let scrollX = await page.evaluate(() => window.scrollX);
+    expect(scrollX).toBe(0);
+
+    // Scroll right (positive deltaX)
+    await page.scroll(640, 400, 300, 0);
+
+    // Wait for scroll to complete
+    await page.evaluate(() => new Promise((r) => setTimeout(r, 200)));
+
+    // Check that we've scrolled right
+    scrollX = await page.evaluate(() => window.scrollX);
+    expect(scrollX).toBeGreaterThan(0);
+  });
+
+  test("scrolls in both directions simultaneously", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body style="width: 2000px; height: 2000px;">
+            <div style="width: 100%; height: 100%; background: linear-gradient(135deg, lightblue, lightcoral);">
+              Diagonal content
+            </div>
+          </body></html>`,
+        ),
+    );
+
+    // Scroll both horizontally and vertically
+    await page.scroll(640, 400, 200, 200);
+
+    // Wait for scroll to complete
+    await page.evaluate(() => new Promise((r) => setTimeout(r, 200)));
+
+    // Check both directions changed
+    const scrollPos = await page.evaluate(() => ({
+      x: window.scrollX,
+      y: window.scrollY,
+    }));
+
+    expect(scrollPos.x).toBeGreaterThan(0);
+    expect(scrollPos.y).toBeGreaterThan(0);
+  });
+
+  test("scrolls at specific coordinate on page", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body style="height: 2000px;">
+            <div id="marker" style="position: fixed; top: 400px; left: 640px; width: 2px; height: 2px; background: red;"></div>
+            <div style="height: 500px; background: lightblue;">Top</div>
+            <div style="height: 500px; background: lightgreen;">Middle</div>
+            <div style="height: 500px; background: lightyellow;">Bottom</div>
+          </body></html>`,
+        ),
+    );
+
+    // Scroll from specific coordinates
+    await page.scroll(640, 400, 0, 400);
+
+    // Wait for scroll to complete
+    await page.evaluate(() => new Promise((r) => setTimeout(r, 200)));
+
+    // Verify scroll happened
+    const scrollY = await page.evaluate(() => window.scrollY);
+    expect(scrollY).toBeGreaterThan(0);
+  });
+
+  test("scrolls with large deltaY values", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body style="height: 5000px;">
+            <div style="height: 1000px; background: lightblue;">Section 1</div>
+            <div style="height: 1000px; background: lightgreen;">Section 2</div>
+            <div style="height: 1000px; background: lightyellow;">Section 3</div>
+            <div style="height: 1000px; background: lightcoral;">Section 4</div>
+            <div style="height: 1000px; background: lightgray;">Section 5</div>
+          </body></html>`,
+        ),
+    );
+
+    // Scroll with large delta
+    await page.scroll(640, 400, 0, 1000);
+
+    // Wait for scroll to complete
+    await page.evaluate(() => new Promise((r) => setTimeout(r, 200)));
+
+    // Should scroll significantly
+    const scrollY = await page.evaluate(() => window.scrollY);
+    expect(scrollY).toBeGreaterThan(500);
+  });
+
+  test("negative deltaY scrolls up", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body style="height: 2000px;">
+            <div style="height: 500px; background: lightblue;">Top</div>
+            <div style="height: 500px; background: lightgreen;">Middle 1</div>
+            <div style="height: 500px; background: lightyellow;">Middle 2</div>
+            <div style="height: 500px; background: lightcoral;">Bottom</div>
+          </body></html>`,
+        ),
+    );
+
+    // First scroll down
+    await page.scroll(640, 400, 0, 500);
+    await page.evaluate(() => new Promise((r) => setTimeout(r, 200)));
+
+    let scrollY = await page.evaluate(() => window.scrollY);
+    const scrolledDown = scrollY;
+    expect(scrolledDown).toBeGreaterThan(0);
+
+    // Now scroll up (negative delta)
+    await page.scroll(640, 400, 0, -300);
+    await page.evaluate(() => new Promise((r) => setTimeout(r, 200)));
+
+    scrollY = await page.evaluate(() => window.scrollY);
+    expect(scrollY).toBeLessThan(scrolledDown);
+  });
+
+  test("scroll returns xpath when requested", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body style="height: 2000px; margin: 0; padding: 0;">
+            <div id="target" style="position: absolute; top: 0px; left: 400px; width: 300px; height: 100px; background: blue;">
+              Target element
+            </div>
+            <p style="position: absolute; top: 200px; left: 0px;">Content below</p>
+          </body></html>`,
+        ),
+    );
+
+    // Scroll at coordinate (550, 50) which should be directly over the target div
+    // div spans: left 400-700px, top 0-100px
+    // coordinate 550,50 is within that range
+    const xpath = await page.scroll(550, 50, 0, 200, { returnXpath: true });
+
+    // Should return a non-empty xpath string for the element at that coordinate
+    expect(typeof xpath).toBe("string");
+    expect(xpath.length).toBeGreaterThan(0);
+    // Xpath should reference the div or contain "target"
+    expect(xpath.toLowerCase()).toMatch(/div|target/);
+  });
+
+  test("scroll without returnXpath returns empty string", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body style="height: 2000px;">
+            <div style="height: 500px; background: lightblue;">Content</div>
+          </body></html>`,
+        ),
+    );
+
+    // Scroll without returnXpath
+    const result = await page.scroll(640, 400, 0, 200);
+
+    // Should return empty string
+    expect(result).toBe("");
+  });
+
+  test("multiple sequential scrolls accumulate", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          `<!doctype html><html><body style="height: 3000px;">
+            <div style="height: 750px; background: lightblue;">Section 1</div>
+            <div style="height: 750px; background: lightgreen;">Section 2</div>
+            <div style="height: 750px; background: lightyellow;">Section 3</div>
+            <div style="height: 750px; background: lightcoral;">Section 4</div>
+          </body></html>`,
+        ),
+    );
+
+    // First scroll
+    await page.scroll(640, 400, 0, 200);
+    await page.evaluate(() => new Promise((r) => setTimeout(r, 200)));
+
+    const after1 = await page.evaluate(() => window.scrollY);
+    expect(after1).toBeGreaterThan(0);
+
+    // Second scroll
+    await page.scroll(640, 400, 0, 200);
+    await page.evaluate(() => new Promise((r) => setTimeout(r, 200)));
+
+    const after2 = await page.evaluate(() => window.scrollY);
+
+    expect(after2).toBeGreaterThan(after1);
+  });
+});
diff --git a/packages/core/tests/integration/page-send-cdp.spec.ts b/packages/core/tests/integration/page-send-cdp.spec.ts
new file mode 100644
index 000000000..c1ddfb26d
--- /dev/null
+++ b/packages/core/tests/integration/page-send-cdp.spec.ts
@@ -0,0 +1,57 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+
+test.describe("Page sendCDP method", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+  });
+
+  test("sends CDP commands and requires domain to be enabled first", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto("https://example.com");
+
+    // Try to add a virtual authenticator without enabling WebAuthn first
+    // This should fail because the domain needs to be enabled
+    await expect(
+      page.sendCDP("WebAuthn.addVirtualAuthenticator", {
+        options: {
+          protocol: "ctap2",
+          transport: "usb",
+          hasResidentKey: false,
+          hasUserVerification: false,
+          isUserVerified: false,
+        },
+      }),
+    ).rejects.toThrow();
+
+    // Enable the WebAuthn domain
+    await page.sendCDP("WebAuthn.enable");
+
+    // Now adding a virtual authenticator should succeed
+    const result = await page.sendCDP<{ authenticatorId: string }>(
+      "WebAuthn.addVirtualAuthenticator",
+      {
+        options: {
+          protocol: "ctap2",
+          transport: "usb",
+          hasResidentKey: false,
+          hasUserVerification: false,
+          isUserVerified: false,
+        },
+      },
+    );
+
+    // Verify we got an authenticator ID back
+    expect(result).toHaveProperty("authenticatorId");
+    expect(typeof result.authenticatorId).toBe("string");
+    expect(result.authenticatorId.length).toBeGreaterThan(0);
+  });
+});
diff --git a/packages/core/tests/integration/perform-understudy-method.spec.ts b/packages/core/tests/integration/perform-understudy-method.spec.ts
new file mode 100644
index 000000000..4e8ae2ef4
--- /dev/null
+++ b/packages/core/tests/integration/perform-understudy-method.spec.ts
@@ -0,0 +1,121 @@
+import { expect, test } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3DynamicTestConfig } from "./v3.dynamic.config.js";
+import { performUnderstudyMethod } from "../../lib/v3/handlers/handlerUtils/actHandlerUtils.js";
+import { closeV3 } from "./testUtils.js";
+
+test.describe("tests performUnderstudyMethod", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3DynamicTestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await closeV3(v3);
+  });
+
+  test("tests that clicking works", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/no-js-click/",
+    );
+
+    await performUnderstudyMethod(
+      page,
+      page.mainFrame(),
+      "click",
+      "/html/body/button",
+      [],
+      30000,
+    );
+
+    const isVisible = await page.locator("#success-msg").isVisible();
+    expect(isVisible).toBe(true);
+  });
+
+  test("fill sets input value", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/login/",
+    );
+
+    await performUnderstudyMethod(
+      page,
+      page.mainFrame(),
+      "fill",
+      "/html/body/main/form/div[1]/input",
+      ["Alice"],
+      30000,
+    );
+
+    const textContent = await page
+      .locator("/html/body/main/form/div[1]/input")
+      .inputValue();
+    expect(textContent).toBe("Alice");
+  });
+
+  test("tests that key presses work", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/key-press/",
+    );
+
+    await performUnderstudyMethod(
+      page,
+      page.mainFrame(),
+      "press",
+      "xpath=/html",
+      ["Enter"],
+      30000,
+    );
+
+    const textContent = await page
+      .locator("/html/body/div/div/h1")
+      .textContent();
+    expect(textContent).toContain("Enter");
+  });
+
+  test("tests select option from a dropdown", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/nested-dropdown/",
+    );
+
+    await performUnderstudyMethod(
+      page,
+      page.mainFrame(),
+      "selectOptionFromDropdown",
+      "xpath=//*[@id='licenseType']",
+      ["Smog Check Technician"],
+      30000,
+    );
+
+    const inputValue = await page
+      .locator("#licenseType >> option:checked")
+      .textContent();
+    expect(inputValue).toBe("Smog Check Technician");
+  });
+
+  test("tests drag & drop works (start xpath & end xpath)", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/drag-drop/",
+    );
+
+    await performUnderstudyMethod(
+      page,
+      page.mainFrame(),
+      "dragAndDrop",
+      "xpath=/html/body/div/section[1]/div[1]/div[1]", // start xpath
+      ["/html/body/div/section[2]/div/div[1]"], // end xpath
+      30000,
+    );
+
+    const droppedContent = await page
+      .locator("/html/body/div/section[2]/div/div[1]/div")
+      .textContent();
+    expect(droppedContent).toBe("TEXT: Hello from text");
+  });
+});
diff --git a/packages/core/tests/integration/setinputfiles.spec.ts b/packages/core/tests/integration/setinputfiles.spec.ts
new file mode 100644
index 000000000..53c863b21
--- /dev/null
+++ b/packages/core/tests/integration/setinputfiles.spec.ts
@@ -0,0 +1,165 @@
+import { expect, test } from "@playwright/test";
+import { Buffer } from "buffer";
+import { promises as fs } from "fs";
+import path from "path";
+import crypto from "crypto";
+import type { Page as V3Page } from "../../lib/v3/understudy/page.js";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+
+const FILE_UPLOAD_IFRAME_URL =
+  "https://browserbase.github.io/stagehand-eval-sites/sites/file-uploads-iframe/";
+const FILE_UPLOAD_V2_URL =
+  "https://browserbase.github.io/stagehand-eval-sites/sites/file-uploads-2/";
+
+const RESUME_INPUT = "#resumeUpload";
+const RESUME_SUCCESS = "#resumeSuccess";
+const IMAGES_INPUT = "#imagesUpload";
+const IMAGES_SUCCESS = "#imagesSuccess";
+const AUDIO_INPUT = "#audioUpload";
+const AUDIO_SUCCESS = "#audioSuccess";
+const IFRAME_UPLOAD_INPUT = "/html/body/div/iframe/html/body/div/div[1]/input";
+const IFRAME_SUCCESS =
+  "body > div > iframe >> html > body > div > div:nth-of-type(2)";
+
+test.describe("tests setInputFiles()", () => {
+  let v3: V3;
+  const fixtures: string[] = [];
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3TestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+    await Promise.all(
+      fixtures.splice(0).map((file) => fs.unlink(file).catch(() => {})),
+    );
+  });
+
+  const createFixture = async (
+    namePrefix: string,
+    contents: string,
+    ext = ".txt",
+  ): Promise<string> => {
+    const normalizedExt = ext.startsWith(".") ? ext : `.${ext}`;
+    const filename = `${namePrefix}-${crypto.randomBytes(4).toString("hex")}${normalizedExt}`;
+    const filePath = path.resolve(process.cwd(), filename);
+    await fs.writeFile(filePath, contents, "utf-8");
+    fixtures.push(filePath);
+    return filePath;
+  };
+
+  const expectUploadSuccess = async (
+    page: V3Page,
+    successSelector: string,
+    expectedText: string,
+  ) => {
+    await expect
+      .poll(
+        () =>
+          page.evaluate((selector) => {
+            const el = document.querySelector(selector);
+            if (!el) return "";
+            const display = window.getComputedStyle(el).display;
+            if (display === "none") return "";
+            return el.textContent ?? "";
+          }, successSelector),
+        { message: `wait for success message at ${successSelector}` },
+      )
+      .toContain(expectedText);
+  };
+
+  const getInputFileCount = async (page: V3Page, inputSelector: string) => {
+    return await page.evaluate((selector) => {
+      const el = document.querySelector(selector);
+      if (!(el instanceof HTMLInputElement)) return 0;
+      return el.files?.length ?? 0;
+    }, inputSelector);
+  };
+
+  const expectFileCount = async (
+    page: V3Page,
+    inputSelector: string,
+    expected: number,
+  ) => {
+    await expect
+      .poll(() => getInputFileCount(page, inputSelector), {
+        message: `wait for file count on ${inputSelector}`,
+      })
+      .toBe(expected);
+  };
+
+  test("deepLocator uploads and validates within iframe", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto(FILE_UPLOAD_IFRAME_URL);
+    const fixture = await createFixture(
+      "iframe-upload",
+      "<p>iframe upload</p>",
+      ".txt",
+    );
+    await page
+      .deepLocator(IFRAME_UPLOAD_INPUT)
+      .setInputFiles(path.relative(process.cwd(), fixture));
+
+    const successLocator = page.deepLocator(IFRAME_SUCCESS);
+    await expect
+      .poll(async () => (await successLocator.textContent()) ?? "", {
+        message: "wait for iframe upload success",
+      })
+      .toContain("file uploaded successfully");
+  });
+
+  test("locator uploads resume via relative path string", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto(FILE_UPLOAD_V2_URL);
+    const fixture = await createFixture("resume", "<p>resume</p>", ".pdf");
+    await page
+      .locator(RESUME_INPUT)
+      .setInputFiles(path.relative(process.cwd(), fixture));
+    await expectUploadSuccess(page, RESUME_SUCCESS, "Resume uploaded!");
+    await expectFileCount(page, RESUME_INPUT, 1);
+  });
+
+  test("locator uploads multiple images via absolute paths", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto(FILE_UPLOAD_V2_URL);
+    const first = await createFixture("image-a", "<p>A</p>", ".png");
+    const second = await createFixture("image-b", "<p>B</p>", ".jpeg");
+    await page.locator(IMAGES_INPUT).setInputFiles([first, second]);
+    await expectUploadSuccess(page, IMAGES_SUCCESS, "Images uploaded!");
+    await expectFileCount(page, IMAGES_INPUT, 2);
+  });
+
+  test("locator uploads audio via payload object", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto(FILE_UPLOAD_V2_URL);
+    await page.locator(AUDIO_INPUT).setInputFiles({
+      name: "voice-sample.mp3",
+      mimeType: "audio/mpeg",
+      buffer: Buffer.from("fake audio bytes", "utf-8"),
+    });
+    await expectUploadSuccess(page, AUDIO_SUCCESS, "Audio file uploaded!");
+    await expectFileCount(page, AUDIO_INPUT, 1);
+  });
+
+  test("locator uploads multiple payload objects to images input", async () => {
+    const page = v3.context.pages()[0];
+    await page.goto(FILE_UPLOAD_V2_URL);
+    await page.locator(IMAGES_INPUT).setInputFiles([
+      {
+        name: "payload-a.png",
+        mimeType: "image/png",
+        buffer: Buffer.from("payload-a", "utf-8"),
+      },
+      {
+        name: "payload-b.png",
+        mimeType: "image/png",
+        buffer: Buffer.from("payload-b", "utf-8"),
+      },
+    ]);
+    await expectUploadSuccess(page, IMAGES_SUCCESS, "Images uploaded!");
+    await expectFileCount(page, IMAGES_INPUT, 2);
+  });
+});
diff --git a/packages/core/tests/integration/shadow-iframe-oopif.spec.ts b/packages/core/tests/integration/shadow-iframe-oopif.spec.ts
new file mode 100644
index 000000000..10b794675
--- /dev/null
+++ b/packages/core/tests/integration/shadow-iframe-oopif.spec.ts
@@ -0,0 +1,186 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import puppeteer from "puppeteer-core";
+import { chromium as playwrightChromium } from "playwright-core";
+import { chromium as patchrightChromium } from "patchright-core";
+import { Action } from "../../lib/v3/types/public/methods.js";
+import { AnyPage } from "../../lib/v3/types/public/page.js";
+import { v3DynamicTestConfig } from "./v3.dynamic.config.js";
+import { closeV3 } from "./testUtils.js";
+
+/**
+ * IMPORTANT:
+ * - We create a single V3 instance/test to avoid cross-test state. Increase parallelism later if needed.
+ * - We assert an *effect* when feasible (e.g. input value). For pure clicks we assert no thrown error.
+ */
+
+type Case = {
+  title: string;
+  url: string;
+  action: Action;
+  expectedSubstrings: string[]; // check v3.extract().pageText contains these
+};
+
+type Framework = "v3" | "puppeteer" | "playwright" | "patchright";
+
+async function runCase(v3: V3, c: Case, framework: Framework): Promise<void> {
+  let cleanup: (() => Promise<void> | void) | null = null;
+
+  // Acquire the correct page for the requested framework
+  let page: AnyPage | undefined;
+  switch (framework) {
+    case "v3": {
+      const v3Page = v3.context.pages()[0];
+      await v3Page.goto(c.url, { waitUntil: "networkidle" });
+      page = v3Page;
+      break;
+    }
+    case "puppeteer": {
+      const browser = await puppeteer.connect({
+        browserWSEndpoint: v3.connectURL(),
+        defaultViewport: null,
+      });
+      const pages = await browser.pages();
+      const puppeteerPage = pages[0];
+      await puppeteerPage.goto(c.url, { waitUntil: "networkidle0" });
+      page = puppeteerPage;
+      cleanup = async () => {
+        try {
+          await browser.close();
+        } catch {
+          //
+        }
+      };
+      break;
+    }
+    case "playwright": {
+      const pwBrowser = await playwrightChromium.connectOverCDP(
+        v3.connectURL(),
+      );
+      const pwContext = pwBrowser.contexts()[0];
+      const pwPage = pwContext.pages()[0];
+      await pwPage.goto(c.url, { waitUntil: "networkidle" as never });
+      page = pwPage as unknown as AnyPage;
+      cleanup = async () => {
+        try {
+          await pwBrowser.close();
+        } catch {
+          // ignore
+        }
+      };
+      break;
+    }
+    case "patchright": {
+      const prBrowser = await patchrightChromium.connectOverCDP(
+        v3.connectURL(),
+      );
+      const prContext = prBrowser.contexts()[0];
+      const prPage = prContext.pages()[0];
+      await prPage.goto(c.url, { waitUntil: "networkidle" as never });
+      page = prPage as unknown as AnyPage;
+      cleanup = async () => {
+        try {
+          await prBrowser.close();
+        } catch {
+          // ignore
+        }
+      };
+      break;
+    }
+  }
+
+  try {
+    if (!page) throw new Error("Missing page for selected framework");
+    await v3.act(c.action, { page });
+    // Post-action extraction; verify expected text appears
+    const extraction = await v3.extract({ page });
+    const text = extraction.pageText ?? "";
+    for (const s of c.expectedSubstrings) {
+      expect(
+        text.includes(s),
+        `expected pageText to include substring: ${s}`,
+      ).toBeTruthy();
+    }
+  } finally {
+    await cleanup?.();
+  }
+}
+
+const cases: Case[] = [
+  {
+    title: "Closed shadow root inside OOPIF",
+    url: "https://browserbase.github.io/stagehand-eval-sites/sites/closed-shadow-root-in-oopif/",
+    action: {
+      selector:
+        "xpath=/html/body/main/section/iframe/html/body/shadow-demo//div/button",
+      method: "click",
+      arguments: [""],
+      description: "click button inside closed shadow root in OOPIF",
+    },
+    expectedSubstrings: ["button successfully clicked"],
+  },
+  {
+    title: "Open shadow root inside OOPIF",
+    url: "https://browserbase.github.io/stagehand-eval-sites/sites/open-shadow-root-in-oopif/",
+    action: {
+      selector:
+        "xpath=/html/body/main/section/iframe/html/body/shadow-demo//div/button",
+      method: "click",
+      arguments: [""],
+      description: "",
+    },
+    expectedSubstrings: ["button successfully clicked"],
+  },
+  {
+    title: "OOPIF inside open shadow root",
+    url: "https://browserbase.github.io/stagehand-eval-sites/sites/oopif-in-open-shadow-dom/",
+    action: {
+      selector:
+        "xpath=/html/body/shadow-host//section/iframe/html/body/main/section[1]/form/div/div[1]/input",
+      method: "fill",
+      arguments: ["nunya"],
+      description: "",
+    },
+    expectedSubstrings: ["nunya"],
+  },
+  {
+    title: "OOPIF inside closed shadow root",
+    url: "https://browserbase.github.io/stagehand-eval-sites/sites/oopif-in-closed-shadow-dom/",
+    action: {
+      selector:
+        "xpath=/html/body/shadow-host//section/iframe/html/body/main/section[1]/form/div/div[1]/input",
+      method: "fill",
+      arguments: ["nunya"],
+      description: "fill input inside OOPIF",
+    },
+    expectedSubstrings: ["nunya"],
+  },
+];
+
+test.describe
+  .parallel("Stagehand v3: shadow <-> iframe OOPIF scenarios", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3DynamicTestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await closeV3(v3);
+  });
+
+  const frameworks: Framework[] = [
+    "v3",
+    "playwright",
+    "puppeteer",
+    "patchright",
+  ];
+  for (const fw of frameworks) {
+    for (const c of cases) {
+      test(`[${fw}] ${c.title}`, async () => {
+        await runCase(v3, c, fw);
+      });
+    }
+  }
+});
diff --git a/packages/core/tests/integration/shadow-iframe-spif.spec.ts b/packages/core/tests/integration/shadow-iframe-spif.spec.ts
new file mode 100644
index 000000000..07d328ee3
--- /dev/null
+++ b/packages/core/tests/integration/shadow-iframe-spif.spec.ts
@@ -0,0 +1,182 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import puppeteer from "puppeteer-core";
+import { chromium as playwrightChromium } from "playwright-core";
+import { chromium as patchrightChromium } from "patchright-core";
+import { Action } from "../../lib/v3/types/public/methods.js";
+import { AnyPage } from "../../lib/v3/types/public/page.js";
+import { v3DynamicTestConfig } from "./v3.dynamic.config.js";
+import { closeV3 } from "./testUtils.js";
+
+/**
+ * IMPORTANT:
+ * - We create a single V3 instance/test to avoid cross-test state. Increase parallelism later if needed.
+ * - We assert an *effect* when feasible (e.g. input value). For pure clicks we assert no thrown error.
+ */
+
+type Case = {
+  title: string;
+  url: string;
+  action: Action;
+  expectedSubstrings: string[]; // check v3.extract().pageText contains these
+};
+
+type Framework = "v3" | "puppeteer" | "playwright" | "patchright";
+
+async function runCase(v3: V3, c: Case, framework: Framework): Promise<void> {
+  let cleanup: (() => Promise<void> | void) | null = null;
+
+  // Acquire the correct page for the requested framework
+  let page: AnyPage | undefined;
+  switch (framework) {
+    case "v3": {
+      const v3Page = v3.context.pages()[0];
+      await v3Page.goto(c.url, { waitUntil: "networkidle" });
+      page = v3Page;
+      break;
+    }
+    case "puppeteer": {
+      const browser = await puppeteer.connect({
+        browserWSEndpoint: v3.connectURL(),
+        defaultViewport: null,
+      });
+      const pages = await browser.pages();
+      const puppeteerPage = pages[0];
+      await puppeteerPage.goto(c.url, { waitUntil: "networkidle0" });
+      page = puppeteerPage;
+      cleanup = async () => {
+        try {
+          await browser.close();
+        } catch {
+          //
+        }
+      };
+      break;
+    }
+    case "playwright": {
+      const pwBrowser = await playwrightChromium.connectOverCDP(
+        v3.connectURL(),
+      );
+      const pwContext = pwBrowser.contexts()[0];
+      const pwPage = pwContext.pages()[0];
+      await pwPage.goto(c.url, { waitUntil: "networkidle" as never });
+      page = pwPage as unknown as AnyPage;
+      cleanup = async () => {
+        try {
+          await pwBrowser.close();
+        } catch {
+          // ignore
+        }
+      };
+      break;
+    }
+    case "patchright": {
+      const prBrowser = await patchrightChromium.connectOverCDP(
+        v3.connectURL(),
+      );
+      const prContext = prBrowser.contexts()[0];
+      const prPage = prContext.pages()[0];
+      await prPage.goto(c.url, { waitUntil: "networkidle" as never });
+      page = prPage as unknown as AnyPage;
+      cleanup = async () => {
+        try {
+          await prBrowser.close();
+        } catch {
+          // ignore
+        }
+      };
+      break;
+    }
+  }
+
+  try {
+    if (!page) throw new Error("Missing page for selected framework");
+    await v3.act(c.action, { page });
+    // Post-action extraction; verify expected text appears
+    const extraction = await v3.extract({ page });
+    const text = extraction.pageText ?? "";
+    for (const s of c.expectedSubstrings) {
+      expect(
+        text.includes(s),
+        `expected pageText to include substring: ${s}`,
+      ).toBeTruthy();
+    }
+  } finally {
+    await cleanup?.();
+  }
+}
+
+const cases: Case[] = [
+  {
+    title: "Open shadow root inside SPIF",
+    url: "https://browserbase.github.io/stagehand-eval-sites/sites/open-shadow-root-in-spif/",
+    action: {
+      selector:
+        "xpath=/html/body/main/section/iframe/html/body/shadow-demo//div/button",
+      method: "click",
+      arguments: [""],
+      description: "",
+    },
+    expectedSubstrings: ["button successfully clicked"],
+  },
+  {
+    title: "Closed shadow root inside SPIF",
+    url: "https://browserbase.github.io/stagehand-eval-sites/sites/closed-shadow-dom-in-spif/",
+    action: {
+      selector: "xpath=/html/body/div/iframe/html/body/shadow-demo//div/button",
+      method: "click",
+      arguments: [""],
+      description: "",
+    },
+    expectedSubstrings: ["button successfully clicked"],
+  },
+  {
+    title: "SPIF inside closed shadow root",
+    url: "https://browserbase.github.io/stagehand-eval-sites/sites/spif-in-closed-shadow-dom/",
+    action: {
+      selector: "xpath=/html/body/shadow-host//div/iframe/html/body/button",
+      method: "click",
+      arguments: [""],
+      description: "",
+    },
+    expectedSubstrings: ["button successfully clicked"],
+  },
+  {
+    title: "SPIF inside open shadow root",
+    url: "https://browserbase.github.io/stagehand-eval-sites/sites/spif-in-open-shadow-dom/",
+    action: {
+      selector: "xpath=/html/body/shadow-host//div/iframe/html/body/button",
+      method: "click",
+      arguments: [""],
+      description: "click button inside SPIF under open shadow",
+    },
+    expectedSubstrings: ["button successfully clicked"],
+  },
+];
+
+test.describe.parallel("Stagehand v3: shadow <-> iframe SPIF scenarios", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3DynamicTestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await closeV3(v3);
+  });
+
+  const frameworks: Framework[] = [
+    "v3",
+    "playwright",
+    "puppeteer",
+    "patchright",
+  ];
+  for (const fw of frameworks) {
+    for (const c of cases) {
+      test(`[${fw}] ${c.title}`, async () => {
+        await runCase(v3, c, fw);
+      });
+    }
+  }
+});
diff --git a/packages/core/tests/integration/testUtils.ts b/packages/core/tests/integration/testUtils.ts
new file mode 100644
index 000000000..0724f96ca
--- /dev/null
+++ b/packages/core/tests/integration/testUtils.ts
@@ -0,0 +1,50 @@
+import type { V3 } from "../../lib/v3/v3.js";
+
+/**
+ * Races a promise against a timeout.
+ * Resolves to the promise value or "timeout" if the deadline expires.
+ */
+export function raceTimeout<T>(
+  promise: Promise<T>,
+  ms: number,
+): Promise<T | "timeout"> {
+  let timer: ReturnType<typeof setTimeout>;
+  const timeout = new Promise<"timeout">((resolve) => {
+    timer = setTimeout(() => resolve("timeout"), ms);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+
+const CLOSE_TIMEOUT_MS = 5_000;
+
+async function settleWithTimeout(
+  promise: Promise<unknown>,
+  timeoutMs: number,
+): Promise<void> {
+  let timeoutId: NodeJS.Timeout | undefined;
+  const timeout = new Promise<void>((resolve) => {
+    timeoutId = setTimeout(resolve, timeoutMs);
+  });
+  try {
+    await Promise.race([promise.catch(() => {}), timeout]);
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
+  }
+}
+
+export async function closeV3(v3?: V3 | null): Promise<void> {
+  if (!v3) return;
+  const isBrowserbase = v3.isBrowserbase;
+  if (isBrowserbase) {
+    try {
+      await settleWithTimeout(
+        v3.context.conn.send("Browser.close"),
+        CLOSE_TIMEOUT_MS,
+      );
+    } catch {
+      // best-effort cleanup
+    }
+  }
+
+  await settleWithTimeout(v3.close(), CLOSE_TIMEOUT_MS);
+}
diff --git a/packages/core/tests/integration/text-selector-innermost.spec.ts b/packages/core/tests/integration/text-selector-innermost.spec.ts
new file mode 100644
index 000000000..a5a56514d
--- /dev/null
+++ b/packages/core/tests/integration/text-selector-innermost.spec.ts
@@ -0,0 +1,131 @@
+import { expect, test } from "@playwright/test";
+import { Protocol } from "devtools-protocol";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3DynamicTestConfig } from "./v3.dynamic.config.js";
+import { closeV3 } from "./testUtils.js";
+
+test.describe("Text selector innermost element matching", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3DynamicTestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await closeV3(v3);
+  });
+
+  test("text selector matches only innermost elements", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(`
+        <div id="outer">
+          <span id="middle">
+            <button id="inner">Click me</button>
+          </span>
+        </div>
+      `),
+    );
+
+    // Only the button should be counted, not the parent elements
+    const count = await page.mainFrame().locator("text=Click me").count();
+    expect(count).toBe(1);
+
+    // Verify it finds the button element specifically
+    const session = page.mainFrame().session;
+    const { executionContextId } = await session.send<{
+      executionContextId: number;
+    }>("Page.createIsolatedWorld", {
+      frameId: page.mainFrame().frameId,
+      worldName: "test-world",
+    });
+
+    const evalRes = await session.send<Protocol.Runtime.EvaluateResponse>(
+      "Runtime.evaluate",
+      {
+        expression: `(() => {
+          const candidates = [];
+          const iter = document.createNodeIterator(document.documentElement, NodeFilter.SHOW_ELEMENT);
+          let n;
+          while ((n = iter.nextNode())) {
+            const el = n;
+            const t = (el.innerText ?? el.textContent ?? '').trim();
+            if (t && t.includes("Click me")) {
+              candidates.push(el);
+            }
+          }
+          
+          // Find innermost
+          for (const candidate of candidates) {
+            let isInnermost = true;
+            for (const other of candidates) {
+              if (candidate !== other && candidate.contains(other)) {
+                isInnermost = false;
+                break;
+              }
+            }
+            if (isInnermost) return candidate.id;
+          }
+          return null;
+        })()`,
+        contextId: executionContextId,
+        returnByValue: true,
+      },
+    );
+
+    expect(evalRes.result.value).toBe("inner");
+  });
+
+  test("multiple innermost elements with same text", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(`
+        <div>
+          <button>Submit</button>
+          <span>Some other content</span>
+          <button>Submit</button>
+        </div>
+        <div>
+          <a href="#">Submit</a>
+        </div>
+      `),
+    );
+
+    // Should find all three innermost elements (2 buttons + 1 link)
+    const count = await page.mainFrame().locator("text=Submit").count();
+    expect(count).toBe(3);
+  });
+
+  test("nested text with different innermost elements", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(`
+        <div id="parent">
+          Hello <span id="child">World</span>
+        </div>
+      `),
+    );
+
+    // "Hello" is only in the parent div
+    const helloCount = await page.mainFrame().locator("text=Hello").count();
+    expect(helloCount).toBe(1); // Only the div
+
+    // "World" is only in the span
+    const worldCount = await page.mainFrame().locator("text=World").count();
+    expect(worldCount).toBe(1); // Only the span
+
+    // "Hello World" matches only the parent div (as it's the innermost containing both words)
+    const bothCount = await page
+      .mainFrame()
+      .locator("text=Hello World")
+      .count();
+    expect(bothCount).toBe(1); // Only the div
+  });
+});
diff --git a/packages/core/tests/integration/timeouts.spec.ts b/packages/core/tests/integration/timeouts.spec.ts
new file mode 100644
index 000000000..2580e2208
--- /dev/null
+++ b/packages/core/tests/integration/timeouts.spec.ts
@@ -0,0 +1,261 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3DynamicTestConfig } from "./v3.dynamic.config.js";
+import { z } from "zod";
+import { closeV3 } from "./testUtils.js";
+import type { LLMClient } from "../../lib/v3/llm/LLMClient.js";
+import { generateText } from "ai";
+
+type AgentToolNameWithTimeout = "act" | "extract" | "fillForm" | "ariaTree";
+
+type ToolTimeoutTestModel = {
+  provider: string;
+  modelId: string;
+  specificationVersion: "v2";
+  supportedUrls: Record<string, RegExp[]>;
+  doGenerate: () => Promise<{
+    content: Array<{
+      type: "tool-call";
+      toolCallId: string;
+      toolName: string;
+      input: string;
+    }>;
+    finishReason: "tool-calls";
+    usage: { inputTokens: number; outputTokens: number; totalTokens: number };
+    warnings: [];
+  }>;
+  doStream: (_options: unknown) => Promise<never>;
+};
+
+type ToolTimeoutTestLLMClient = LLMClient & {
+  model: ToolTimeoutTestModel;
+};
+
+function createToolTimeoutTestLlmClient(
+  toolName: AgentToolNameWithTimeout,
+  toolInput: Record<string, unknown>,
+): ToolTimeoutTestLLMClient {
+  const usage = {
+    prompt_tokens: 0,
+    completion_tokens: 0,
+    reasoning_tokens: 0,
+    cached_input_tokens: 0,
+    total_tokens: 0,
+  };
+  let generateCallCount = 0;
+
+  const model: ToolTimeoutTestModel = {
+    provider: "mock",
+    modelId: "mock/tool-timeout-test",
+    specificationVersion: "v2",
+    supportedUrls: {},
+    doGenerate: async () => {
+      generateCallCount += 1;
+      if (generateCallCount === 1) {
+        return {
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "tool-1",
+              toolName,
+              input: JSON.stringify(toolInput),
+            },
+          ],
+          finishReason: "tool-calls",
+          usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+          warnings: [],
+        };
+      }
+
+      return {
+        content: [
+          {
+            type: "tool-call",
+            toolCallId: "done-1",
+            toolName: "done",
+            input: JSON.stringify({ reasoning: "done", taskComplete: true }),
+          },
+        ],
+        finishReason: "tool-calls",
+        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+        warnings: [],
+      };
+    },
+    doStream: async () => {
+      throw new Error("doStream not implemented in timeout test model");
+    },
+  };
+
+  const llm = {
+    type: "openai",
+    modelName: "openai/gpt-4.1-mini",
+    hasVision: false,
+    clientOptions: {},
+    model,
+    getLanguageModel: () => model,
+    generateText,
+    createChatCompletion: async <T = unknown>(options: unknown): Promise<T> => {
+      const responseModelName = (
+        options as { options?: { response_model?: { name?: string } } }
+      )?.options?.response_model?.name;
+
+      if (responseModelName === "act") {
+        return {
+          data: {
+            elementId: "1-0",
+            description: "click body",
+            method: "click",
+            arguments: [],
+            twoStep: false,
+          },
+          usage,
+        } as T;
+      }
+      if (responseModelName === "Observation") {
+        return { data: { elements: [] }, usage } as T;
+      }
+      if (responseModelName === "Extraction") {
+        return { data: {}, usage } as T;
+      }
+      if (responseModelName === "Metadata") {
+        return { data: { completed: true, progress: "" }, usage } as T;
+      }
+      return { data: {}, usage } as T;
+    },
+  };
+
+  return llm as unknown as ToolTimeoutTestLLMClient;
+}
+
+function findToolOutput(
+  stepEvents: Array<{
+    toolCalls?: Array<{ toolName?: string }>;
+    toolResults?: Array<{ output?: unknown }>;
+  }>,
+  toolName: string,
+) {
+  for (const event of stepEvents) {
+    if (!event.toolCalls || !event.toolResults) continue;
+    const toolIndex = event.toolCalls.findIndex(
+      (tc) => tc.toolName === toolName,
+    );
+    if (toolIndex !== -1) {
+      return event.toolResults[toolIndex]?.output;
+    }
+  }
+  return undefined;
+}
+
+async function runAgentToolTimeoutScenario(
+  toolName: AgentToolNameWithTimeout,
+  toolInput: Record<string, unknown>,
+) {
+  const llmClient = createToolTimeoutTestLlmClient(toolName, toolInput);
+  const stepEvents: Array<{
+    toolCalls?: Array<{ toolName?: string }>;
+    toolResults?: Array<{ output?: unknown }>;
+  }> = [];
+  const v3 = new V3({
+    ...v3DynamicTestConfig,
+    experimental: true,
+    llmClient,
+  });
+  await v3.init();
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://example.com");
+    const agent = v3.agent();
+    await agent.execute({
+      instruction: `Use ${toolName} and then finish`,
+      maxSteps: 2,
+      toolTimeout: 1,
+      callbacks: {
+        onStepFinish: (event) => {
+          stepEvents.push({
+            toolCalls: event.toolCalls?.map((tc) => ({
+              toolName: tc.toolName,
+            })),
+            toolResults: event.toolResults?.map((tr) => ({
+              output: tr.output,
+            })),
+          });
+        },
+      },
+    });
+    const toolOutput = findToolOutput(stepEvents, toolName);
+    if (!toolOutput) {
+      throw new Error(`No tool output captured for ${toolName}`);
+    }
+    return { toolOutput };
+  } finally {
+    await closeV3(v3);
+  }
+}
+
+test.describe("V3 hard timeouts", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3DynamicTestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await closeV3(v3);
+  });
+
+  test("observe() enforces timeoutMs", async () => {
+    // Tiny timeout to force the race to hit the timeout branch
+    await expect(v3.observe("find something", { timeout: 5 })).rejects.toThrow(
+      /timed out/i,
+    );
+  });
+
+  test("extract() enforces timeoutMs", async () => {
+    const schema = z.object({ title: z.string().optional() });
+    await expect(
+      v3.extract("Extract title", schema, { timeout: 5 }),
+    ).rejects.toThrow(/timed out/i);
+  });
+
+  test("act() enforces timeoutMs", async () => {
+    await expect(v3.act("do nothing", { timeout: 5 })).rejects.toThrow(
+      /timed out/i,
+    );
+  });
+
+  test("agent toolTimeout enforces timeout for act tool", async () => {
+    const { toolOutput } = await runAgentToolTimeoutScenario("act", {
+      action: "click somewhere",
+    });
+    const output = toolOutput as { success: boolean; error: string };
+    expect(output.success).toBe(false);
+    expect(output.error).toContain("TimeoutError");
+  });
+
+  test("agent toolTimeout enforces timeout for extract tool", async () => {
+    const { toolOutput } = await runAgentToolTimeoutScenario("extract", {
+      instruction: "extract the page title",
+      schema: { type: "object", properties: { title: { type: "string" } } },
+    });
+    const output = toolOutput as { success: boolean; error: string };
+    expect(output.success).toBe(false);
+    expect(output.error).toContain("TimeoutError");
+  });
+
+  test("agent toolTimeout enforces timeout for fillForm tool", async () => {
+    const { toolOutput } = await runAgentToolTimeoutScenario("fillForm", {
+      fields: [{ action: "type hello into name", value: "hello" }],
+    });
+    const output = toolOutput as { success: boolean; error: string };
+    expect(output.success).toBe(false);
+    expect(output.error).toContain("TimeoutError");
+  });
+
+  test("agent toolTimeout enforces timeout for ariaTree", async () => {
+    const { toolOutput } = await runAgentToolTimeoutScenario("ariaTree", {});
+    const output = toolOutput as { success: boolean; error: string };
+    expect(output.success).toBe(false);
+    expect(output.error).toContain("TimeoutError");
+  });
+});
diff --git a/packages/core/tests/integration/user-data-dir.spec.ts b/packages/core/tests/integration/user-data-dir.spec.ts
new file mode 100644
index 000000000..5f898c790
--- /dev/null
+++ b/packages/core/tests/integration/user-data-dir.spec.ts
@@ -0,0 +1,54 @@
+import { test, expect } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3TestConfig } from "./v3.config.js";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+test.describe("userDataDir persistence", () => {
+  let v3: V3;
+  let testDir: string;
+
+  test.beforeEach(() => {
+    testDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), "stagehand-userdata-test-"),
+    );
+  });
+
+  test.afterEach(async () => {
+    await v3?.close?.().catch(() => {});
+    if (testDir && fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  test("Chrome uses the specified userDataDir", async () => {
+    const browserTarget = (
+      process.env.STAGEHAND_BROWSER_TARGET ?? "local"
+    ).toLowerCase();
+    const isBrowserbase = browserTarget === "browserbase";
+    test.skip(isBrowserbase, "Requires local Chromium for userDataDir checks");
+
+    v3 = new V3({
+      ...v3TestConfig,
+      localBrowserLaunchOptions: {
+        ...(v3TestConfig.localBrowserLaunchOptions ?? {}),
+        userDataDir: testDir,
+        preserveUserDataDir: true,
+      },
+    });
+
+    await v3.init();
+
+    const page = v3.context.pages()[0];
+    await page.goto("about:blank");
+
+    await expect
+      .poll(() => fs.existsSync(path.join(testDir, "Default")), {
+        timeout: 10_000,
+      })
+      .toBe(true);
+
+    expect(fs.existsSync(path.join(testDir, "Local State"))).toBe(true);
+  });
+});
diff --git a/packages/core/tests/integration/v3.config.ts b/packages/core/tests/integration/v3.config.ts
new file mode 100644
index 000000000..12f565b42
--- /dev/null
+++ b/packages/core/tests/integration/v3.config.ts
@@ -0,0 +1,13 @@
+import type { V3Options } from "../../lib/v3/types/public/options.js";
+import {
+  v3DynamicTestConfig,
+  getV3DynamicTestConfig,
+} from "./v3.dynamic.config.js";
+
+export const v3TestConfig: V3Options = v3DynamicTestConfig;
+
+export function getV3TestConfig(overrides: Partial<V3Options> = {}): V3Options {
+  return getV3DynamicTestConfig(overrides);
+}
+
+export default getV3TestConfig;
diff --git a/packages/core/tests/integration/v3.dynamic.config.ts b/packages/core/tests/integration/v3.dynamic.config.ts
new file mode 100644
index 000000000..9a41f767f
--- /dev/null
+++ b/packages/core/tests/integration/v3.dynamic.config.ts
@@ -0,0 +1,57 @@
+import type { V3Options } from "../../lib/v3/types/public/options.js";
+import type { BrowserbaseSessionCreateParams } from "../../lib/v3/types/public/api.js";
+import type { LogLine } from "../../lib/v3/types/public/logs.js";
+
+const browserTarget = (
+  process.env.STAGEHAND_BROWSER_TARGET ?? "local"
+).toLowerCase();
+const isBrowserbase = browserTarget === "browserbase";
+const browserbaseRegionRaw = process.env.BROWSERBASE_REGION;
+const browserbaseRegion = (
+  [
+    "us-west-2",
+    "us-east-1",
+    "eu-central-1",
+    "ap-southeast-1",
+  ] as BrowserbaseSessionCreateParams["region"][]
+).includes(browserbaseRegionRaw as BrowserbaseSessionCreateParams["region"])
+  ? (browserbaseRegionRaw as BrowserbaseSessionCreateParams["region"])
+  : undefined;
+
+const baseConfig = {
+  verbose: 0 as const,
+  disablePino: true,
+  logger: (line: LogLine) => console.log(line),
+  disableAPI: true,
+};
+
+export const v3DynamicTestConfig: V3Options = isBrowserbase
+  ? {
+      ...baseConfig,
+      env: "BROWSERBASE",
+      apiKey: process.env.BROWSERBASE_API_KEY!,
+      projectId: process.env.BROWSERBASE_PROJECT_ID!,
+      disableAPI: true,
+      selfHeal: false,
+      ...(browserbaseRegion
+        ? { browserbaseSessionCreateParams: { region: browserbaseRegion } }
+        : {}),
+    }
+  : {
+      ...baseConfig,
+      env: "LOCAL",
+      localBrowserLaunchOptions: {
+        executablePath: process.env.CHROME_PATH,
+        args: process.env.CI ? ["--no-sandbox"] : undefined,
+        headless: true,
+        viewport: { width: 1288, height: 711 },
+      },
+    };
+
+export function getV3DynamicTestConfig(
+  overrides: Partial<V3Options> = {},
+): V3Options {
+  return { ...v3DynamicTestConfig, ...overrides };
+}
+
+export default getV3DynamicTestConfig;
diff --git a/packages/core/tests/integration/v3.playwright.config.ts b/packages/core/tests/integration/v3.playwright.config.ts
new file mode 100644
index 000000000..f57ad11a9
--- /dev/null
+++ b/packages/core/tests/integration/v3.playwright.config.ts
@@ -0,0 +1,58 @@
+import { defineConfig, type ReporterDescription } from "@playwright/test";
+import { getPackageRootDir } from "../../lib/v3/runtimePaths.js";
+const coreDir = getPackageRootDir();
+const testDir = `${coreDir}/dist/esm/tests/integration`;
+
+const browserTarget = (
+  process.env.STAGEHAND_BROWSER_TARGET ?? "local"
+).toLowerCase();
+const isBrowserbase = browserTarget === "browserbase";
+const consoleReporter = process.env.PLAYWRIGHT_CONSOLE_REPORTER ?? "list";
+
+const localWorkerOverride = Number(
+  process.env.LOCAL_SESSION_LIMIT_PER_E2E_TEST,
+);
+const localWorkers =
+  Number.isFinite(localWorkerOverride) && localWorkerOverride > 0
+    ? localWorkerOverride
+    : process.env.CI
+      ? 3
+      : 5;
+
+const ciWorkerOverride = Number(
+  process.env.BROWSERBASE_SESSION_LIMIT_PER_E2E_TEST,
+);
+const bbWorkers =
+  process.env.CI && Number.isFinite(ciWorkerOverride) && ciWorkerOverride > 0
+    ? ciWorkerOverride
+    : 3;
+
+const ctrfJunitPath = process.env.CTRF_JUNIT_PATH;
+const reporter: ReporterDescription[] = ctrfJunitPath
+  ? [
+      [consoleReporter] as ReporterDescription,
+      [
+        "junit",
+        { outputFile: ctrfJunitPath, includeProjectInTestName: true },
+      ] as ReporterDescription,
+    ]
+  : [[consoleReporter] as ReporterDescription];
+
+export default defineConfig({
+  testDir,
+  timeout: 90_000,
+  expect: { timeout: 10_000 },
+  retries: process.env.CI ? 1 : 0,
+  workers: isBrowserbase ? bbWorkers : localWorkers,
+  fullyParallel: true,
+  projects: [
+    {
+      name: isBrowserbase ? "e2e-bb" : "e2e-local",
+    },
+  ],
+  reporter,
+  use: {
+    // we're not launching Playwright browsers in these tests; we connect via Puppeteer/CDP to V3.
+    headless: false,
+  },
+});
diff --git a/packages/core/tests/integration/wait-for-selector.spec.ts b/packages/core/tests/integration/wait-for-selector.spec.ts
new file mode 100644
index 000000000..190404e26
--- /dev/null
+++ b/packages/core/tests/integration/wait-for-selector.spec.ts
@@ -0,0 +1,929 @@
+import { expect, test } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3DynamicTestConfig } from "./v3.dynamic.config.js";
+import { closeV3 } from "./testUtils.js";
+
+test.describe.configure({ mode: "serial" });
+test.describe("Page.waitForSelector tests", () => {
+  let v3: V3;
+
+  test.beforeAll(async () => {
+    v3 = new V3(v3DynamicTestConfig);
+    await v3.init();
+  });
+
+  test.beforeEach(async () => {
+    const pages = v3.context.pages();
+    if (pages.length === 0) {
+      await v3.context.newPage("about:blank");
+      return;
+    }
+
+    const [primary, ...extras] = pages;
+    for (const page of extras) {
+      await page.close().catch(() => {});
+    }
+
+    v3.context.setActivePage(primary);
+    await primary.goto("about:blank", {
+      waitUntil: "load",
+      timeoutMs: 15_000,
+    });
+  });
+
+  test.afterAll(async () => {
+    await closeV3(v3);
+  });
+
+  test.describe("Basic state tests", () => {
+    test("resolves when element is already visible", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent('<button id="submit-btn">Submit</button>'),
+      );
+
+      const result = await page.waitForSelector("#submit-btn");
+      expect(result).toBe(true);
+    });
+
+    test("resolves when element appears after delay", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            "<div id='container'></div>" +
+              "<script>" +
+              "setTimeout(() => {" +
+              "  const btn = document.createElement('button');" +
+              "  btn.id = 'delayed-btn';" +
+              "  btn.textContent = 'Delayed Button';" +
+              "  document.getElementById('container').appendChild(btn);" +
+              "}, 300);" +
+              "</script>",
+          ),
+      );
+
+      const result = await page.waitForSelector("#delayed-btn", {
+        timeout: 5000,
+      });
+      expect(result).toBe(true);
+    });
+
+    test("state 'attached' resolves for hidden elements", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="hidden-div" style="display: none;">Hidden Content</div>',
+          ),
+      );
+
+      const result = await page.waitForSelector("#hidden-div", {
+        state: "attached",
+      });
+      expect(result).toBe(true);
+    });
+
+    test("state 'visible' waits for element to become visible", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="show-later" style="display: none;">Now Visible</div>' +
+              "<script>" +
+              "setTimeout(() => {" +
+              "  document.getElementById('show-later').style.display = 'block';" +
+              "}, 300);" +
+              "</script>",
+          ),
+      );
+
+      const result = await page.waitForSelector("#show-later", {
+        state: "visible",
+        timeout: 5000,
+      });
+      expect(result).toBe(true);
+    });
+
+    test("state 'hidden' waits for element to become hidden", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="hide-later" style="display: block;">Will Hide</div>' +
+              "<script>" +
+              "setTimeout(() => {" +
+              "  document.getElementById('hide-later').style.display = 'none';" +
+              "}, 300);" +
+              "</script>",
+          ),
+      );
+
+      const result = await page.waitForSelector("#hide-later", {
+        state: "hidden",
+        timeout: 5000,
+      });
+      expect(result).toBe(true);
+    });
+
+    test("state 'detached' waits for element to be removed", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="remove-me">Will Be Removed</div>' +
+              "<script>" +
+              "setTimeout(() => {" +
+              "  const el = document.getElementById('remove-me');" +
+              "  el.parentNode.removeChild(el);" +
+              "}, 300);" +
+              "</script>",
+          ),
+      );
+
+      const result = await page.waitForSelector("#remove-me", {
+        state: "detached",
+        timeout: 5000,
+      });
+      expect(result).toBe(true);
+    });
+
+    test("state 'detached' resolves immediately for non-existent element", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," + encodeURIComponent("<div>Content</div>"),
+      );
+
+      const result = await page.waitForSelector("#does-not-exist", {
+        state: "detached",
+        timeout: 1000,
+      });
+      expect(result).toBe(true);
+    });
+  });
+
+  test.describe("Timeout behavior", () => {
+    test("throws on timeout when element never appears", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," + encodeURIComponent("<div>No button here</div>"),
+      );
+
+      let error: Error | null = null;
+      try {
+        await page.waitForSelector("#nonexistent", { timeout: 300 });
+      } catch (e) {
+        error = e as Error;
+      }
+
+      expect(error).not.toBeNull();
+      expect(error?.message).toContain("Timeout");
+      expect(error?.message).toContain("#nonexistent");
+    });
+
+    test("respects custom timeout duration", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," + encodeURIComponent("<div>Content</div>"),
+      );
+
+      const startTime = Date.now();
+      try {
+        await page.waitForSelector("#nonexistent", { timeout: 500 });
+      } catch {
+        // Expected to timeout
+      }
+      const elapsed = Date.now() - startTime;
+
+      // Should timeout around 500ms (allow some margin)
+      expect(elapsed).toBeGreaterThanOrEqual(450);
+      expect(elapsed).toBeLessThan(2000);
+    });
+  });
+
+  test.describe("CSS selector variants", () => {
+    test("handles complex CSS selectors", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div class="container">' +
+              '<form id="login-form">' +
+              '<button type="submit">Login</button>' +
+              "</form>" +
+              "</div>",
+          ),
+      );
+
+      const result = await page.waitForSelector(
+        ".container #login-form button[type='submit']",
+      );
+      expect(result).toBe(true);
+    });
+  });
+
+  test.describe("Open shadow DOM", () => {
+    test("finds element inside open shadow DOM with pierceShadow: true", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="host"></div>' +
+              "<script>" +
+              'const host = document.getElementById("host");' +
+              'const shadow = host.attachShadow({mode: "open"});' +
+              'shadow.innerHTML = "<button id=\\"shadow-btn\\">Shadow Button</button>";' +
+              "</script>",
+          ),
+        { waitUntil: "load", timeoutMs: 30000 },
+      );
+      await page.waitForTimeout(100);
+
+      const result = await page.waitForSelector("#shadow-btn", {
+        pierceShadow: true,
+        timeout: 5000,
+      });
+      expect(result).toBe(true);
+    });
+
+    test("does NOT find shadow DOM element with pierceShadow: false", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="host"></div>' +
+              "<script>" +
+              'const host = document.getElementById("host");' +
+              'const shadow = host.attachShadow({mode: "open"});' +
+              'shadow.innerHTML = "<button id=\\"shadow-only-btn\\">Shadow Only</button>";' +
+              "</script>",
+          ),
+        { waitUntil: "load", timeoutMs: 30000 },
+      );
+      await page.waitForTimeout(100);
+
+      let error: Error | null = null;
+      try {
+        await page.waitForSelector("#shadow-only-btn", {
+          pierceShadow: false,
+          timeout: 300,
+        });
+      } catch (e) {
+        error = e as Error;
+      }
+
+      expect(error).not.toBeNull();
+      expect(error?.message).toContain("Timeout");
+    });
+
+    test("finds element in nested open shadow DOM", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="outer-host"></div>' +
+              "<script>" +
+              'const outerHost = document.getElementById("outer-host");' +
+              'const outerShadow = outerHost.attachShadow({mode: "open"});' +
+              'outerShadow.innerHTML = "<div id=\\"inner-host\\"></div>";' +
+              'const innerHost = outerShadow.getElementById("inner-host");' +
+              'const innerShadow = innerHost.attachShadow({mode: "open"});' +
+              'innerShadow.innerHTML = "<span id=\\"deep-element\\">Deep!</span>";' +
+              "</script>",
+          ),
+        { waitUntil: "load", timeoutMs: 30000 },
+      );
+      await page.waitForTimeout(100);
+
+      const result = await page.waitForSelector("#deep-element", {
+        pierceShadow: true,
+        timeout: 5000,
+      });
+      expect(result).toBe(true);
+    });
+  });
+
+  test.describe("Closed shadow DOM (via piercer)", () => {
+    test("finds element inside closed shadow DOM via custom element", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            "<closed-shadow-host></closed-shadow-host>" +
+              "<script>" +
+              "class ClosedShadowHost extends HTMLElement {" +
+              "  constructor() {" +
+              "    super();" +
+              '    const shadow = this.attachShadow({mode: "closed"});' +
+              '    shadow.innerHTML = "<button id=\\"closed-btn\\">Closed Shadow Button</button>";' +
+              "  }" +
+              "}" +
+              "customElements.define('closed-shadow-host', ClosedShadowHost);" +
+              "</script>",
+          ),
+        { waitUntil: "load", timeoutMs: 30000 },
+      );
+      await page.waitForTimeout(100);
+
+      // The piercer hooks attachShadow and stores closed shadow roots
+      const result = await page.waitForSelector("#closed-btn", {
+        pierceShadow: true,
+        timeout: 5000,
+      });
+      expect(result).toBe(true);
+    });
+
+    test("finds element in nested closed shadow DOM", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            "<outer-closed></outer-closed>" +
+              "<script>" +
+              "class InnerClosed extends HTMLElement {" +
+              "  constructor() {" +
+              "    super();" +
+              '    const shadow = this.attachShadow({mode: "closed"});' +
+              '    shadow.innerHTML = "<span id=\\"deeply-closed\\">Deeply Nested Closed</span>";' +
+              "  }" +
+              "}" +
+              "customElements.define('inner-closed', InnerClosed);" +
+              "" +
+              "class OuterClosed extends HTMLElement {" +
+              "  constructor() {" +
+              "    super();" +
+              '    const shadow = this.attachShadow({mode: "closed"});' +
+              '    shadow.innerHTML = "<inner-closed></inner-closed>";' +
+              "  }" +
+              "}" +
+              "customElements.define('outer-closed', OuterClosed);" +
+              "</script>",
+          ),
+        { waitUntil: "load", timeoutMs: 30000 },
+      );
+      await page.waitForTimeout(100);
+
+      const result = await page.waitForSelector("#deeply-closed", {
+        pierceShadow: true,
+        timeout: 5000,
+      });
+      expect(result).toBe(true);
+    });
+
+    test("finds element in mixed open/closed nested shadow DOM", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="open-host"></div>' +
+              "<script>" +
+              // Inner closed component
+              "class ClosedInner extends HTMLElement {" +
+              "  constructor() {" +
+              "    super();" +
+              '    const shadow = this.attachShadow({mode: "closed"});' +
+              '    shadow.innerHTML = "<button id=\\"mixed-deep-btn\\">Mixed Deep Button</button>";' +
+              "  }" +
+              "}" +
+              "customElements.define('closed-inner', ClosedInner);" +
+              // Outer open shadow
+              'const openHost = document.getElementById("open-host");' +
+              'const openShadow = openHost.attachShadow({mode: "open"});' +
+              'openShadow.innerHTML = "<closed-inner></closed-inner>";' +
+              "</script>",
+          ),
+        { waitUntil: "load", timeoutMs: 30000 },
+      );
+      await page.waitForTimeout(100);
+
+      const result = await page.waitForSelector("#mixed-deep-btn", {
+        pierceShadow: true,
+        timeout: 5000,
+      });
+      expect(result).toBe(true);
+    });
+
+    test("waits for element to appear inside closed shadow DOM", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            "<delayed-closed-host></delayed-closed-host>" +
+              "<script>" +
+              "class DelayedClosedHost extends HTMLElement {" +
+              "  constructor() {" +
+              "    super();" +
+              '    const shadow = this.attachShadow({mode: "closed"});' +
+              '    shadow.innerHTML = "<div id=\\"container\\"></div>";' +
+              "    setTimeout(() => {" +
+              '      shadow.getElementById("container").innerHTML = ' +
+              '        "<button id=\\"delayed-closed-btn\\">Appeared!</button>";' +
+              "    }, 300);" +
+              "  }" +
+              "}" +
+              "customElements.define('delayed-closed-host', DelayedClosedHost);" +
+              "</script>",
+          ),
+        { waitUntil: "load", timeoutMs: 30000 },
+      );
+
+      const result = await page.waitForSelector("#delayed-closed-btn", {
+        pierceShadow: true,
+        timeout: 5000,
+      });
+      expect(result).toBe(true);
+    });
+  });
+
+  test.describe("XPath selectors", () => {
+    test("finds element with basic XPath", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent('<button id="xpath-btn">XPath Button</button>'),
+      );
+
+      const result = await page.waitForSelector("//button[@id='xpath-btn']", {
+        timeout: 5000,
+      });
+      expect(result).toBe(true);
+    });
+
+    test("finds element with xpath= prefix", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="container"><span class="target">Target</span></div>',
+          ),
+      );
+
+      const result = await page.waitForSelector(
+        "xpath=//span[@class='target']",
+        {
+          timeout: 5000,
+        },
+      );
+      expect(result).toBe(true);
+    });
+
+    test("waits for element to appear with XPath", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            "<div id='container'></div>" +
+              "<script>" +
+              "setTimeout(() => {" +
+              '  document.getElementById("container").innerHTML = ' +
+              '    "<span id=\\"delayed-xpath\\">Delayed XPath</span>";' +
+              "}, 300);" +
+              "</script>",
+          ),
+      );
+
+      const result = await page.waitForSelector("//span[@id='delayed-xpath']", {
+        timeout: 5000,
+      });
+      expect(result).toBe(true);
+    });
+
+    test("finds element in open shadow DOM with XPath", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="host"></div>' +
+              "<script>" +
+              'const host = document.getElementById("host");' +
+              'const shadow = host.attachShadow({mode: "open"});' +
+              'shadow.innerHTML = "<button id=\\"shadow-xpath-btn\\">Shadow XPath</button>";' +
+              "</script>",
+          ),
+        { waitUntil: "load", timeoutMs: 30000 },
+      );
+      await page.waitForTimeout(100);
+
+      const result = await page.waitForSelector(
+        "//button[@id='shadow-xpath-btn']",
+        {
+          pierceShadow: true,
+          timeout: 5000,
+        },
+      );
+      expect(result).toBe(true);
+    });
+
+    test("finds element in closed shadow DOM with XPath", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            "<xpath-closed-host></xpath-closed-host>" +
+              "<script>" +
+              "class XPathClosedHost extends HTMLElement {" +
+              "  constructor() {" +
+              "    super();" +
+              '    const shadow = this.attachShadow({mode: "closed"});' +
+              '    shadow.innerHTML = "<span id=\\"xpath-closed-target\\">Closed XPath Target</span>";' +
+              "  }" +
+              "}" +
+              "customElements.define('xpath-closed-host', XPathClosedHost);" +
+              "</script>",
+          ),
+        { waitUntil: "load", timeoutMs: 30000 },
+      );
+      await page.waitForTimeout(100);
+
+      const result = await page.waitForSelector(
+        "//span[@id='xpath-closed-target']",
+        {
+          pierceShadow: true,
+          timeout: 5000,
+        },
+      );
+      expect(result).toBe(true);
+    });
+  });
+
+  test.describe("Iframe hop notation (>>)", () => {
+    test("finds element inside single iframe", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<button id="main-btn">Main Button</button>' +
+              '<iframe id="my-frame"></iframe>' +
+              "<script>" +
+              'const frame = document.getElementById("my-frame");' +
+              "const doc = frame.contentDocument;" +
+              "doc.open();" +
+              'doc.write("<button id=\\"frame-btn\\">Frame Button</button>");' +
+              "doc.close();" +
+              "</script>",
+          ),
+      );
+      await page.waitForTimeout(100);
+
+      const result = await page.waitForSelector(
+        "iframe#my-frame >> #frame-btn",
+        {
+          timeout: 5000,
+        },
+      );
+      expect(result).toBe(true);
+    });
+
+    test("finds element through multiple iframe hops", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<iframe id="outer-frame"></iframe>' +
+              "<script>" +
+              'const outerFrame = document.getElementById("outer-frame");' +
+              "const outerDoc = outerFrame.contentDocument;" +
+              "outerDoc.open();" +
+              'outerDoc.write("<iframe id=\\"inner-frame\\"></iframe>");' +
+              "outerDoc.close();" +
+              "setTimeout(() => {" +
+              '  const innerFrame = outerDoc.getElementById("inner-frame");' +
+              "  const innerDoc = innerFrame.contentDocument;" +
+              "  innerDoc.open();" +
+              '  innerDoc.write("<div id=\\"nested-content\\">Deeply Nested</div>");' +
+              "  innerDoc.close();" +
+              "}, 100);" +
+              "</script>",
+          ),
+      );
+      await page.waitForTimeout(300);
+
+      const result = await page.waitForSelector(
+        "iframe#outer-frame >> iframe#inner-frame >> #nested-content",
+        { timeout: 5000 },
+      );
+      expect(result).toBe(true);
+    });
+
+    test("waits for element to appear inside iframe", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<iframe id="delay-frame"></iframe>' +
+              "<script>" +
+              'const frame = document.getElementById("delay-frame");' +
+              "const doc = frame.contentDocument;" +
+              "doc.open();" +
+              'doc.write("<div id=\\"container\\"></div>");' +
+              "doc.close();" +
+              "setTimeout(() => {" +
+              '  doc.getElementById("container").innerHTML = ' +
+              '    "<span id=\\"delayed-in-frame\\">Appeared!</span>";' +
+              "}, 300);" +
+              "</script>",
+          ),
+      );
+
+      const result = await page.waitForSelector(
+        "iframe#delay-frame >> #delayed-in-frame",
+        {
+          timeout: 5000,
+        },
+      );
+      expect(result).toBe(true);
+    });
+  });
+
+  test.describe("Visibility edge cases", () => {
+    test("visibility: hidden is not visible", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="vis-hidden" style="visibility: hidden;">Hidden</div>',
+          ),
+      );
+
+      // Should be attached but not visible
+      const attached = await page.waitForSelector("#vis-hidden", {
+        state: "attached",
+      });
+      expect(attached).toBe(true);
+
+      let error: Error | null = null;
+      try {
+        await page.waitForSelector("#vis-hidden", {
+          state: "visible",
+          timeout: 200,
+        });
+      } catch (e) {
+        error = e as Error;
+      }
+      expect(error).not.toBeNull();
+    });
+
+    test("opacity: 0 is not visible", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="transparent" style="opacity: 0;">Transparent</div>',
+          ),
+      );
+
+      const attached = await page.waitForSelector("#transparent", {
+        state: "attached",
+      });
+      expect(attached).toBe(true);
+
+      let error: Error | null = null;
+      try {
+        await page.waitForSelector("#transparent", {
+          state: "visible",
+          timeout: 200,
+        });
+      } catch (e) {
+        error = e as Error;
+      }
+      expect(error).not.toBeNull();
+    });
+
+    test("zero dimensions is not visible", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="zero-size" style="width: 0; height: 0;">Zero</div>',
+          ),
+      );
+
+      const attached = await page.waitForSelector("#zero-size", {
+        state: "attached",
+      });
+      expect(attached).toBe(true);
+
+      let error: Error | null = null;
+      try {
+        await page.waitForSelector("#zero-size", {
+          state: "visible",
+          timeout: 200,
+        });
+      } catch (e) {
+        error = e as Error;
+      }
+      expect(error).not.toBeNull();
+    });
+
+    test("detects visibility change via class toggle", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            "<style>.hidden { display: none; }</style>" +
+              '<div id="class-toggle" class="hidden">Class Toggle</div>' +
+              "<script>" +
+              "setTimeout(() => {" +
+              "  document.getElementById('class-toggle').classList.remove('hidden');" +
+              "}, 300);" +
+              "</script>",
+          ),
+      );
+
+      const result = await page.waitForSelector("#class-toggle", {
+        state: "visible",
+        timeout: 5000,
+      });
+      expect(result).toBe(true);
+    });
+
+    test("detects visibility change via style attribute", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="style-toggle" style="display: none;">Style Toggle</div>' +
+              "<script>" +
+              "setTimeout(() => {" +
+              "  document.getElementById('style-toggle').style.display = 'block';" +
+              "}, 300);" +
+              "</script>",
+          ),
+      );
+
+      const result = await page.waitForSelector("#style-toggle", {
+        state: "visible",
+        timeout: 5000,
+      });
+      expect(result).toBe(true);
+    });
+  });
+
+  test.describe("Dynamic DOM scenarios", () => {
+    test("handles rapid DOM mutations", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            "<div id='container'></div>" +
+              "<script>" +
+              "let count = 0;" +
+              "const interval = setInterval(() => {" +
+              "  count++;" +
+              "  const div = document.createElement('div');" +
+              "  div.id = 'item-' + count;" +
+              "  div.textContent = 'item';" +
+              "  document.getElementById('container').appendChild(div);" +
+              "  if (count >= 10) clearInterval(interval);" +
+              "}, 50);" +
+              "</script>",
+          ),
+        { waitUntil: "load", timeoutMs: 30000 },
+      );
+      // Small delay to ensure script starts
+      await page.waitForTimeout(50);
+
+      const result = await page.waitForSelector("#item-7", { timeout: 10000 });
+      expect(result).toBe(true);
+    });
+
+    test("handles element removed and re-added", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent('<div id="toggle-me">Toggle</div>'),
+      );
+
+      const browserTarget = (
+        process.env.STAGEHAND_BROWSER_TARGET ?? "local"
+      ).toLowerCase();
+      const isBrowserbase = browserTarget === "browserbase";
+      const removeDelayMs = isBrowserbase ? 1000 : 200;
+      const addDelayMs = isBrowserbase ? 1600 : 500;
+      const waitTimeoutMs = isBrowserbase ? 10000 : 5000;
+
+      // Start waiting before scheduling DOM changes to avoid racey timing in CI.
+      const detachedPromise = page.waitForSelector("#toggle-me", {
+        state: "detached",
+        timeout: waitTimeoutMs,
+      });
+      await page.evaluate(
+        ({ removeDelay, addDelay }) => {
+          const el = document.getElementById("toggle-me");
+          const parent = el?.parentNode;
+          if (!el || !parent) return;
+          setTimeout(() => parent.removeChild(el), removeDelay);
+          setTimeout(() => parent.appendChild(el), addDelay);
+        },
+        { removeDelay: removeDelayMs, addDelay: addDelayMs },
+      );
+
+      const detached = await detachedPromise;
+      expect(detached).toBe(true);
+
+      // Then wait for visible again
+      const visible = await page.waitForSelector("#toggle-me", {
+        state: "visible",
+        timeout: waitTimeoutMs,
+      });
+      expect(visible).toBe(true);
+    });
+
+    test("handles dynamically replaced innerHTML", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="container">Loading...</div>' +
+              "<script>" +
+              "setTimeout(() => {" +
+              '  document.getElementById("container").innerHTML = ' +
+              '    "<button id=\\"loaded-btn\\">Loaded!</button>";' +
+              "}, 300);" +
+              "</script>",
+          ),
+      );
+
+      const result = await page.waitForSelector("#loaded-btn", {
+        timeout: 5000,
+      });
+      expect(result).toBe(true);
+    });
+
+    test("handles element created via insertAdjacentHTML", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="anchor"></div>' +
+              "<script>" +
+              "setTimeout(() => {" +
+              '  document.getElementById("anchor").insertAdjacentHTML(' +
+              '    "afterend", "<div id=\\"inserted\\">Inserted</div>"' +
+              "  );" +
+              "}, 300);" +
+              "</script>",
+          ),
+      );
+
+      const result = await page.waitForSelector("#inserted", { timeout: 5000 });
+      expect(result).toBe(true);
+    });
+  });
+
+  test.describe("Shadow DOM visibility changes", () => {
+    test("detects element becoming visible inside open shadow DOM", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="host"></div>' +
+              "<script>" +
+              'const host = document.getElementById("host");' +
+              'const shadow = host.attachShadow({mode: "open"});' +
+              'shadow.innerHTML = "<button id=\\"shadow-btn\\" style=\\"display:none\\">Shadow</button>";' +
+              "setTimeout(() => {" +
+              '  shadow.getElementById("shadow-btn").style.display = "block";' +
+              "}, 300);" +
+              "</script>",
+          ),
+        { waitUntil: "load", timeoutMs: 30000 },
+      );
+
+      const result = await page.waitForSelector("#shadow-btn", {
+        state: "visible",
+        pierceShadow: true,
+        timeout: 5000,
+      });
+      expect(result).toBe(true);
+    });
+
+    test("detects element becoming hidden inside shadow DOM", async () => {
+      const page = v3.context.pages()[0];
+      await page.goto(
+        "data:text/html," +
+          encodeURIComponent(
+            '<div id="host"></div>' +
+              "<script>" +
+              'const host = document.getElementById("host");' +
+              'const shadow = host.attachShadow({mode: "open"});' +
+              'shadow.innerHTML = "<button id=\\"hide-shadow-btn\\">Will Hide</button>";' +
+              "setTimeout(() => {" +
+              '  shadow.getElementById("hide-shadow-btn").style.display = "none";' +
+              "}, 300);" +
+              "</script>",
+          ),
+        { waitUntil: "load", timeoutMs: 30000 },
+      );
+      await page.waitForTimeout(100);
+
+      const result = await page.waitForSelector("#hide-shadow-btn", {
+        state: "hidden",
+        pierceShadow: true,
+        timeout: 5000,
+      });
+      expect(result).toBe(true);
+    });
+  });
+});
diff --git a/packages/core/tests/integration/wait-for-timeout.spec.ts b/packages/core/tests/integration/wait-for-timeout.spec.ts
new file mode 100644
index 000000000..ebfbd4b0e
--- /dev/null
+++ b/packages/core/tests/integration/wait-for-timeout.spec.ts
@@ -0,0 +1,168 @@
+import { expect, test } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3DynamicTestConfig } from "./v3.dynamic.config.js";
+import { closeV3 } from "./testUtils.js";
+
+test.describe("Page.waitForTimeout tests", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3DynamicTestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await closeV3(v3);
+  });
+
+  test("waitForTimeout resolves after specified duration", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," + encodeURIComponent("<div>Test Page</div>"),
+    );
+
+    const startTime = Date.now();
+    await page.waitForTimeout(200);
+    const elapsed = Date.now() - startTime;
+
+    // Should have waited at least 200ms (allow some tolerance)
+    expect(elapsed).toBeGreaterThanOrEqual(190);
+  });
+
+  test("waitForTimeout resolves immediately for 0ms", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," + encodeURIComponent("<div>Test Page</div>"),
+    );
+
+    const startTime = Date.now();
+    await page.waitForTimeout(0);
+    const elapsed = Date.now() - startTime;
+
+    // Should resolve nearly immediately (within 50ms tolerance)
+    expect(elapsed).toBeLessThan(50);
+  });
+
+  test("waitForTimeout can be chained with other operations", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          "<div id='counter'>0</div>" +
+            "<script>" +
+            "let count = 0;" +
+            "setInterval(() => {" +
+            "  count++;" +
+            "  document.getElementById('counter').textContent = count;" +
+            "}, 100);" +
+            "</script>",
+        ),
+    );
+
+    // Wait for counter to increment
+    await page.waitForTimeout(350);
+
+    // Counter should have incremented at least 3 times
+    const text = await page.mainFrame().locator("#counter").textContent();
+    expect(parseInt(text ?? "0")).toBeGreaterThanOrEqual(3);
+  });
+
+  test("waitForTimeout works with async/await syntax", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto("data:text/html," + encodeURIComponent("<div>Test</div>"));
+
+    const results: number[] = [];
+
+    results.push(1);
+    await page.waitForTimeout(50);
+    results.push(2);
+    await page.waitForTimeout(50);
+    results.push(3);
+
+    expect(results).toEqual([1, 2, 3]);
+  });
+
+  test("waitForTimeout allows DOM to update", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          "<div id='delayed'></div>" +
+            "<script>" +
+            "window.startUpdate = () => {" +
+            "  setTimeout(() => {" +
+            "    document.getElementById('delayed').textContent = 'Loaded';" +
+            "  }, 200);" +
+            "};" +
+            "</script>",
+        ),
+    );
+
+    // Trigger the delayed update
+    await page.evaluate(() => {
+      (window as unknown as { startUpdate: () => void }).startUpdate();
+    });
+
+    // Wait for the timeout to allow DOM update
+    await page.waitForTimeout(300);
+
+    // Content should now be loaded
+    const afterText = await page.mainFrame().locator("#delayed").textContent();
+    expect(afterText).toBe("Loaded");
+  });
+
+  test("waitForTimeout with small increments", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto("data:text/html," + encodeURIComponent("<div>Test</div>"));
+
+    const startTime = Date.now();
+
+    // Multiple small waits
+    await page.waitForTimeout(50);
+    await page.waitForTimeout(50);
+    await page.waitForTimeout(50);
+    await page.waitForTimeout(50);
+
+    const elapsed = Date.now() - startTime;
+
+    // Should have waited at least 200ms total (4 * 50ms)
+    expect(elapsed).toBeGreaterThanOrEqual(190);
+  });
+
+  test("waitForTimeout does not block other async operations", async () => {
+    const page = v3.context.pages()[0];
+
+    await page.goto(
+      "data:text/html," +
+        encodeURIComponent(
+          "<div id='async-test'>Initial</div>" +
+            "<script>" +
+            "window.updateText = () => {" +
+            "  document.getElementById('async-test').textContent = 'Updated';" +
+            "};" +
+            "</script>",
+        ),
+    );
+
+    // Start a timeout
+    const timeoutPromise = page.waitForTimeout(100);
+
+    // Execute something else while waiting
+    await page.evaluate(() => {
+      (window as unknown as { updateText: () => void }).updateText();
+    });
+
+    // Verify the update happened
+    const text = await page.mainFrame().locator("#async-test").textContent();
+    expect(text).toBe("Updated");
+
+    // Wait for the timeout to complete
+    await timeoutPromise;
+  });
+});
diff --git a/packages/core/tests/integration/xpath-for-location-deep.spec.ts b/packages/core/tests/integration/xpath-for-location-deep.spec.ts
new file mode 100644
index 000000000..d8a9b7e9e
--- /dev/null
+++ b/packages/core/tests/integration/xpath-for-location-deep.spec.ts
@@ -0,0 +1,110 @@
+import { expect, test } from "@playwright/test";
+import { V3 } from "../../lib/v3/v3.js";
+import { v3DynamicTestConfig } from "./v3.dynamic.config.js";
+import { resolveXpathForLocation } from "../../lib/v3/understudy/a11y/snapshot/index.js";
+import { executionContexts } from "../../lib/v3/understudy/executionContextRegistry.js";
+import { closeV3 } from "./testUtils.js";
+
+test.describe("resolveNodeForLocationDeep", () => {
+  let v3: V3;
+
+  test.beforeEach(async () => {
+    v3 = new V3(v3DynamicTestConfig);
+    await v3.init();
+  });
+
+  test.afterEach(async () => {
+    await closeV3(v3);
+  });
+
+  test("click resolves inside same-process iframe and returns absolute XPath", async () => {
+    const page = await v3.context.awaitActivePage();
+
+    // Set consistent viewport size to ensure stable rendering across environments
+    await page.setViewportSize(1280, 720);
+
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/iframe-hn/",
+      { waitUntil: "networkidle" },
+    );
+
+    await page.waitForSelector("section iframe", {
+      state: "attached",
+      timeout: 10000,
+    });
+    const frame = await page.frameLocator("section iframe").resolveFrame();
+    await executionContexts.waitForMainWorld(
+      frame.session,
+      frame.frameId,
+      5000,
+    );
+
+    // scroll to the bottom of the page
+    await page.evaluate(() => {
+      window.scrollTo(0, document.body.scrollHeight);
+    });
+
+    // scroll to the bottom of the iframe
+    await frame.evaluate(() => {
+      window.scrollTo(0, document.body.scrollHeight);
+    });
+
+    // Wait a bit for the iframe content to settle after scrolling
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // Get the iframe's position in the main page
+    const iframeOffset = await page.evaluate(() => {
+      const iframe = document.querySelector("section iframe");
+      if (!iframe) return null;
+      const rect = iframe.getBoundingClientRect();
+      return {
+        left: rect.left,
+        top: rect.top,
+      };
+    });
+
+    // Get the link's position within the iframe
+    const linkOffsetInFrame = await frame.evaluate(() => {
+      // Find the 88th row, 3rd column link (the one we're testing)
+      const table = document.querySelector(
+        "center > table > tbody > tr:nth-child(3) > td > table",
+      );
+      if (!table) return null;
+
+      const row88 = table.querySelector("tbody > tr:nth-child(88)");
+      if (!row88) return null;
+
+      const cell3 = row88.querySelector("td:nth-child(3)");
+      if (!cell3) return null;
+
+      const link = cell3.querySelector("span > a");
+      if (!link) return null;
+
+      const rect = link.getBoundingClientRect();
+      // Return center coordinates of the link relative to iframe
+      return {
+        x: rect.left + rect.width / 2,
+        y: rect.top + rect.height / 2,
+      };
+    });
+
+    // Combine iframe offset and link offset to get page-level coordinates
+    // Fallback to hardcoded coordinates if element not found (shouldn't happen)
+    const x =
+      iframeOffset && linkOffsetInFrame
+        ? iframeOffset.left + linkOffsetInFrame.x
+        : 356;
+    const y =
+      iframeOffset && linkOffsetInFrame
+        ? iframeOffset.top + linkOffsetInFrame.y
+        : 503;
+
+    const result = await resolveXpathForLocation(page, x, y);
+    console.log("=== Coordinates used:", { x, y });
+    console.log("=== Result:", result);
+    const xpath = result.absoluteXPath;
+    expect(xpath).toBe(
+      "/html[1]/body[1]/main[1]/section[3]/iframe[1]/html[1]/body[1]/center[1]/table[1]/tbody[1]/tr[3]/td[1]/table[1]/tbody[1]/tr[88]/td[3]/span[1]/a[1]",
+    );
+  });
+});
diff --git a/packages/core/tests/unit/agent-execution-model.test.ts b/packages/core/tests/unit/agent-execution-model.test.ts
new file mode 100644
index 000000000..1ab1b088b
--- /dev/null
+++ b/packages/core/tests/unit/agent-execution-model.test.ts
@@ -0,0 +1,170 @@
+import { describe, expect, it, vi } from "vitest";
+import { actTool } from "../../lib/v3/agent/tools/act.js";
+import { extractTool } from "../../lib/v3/agent/tools/extract.js";
+import { fillFormTool } from "../../lib/v3/agent/tools/fillform.js";
+import type { V3 } from "../../lib/v3/v3.js";
+
+/**
+ * Minimal mock of V3 that captures how tools pass `model` options
+ * into v3.act(), v3.extract(), and v3.observe().
+ */
+function createMockV3() {
+  const calls: { method: string; model: unknown }[] = [];
+
+  const mock = {
+    logger: vi.fn(),
+    recordAgentReplayStep: vi.fn(),
+    act: vi.fn(async (_instruction: unknown, options?: { model?: unknown }) => {
+      calls.push({ method: "act", model: options?.model });
+      return {
+        success: true,
+        message: "ok",
+        actionDescription: "clicked",
+        actions: [],
+      };
+    }),
+    extract: vi.fn(
+      async (
+        _instruction: unknown,
+        _schema: unknown,
+        options?: { model?: unknown },
+      ) => {
+        calls.push({ method: "extract", model: options?.model });
+        return { extraction: "data" };
+      },
+    ),
+    observe: vi.fn(
+      async (_instruction: unknown, options?: { model?: unknown }) => {
+        calls.push({ method: "observe", model: options?.model });
+        return [];
+      },
+    ),
+    calls,
+  };
+
+  return mock as unknown as V3 & { calls: typeof calls };
+}
+
+describe("agent tools pass full executionModel config to v3 methods", () => {
+  const modelConfig = {
+    modelName: "openai/gpt-4o-mini",
+    apiKey: "sk-test-key",
+    baseURL: "https://custom.api",
+  };
+
+  it("actTool passes AgentModelConfig object to v3.act()", async () => {
+    const v3 = createMockV3();
+    const tool = actTool(v3, modelConfig);
+    await tool.execute!(
+      { action: "click the button" },
+      {
+        toolCallId: "t1",
+        messages: [],
+        abortSignal: new AbortController().signal,
+      },
+    );
+
+    expect(v3.calls).toHaveLength(1);
+    expect(v3.calls[0].method).toBe("act");
+    expect(v3.calls[0].model).toBe(modelConfig);
+  });
+
+  it("extractTool passes AgentModelConfig object to v3.extract()", async () => {
+    const v3 = createMockV3();
+    const tool = extractTool(v3, modelConfig);
+    await tool.execute!(
+      { instruction: "get the title", schema: undefined },
+      {
+        toolCallId: "t2",
+        messages: [],
+        abortSignal: new AbortController().signal,
+      },
+    );
+
+    expect(v3.calls).toHaveLength(1);
+    expect(v3.calls[0].method).toBe("extract");
+    expect(v3.calls[0].model).toBe(modelConfig);
+  });
+
+  it("fillFormTool passes AgentModelConfig object to v3.observe()", async () => {
+    const v3 = createMockV3();
+    const tool = fillFormTool(v3, modelConfig);
+    await tool.execute!(
+      { fields: [{ action: "type hello into name", value: "hello" }] },
+      {
+        toolCallId: "t3",
+        messages: [],
+        abortSignal: new AbortController().signal,
+      },
+    );
+
+    expect(v3.calls).toHaveLength(1);
+    expect(v3.calls[0].method).toBe("observe");
+    expect(v3.calls[0].model).toBe(modelConfig);
+  });
+
+  it("actTool passes undefined when no executionModel is set", async () => {
+    const v3 = createMockV3();
+    const tool = actTool(v3, undefined);
+    await tool.execute!(
+      { action: "click the button" },
+      {
+        toolCallId: "t4",
+        messages: [],
+        abortSignal: new AbortController().signal,
+      },
+    );
+
+    expect(v3.calls).toHaveLength(1);
+    expect(v3.calls[0].model).toBeUndefined();
+  });
+
+  it("actTool passes plain string executionModel to v3.act()", async () => {
+    const v3 = createMockV3();
+    const tool = actTool(v3, "openai/gpt-4o-mini");
+    await tool.execute!(
+      { action: "click the button" },
+      {
+        toolCallId: "t5",
+        messages: [],
+        abortSignal: new AbortController().signal,
+      },
+    );
+
+    expect(v3.calls).toHaveLength(1);
+    expect(v3.calls[0].model).toBe("openai/gpt-4o-mini");
+  });
+});
+
+describe("executionModel fallback logic", () => {
+  // This mirrors the resolution in V3.prepareAgentExecution (v3.ts:1682):
+  //   const resolvedExecutionModel = options?.executionModel ?? options?.model;
+  function resolveExecutionModel(options?: {
+    executionModel?: string | { modelName: string };
+    model?: string | { modelName: string };
+  }) {
+    return options?.executionModel ?? options?.model;
+  }
+
+  it("prefers explicit executionModel over model", () => {
+    const result = resolveExecutionModel({
+      executionModel: "openai/gpt-4o-mini",
+      model: "anthropic/claude-sonnet-4-20250514",
+    });
+    expect(result).toBe("openai/gpt-4o-mini");
+  });
+
+  it("falls back to model when executionModel is not set", () => {
+    const modelConfig = {
+      modelName: "anthropic/claude-sonnet-4-20250514",
+      apiKey: "sk-test",
+    };
+    const result = resolveExecutionModel({ model: modelConfig });
+    expect(result).toBe(modelConfig);
+  });
+
+  it("returns undefined when neither is set", () => {
+    expect(resolveExecutionModel({})).toBeUndefined();
+    expect(resolveExecutionModel(undefined)).toBeUndefined();
+  });
+});
diff --git a/packages/core/tests/unit/api-multiregion.test.ts b/packages/core/tests/unit/api-multiregion.test.ts
new file mode 100644
index 000000000..3760a66c5
--- /dev/null
+++ b/packages/core/tests/unit/api-multiregion.test.ts
@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import { getApiUrlForRegion, REGION_API_URLS } from "../../lib/v3/api";
+
+describe("Multi-region API URL mapping", () => {
+  describe("REGION_API_URLS constant", () => {
+    it("should have the correct URL for us-west-2 (default)", () => {
+      expect(REGION_API_URLS["us-west-2"]).toBe(
+        "https://api.stagehand.browserbase.com",
+      );
+    });
+
+    it("should have the correct URL for us-east-1", () => {
+      expect(REGION_API_URLS["us-east-1"]).toBe(
+        "https://api.use1.stagehand.browserbase.com",
+      );
+    });
+
+    it("should have the correct URL for eu-central-1", () => {
+      expect(REGION_API_URLS["eu-central-1"]).toBe(
+        "https://api.euc1.stagehand.browserbase.com",
+      );
+    });
+
+    it("should have the correct URL for ap-southeast-1", () => {
+      expect(REGION_API_URLS["ap-southeast-1"]).toBe(
+        "https://api.apse1.stagehand.browserbase.com",
+      );
+    });
+  });
+
+  describe("getApiUrlForRegion", () => {
+    it("should return the correct URL for us-west-2", () => {
+      expect(getApiUrlForRegion("us-west-2")).toBe(
+        "https://api.stagehand.browserbase.com/v1",
+      );
+    });
+
+    it("should return the correct URL for us-east-1", () => {
+      expect(getApiUrlForRegion("us-east-1")).toBe(
+        "https://api.use1.stagehand.browserbase.com/v1",
+      );
+    });
+
+    it("should return the correct URL for eu-central-1", () => {
+      expect(getApiUrlForRegion("eu-central-1")).toBe(
+        "https://api.euc1.stagehand.browserbase.com/v1",
+      );
+    });
+
+    it("should return the correct URL for ap-southeast-1", () => {
+      expect(getApiUrlForRegion("ap-southeast-1")).toBe(
+        "https://api.apse1.stagehand.browserbase.com/v1",
+      );
+    });
+
+    it("should return the default us-west-2 URL when no region is specified", () => {
+      expect(getApiUrlForRegion(undefined)).toBe(
+        "https://api.stagehand.browserbase.com/v1",
+      );
+    });
+
+    it("should return the default us-west-2 URL for unknown regions", () => {
+      // @ts-expect-error - testing invalid region
+      expect(getApiUrlForRegion("invalid-region")).toBe(
+        "https://api.stagehand.browserbase.com/v1",
+      );
+    });
+  });
+
+  describe("URL /v1 suffix handling", () => {
+    it("getApiUrlForRegion always includes /v1 suffix for consistency", () => {
+      // getApiUrlForRegion returns a URL with /v1
+      // This documents the expected contract that all API base URLs include /v1
+      const url = getApiUrlForRegion("us-west-2");
+      expect(url.endsWith("/v1")).toBe(true);
+    });
+
+    it("all regional URLs should be base URLs without /v1 in REGION_API_URLS", () => {
+      // Verify REGION_API_URLS contains base URLs (without /v1)
+      // The /v1 suffix is added by getApiUrlForRegion
+      for (const [region, baseUrl] of Object.entries(REGION_API_URLS)) {
+        expect(baseUrl.endsWith("/v1")).toBe(false);
+        expect(getApiUrlForRegion(region as keyof typeof REGION_API_URLS)).toBe(
+          `${baseUrl}/v1`,
+        );
+      }
+    });
+  });
+});
diff --git a/packages/core/tests/unit/browserbase-session-accessors.test.ts b/packages/core/tests/unit/browserbase-session-accessors.test.ts
new file mode 100644
index 000000000..8ea305f94
--- /dev/null
+++ b/packages/core/tests/unit/browserbase-session-accessors.test.ts
@@ -0,0 +1,116 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import { V3 } from "../../lib/v3/v3.js";
+
+const MOCK_SESSION_ID = "session-123";
+const MOCK_SESSION_URL = `https://www.browserbase.com/sessions/${MOCK_SESSION_ID}`;
+const MOCK_DEBUG_URL = `https://debug.browserbase.com/${MOCK_SESSION_ID}`;
+
+vi.mock("../../lib/v3/understudy/context", () => {
+  class MockConnection {
+    onTransportClosed = vi.fn();
+    offTransportClosed = vi.fn();
+    send = vi.fn(async () => {});
+  }
+
+  class MockV3Context {
+    static async create(): Promise<MockV3Context> {
+      return new MockV3Context();
+    }
+
+    conn = new MockConnection();
+
+    pages(): never[] {
+      return [];
+    }
+
+    async close(): Promise<void> {
+      // noop
+    }
+  }
+
+  return { V3Context: MockV3Context };
+});
+
+vi.mock("../../lib/v3/launch/browserbase", () => ({
+  createBrowserbaseSession: vi.fn(async () => ({
+    ws: "wss://mock-browserbase",
+    sessionId: MOCK_SESSION_ID,
+    bb: {
+      sessions: {
+        debug: vi.fn(async () => ({ debuggerUrl: MOCK_DEBUG_URL })),
+      },
+    },
+  })),
+}));
+
+vi.mock("../../lib/v3/launch/local", () => ({
+  launchLocalChrome: vi.fn(async () => ({
+    ws: "ws://local-cdp",
+    chrome: { kill: vi.fn(async () => {}) },
+  })),
+}));
+
+describe("browserbase accessors", () => {
+  beforeEach(() => {
+    process.env.BROWSERBASE_API_KEY = "fake-key";
+    process.env.BROWSERBASE_PROJECT_ID = "fake-project";
+  });
+
+  afterEach(() => {
+    delete process.env.BROWSERBASE_API_KEY;
+    delete process.env.BROWSERBASE_PROJECT_ID;
+    vi.clearAllMocks();
+  });
+
+  it("exposes Browserbase session and debug URLs after init", async () => {
+    const v3 = new V3({
+      env: "BROWSERBASE",
+      disableAPI: true,
+      verbose: 0,
+    });
+
+    try {
+      await v3.init();
+
+      expect(v3.browserbaseSessionURL).toBe(MOCK_SESSION_URL);
+      expect(v3.browserbaseDebugURL).toBe(MOCK_DEBUG_URL);
+    } finally {
+      await v3.close().catch(() => {});
+    }
+  });
+
+  it("clears stored URLs after close", async () => {
+    const v3 = new V3({
+      env: "BROWSERBASE",
+      disableAPI: true,
+      verbose: 0,
+    });
+
+    await v3.init();
+    await v3.close();
+
+    expect(v3.browserbaseSessionURL).toBeUndefined();
+    expect(v3.browserbaseDebugURL).toBeUndefined();
+  });
+});
+
+describe("local accessors", () => {
+  it("stay empty for LOCAL environments", async () => {
+    const v3 = new V3({
+      env: "LOCAL",
+      disableAPI: true,
+      verbose: 0,
+      localBrowserLaunchOptions: {
+        cdpUrl: "ws://local-existing-session",
+      },
+    });
+
+    try {
+      await v3.init();
+      expect(v3.browserbaseSessionURL).toBeUndefined();
+      expect(v3.browserbaseDebugURL).toBeUndefined();
+    } finally {
+      await v3.close().catch(() => {});
+    }
+  });
+});
diff --git a/packages/core/tests/unit/cache-llm-resolution.test.ts b/packages/core/tests/unit/cache-llm-resolution.test.ts
new file mode 100644
index 000000000..a1c58a3f9
--- /dev/null
+++ b/packages/core/tests/unit/cache-llm-resolution.test.ts
@@ -0,0 +1,232 @@
+import { describe, expect, it, vi } from "vitest";
+import { ActCache } from "../../lib/v3/cache/ActCache.js";
+import { AgentCache } from "../../lib/v3/cache/AgentCache.js";
+import type { CacheStorage } from "../../lib/v3/cache/CacheStorage.js";
+import type { ActHandler } from "../../lib/v3/handlers/actHandler.js";
+import type { LLMClient } from "../../lib/v3/llm/LLMClient.js";
+import type { Page } from "../../lib/v3/understudy/page.js";
+import type { V3Context } from "../../lib/v3/understudy/context.js";
+import type {
+  ActCacheContext,
+  CachedActEntry,
+  CachedAgentEntry,
+  AgentCacheContext,
+  AgentReplayActStep,
+} from "../../lib/v3/types/private/index.js";
+import type {
+  Action,
+  AgentResult,
+  AvailableModel,
+} from "../../lib/v3/types/public/index.js";
+
+function createFakeStorage<T>(entry: T): CacheStorage {
+  return {
+    enabled: true,
+    readJson: vi.fn().mockResolvedValue({ value: entry }),
+    writeJson: vi.fn().mockResolvedValue({}),
+    directory: "/tmp/cache",
+  } as unknown as CacheStorage;
+}
+
+describe("Cache LLM client selection", () => {
+  it("ActCache uses provided override client during replay", async () => {
+    const action: Action = {
+      selector: "xpath=/html/body/button",
+      description: "click button",
+      method: "click",
+      arguments: [],
+    };
+
+    const entry: CachedActEntry = {
+      version: 1,
+      instruction: "click button",
+      url: "https://example.com",
+      variableKeys: [],
+      actions: [action],
+      actionDescription: "click button",
+      message: "done",
+    };
+
+    const storage = createFakeStorage(entry);
+    const handler = {
+      takeDeterministicAction: vi.fn().mockResolvedValue({
+        success: true,
+        message: "ok",
+        actionDescription: "click button",
+        actions: [action],
+      }),
+    } as unknown as ActHandler;
+    const defaultClient = { id: "default" } as unknown as LLMClient;
+    const overrideClient = { id: "override" } as unknown as LLMClient;
+
+    const cache = new ActCache({
+      storage,
+      logger: vi.fn(),
+      getActHandler: () => handler,
+      getDefaultLlmClient: () => defaultClient,
+      domSettleTimeoutMs: undefined,
+    });
+
+    const context: ActCacheContext = {
+      instruction: "click button",
+      cacheKey: "abc",
+      pageUrl: "https://example.com",
+      variableKeys: [],
+      variables: undefined,
+    };
+
+    const result = await cache.tryReplay(
+      context,
+      {} as Page,
+      undefined,
+      overrideClient,
+    );
+
+    expect(result?.success).toBe(true);
+    expect(handler.takeDeterministicAction).toHaveBeenCalledTimes(1);
+    const call = vi.mocked(handler.takeDeterministicAction).mock.calls[0];
+    expect(call?.[3]).toBe(overrideClient);
+  });
+
+  it("AgentCache uses provided override client during replay", async () => {
+    const action: Action = {
+      selector: "xpath=/html/body/input",
+      description: "type email",
+      method: "type",
+      arguments: ["test@example.com"],
+    };
+
+    const agentStep: AgentReplayActStep = {
+      type: "act",
+      instruction: "type email",
+      actions: [action],
+    };
+
+    const entry: CachedAgentEntry = {
+      version: 1,
+      instruction: "fill form",
+      startUrl: "https://example.com",
+      options: {},
+      configSignature: "sig",
+      steps: [agentStep],
+      result: { success: true, actions: [] } as AgentResult,
+      timestamp: new Date().toISOString(),
+    };
+
+    const storage = {
+      enabled: true,
+      readJson: vi.fn().mockImplementation(async () => ({ value: entry })),
+      writeJson: vi.fn().mockResolvedValue({}),
+      directory: "/tmp/cache",
+    } as unknown as CacheStorage;
+
+    const handler = {
+      takeDeterministicAction: vi.fn().mockResolvedValue({
+        success: true,
+        message: "ok",
+        actionDescription: "type email",
+        actions: [action],
+      }),
+    } as unknown as ActHandler;
+
+    const fakePage = {} as Page;
+    const ctx = {
+      awaitActivePage: vi.fn().mockResolvedValue(fakePage),
+    } as unknown as V3Context;
+
+    const defaultClient = { id: "default-agent" } as unknown as LLMClient;
+    const overrideClient = { id: "override-agent" } as unknown as LLMClient;
+
+    const cache = new AgentCache({
+      storage,
+      logger: vi.fn(),
+      getActHandler: () => handler,
+      getContext: () => ctx,
+      getDefaultLlmClient: () => defaultClient,
+      getBaseModelName: () => "openai/gpt-4.1-mini" as AvailableModel,
+      getSystemPrompt: () => undefined,
+      domSettleTimeoutMs: undefined,
+      act: vi.fn(),
+    });
+
+    const context: AgentCacheContext = {
+      instruction: "fill form",
+      startUrl: "https://example.com",
+      options: {},
+      configSignature: "sig",
+      cacheKey: "agent-key",
+      variableKeys: [],
+    };
+
+    const result = await cache.tryReplay(context, overrideClient);
+
+    expect(result?.success).toBe(true);
+    expect(handler.takeDeterministicAction).toHaveBeenCalledTimes(1);
+    const call = vi.mocked(handler.takeDeterministicAction).mock.calls[0];
+    expect(call?.[3]).toBe(overrideClient);
+  });
+
+  it("AgentCache replays non-act steps without requiring an override client", async () => {
+    const gotoEntry: CachedAgentEntry = {
+      version: 1,
+      instruction: "navigate home",
+      startUrl: "https://example.com/source",
+      options: {},
+      configSignature: "sig",
+      steps: [
+        {
+          type: "goto",
+          url: "https://example.com/target",
+          waitUntil: "load",
+        },
+      ],
+      result: { success: true, actions: [] } as AgentResult,
+      timestamp: new Date().toISOString(),
+    };
+
+    const storage = {
+      enabled: true,
+      readJson: vi.fn().mockResolvedValue({ value: gotoEntry }),
+      writeJson: vi.fn().mockResolvedValue({}),
+      directory: "/tmp/cache",
+    } as unknown as CacheStorage;
+
+    const handler = {
+      takeDeterministicAction: vi.fn(),
+    } as unknown as ActHandler;
+
+    const fakePage = { goto: vi.fn() } as unknown as Page;
+    const ctx = {
+      awaitActivePage: vi.fn().mockResolvedValue(fakePage),
+    } as unknown as V3Context;
+
+    const cache = new AgentCache({
+      storage,
+      logger: vi.fn(),
+      getActHandler: () => handler,
+      getContext: () => ctx,
+      getDefaultLlmClient: () => ({ id: "default" }) as unknown as LLMClient,
+      getBaseModelName: () => "openai/gpt-4.1-mini" as AvailableModel,
+      getSystemPrompt: () => undefined,
+      domSettleTimeoutMs: undefined,
+      act: vi.fn(),
+    });
+
+    const context: AgentCacheContext = {
+      instruction: "navigate home",
+      startUrl: "https://example.com/source",
+      options: {},
+      configSignature: "sig",
+      cacheKey: "agent-goto",
+      variableKeys: [],
+    };
+
+    const result = await cache.tryReplay(context);
+
+    expect(result?.success).toBe(true);
+    expect(handler.takeDeterministicAction).not.toHaveBeenCalled();
+    expect(fakePage.goto).toHaveBeenCalledWith("https://example.com/target", {
+      waitUntil: "load",
+    });
+  });
+});
diff --git a/packages/core/tests/unit/cdp-connection-close.test.ts b/packages/core/tests/unit/cdp-connection-close.test.ts
new file mode 100644
index 000000000..6418d5b43
--- /dev/null
+++ b/packages/core/tests/unit/cdp-connection-close.test.ts
@@ -0,0 +1,101 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { WebSocketServer, type WebSocket as ServerWebSocket } from "ws";
+import { CdpConnection } from "../../lib/v3/understudy/cdp.js";
+
+/**
+ * Races a promise against a timeout. Returns "resolved" if the promise
+ * settles before the deadline, or "timeout" if it doesn't.
+ */
+// TODO: dedupe this with the implementation in testUtils.ts after we unify the test directories
+function raceTimeout<T>(
+  promise: Promise<T>,
+  ms: number,
+): Promise<T | "timeout"> {
+  let timer: ReturnType<typeof setTimeout>;
+  const timeout = new Promise<"timeout">((resolve) => {
+    timer = setTimeout(() => resolve("timeout"), ms);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+
+/**
+ * Creates a local WebSocket server and connects a CdpConnection to it.
+ * Returns the connection plus a handle to the server-side socket.
+ */
+async function createPair(): Promise<{
+  conn: CdpConnection;
+  serverSocket: ServerWebSocket;
+  wss: WebSocketServer;
+}> {
+  const wss = new WebSocketServer({ port: 0 });
+  const port = (wss.address() as { port: number }).port;
+
+  const serverSocketPromise = new Promise<ServerWebSocket>((resolve) => {
+    wss.once("connection", resolve);
+  });
+
+  const conn = await CdpConnection.connect(`ws://localhost:${port}`);
+  const serverSocket = await serverSocketPromise;
+
+  return { conn, serverSocket, wss };
+}
+
+describe("CdpConnection", () => {
+  let wss: WebSocketServer | null = null;
+
+  afterEach(async () => {
+    if (wss) {
+      await new Promise<void>((resolve) => wss!.close(() => resolve()));
+      wss = null;
+    }
+  });
+
+  describe("close() when WebSocket is already closed", () => {
+    it("resolves instead of hanging forever", async () => {
+      const pair = await createPair();
+      wss = pair.wss;
+
+      // Wait for the client-side close event to be fully processed.
+      const transportClosed = new Promise<void>((resolve) => {
+        pair.conn.onTransportClosed(() => resolve());
+      });
+
+      // Simulate the hosted API terminating the Browserbase session:
+      // the server closes the WebSocket from its side.
+      pair.serverSocket.close();
+      await transportClosed;
+
+      // conn.close() on an already-CLOSED WebSocket must resolve.
+      // Without the fix it awaits a "close" event that already fired → hangs.
+      const result = await raceTimeout(
+        pair.conn.close().then(() => "resolved"),
+        3_000,
+      );
+
+      expect(result).toBe("resolved");
+    });
+  });
+
+  describe("inflight CDP calls on unexpected close", () => {
+    it("rejects pending calls instead of hanging forever", async () => {
+      const pair = await createPair();
+      wss = pair.wss;
+
+      // Send a CDP command; the mock server will never reply.
+      const pending = pair.conn.send("Runtime.evaluate", {
+        expression: "1+1",
+      });
+
+      // Server terminates the connection while the call is inflight.
+      pair.serverSocket.close();
+
+      // The pending promise must reject, not hang.
+      const result = await raceTimeout(
+        pending.then(() => "resolved").catch(() => "rejected"),
+        3_000,
+      );
+
+      expect(result).toBe("rejected");
+    });
+  });
+});
diff --git a/packages/core/tests/unit/context-extra-http-headers.test.ts b/packages/core/tests/unit/context-extra-http-headers.test.ts
new file mode 100644
index 000000000..6695e1d2e
--- /dev/null
+++ b/packages/core/tests/unit/context-extra-http-headers.test.ts
@@ -0,0 +1,84 @@
+import { describe, expect, it } from "vitest";
+import { V3Context } from "../../lib/v3/understudy/context.js";
+import { MockCDPSession } from "./helpers/mockCDPSession.js";
+import { StagehandSetExtraHTTPHeadersError } from "../../lib/v3/types/public/sdkErrors.js";
+
+type ContextStub = {
+  _sessionInit: Set<string>;
+  conn: {
+    getSession: (id: string) => MockCDPSession | undefined;
+  };
+  extraHttpHeaders: Record<string, string> | null;
+};
+
+const makeContext = (sessions: MockCDPSession[]): ContextStub => {
+  const sessionsById = new Map(
+    sessions.map((session) => [session.id, session]),
+  );
+  return {
+    _sessionInit: new Set(sessions.map((session) => session.id)),
+    conn: {
+      getSession: (id: string) => sessionsById.get(id),
+    },
+    extraHttpHeaders: null,
+  };
+};
+
+describe("V3Context.setExtraHTTPHeaders", () => {
+  const setExtraHTTPHeaders = V3Context.prototype.setExtraHTTPHeaders as (
+    this: ContextStub,
+    headers: Record<string, string>,
+  ) => Promise<void>;
+
+  it("sends headers to all sessions", async () => {
+    const sessionA = new MockCDPSession({}, "session-a");
+    const sessionB = new MockCDPSession({}, "session-b");
+    const ctx = makeContext([sessionA, sessionB]);
+
+    await setExtraHTTPHeaders.call(ctx, {
+      "x-stagehand-test": "yes",
+    });
+
+    for (const session of [sessionA, sessionB]) {
+      expect(session.callsFor("Network.enable").length).toBe(1);
+      expect(
+        session.callsFor("Network.setExtraHTTPHeaders")[0]?.params,
+      ).toEqual({
+        headers: { "x-stagehand-test": "yes" },
+      });
+    }
+  });
+
+  it("throws a custom error with session failure details", async () => {
+    const sessionA = new MockCDPSession(
+      {
+        "Network.setExtraHTTPHeaders": () => {
+          throw new Error("boom");
+        },
+      },
+      "session-a",
+    );
+    const sessionB = new MockCDPSession({}, "session-b");
+    const ctx = makeContext([sessionA, sessionB]);
+
+    const promise = setExtraHTTPHeaders.call(ctx, {
+      "x-stagehand-test": "yes",
+    });
+
+    await expect(promise).rejects.toBeInstanceOf(
+      StagehandSetExtraHTTPHeadersError,
+    );
+
+    try {
+      await promise;
+    } catch (error) {
+      const err = error as StagehandSetExtraHTTPHeadersError;
+      expect(err.failures).toHaveLength(1);
+      expect(err.failures[0]).toContain("session=session-a");
+      expect(err.failures[0]).toContain("boom");
+    }
+
+    expect(sessionA.callsFor("Network.setExtraHTTPHeaders").length).toBe(1);
+    expect(sessionB.callsFor("Network.setExtraHTTPHeaders").length).toBe(1);
+  });
+});
diff --git a/packages/core/tests/unit/cookies.test.ts b/packages/core/tests/unit/cookies.test.ts
new file mode 100644
index 000000000..a7b7e78b3
--- /dev/null
+++ b/packages/core/tests/unit/cookies.test.ts
@@ -0,0 +1,1150 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import {
+  filterCookies,
+  normalizeCookieParams,
+  cookieMatchesFilter,
+} from "../../lib/v3/understudy/cookies.js";
+import { MockCDPSession } from "./helpers/mockCDPSession.js";
+import type { V3Context } from "../../lib/v3/understudy/context.js";
+import { Cookie, CookieParam } from "../../lib/v3/types/public/context.js";
+
+function makeCookie(overrides: Partial<Cookie> = {}): Cookie {
+  return {
+    name: "sid",
+    value: "abc123",
+    domain: "example.com",
+    path: "/",
+    expires: -1,
+    httpOnly: false,
+    secure: false,
+    sameSite: "Lax",
+    ...overrides,
+  };
+}
+
+/** Convert our Cookie type into the shape CDP's Storage.getCookies returns. */
+function toCdpCookie(c: Cookie) {
+  return {
+    name: c.name,
+    value: c.value,
+    domain: c.domain,
+    path: c.path,
+    expires: c.expires,
+    httpOnly: c.httpOnly,
+    secure: c.secure,
+    sameSite: c.sameSite,
+    size: c.name.length + c.value.length,
+    session: c.expires === -1,
+    priority: "Medium",
+    sameParty: false,
+    sourceScheme: "Secure",
+    sourcePort: 443,
+  };
+}
+
+describe("filterCookies", () => {
+  const cookies: Cookie[] = [
+    makeCookie({ name: "a", domain: "example.com", path: "/", secure: false }),
+    makeCookie({
+      name: "b",
+      domain: ".example.com",
+      path: "/app",
+      secure: true,
+    }),
+    makeCookie({ name: "c", domain: "other.com", path: "/", secure: false }),
+    makeCookie({
+      name: "d",
+      domain: "sub.example.com",
+      path: "/",
+      secure: false,
+    }),
+  ];
+
+  it("returns all cookies when urls is empty", () => {
+    expect(filterCookies(cookies, [])).toEqual(cookies);
+  });
+
+  it("filters by domain (exact host match)", () => {
+    const result = filterCookies(cookies, ["http://example.com/"]);
+    const names = result.map((c) => c.name);
+    expect(names).toContain("a");
+    // "b" (.example.com) domain-matches but is secure — excluded on http://
+    expect(names).not.toContain("b");
+    expect(names).not.toContain("c");
+    expect(names).not.toContain("d");
+  });
+
+  it("filters by domain (dot-prefixed domain matches on https)", () => {
+    const result = filterCookies(cookies, ["https://example.com/app/settings"]);
+    const names = result.map((c) => c.name);
+    expect(names).toContain("a"); // example.com domain match, path "/" prefix
+    expect(names).toContain("b"); // .example.com domain match + secure + https
+  });
+
+  it("filters by domain (subdomain matches dot-prefixed domain)", () => {
+    const result = filterCookies(cookies, ["http://sub.example.com/"]);
+    const names = result.map((c) => c.name);
+    // "a" (example.com) → prepend dot → .example.com → matches .sub.example.com
+    expect(names).toContain("a");
+    // "b" (.example.com) domain-matches sub.example.com but is secure — excluded on http://
+    expect(names).not.toContain("b");
+    expect(names).toContain("d"); // sub.example.com matches exactly
+    expect(names).not.toContain("c");
+  });
+
+  it("filters by path prefix", () => {
+    const result = filterCookies(cookies, ["https://example.com/app/settings"]);
+    const names = result.map((c) => c.name);
+    expect(names).toContain("a"); // path "/" is a prefix of "/app/settings"
+    expect(names).toContain("b"); // path "/app" is a prefix of "/app/settings"
+  });
+
+  it("excludes secure cookies for non-https URLs", () => {
+    const result = filterCookies(cookies, ["http://example.com/app/page"]);
+    const names = result.map((c) => c.name);
+    expect(names).toContain("a");
+    expect(names).not.toContain("b"); // secure cookie, http URL
+  });
+
+  it("allows secure cookies on loopback addresses regardless of protocol", () => {
+    const cases = [
+      { domain: "localhost", url: "http://localhost/" },
+      { domain: "127.0.0.1", url: "http://127.0.0.1/" },
+      { domain: "[::1]", url: "http://[::1]/" },
+    ];
+    for (const { domain, url } of cases) {
+      const cookie = makeCookie({ name: "loop", domain, secure: true });
+      const result = filterCookies([cookie], [url]);
+      expect(result).toHaveLength(1);
+      expect(result[0]!.name).toBe("loop");
+    }
+  });
+
+  it("matches against multiple URLs (union)", () => {
+    const result = filterCookies(cookies, [
+      "http://example.com/",
+      "http://other.com/",
+    ]);
+    const names = result.map((c) => c.name);
+    expect(names).toContain("a");
+    expect(names).toContain("c");
+  });
+
+  it("returns empty array when no cookies match any URL", () => {
+    const result = filterCookies(cookies, ["http://nomatch.dev/"]);
+    expect(result).toHaveLength(0);
+  });
+
+  it("returns empty array when cookie list is empty", () => {
+    const result = filterCookies([], ["http://example.com/"]);
+    expect(result).toHaveLength(0);
+  });
+
+  it("does not match a sibling subdomain against a host-only domain", () => {
+    // Cookie for "api.example.com" should NOT match "www.example.com"
+    const apiCookie = makeCookie({ name: "api", domain: "api.example.com" });
+    const result = filterCookies([apiCookie], ["http://www.example.com/"]);
+    expect(result).toHaveLength(0);
+  });
+
+  it("does not match a parent domain against a more specific cookie", () => {
+    // Cookie for "sub.example.com" should NOT match "example.com"
+    const subCookie = makeCookie({ name: "sub", domain: "sub.example.com" });
+    const result = filterCookies([subCookie], ["http://example.com/"]);
+    expect(result).toHaveLength(0);
+  });
+
+  it("does not match when path does not prefix the URL path", () => {
+    const deepCookie = makeCookie({
+      name: "deep",
+      domain: "example.com",
+      path: "/admin",
+    });
+    const result = filterCookies([deepCookie], ["http://example.com/public"]);
+    expect(result).toHaveLength(0);
+  });
+
+  it("does not match when cookie path is a string prefix but not a path boundary", () => {
+    // "/foo" should NOT match "/foobar" — only "/foo", "/foo/", "/foo/bar"
+    const cookie = makeCookie({
+      name: "boundary",
+      domain: "example.com",
+      path: "/foo",
+    });
+    expect(filterCookies([cookie], ["http://example.com/foobar"])).toHaveLength(
+      0,
+    );
+    expect(filterCookies([cookie], ["http://example.com/foo"])).toHaveLength(1);
+    expect(
+      filterCookies([cookie], ["http://example.com/foo/bar"]),
+    ).toHaveLength(1);
+  });
+
+  it("matches root path against any URL path", () => {
+    const rootCookie = makeCookie({
+      name: "root",
+      domain: "example.com",
+      path: "/",
+    });
+    const result = filterCookies(
+      [rootCookie],
+      ["http://example.com/deeply/nested/page"],
+    );
+    expect(result).toHaveLength(1);
+  });
+
+  it("handles URL with port numbers", () => {
+    const c = makeCookie({ name: "port", domain: "localhost", path: "/" });
+    const result = filterCookies([c], ["http://localhost:3000/api"]);
+    expect(result).toHaveLength(1);
+  });
+
+  it("handles URL with query string and fragment", () => {
+    const c = makeCookie({ name: "q", domain: "example.com", path: "/" });
+    const result = filterCookies(
+      [c],
+      ["http://example.com/page?q=1&r=2#section"],
+    );
+    expect(result).toHaveLength(1);
+  });
+
+  it("throws CookieValidationError for malformed URL", () => {
+    const c = makeCookie({ name: "a", domain: "example.com" });
+    expect(() => filterCookies([c], ["not-a-valid-url"])).toThrow(
+      /Invalid URL passed to cookies\(\)/,
+    );
+  });
+});
+
+describe("normalizeCookieParams", () => {
+  it("passes through cookies with domain+path", () => {
+    const input: CookieParam[] = [
+      { name: "a", value: "1", domain: "example.com", path: "/" },
+    ];
+    const result = normalizeCookieParams(input);
+    expect(result[0]!.domain).toBe("example.com");
+    expect(result[0]!.path).toBe("/");
+    expect(result[0]!.url).toBeUndefined();
+  });
+
+  it("derives domain, path, and secure from url", () => {
+    const input: CookieParam[] = [
+      { name: "a", value: "1", url: "https://example.com/app/page" },
+    ];
+    const result = normalizeCookieParams(input);
+    expect(result[0]!.domain).toBe("example.com");
+    expect(result[0]!.path).toBe("/app/");
+    expect(result[0]!.secure).toBe(true);
+    expect(result[0]!.url).toBeUndefined();
+  });
+
+  it("sets secure to false for http urls", () => {
+    const input: CookieParam[] = [
+      { name: "a", value: "1", url: "http://example.com/" },
+    ];
+    const result = normalizeCookieParams(input);
+    expect(result[0]!.secure).toBe(false);
+  });
+
+  it("throws when neither url nor domain+path is provided", () => {
+    expect(() => normalizeCookieParams([{ name: "a", value: "1" }])).toThrow(
+      /must have a url or a domain\/path pair/,
+    );
+  });
+
+  it("throws when both url and domain are provided", () => {
+    expect(() =>
+      normalizeCookieParams([
+        { name: "a", value: "1", url: "https://x.com/", domain: "x.com" },
+      ]),
+    ).toThrow(/should have either url or domain/);
+  });
+
+  it("throws when both url and path are provided", () => {
+    expect(() =>
+      normalizeCookieParams([
+        { name: "a", value: "1", url: "https://x.com/", path: "/" },
+      ]),
+    ).toThrow(/should have either url or path/);
+  });
+
+  it("throws for invalid expires (negative, not -1)", () => {
+    expect(() =>
+      normalizeCookieParams([
+        { name: "a", value: "1", domain: "x.com", path: "/", expires: -5 },
+      ]),
+    ).toThrow(/invalid expires/);
+  });
+
+  it("allows expires of -1 (session cookie)", () => {
+    const result = normalizeCookieParams([
+      { name: "a", value: "1", domain: "x.com", path: "/", expires: -1 },
+    ]);
+    expect(result[0]!.expires).toBe(-1);
+  });
+
+  it("allows a positive expires timestamp", () => {
+    const future = Math.floor(Date.now() / 1000) + 3600;
+    const result = normalizeCookieParams([
+      { name: "a", value: "1", domain: "x.com", path: "/", expires: future },
+    ]);
+    expect(result[0]!.expires).toBe(future);
+  });
+
+  it("throws for about:blank url", () => {
+    expect(() =>
+      normalizeCookieParams([{ name: "a", value: "1", url: "about:blank" }]),
+    ).toThrow(/Blank page/);
+  });
+
+  it("throws for data: url", () => {
+    expect(() =>
+      normalizeCookieParams([
+        { name: "a", value: "1", url: "data:text/html,hi" },
+      ]),
+    ).toThrow(/Data URL/);
+  });
+
+  it("throws CookieValidationError for malformed url", () => {
+    expect(() =>
+      normalizeCookieParams([{ name: "a", value: "1", url: "not-a-url" }]),
+    ).toThrow(/Cookie "a" has an invalid url/);
+  });
+
+  it("throws when sameSite is None but secure is false", () => {
+    expect(() =>
+      normalizeCookieParams([
+        {
+          name: "a",
+          value: "1",
+          domain: "x.com",
+          path: "/",
+          sameSite: "None",
+          secure: false,
+        },
+      ]),
+    ).toThrow(/sameSite: "None" without secure: true/);
+  });
+
+  it("throws when sameSite is None and secure is omitted (undefined)", () => {
+    // CDP defaults secure to false when omitted, so the browser will reject it.
+    expect(() =>
+      normalizeCookieParams([
+        { name: "a", value: "1", domain: "x.com", path: "/", sameSite: "None" },
+      ]),
+    ).toThrow(/sameSite: "None" without secure: true/);
+  });
+
+  it("does NOT throw when sameSite is None and secure is true", () => {
+    const result = normalizeCookieParams([
+      {
+        name: "a",
+        value: "1",
+        domain: "x.com",
+        path: "/",
+        sameSite: "None",
+        secure: true,
+      },
+    ]);
+    expect(result[0]!.sameSite).toBe("None");
+    expect(result[0]!.secure).toBe(true);
+  });
+
+  it("derives root path from URL with no trailing path segments", () => {
+    const result = normalizeCookieParams([
+      { name: "a", value: "1", url: "https://example.com" },
+    ]);
+    // URL("https://example.com").pathname is "/", lastIndexOf("/") + 1 = 1 → "/"
+    expect(result[0]!.path).toBe("/");
+  });
+
+  it("handles URL with port number", () => {
+    const result = normalizeCookieParams([
+      { name: "a", value: "1", url: "https://localhost:3000/api/v1" },
+    ]);
+    expect(result[0]!.domain).toBe("localhost");
+    expect(result[0]!.path).toBe("/api/");
+    expect(result[0]!.secure).toBe(true);
+  });
+
+  it("handles URL with query string (ignores query)", () => {
+    const result = normalizeCookieParams([
+      { name: "a", value: "1", url: "https://example.com/page?q=1" },
+    ]);
+    expect(result[0]!.domain).toBe("example.com");
+    expect(result[0]!.path).toBe("/");
+  });
+
+  it("normalises multiple cookies in a single call", () => {
+    const result = normalizeCookieParams([
+      { name: "a", value: "1", url: "https://one.com/x" },
+      { name: "b", value: "2", domain: "two.com", path: "/" },
+      { name: "c", value: "3", url: "http://three.com/y/z" },
+    ]);
+    expect(result).toHaveLength(3);
+    expect(result[0]!.domain).toBe("one.com");
+    expect(result[1]!.domain).toBe("two.com");
+    expect(result[2]!.domain).toBe("three.com");
+    expect(result[2]!.secure).toBe(false);
+  });
+
+  it("does not mutate the original input array", () => {
+    const input: CookieParam[] = [
+      { name: "a", value: "1", url: "https://example.com/app" },
+    ];
+    const frozen = { ...input[0]! };
+    normalizeCookieParams(input);
+    expect(input[0]).toEqual(frozen);
+  });
+
+  it("preserves optional fields that are explicitly set", () => {
+    const result = normalizeCookieParams([
+      {
+        name: "full",
+        value: "val",
+        domain: "x.com",
+        path: "/p",
+        expires: 9999999999,
+        httpOnly: true,
+        secure: true,
+        sameSite: "Strict",
+      },
+    ]);
+    const c = result[0]!;
+    expect(c.httpOnly).toBe(true);
+    expect(c.secure).toBe(true);
+    expect(c.sameSite).toBe("Strict");
+    expect(c.expires).toBe(9999999999);
+  });
+
+  it("allows expires of 0 (epoch — effectively expired)", () => {
+    // 0 is a positive-ish edge case; browsers treat it as already expired
+    const result = normalizeCookieParams([
+      { name: "a", value: "1", domain: "x.com", path: "/", expires: 0 },
+    ]);
+    expect(result[0]!.expires).toBe(0);
+  });
+
+  it("throws on the first invalid cookie in a batch", () => {
+    expect(() =>
+      normalizeCookieParams([
+        { name: "ok", value: "1", domain: "x.com", path: "/" },
+        { name: "bad", value: "2" }, // missing url/domain+path
+      ]),
+    ).toThrow(/Cookie "bad"/);
+  });
+
+  it("includes cookie name in every error message", () => {
+    const cases = [
+      () => normalizeCookieParams([{ name: "NAMED", value: "1" }]),
+      () =>
+        normalizeCookieParams([
+          { name: "NAMED", value: "1", url: "https://x.com/", domain: "x" },
+        ]),
+      () =>
+        normalizeCookieParams([
+          { name: "NAMED", value: "1", url: "about:blank" },
+        ]),
+      () =>
+        normalizeCookieParams([
+          {
+            name: "NAMED",
+            value: "1",
+            domain: "x.com",
+            path: "/",
+            sameSite: "None",
+            secure: false,
+          },
+        ]),
+    ];
+    for (const fn of cases) {
+      expect(fn).toThrow(/NAMED/);
+    }
+  });
+});
+
+describe("cookieMatchesFilter", () => {
+  const cookie = makeCookie({
+    name: "session",
+    domain: ".example.com",
+    path: "/app",
+  });
+
+  it("matches when all filters match (exact strings)", () => {
+    expect(
+      cookieMatchesFilter(cookie, {
+        name: "session",
+        domain: ".example.com",
+        path: "/app",
+      }),
+    ).toBe(true);
+  });
+
+  it("does not match when name differs", () => {
+    expect(cookieMatchesFilter(cookie, { name: "other" })).toBe(false);
+  });
+
+  it("does not match when domain differs", () => {
+    expect(cookieMatchesFilter(cookie, { domain: "other.com" })).toBe(false);
+  });
+
+  it("does not match when path differs", () => {
+    expect(cookieMatchesFilter(cookie, { path: "/other" })).toBe(false);
+  });
+
+  it("matches with regex name", () => {
+    expect(cookieMatchesFilter(cookie, { name: /^sess/ })).toBe(true);
+    expect(cookieMatchesFilter(cookie, { name: /^nope/ })).toBe(false);
+  });
+
+  it("matches with regex domain", () => {
+    expect(cookieMatchesFilter(cookie, { domain: /example\.com$/ })).toBe(true);
+    expect(cookieMatchesFilter(cookie, { domain: /^other/ })).toBe(false);
+  });
+
+  it("matches with regex path", () => {
+    expect(cookieMatchesFilter(cookie, { path: /^\/app/ })).toBe(true);
+  });
+
+  it("undefined filters match everything", () => {
+    expect(cookieMatchesFilter(cookie, {})).toBe(true);
+    expect(cookieMatchesFilter(cookie, { name: undefined })).toBe(true);
+  });
+
+  it("requires ALL filters to match (AND logic)", () => {
+    // name matches but domain does not
+    expect(
+      cookieMatchesFilter(cookie, { name: "session", domain: "wrong.com" }),
+    ).toBe(false);
+  });
+
+  it("handles global regex lastIndex correctly", () => {
+    const re = /sess/g;
+    re.lastIndex = 999;
+    expect(cookieMatchesFilter(cookie, { name: re })).toBe(true);
+  });
+
+  it("exact string does not do substring matching", () => {
+    // filter name "sess" should NOT match cookie name "session"
+    expect(cookieMatchesFilter(cookie, { name: "sess" })).toBe(false);
+  });
+
+  it("regex can do substring matching", () => {
+    // regex /sess/ SHOULD match cookie name "session" (substring)
+    expect(cookieMatchesFilter(cookie, { name: /sess/ })).toBe(true);
+  });
+
+  it("works with all three regex filters combined", () => {
+    expect(
+      cookieMatchesFilter(cookie, {
+        name: /^session$/,
+        domain: /example/,
+        path: /^\/app$/,
+      }),
+    ).toBe(true);
+
+    // One of three fails
+    expect(
+      cookieMatchesFilter(cookie, {
+        name: /^session$/,
+        domain: /example/,
+        path: /^\/wrong$/,
+      }),
+    ).toBe(false);
+  });
+
+  it("empty string filter only matches empty cookie property", () => {
+    const emptyPathCookie = makeCookie({
+      name: "x",
+      domain: "a.com",
+      path: "",
+    });
+    expect(cookieMatchesFilter(emptyPathCookie, { path: "" })).toBe(true);
+    expect(cookieMatchesFilter(cookie, { path: "" })).toBe(false);
+  });
+
+  it("is called once per cookie (no cross-contamination between calls)", () => {
+    const c1 = makeCookie({ name: "alpha", domain: "a.com", path: "/" });
+    const c2 = makeCookie({ name: "beta", domain: "b.com", path: "/x" });
+    const filter = { name: "alpha", domain: "a.com" };
+    expect(cookieMatchesFilter(c1, filter)).toBe(true);
+    expect(cookieMatchesFilter(c2, filter)).toBe(false);
+  });
+});
+
+describe("V3Context cookie methods", () => {
+  // We test V3Context methods by constructing a minimal instance with a mock
+  // CDP connection. V3Context.create() requires a real WebSocket, so we build
+  // one via type-casting a MockCDPSession into the `conn` slot.
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let V3ContextClass: { prototype: V3Context } & Record<string, any>;
+
+  beforeEach(async () => {
+    const mod = await import("../../lib/v3/understudy/context.js");
+    V3ContextClass = mod.V3Context as typeof V3ContextClass;
+  });
+
+  function makeContext(
+    cdpHandlers: Record<string, (params?: Record<string, unknown>) => unknown>,
+  ): V3Context {
+    const mockConn = new MockCDPSession(cdpHandlers, "root");
+    // V3Context stores the connection as `conn` (readonly). We create an
+    // object with the real prototype so we get the actual method implementations.
+    const ctx = Object.create(V3ContextClass.prototype) as V3Context & {
+      conn: MockCDPSession;
+    };
+    // Assign the mock connection
+    Object.defineProperty(ctx, "conn", { value: mockConn, writable: false });
+    return ctx;
+  }
+
+  function getMockConn(ctx: V3Context): MockCDPSession {
+    return (ctx as unknown as { conn: MockCDPSession }).conn;
+  }
+
+  describe("cookies()", () => {
+    it("returns all cookies from Storage.getCookies", async () => {
+      const cdpCookies = [
+        toCdpCookie(makeCookie({ name: "a", domain: "example.com" })),
+        toCdpCookie(makeCookie({ name: "b", domain: "other.com" })),
+      ];
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: cdpCookies }),
+      });
+
+      const result = await ctx.cookies();
+      expect(result).toHaveLength(2);
+      expect(result.map((c) => c.name)).toEqual(["a", "b"]);
+    });
+
+    it("filters by URL when provided as string", async () => {
+      const cdpCookies = [
+        toCdpCookie(makeCookie({ name: "a", domain: "example.com" })),
+        toCdpCookie(makeCookie({ name: "b", domain: "other.com" })),
+      ];
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: cdpCookies }),
+      });
+
+      const result = await ctx.cookies("http://example.com/");
+      expect(result).toHaveLength(1);
+      expect(result[0]!.name).toBe("a");
+    });
+
+    it("filters by URL when provided as array", async () => {
+      const cdpCookies = [
+        toCdpCookie(makeCookie({ name: "a", domain: "example.com" })),
+        toCdpCookie(makeCookie({ name: "b", domain: "other.com" })),
+      ];
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: cdpCookies }),
+      });
+
+      const result = await ctx.cookies(["http://other.com/"]);
+      expect(result).toHaveLength(1);
+      expect(result[0]!.name).toBe("b");
+    });
+
+    it("defaults sameSite to Lax when CDP returns undefined", async () => {
+      const cdpCookie = {
+        ...toCdpCookie(makeCookie()),
+        sameSite: undefined as string | undefined,
+      };
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: [cdpCookie] }),
+      });
+
+      const result = await ctx.cookies();
+      expect(result[0]!.sameSite).toBe("Lax");
+    });
+
+    it("returns empty array when browser has no cookies", async () => {
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: [] }),
+      });
+      const result = await ctx.cookies();
+      expect(result).toEqual([]);
+    });
+
+    it("maps all CDP cookie fields to our Cookie type", async () => {
+      const cdpCookie = toCdpCookie(
+        makeCookie({
+          name: "full",
+          value: "v",
+          domain: ".test.com",
+          path: "/p",
+          expires: 1700000000,
+          httpOnly: true,
+          secure: true,
+          sameSite: "Strict",
+        }),
+      );
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: [cdpCookie] }),
+      });
+
+      const result = await ctx.cookies();
+      expect(result[0]).toEqual({
+        name: "full",
+        value: "v",
+        domain: ".test.com",
+        path: "/p",
+        expires: 1700000000,
+        httpOnly: true,
+        secure: true,
+        sameSite: "Strict",
+      });
+    });
+
+    it("strips extra CDP fields (size, priority, etc.) from result", async () => {
+      const cdpCookie = toCdpCookie(makeCookie({ name: "stripped" }));
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: [cdpCookie] }),
+      });
+
+      const result = await ctx.cookies();
+      const keys = Object.keys(result[0]!);
+      expect(keys).not.toContain("size");
+      expect(keys).not.toContain("priority");
+      expect(keys).not.toContain("sourceScheme");
+      expect(keys).not.toContain("sourcePort");
+    });
+
+    it("calls Storage.getCookies exactly once per invocation", async () => {
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: [] }),
+      });
+
+      await ctx.cookies();
+      await ctx.cookies("http://example.com");
+
+      const calls = getMockConn(ctx).callsFor("Storage.getCookies");
+      expect(calls).toHaveLength(2);
+    });
+  });
+
+  describe("addCookies()", () => {
+    it("sends all cookies in a single Storage.setCookies call", async () => {
+      const ctx = makeContext({
+        "Storage.setCookies": () => ({}),
+      });
+
+      await ctx.addCookies([
+        { name: "a", value: "1", domain: "example.com", path: "/" },
+        { name: "b", value: "2", domain: "other.com", path: "/" },
+      ]);
+
+      const calls = getMockConn(ctx).callsFor("Storage.setCookies");
+      expect(calls).toHaveLength(1);
+      expect(calls[0]!.params).toMatchObject({
+        cookies: [
+          { name: "a", domain: "example.com" },
+          { name: "b", domain: "other.com" },
+        ],
+      });
+    });
+
+    it("derives domain/path/secure from url", async () => {
+      const ctx = makeContext({
+        "Storage.setCookies": () => ({}),
+      });
+
+      await ctx.addCookies([
+        { name: "a", value: "1", url: "https://example.com/app/page" },
+      ]);
+
+      const calls = getMockConn(ctx).callsFor("Storage.setCookies");
+      expect(calls[0]!.params).toMatchObject({
+        cookies: [
+          { name: "a", domain: "example.com", path: "/app/", secure: true },
+        ],
+      });
+    });
+
+    it("throws when Storage.setCookies fails", async () => {
+      const ctx = makeContext({
+        "Storage.setCookies": () => {
+          throw new Error("CDP failure");
+        },
+      });
+
+      await expect(
+        ctx.addCookies([
+          { name: "bad", value: "x", domain: "example.com", path: "/" },
+        ]),
+      ).rejects.toThrow(/Failed to set cookies \["bad"\]/);
+    });
+
+    it("throws for sameSite None without secure", async () => {
+      const ctx = makeContext({
+        "Storage.setCookies": () => ({}),
+      });
+
+      await expect(
+        ctx.addCookies([
+          {
+            name: "x",
+            value: "1",
+            domain: "example.com",
+            path: "/",
+            sameSite: "None",
+            secure: false,
+          },
+        ]),
+      ).rejects.toThrow(/sameSite: "None" without secure: true/);
+    });
+
+    it("does nothing when passed an empty array", async () => {
+      const ctx = makeContext({
+        "Storage.setCookies": () => ({}),
+      });
+
+      await ctx.addCookies([]);
+
+      const calls = getMockConn(ctx).callsFor("Storage.setCookies");
+      expect(calls).toHaveLength(0);
+    });
+
+    it("sends all cookie fields to CDP (including optional ones)", async () => {
+      const ctx = makeContext({
+        "Storage.setCookies": () => ({}),
+      });
+
+      await ctx.addCookies([
+        {
+          name: "full",
+          value: "val",
+          domain: "x.com",
+          path: "/p",
+          expires: 9999999999,
+          httpOnly: true,
+          secure: true,
+          sameSite: "Strict",
+        },
+      ]);
+
+      const calls = getMockConn(ctx).callsFor("Storage.setCookies");
+      expect(calls[0]!.params).toEqual({
+        cookies: [
+          {
+            name: "full",
+            value: "val",
+            domain: "x.com",
+            path: "/p",
+            expires: 9999999999,
+            httpOnly: true,
+            secure: true,
+            sameSite: "Strict",
+          },
+        ],
+      });
+    });
+
+    it("error message includes all cookie names when batch fails", async () => {
+      const ctx = makeContext({
+        "Storage.setCookies": () => {
+          throw new Error("CDP failure");
+        },
+      });
+
+      await expect(
+        ctx.addCookies([
+          { name: "alpha", value: "1", domain: "a.com", path: "/" },
+          { name: "beta", value: "2", domain: "b.com", path: "/" },
+        ]),
+      ).rejects.toThrow(/Failed to set cookies \["alpha", "beta"\]/);
+    });
+  });
+
+  describe("clearCookies()", () => {
+    const cdpCookies = [
+      toCdpCookie(
+        makeCookie({ name: "session", domain: "example.com", path: "/" }),
+      ),
+      toCdpCookie(
+        makeCookie({ name: "_ga", domain: ".example.com", path: "/" }),
+      ),
+      toCdpCookie(
+        makeCookie({ name: "pref", domain: "other.com", path: "/settings" }),
+      ),
+    ];
+
+    it("uses atomic Storage.clearCookies when called with no options", async () => {
+      const ctx = makeContext({
+        "Storage.clearCookies": () => ({}),
+      });
+
+      await ctx.clearCookies();
+
+      const clearCalls = getMockConn(ctx).callsFor("Storage.clearCookies");
+      expect(clearCalls).toHaveLength(1);
+
+      // Should NOT have fetched or re-set anything
+      const getCalls = getMockConn(ctx).callsFor("Storage.getCookies");
+      expect(getCalls).toHaveLength(0);
+      const setCalls = getMockConn(ctx).callsFor("Storage.setCookies");
+      expect(setCalls).toHaveLength(0);
+    });
+
+    it("clears and re-adds only non-matching cookies (name filter)", async () => {
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: [...cdpCookies] }),
+        "Storage.clearCookies": () => ({}),
+        "Storage.setCookies": () => ({}),
+      });
+
+      await ctx.clearCookies({ name: "_ga" });
+
+      const clearCalls = getMockConn(ctx).callsFor("Storage.clearCookies");
+      expect(clearCalls).toHaveLength(1);
+
+      const setCalls = getMockConn(ctx).callsFor("Storage.setCookies");
+      expect(setCalls).toHaveLength(1);
+      const kept = (
+        setCalls[0]!.params?.cookies as Array<{ name: string }>
+      ).map((c) => c.name);
+      expect(kept).toEqual(["session", "pref"]);
+    });
+
+    it("clears and re-adds only non-matching cookies (domain filter)", async () => {
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: [...cdpCookies] }),
+        "Storage.clearCookies": () => ({}),
+        "Storage.setCookies": () => ({}),
+      });
+
+      await ctx.clearCookies({ domain: "other.com" });
+
+      const setCalls = getMockConn(ctx).callsFor("Storage.setCookies");
+      const kept = (
+        setCalls[0]!.params?.cookies as Array<{ name: string }>
+      ).map((c) => c.name);
+      expect(kept).toEqual(["session", "_ga"]);
+    });
+
+    it("clears and re-adds only non-matching cookies (regex name)", async () => {
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: [...cdpCookies] }),
+        "Storage.clearCookies": () => ({}),
+        "Storage.setCookies": () => ({}),
+      });
+
+      await ctx.clearCookies({ name: /^_ga/ });
+
+      const setCalls = getMockConn(ctx).callsFor("Storage.setCookies");
+      const kept = (
+        setCalls[0]!.params?.cookies as Array<{ name: string }>
+      ).map((c) => c.name);
+      expect(kept).toEqual(["session", "pref"]);
+    });
+
+    it("applies AND logic across multiple filters", async () => {
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: [...cdpCookies] }),
+        "Storage.clearCookies": () => ({}),
+        "Storage.setCookies": () => ({}),
+      });
+
+      await ctx.clearCookies({ name: "session", domain: "example.com" });
+
+      const setCalls = getMockConn(ctx).callsFor("Storage.setCookies");
+      const kept = (
+        setCalls[0]!.params?.cookies as Array<{ name: string }>
+      ).map((c) => c.name);
+      expect(kept).toEqual(["_ga", "pref"]);
+    });
+
+    it("does nothing when filter matches no cookies", async () => {
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: [...cdpCookies] }),
+        "Storage.clearCookies": () => ({}),
+        "Storage.setCookies": () => ({}),
+      });
+
+      await ctx.clearCookies({ name: "nonexistent" });
+
+      const clearCalls = getMockConn(ctx).callsFor("Storage.clearCookies");
+      expect(clearCalls).toHaveLength(0);
+      const setCalls = getMockConn(ctx).callsFor("Storage.setCookies");
+      expect(setCalls).toHaveLength(0);
+    });
+
+    it("clears without re-adding when filter matches all cookies", async () => {
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: [...cdpCookies] }),
+        "Storage.clearCookies": () => ({}),
+        "Storage.setCookies": () => ({}),
+      });
+
+      await ctx.clearCookies({ name: /.*/ });
+
+      const clearCalls = getMockConn(ctx).callsFor("Storage.clearCookies");
+      expect(clearCalls).toHaveLength(1);
+      const setCalls = getMockConn(ctx).callsFor("Storage.setCookies");
+      expect(setCalls).toHaveLength(0);
+    });
+
+    it("handles regex that matches multiple cookies", async () => {
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({
+          cookies: [
+            toCdpCookie(
+              makeCookie({ name: "_ga_ABC", domain: "example.com", path: "/" }),
+            ),
+            toCdpCookie(
+              makeCookie({ name: "_ga_DEF", domain: "example.com", path: "/" }),
+            ),
+            toCdpCookie(
+              makeCookie({ name: "_gid", domain: "example.com", path: "/" }),
+            ),
+            toCdpCookie(
+              makeCookie({ name: "session", domain: "example.com", path: "/" }),
+            ),
+          ],
+        }),
+        "Storage.clearCookies": () => ({}),
+        "Storage.setCookies": () => ({}),
+      });
+
+      await ctx.clearCookies({ name: /^_ga/ });
+
+      const setCalls = getMockConn(ctx).callsFor("Storage.setCookies");
+      const kept = (
+        setCalls[0]!.params?.cookies as Array<{ name: string }>
+      ).map((c) => c.name);
+      expect(kept).toContain("_gid");
+      expect(kept).toContain("session");
+      expect(kept).not.toContain("_ga_ABC");
+      expect(kept).not.toContain("_ga_DEF");
+    });
+
+    it("regex domain filter combined with path filter", async () => {
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: [...cdpCookies] }),
+        "Storage.clearCookies": () => ({}),
+        "Storage.setCookies": () => ({}),
+      });
+
+      await ctx.clearCookies({ domain: /example/, path: "/settings" });
+
+      const clearCalls = getMockConn(ctx).callsFor("Storage.clearCookies");
+      expect(clearCalls).toHaveLength(0);
+      const setCalls = getMockConn(ctx).callsFor("Storage.setCookies");
+      expect(setCalls).toHaveLength(0);
+    });
+
+    it("clearCookies with empty options object uses atomic clear (same as no args)", async () => {
+      const ctx = makeContext({
+        "Storage.clearCookies": () => ({}),
+      });
+
+      await ctx.clearCookies({});
+
+      const clearCalls = getMockConn(ctx).callsFor("Storage.clearCookies");
+      expect(clearCalls).toHaveLength(1);
+    });
+
+    it("clears and re-adds only non-matching cookies (path filter)", async () => {
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: [...cdpCookies] }),
+        "Storage.clearCookies": () => ({}),
+        "Storage.setCookies": () => ({}),
+      });
+
+      await ctx.clearCookies({ path: "/settings" });
+
+      const clearCalls = getMockConn(ctx).callsFor("Storage.clearCookies");
+      expect(clearCalls).toHaveLength(1);
+
+      const setCalls = getMockConn(ctx).callsFor("Storage.setCookies");
+      expect(setCalls).toHaveLength(1);
+      const kept = (
+        setCalls[0]!.params?.cookies as Array<{ name: string }>
+      ).map((c) => c.name);
+      expect(kept).toEqual(["session", "_ga"]);
+      expect(kept).not.toContain("pref");
+    });
+
+    it("throws when Storage.getCookies fails during filtered clear", async () => {
+      const ctx = makeContext({
+        "Storage.getCookies": () => {
+          throw new Error("CDP getCookies failure");
+        },
+        "Storage.clearCookies": () => ({}),
+        "Storage.setCookies": () => ({}),
+      });
+
+      await expect(ctx.clearCookies({ name: "session" })).rejects.toThrow(
+        /CDP getCookies failure/,
+      );
+
+      // clearCookies and setCookies should never have been called
+      const clearCalls = getMockConn(ctx).callsFor("Storage.clearCookies");
+      expect(clearCalls).toHaveLength(0);
+      const setCalls = getMockConn(ctx).callsFor("Storage.setCookies");
+      expect(setCalls).toHaveLength(0);
+    });
+
+    it("throws when Storage.clearCookies fails during filtered clear", async () => {
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: [...cdpCookies] }),
+        "Storage.clearCookies": () => {
+          throw new Error("CDP clearCookies failure");
+        },
+        "Storage.setCookies": () => ({}),
+      });
+
+      await expect(ctx.clearCookies({ name: "session" })).rejects.toThrow(
+        /CDP clearCookies failure/,
+      );
+
+      // setCookies should never have been called — cookies are untouched
+      const setCalls = getMockConn(ctx).callsFor("Storage.setCookies");
+      expect(setCalls).toHaveLength(0);
+    });
+
+    it("throws when Storage.setCookies fails during re-add, cookies are already wiped", async () => {
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: [...cdpCookies] }),
+        "Storage.clearCookies": () => ({}),
+        "Storage.setCookies": () => {
+          throw new Error("CDP setCookies failure");
+        },
+      });
+
+      await expect(ctx.clearCookies({ name: "session" })).rejects.toThrow(
+        /cookie jar is now empty/,
+      );
+
+      // clearCookies WAS called — cookies are gone
+      const clearCalls = getMockConn(ctx).callsFor("Storage.clearCookies");
+      expect(clearCalls).toHaveLength(1);
+    });
+  });
+
+  describe("cookies() sameSite mapping", () => {
+    it("passes through valid sameSite values as-is", async () => {
+      for (const sameSite of ["Strict", "Lax", "None"] as const) {
+        const cdpCookie = { ...toCdpCookie(makeCookie()), sameSite };
+        const ctx = makeContext({
+          "Storage.getCookies": () => ({ cookies: [cdpCookie] }),
+        });
+        const result = await ctx.cookies();
+        expect(result[0]!.sameSite).toBe(sameSite);
+      }
+    });
+
+    it("does not normalize lowercase sameSite values from CDP", async () => {
+      // CDP may return lowercase values; the current implementation casts
+      // without normalizing, so "none" passes through as-is.
+      const cdpCookie = { ...toCdpCookie(makeCookie()), sameSite: "none" };
+      const ctx = makeContext({
+        "Storage.getCookies": () => ({ cookies: [cdpCookie] }),
+      });
+      const result = await ctx.cookies();
+      // This documents the current behavior: lowercase is NOT normalized.
+      expect(result[0]!.sameSite).toBe("none");
+    });
+  });
+});
diff --git a/packages/core/tests/unit/helpers/mockCDPSession.ts b/packages/core/tests/unit/helpers/mockCDPSession.ts
new file mode 100644
index 000000000..341001837
--- /dev/null
+++ b/packages/core/tests/unit/helpers/mockCDPSession.ts
@@ -0,0 +1,38 @@
+import type { CDPSessionLike } from "../../../lib/v3/understudy/cdp.js";
+
+type Handler = (params?: Record<string, unknown>) => Promise<unknown> | unknown;
+
+export class MockCDPSession implements CDPSessionLike {
+  public readonly id: string;
+  public readonly calls: Array<{
+    method: string;
+    params?: Record<string, unknown>;
+  }> = [];
+
+  constructor(
+    private readonly handlers: Record<string, Handler> = {},
+    sessionId = "mock-session",
+  ) {
+    this.id = sessionId;
+  }
+
+  async send<R = unknown>(
+    method: string,
+    params: Record<string, unknown> = {},
+  ): Promise<R> {
+    this.calls.push({ method, params });
+    const handler = this.handlers[method];
+    if (!handler) return {} as R;
+    return (await handler(params)) as R;
+  }
+
+  on(): void {}
+  off(): void {}
+  async close(): Promise<void> {}
+
+  callsFor(method: string): Array<{ params?: Record<string, unknown> }> {
+    return this.calls
+      .filter((call) => call.method === method)
+      .map(({ params }) => ({ params }));
+  }
+}
diff --git a/packages/core/tests/unit/llm-provider.test.ts b/packages/core/tests/unit/llm-provider.test.ts
new file mode 100644
index 000000000..5bbde12f7
--- /dev/null
+++ b/packages/core/tests/unit/llm-provider.test.ts
@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+import { getAISDKLanguageModel } from "../../lib/v3/llm/LLMProvider.js";
+
+describe("getAISDKLanguageModel", () => {
+  describe("ollama provider", () => {
+    it("works without clientOptions", () => {
+      const model = getAISDKLanguageModel("ollama", "llama3.2");
+      expect(model).toBeDefined();
+    });
+
+    it("works with empty clientOptions", () => {
+      const model = getAISDKLanguageModel("ollama", "llama3.2", {});
+      expect(model).toBeDefined();
+    });
+
+    it("works with clientOptions containing only undefined values", () => {
+      const model = getAISDKLanguageModel("ollama", "llama3.2", {
+        apiKey: undefined,
+      });
+      expect(model).toBeDefined();
+    });
+
+    it("works with clientOptions containing only null values", () => {
+      const model = getAISDKLanguageModel("ollama", "llama3.2", {
+        apiKey: null as unknown as string,
+      });
+      expect(model).toBeDefined();
+    });
+
+    it("works with custom baseURL", () => {
+      const model = getAISDKLanguageModel("ollama", "llama3.2", {
+        baseURL: "http://custom-ollama:11434",
+      });
+      expect(model).toBeDefined();
+    });
+
+    it("works even when apiKey is mistakenly provided", () => {
+      // Ollama doesn't need an API key, but users might set one anyway
+      const model = getAISDKLanguageModel("ollama", "llama3.2", {
+        apiKey: "unnecessary-key",
+      });
+      expect(model).toBeDefined();
+    });
+  });
+
+  describe("providers with API keys", () => {
+    it("openai requires valid clientOptions for custom configuration", () => {
+      // Without clientOptions, uses default provider
+      const defaultModel = getAISDKLanguageModel("openai", "gpt-4o");
+      expect(defaultModel).toBeDefined();
+
+      // With valid apiKey, uses custom provider
+      const customModel = getAISDKLanguageModel("openai", "gpt-4o", {
+        apiKey: "test-key",
+      });
+      expect(customModel).toBeDefined();
+    });
+  });
+
+  describe("hasValidOptions logic", () => {
+    it("treats undefined apiKey as no options", () => {
+      // This should use the default provider path (AISDKProviders)
+      // not the custom provider path (AISDKProvidersWithAPIKey)
+      const model = getAISDKLanguageModel("ollama", "llama3.2", {
+        apiKey: undefined,
+      });
+      expect(model).toBeDefined();
+    });
+  });
+});
diff --git a/packages/core/tests/unit/model-deprecation.test.ts b/packages/core/tests/unit/model-deprecation.test.ts
new file mode 100644
index 000000000..32d45940b
--- /dev/null
+++ b/packages/core/tests/unit/model-deprecation.test.ts
@@ -0,0 +1,187 @@
+import { describe, expect, it } from "vitest";
+import { LLMProvider } from "../../lib/v3/llm/LLMProvider.js";
+import {
+  UnsupportedModelError,
+  UnsupportedAISDKModelProviderError,
+} from "../../lib/v3/types/public/sdkErrors.js";
+import type { LogLine } from "../../lib/v3/types/public/logs.js";
+
+// Mock client options with fake API keys for testing
+const mockClientOptions = { apiKey: "test-api-key-for-testing" };
+
+describe("Model format deprecation", () => {
+  describe("UnsupportedModelError", () => {
+    it("includes guidance to use provider/model format for unknown model names", () => {
+      const error = new UnsupportedModelError(["gpt-4o", "gemini-2.0-flash"]);
+
+      // Should mention the new format
+      expect(error.message).toContain("provider/model");
+      // Should include link to docs
+      expect(error.message).toContain(
+        "https://docs.stagehand.dev/v3/configuration/models",
+      );
+    });
+
+    it("includes example of provider/model format", () => {
+      const error = new UnsupportedModelError(["gpt-4o"]);
+
+      // Should provide examples like openai/gpt-4o
+      expect(error.message).toContain("openai/gpt-4o");
+      expect(error.message).toContain("anthropic/claude-sonnet-4");
+    });
+
+    it("works with feature parameter", () => {
+      const error = new UnsupportedModelError(["gpt-4o"], "extract");
+
+      expect(error.message).toContain("extract");
+      expect(error.message).toContain("provider/model");
+      expect(error.message).toContain(
+        "https://docs.stagehand.dev/v3/configuration/models",
+      );
+    });
+  });
+
+  describe("LLMProvider.getClient deprecation warning", () => {
+    it("logs deprecation warning for legacy model names", () => {
+      const logs: LogLine[] = [];
+      const logger = (line: LogLine) => logs.push(line);
+      const provider = new LLMProvider(logger);
+
+      // Using a legacy model name like "gpt-4o" instead of "openai/gpt-4o"
+      // Should not throw, but should log a deprecation warning
+      const client = provider.getClient("gpt-4o", mockClientOptions);
+
+      // Should return a client (not throw)
+      expect(client).toBeDefined();
+
+      // Should have logged a deprecation warning at level 0
+      const deprecationWarning = logs.find(
+        (log) =>
+          log.message.toLowerCase().includes("deprecated") ||
+          log.message.toLowerCase().includes("deprecation"),
+      );
+      expect(deprecationWarning).toBeDefined();
+      expect(deprecationWarning!.level).toBe(0);
+    });
+
+    it("deprecation warning mentions provider/model format", () => {
+      const logs: LogLine[] = [];
+      const logger = (line: LogLine) => logs.push(line);
+      const provider = new LLMProvider(logger);
+
+      provider.getClient("gpt-4o", mockClientOptions);
+
+      const deprecationWarning = logs.find(
+        (log) =>
+          log.message.toLowerCase().includes("deprecated") ||
+          log.message.toLowerCase().includes("deprecation"),
+      );
+
+      expect(deprecationWarning).toBeDefined();
+      const message = deprecationWarning!.message;
+      // Should mention the provider/model format
+      expect(message).toContain("provider/model");
+      // Should give an example
+      expect(message).toContain("openai/gpt-5");
+    });
+
+    it("returns OpenAIClient for legacy OpenAI model names", () => {
+      const logs: LogLine[] = [];
+      const logger = (line: LogLine) => logs.push(line);
+      const provider = new LLMProvider(logger);
+
+      const client = provider.getClient("gpt-4o", mockClientOptions);
+
+      // Should return a client
+      expect(client).toBeDefined();
+      // The client should be an OpenAIClient (check constructor name)
+      expect(client.constructor.name).toBe("OpenAIClient");
+    });
+
+    it("returns GoogleClient for legacy Google model names", () => {
+      const logs: LogLine[] = [];
+      const logger = (line: LogLine) => logs.push(line);
+      const provider = new LLMProvider(logger);
+
+      const client = provider.getClient("gemini-2.0-flash", mockClientOptions);
+
+      // Should return a client
+      expect(client).toBeDefined();
+      // The client should be a GoogleClient
+      expect(client.constructor.name).toBe("GoogleClient");
+    });
+  });
+
+  describe("LLMProvider.getClient error handling", () => {
+    it("throws UnsupportedModelError for unknown model without slash", () => {
+      const logs: LogLine[] = [];
+      const logger = (line: LogLine) => logs.push(line);
+      const provider = new LLMProvider(logger);
+
+      // Unknown model without slash should throw UnsupportedModelError
+      expect(() => {
+        provider.getClient("some-unknown-model", mockClientOptions);
+      }).toThrow(UnsupportedModelError);
+    });
+
+    it("UnsupportedModelError includes provider/model format guidance", () => {
+      const logs: LogLine[] = [];
+      const logger = (line: LogLine) => logs.push(line);
+      const provider = new LLMProvider(logger);
+
+      try {
+        provider.getClient("some-unknown-model", mockClientOptions);
+      } catch (error) {
+        expect((error as Error).message).toContain("provider/model");
+      }
+    });
+
+    it("throws UnsupportedAISDKModelProviderError for invalid provider in provider/model format", () => {
+      const logs: LogLine[] = [];
+      const logger = (line: LogLine) => logs.push(line);
+      const provider = new LLMProvider(logger);
+
+      // Invalid provider but correct format
+      expect(() => {
+        provider.getClient("invalid-provider/some-model", mockClientOptions);
+      }).toThrow(UnsupportedAISDKModelProviderError);
+    });
+
+    it("UnsupportedAISDKModelProviderError lists valid providers", () => {
+      const logs: LogLine[] = [];
+      const logger = (line: LogLine) => logs.push(line);
+      const provider = new LLMProvider(logger);
+
+      try {
+        provider.getClient("invalid-provider/some-model", mockClientOptions);
+      } catch (error) {
+        const message = (error as Error).message;
+        // Should list valid providers
+        expect(message).toContain("openai");
+        expect(message).toContain("anthropic");
+        expect(message).toContain("google");
+      }
+    });
+  });
+
+  describe("new provider/model format", () => {
+    it("does not log deprecation warning for provider/model format", () => {
+      const logs: LogLine[] = [];
+      const logger = (line: LogLine) => logs.push(line);
+      const provider = new LLMProvider(logger);
+
+      // Using the new format
+      const client = provider.getClient("openai/gpt-4o", mockClientOptions);
+
+      expect(client).toBeDefined();
+
+      // Should NOT have a deprecation warning
+      const deprecationWarning = logs.find(
+        (log) =>
+          log.message.toLowerCase().includes("deprecated") ||
+          log.message.toLowerCase().includes("deprecation"),
+      );
+      expect(deprecationWarning).toBeUndefined();
+    });
+  });
+});
diff --git a/packages/core/tests/unit/model-utils.test.ts b/packages/core/tests/unit/model-utils.test.ts
new file mode 100644
index 000000000..4a558598c
--- /dev/null
+++ b/packages/core/tests/unit/model-utils.test.ts
@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+import { extractModelName, resolveModel } from "../../lib/modelUtils.js";
+
+describe("extractModelName", () => {
+  it("returns undefined for undefined input", () => {
+    expect(extractModelName(undefined)).toBeUndefined();
+  });
+
+  it("returns the string as-is for a string input", () => {
+    expect(extractModelName("openai/gpt-4o")).toBe("openai/gpt-4o");
+  });
+
+  it("returns modelName from an object input", () => {
+    expect(
+      extractModelName({ modelName: "anthropic/claude-sonnet-4-20250514" }),
+    ).toBe("anthropic/claude-sonnet-4-20250514");
+  });
+
+  it("returns modelName from an object with extra properties", () => {
+    expect(
+      extractModelName({
+        modelName: "openai/gpt-4o-mini",
+        apiKey: "sk-test",
+        baseURL: "https://custom.endpoint",
+      }),
+    ).toBe("openai/gpt-4o-mini");
+  });
+});
+
+describe("resolveModel", () => {
+  it("extracts provider and modelName from a string", () => {
+    const result = resolveModel("openai/gpt-4o");
+    expect(result.provider).toBe("openai");
+    expect(result.modelName).toBe("gpt-4o");
+    expect(result.clientOptions).toEqual({});
+  });
+
+  it("extracts clientOptions from an object config", () => {
+    const result = resolveModel({
+      modelName: "openai/gpt-4o" as never,
+      apiKey: "sk-test",
+    });
+    expect(result.provider).toBe("openai");
+    expect(result.modelName).toBe("gpt-4o");
+    expect(result.clientOptions).toMatchObject({ apiKey: "sk-test" });
+    // modelName should not leak into clientOptions
+    expect(result.clientOptions).not.toHaveProperty("modelName");
+  });
+});
diff --git a/packages/core/tests/unit/page-extra-http-headers.test.ts b/packages/core/tests/unit/page-extra-http-headers.test.ts
new file mode 100644
index 000000000..1f7c53108
--- /dev/null
+++ b/packages/core/tests/unit/page-extra-http-headers.test.ts
@@ -0,0 +1,135 @@
+import { describe, expect, it } from "vitest";
+import { Page } from "../../lib/v3/understudy/page.js";
+import { MockCDPSession } from "./helpers/mockCDPSession.js";
+import { StagehandSetExtraHTTPHeadersError } from "../../lib/v3/types/public/sdkErrors.js";
+
+type PageStub = {
+  mainSession: MockCDPSession;
+  sessions: Map<string, MockCDPSession>;
+  extraHTTPHeaders: Record<string, string>;
+  applyExtraHTTPHeadersToSession: (
+    session: MockCDPSession,
+    headers: Record<string, string>,
+  ) => Promise<void>;
+};
+
+const makePage = (sessions: MockCDPSession[]): PageStub => {
+  const mainSession = sessions[0] ?? new MockCDPSession({}, "main");
+  const stub: PageStub = {
+    mainSession,
+    sessions: new Map(sessions.map((s) => [s.id, s])),
+    extraHTTPHeaders: {},
+    // Bind the private helper from Page.prototype so setExtraHTTPHeaders can call it
+    applyExtraHTTPHeadersToSession: (Page.prototype as unknown as PageStub)
+      .applyExtraHTTPHeadersToSession,
+  };
+  return stub;
+};
+
+describe("Page.setExtraHTTPHeaders", () => {
+  const setExtraHTTPHeaders = Page.prototype.setExtraHTTPHeaders as (
+    this: PageStub,
+    headers: Record<string, string>,
+  ) => Promise<void>;
+
+  it("sends headers to all sessions owned by the page", async () => {
+    const sessionA = new MockCDPSession({}, "session-a");
+    const sessionB = new MockCDPSession({}, "session-b");
+    const page = makePage([sessionA, sessionB]);
+
+    await setExtraHTTPHeaders.call(page, {
+      "x-stagehand-test": "hello",
+    });
+
+    for (const session of [sessionA, sessionB]) {
+      expect(session.callsFor("Network.enable").length).toBe(1);
+      expect(
+        session.callsFor("Network.setExtraHTTPHeaders")[0]?.params,
+      ).toEqual({
+        headers: { "x-stagehand-test": "hello" },
+      });
+    }
+  });
+
+  it("applies headers to mainSession even when sessions map is empty", async () => {
+    const page = makePage([]);
+
+    await setExtraHTTPHeaders.call(page, { "x-test": "value" });
+
+    // mainSession should still receive headers even though it's not in the sessions map
+    expect(page.mainSession.callsFor("Network.enable").length).toBe(1);
+    expect(
+      page.mainSession.callsFor("Network.setExtraHTTPHeaders")[0]?.params,
+    ).toEqual({
+      headers: { "x-test": "value" },
+    });
+  });
+
+  it("throws StagehandSetExtraHTTPHeadersError with session failure details", async () => {
+    const sessionA = new MockCDPSession(
+      {
+        "Network.setExtraHTTPHeaders": () => {
+          throw new Error("connection closed");
+        },
+      },
+      "session-a",
+    );
+    const sessionB = new MockCDPSession({}, "session-b");
+    const page = makePage([sessionA, sessionB]);
+
+    let caughtError: StagehandSetExtraHTTPHeadersError | undefined;
+    try {
+      await setExtraHTTPHeaders.call(page, {
+        "x-stagehand-test": "yes",
+      });
+    } catch (error) {
+      caughtError = error as StagehandSetExtraHTTPHeadersError;
+    }
+
+    expect(caughtError).toBeInstanceOf(StagehandSetExtraHTTPHeadersError);
+    expect(caughtError?.failures).toHaveLength(1);
+    expect(caughtError?.failures[0]).toContain("session=session-a");
+    expect(caughtError?.failures[0]).toContain("connection closed");
+
+    // sessionB should still have been called successfully
+    expect(sessionB.callsFor("Network.setExtraHTTPHeaders").length).toBe(1);
+  });
+
+  it("applies headers to sessions adopted after the call", async () => {
+    const sessionA = new MockCDPSession({}, "session-a");
+    const page = makePage([sessionA]);
+
+    await setExtraHTTPHeaders.call(page, { "x-before": "yes" });
+
+    // A new OOPIF session is adopted after headers were set
+    const sessionB = new MockCDPSession({}, "session-b");
+    page.sessions.set(sessionB.id, sessionB);
+
+    // Simulate what adoptOopifSession does: replay headers onto the new session
+    await page.applyExtraHTTPHeadersToSession.call(
+      page,
+      sessionB,
+      page.extraHTTPHeaders,
+    );
+
+    // The late-arriving session should have received the headers
+    expect(sessionB.callsFor("Network.enable").length).toBe(1);
+    expect(sessionB.callsFor("Network.setExtraHTTPHeaders")[0]?.params).toEqual(
+      {
+        headers: { "x-before": "yes" },
+      },
+    );
+  });
+
+  it("does not mutate the original headers object", async () => {
+    const session = new MockCDPSession({}, "session-a");
+    const page = makePage([session]);
+
+    const original = { "x-custom": "value" };
+    const frozen = { ...original };
+
+    await setExtraHTTPHeaders.call(page, original);
+
+    expect(original).toEqual(frozen);
+  });
+});
diff --git a/packages/core/tests/unit/page-snapshot.test.ts b/packages/core/tests/unit/page-snapshot.test.ts
new file mode 100644
index 000000000..e2c568d2d
--- /dev/null
+++ b/packages/core/tests/unit/page-snapshot.test.ts
@@ -0,0 +1,48 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { promises as fs } from "fs";
+import { Page } from "../../lib/v3/understudy/page.js";
+import * as snapshotModule from "../../lib/v3/understudy/a11y/snapshot/index.js";
+import type { HybridSnapshot } from "../../lib/v3/types/private/index.js";
+
+const baseSnapshot: HybridSnapshot = {
+  combinedTree: "tree",
+  combinedXpathMap: {},
+  combinedUrlMap: {},
+  perFrame: [],
+};
+
+describe("Page.snapshot", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("forwards the includeIframes flag to captureHybridSnapshot", async () => {
+    vi.spyOn(fs, "writeFile").mockResolvedValue();
+    const captureSpy = vi
+      .spyOn(snapshotModule, "captureHybridSnapshot")
+      .mockResolvedValue(baseSnapshot);
+
+    const fakePage = {} as Page;
+    await Page.prototype.snapshot.call(fakePage, { includeIframes: false });
+
+    expect(captureSpy).toHaveBeenCalledWith(fakePage, {
+      pierceShadow: true,
+      includeIframes: false,
+    });
+  });
+
+  it("falls back to default iframe inclusion when option is omitted", async () => {
+    vi.spyOn(fs, "writeFile").mockResolvedValue();
+    const captureSpy = vi
+      .spyOn(snapshotModule, "captureHybridSnapshot")
+      .mockResolvedValue(baseSnapshot);
+
+    const fakePage = {} as Page;
+    await Page.prototype.snapshot.call(fakePage);
+
+    expect(captureSpy).toHaveBeenCalledWith(fakePage, {
+      pierceShadow: true,
+      includeIframes: undefined,
+    });
+  });
+});
diff --git a/packages/core/tests/unit/public-api/export-surface.test.ts b/packages/core/tests/unit/public-api/export-surface.test.ts
new file mode 100644
index 000000000..eda61d500
--- /dev/null
+++ b/packages/core/tests/unit/public-api/export-surface.test.ts
@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import StagehandDefaultExport, * as Stagehand from "@browserbasehq/stagehand";
+import { publicErrorTypes } from "./public-error-types.test.js";
+
+// Type matcher guidelines:
+//
+// toEqualTypeOf – Default. Assert full, deep type equality; any type change should fail.
+//   e.g. expectTypeOf<ReturnType<typeof foo>>().toEqualTypeOf<FooResult>()
+//
+// toMatchObjectType – Assert (part of) an object's shape while allowing extra fields.
+//   e.g. expectTypeOf(user).toMatchObjectType<{ id: string; email: string }>()
+//
+// toExtend – Assert that a type is compatible with a broader contract (assignable/extends).
+//   e.g. expectTypeOf<User>().toExtend<BaseUser>()
+
+const publicApiShape = {
+  __internalMaybeRunShutdownSupervisorFromArgv:
+    Stagehand.__internalMaybeRunShutdownSupervisorFromArgv,
+  __internalCreateInMemoryAgentCacheHandle:
+    Stagehand.__internalCreateInMemoryAgentCacheHandle,
+  AISdkClient: Stagehand.AISdkClient,
+  Api: Stagehand.Api,
+  AVAILABLE_CUA_MODELS: Stagehand.AVAILABLE_CUA_MODELS,
+  AgentProvider: Stagehand.AgentProvider,
+  AnnotatedScreenshotText: Stagehand.AnnotatedScreenshotText,
+  ConsoleMessage: Stagehand.ConsoleMessage,
+  CustomOpenAIClient: Stagehand.CustomOpenAIClient,
+  LLMClient: Stagehand.LLMClient,
+  LOG_LEVEL_NAMES: Stagehand.LOG_LEVEL_NAMES,
+  Response: Stagehand.Response,
+  Stagehand: Stagehand.Stagehand,
+  V3: Stagehand.V3,
+  V3Evaluator: Stagehand.V3Evaluator,
+  V3FunctionName: Stagehand.V3FunctionName,
+  connectToMCPServer: Stagehand.connectToMCPServer,
+  default: StagehandDefaultExport,
+  defaultExtractSchema: Stagehand.defaultExtractSchema,
+  getAISDKLanguageModel: Stagehand.getAISDKLanguageModel,
+  getZodType: Stagehand.getZodType,
+  injectUrls: Stagehand.injectUrls,
+  isRunningInBun: Stagehand.isRunningInBun,
+  isZod3Schema: Stagehand.isZod3Schema,
+  isZod4Schema: Stagehand.isZod4Schema,
+  jsonSchemaToZod: Stagehand.jsonSchemaToZod,
+  loadApiKeyFromEnv: Stagehand.loadApiKeyFromEnv,
+  localBrowserLaunchOptionsSchema: Stagehand.localBrowserLaunchOptionsSchema,
+  modelToAgentProviderMap: Stagehand.modelToAgentProviderMap,
+  pageTextSchema: Stagehand.pageTextSchema,
+  providerEnvVarMap: Stagehand.providerEnvVarMap,
+  toGeminiSchema: Stagehand.toGeminiSchema,
+  toJsonSchema: Stagehand.toJsonSchema,
+  tool: Stagehand.tool,
+  transformSchema: Stagehand.transformSchema,
+  trimTrailingTextNode: Stagehand.trimTrailingTextNode,
+  validateZodSchema: Stagehand.validateZodSchema,
+  ...publicErrorTypes,
+} as const;
+
+type StagehandExports = typeof Stagehand & {
+  default: typeof StagehandDefaultExport;
+};
+
+type PublicAPI = {
+  [K in keyof typeof publicApiShape]: StagehandExports[K];
+};
+
+describe("Stagehand public API export surface", () => {
+  it("public API shape matches module exports", () => {
+    const _check: PublicAPI = publicApiShape;
+    void _check;
+  });
+
+  it("does not expose unexpected top-level exports", () => {
+    const expected = Object.keys(publicApiShape).sort();
+    const actual = Object.keys(Stagehand).sort();
+    expect(actual).toStrictEqual(expected);
+  });
+
+  it("default export mirrors the named export surface", () => {
+    const expected = Object.keys(Stagehand)
+      .filter((key) => key !== "default")
+      .sort();
+    const actual = Object.keys(StagehandDefaultExport).sort();
+    expect(actual).toStrictEqual(expected);
+  });
+});
diff --git a/packages/core/tests/unit/public-api/llm-and-agents.test.ts b/packages/core/tests/unit/public-api/llm-and-agents.test.ts
new file mode 100644
index 000000000..cfec8a209
--- /dev/null
+++ b/packages/core/tests/unit/public-api/llm-and-agents.test.ts
@@ -0,0 +1,304 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import * as Stagehand from "@browserbasehq/stagehand";
+
+describe("LLM and Agents public API types", () => {
+  describe("ModelConfiguration", () => {
+    it("accepts Vertex headers in model config", () => {
+      const googleConfig = {
+        modelName: "google/gemini-3-flash-preview",
+        project: "test-project",
+        location: "global",
+        headers: {
+          "X-Goog-Priority": "high",
+        },
+      } satisfies Stagehand.ModelConfiguration;
+
+      void googleConfig;
+    });
+  });
+
+  describe("AISdkClient", () => {
+    type AISdkClientInstance = InstanceType<typeof Stagehand.AISdkClient>;
+
+    it("is exported", () => {
+      expect(Stagehand.AISdkClient).toBeDefined();
+    });
+
+    it("extends LLMClient", () => {
+      expectTypeOf<AISdkClientInstance>().toExtend<Stagehand.LLMClient>();
+    });
+
+    it("constructor accepts model parameter", () => {
+      // AISdkClient constructor takes { model: LanguageModelV2 }
+      type CtorParams = ConstructorParameters<typeof Stagehand.AISdkClient>;
+      expectTypeOf<CtorParams["length"]>().toEqualTypeOf<1>();
+    });
+  });
+
+  describe("AVAILABLE_CUA_MODELS", () => {
+    const expectedModels = [
+      "openai/computer-use-preview",
+      "openai/computer-use-preview-2025-03-11",
+      "anthropic/claude-opus-4-5-20251101",
+      "anthropic/claude-opus-4-6",
+      "anthropic/claude-sonnet-4-6",
+      "anthropic/claude-haiku-4-5-20251001",
+      "anthropic/claude-sonnet-4-20250514",
+      "anthropic/claude-sonnet-4-5-20250929",
+      "google/gemini-2.5-computer-use-preview-10-2025",
+      "google/gemini-3-flash-preview",
+      "google/gemini-3-pro-preview",
+      "microsoft/fara-7b",
+    ] as const;
+
+    it("AvailableCuaModel matches the known literals", () => {
+      expectTypeOf<Stagehand.AvailableCuaModel>().toEqualTypeOf<
+        (typeof expectedModels)[number]
+      >();
+      void expectedModels; // Mark as used to satisfy ESLint
+    });
+  });
+
+  describe("AgentProvider", () => {
+    type AgentProviderInstance = InstanceType<typeof Stagehand.AgentProvider>;
+
+    it("is exported", () => {
+      expect(Stagehand.AgentProvider).toBeDefined();
+    });
+
+    it("has getClient method", () => {
+      expectTypeOf<AgentProviderInstance["getClient"]>().toBeCallableWith(
+        "test-model",
+      );
+    });
+
+    it("constructor accepts logger parameter", () => {
+      expectTypeOf<
+        ConstructorParameters<typeof Stagehand.AgentProvider>
+      >().toEqualTypeOf<[(message: Stagehand.LogLine) => void]>();
+    });
+  });
+
+  describe("AnnotatedScreenshotText", () => {
+    type ExpectedAnnotatedScreenshotText = string;
+
+    it("is a string literal", () => {
+      expectTypeOf<
+        typeof Stagehand.AnnotatedScreenshotText
+      >().toExtend<ExpectedAnnotatedScreenshotText>();
+    });
+  });
+
+  describe("ConsoleMessage", () => {
+    type ExpectedShape = {
+      type: () => string;
+      text: () => string;
+      args: () => unknown[];
+      location: () => {
+        url?: string;
+        lineNumber?: number;
+        columnNumber?: number;
+      };
+      page: () => unknown;
+      timestamp: () => number | undefined;
+      raw: () => unknown;
+      toString: () => string;
+    };
+
+    type ConsoleMessageInstance = InstanceType<typeof Stagehand.ConsoleMessage>;
+
+    it("has correct public interface shape", () => {
+      expectTypeOf<ConsoleMessageInstance>().toExtend<ExpectedShape>();
+    });
+  });
+
+  describe("AgentClient", () => {
+    type AgentProviderInstance = InstanceType<typeof Stagehand.AgentProvider>;
+    type GetClientReturn = ReturnType<AgentProviderInstance["getClient"]>;
+
+    it("getClient returns object with expected methods", () => {
+      type ExpectedShape = {
+        execute: (
+          options: Stagehand.AgentExecutionOptions,
+        ) => Promise<Stagehand.AgentResult>;
+        captureScreenshot: (
+          options?: Record<string, unknown>,
+        ) => Promise<unknown>;
+        setViewport: (width: number, height: number) => void;
+        setCurrentUrl: (url: string) => void;
+        setScreenshotProvider: (provider: () => Promise<string>) => void;
+        setActionHandler: (
+          handler: (action: Stagehand.AgentAction) => Promise<void>,
+        ) => void;
+      };
+      expectTypeOf<GetClientReturn>().toExtend<ExpectedShape>();
+    });
+  });
+
+  describe("LLMClient", () => {
+    type ExpectedShape = {
+      type: "openai" | "anthropic" | "cerebras" | "groq" | (string & {});
+      modelName: Stagehand.AvailableModel | (string & {});
+      hasVision: boolean;
+      clientOptions: Stagehand.ClientOptions;
+      userProvidedInstructions?: string;
+    };
+
+    type ExpectedCtorParams = [Stagehand.AvailableModel, string?];
+
+    type ExpectedBasicOptions = {
+      options: {
+        messages: Array<{
+          role: "system" | "user" | "assistant";
+          content: string | Array<unknown>;
+        }>;
+      };
+      logger: (message: unknown) => void;
+      retries?: number;
+    };
+
+    type ExpectedWithResponseModel = ExpectedBasicOptions & {
+      options: ExpectedBasicOptions["options"] & {
+        response_model: {
+          name: string;
+          schema: Stagehand.StagehandZodSchema;
+        };
+      };
+    };
+
+    type LLMClientInstance = InstanceType<typeof Stagehand.LLMClient>;
+
+    it("has correct public interface shape", () => {
+      expectTypeOf<LLMClientInstance>().toExtend<ExpectedShape>();
+    });
+
+    it("constructor parameters match expected signature", () => {
+      expectTypeOf<
+        ConstructorParameters<typeof Stagehand.LLMClient>
+      >().toEqualTypeOf<ExpectedCtorParams>();
+    });
+
+    it("createChatCompletion can be called with basic options", () => {
+      expectTypeOf<
+        LLMClientInstance["createChatCompletion"]
+      >().toBeCallableWith({
+        options: {
+          messages: [
+            {
+              role: "user",
+              content: "Hello",
+            },
+          ],
+        },
+        logger: () => {},
+      } satisfies ExpectedBasicOptions);
+    });
+
+    it("createChatCompletion can be called with response_model", () => {
+      const mockSchema = {} as Stagehand.StagehandZodSchema;
+      expectTypeOf<
+        LLMClientInstance["createChatCompletion"]
+      >().toBeCallableWith({
+        options: {
+          messages: [
+            {
+              role: "user",
+              content: "Extract data",
+            },
+          ],
+          response_model: {
+            name: "extracted",
+            schema: mockSchema,
+          },
+        },
+        logger: () => {},
+      } satisfies ExpectedWithResponseModel);
+    });
+
+    it("createChatCompletion supports generic return type", () => {
+      type Result = { custom: string };
+      type ExpectedSignature = (
+        options: Stagehand.CreateChatCompletionOptions,
+      ) => Promise<Result>;
+
+      expectTypeOf<
+        LLMClientInstance["createChatCompletion"]
+      >().toExtend<ExpectedSignature>();
+    });
+
+    it("has additional methods", () => {
+      // These methods exist on LLMClient but have complex signatures from the 'ai' library
+      // We verify they exist by checking they're functions
+      expectTypeOf<LLMClientInstance["generateText"]>().toExtend<
+        (...args: unknown[]) => unknown
+      >();
+      expectTypeOf<LLMClientInstance["generateObject"]>().toExtend<
+        (...args: unknown[]) => unknown
+      >();
+      expectTypeOf<LLMClientInstance["streamText"]>().toExtend<
+        (...args: unknown[]) => unknown
+      >();
+      expectTypeOf<LLMClientInstance["streamObject"]>().toExtend<
+        (...args: unknown[]) => unknown
+      >();
+      expectTypeOf<LLMClientInstance["generateImage"]>().toExtend<
+        (...args: unknown[]) => unknown
+      >();
+      expectTypeOf<LLMClientInstance["embed"]>().toExtend<
+        (...args: unknown[]) => unknown
+      >();
+      expectTypeOf<LLMClientInstance["embedMany"]>().toExtend<
+        (...args: unknown[]) => unknown
+      >();
+      expectTypeOf<LLMClientInstance["transcribe"]>().toExtend<
+        (...args: unknown[]) => unknown
+      >();
+      expectTypeOf<LLMClientInstance["generateSpeech"]>().toExtend<
+        (...args: unknown[]) => unknown
+      >();
+    });
+  });
+
+  describe("modelToAgentProviderMap", () => {
+    type ExpectedModelToAgentProviderMap = Record<
+      string,
+      Stagehand.AgentProviderType
+    >;
+
+    it("only stores valid provider types", () => {
+      expectTypeOf<
+        typeof Stagehand.modelToAgentProviderMap
+      >().toExtend<ExpectedModelToAgentProviderMap>();
+    });
+  });
+
+  describe("Response", () => {
+    type ExpectedShape = {
+      url: () => string;
+      status: () => number;
+      statusText: () => string;
+      ok: () => boolean;
+      frame: () => unknown;
+      fromServiceWorker: () => boolean;
+      securityDetails: () => Promise<unknown>;
+      serverAddr: () => Promise<unknown>;
+      headers: () => Record<string, string>;
+      allHeaders: () => Promise<Record<string, string>>;
+      headerValue: (name: string) => Promise<string | null>;
+      headerValues: (name: string) => Promise<string[]>;
+      headersArray: () => Promise<Array<{ name: string; value: string }>>;
+      body: () => Promise<Buffer>;
+      text: () => Promise<string>;
+      json: <T = unknown>() => Promise<T>;
+      finished: () => Promise<null | Error>;
+      markFinished: (error: Error | null) => void;
+      applyExtraInfo: (info: unknown) => void;
+    };
+
+    type ResponseInstance = InstanceType<typeof Stagehand.Response>;
+
+    it("has correct public interface shape", () => {
+      expectTypeOf<ResponseInstance>().toExtend<ExpectedShape>();
+    });
+  });
+});
diff --git a/packages/core/tests/unit/public-api/public-error-types.test.ts b/packages/core/tests/unit/public-api/public-error-types.test.ts
new file mode 100644
index 000000000..4b211ab00
--- /dev/null
+++ b/packages/core/tests/unit/public-api/public-error-types.test.ts
@@ -0,0 +1,84 @@
+import { describe, expectTypeOf, it } from "vitest";
+import * as Stagehand from "@browserbasehq/stagehand";
+
+export const publicErrorTypes = {
+  AgentAbortError: Stagehand.AgentAbortError,
+  CdpConnectionClosedError: Stagehand.CdpConnectionClosedError,
+  AgentScreenshotProviderError: Stagehand.AgentScreenshotProviderError,
+  BrowserbaseSessionNotFoundError: Stagehand.BrowserbaseSessionNotFoundError,
+  CaptchaTimeoutError: Stagehand.CaptchaTimeoutError,
+  ConnectionTimeoutError: Stagehand.ConnectionTimeoutError,
+  ContentFrameNotFoundError: Stagehand.ContentFrameNotFoundError,
+  CookieSetError: Stagehand.CookieSetError,
+  CookieValidationError: Stagehand.CookieValidationError,
+  CreateChatCompletionResponseError:
+    Stagehand.CreateChatCompletionResponseError,
+  CuaModelRequiredError: Stagehand.CuaModelRequiredError,
+  ElementNotVisibleError: Stagehand.ElementNotVisibleError,
+  ExperimentalApiConflictError: Stagehand.ExperimentalApiConflictError,
+  ExperimentalNotConfiguredError: Stagehand.ExperimentalNotConfiguredError,
+  HandlerNotInitializedError: Stagehand.HandlerNotInitializedError,
+  InvalidAISDKModelFormatError: Stagehand.InvalidAISDKModelFormatError,
+  LLMResponseError: Stagehand.LLMResponseError,
+  MCPConnectionError: Stagehand.MCPConnectionError,
+  MissingEnvironmentVariableError: Stagehand.MissingEnvironmentVariableError,
+  MissingLLMConfigurationError: Stagehand.MissingLLMConfigurationError,
+  PageNotFoundError: Stagehand.PageNotFoundError,
+  ResponseBodyError: Stagehand.ResponseBodyError,
+  ResponseParseError: Stagehand.ResponseParseError,
+  StagehandAPIError: Stagehand.StagehandAPIError,
+  StagehandAPIUnauthorizedError: Stagehand.StagehandAPIUnauthorizedError,
+  StagehandClickError: Stagehand.StagehandClickError,
+  StagehandClosedError: Stagehand.StagehandClosedError,
+  StagehandDefaultError: Stagehand.StagehandDefaultError,
+  StagehandDomProcessError: Stagehand.StagehandDomProcessError,
+  StagehandElementNotFoundError: Stagehand.StagehandElementNotFoundError,
+  StagehandEnvironmentError: Stagehand.StagehandEnvironmentError,
+  StagehandError: Stagehand.StagehandError,
+  StagehandEvalError: Stagehand.StagehandEvalError,
+  StagehandHttpError: Stagehand.StagehandHttpError,
+  StagehandIframeError: Stagehand.StagehandIframeError,
+  StagehandInitError: Stagehand.StagehandInitError,
+  StagehandInvalidArgumentError: Stagehand.StagehandInvalidArgumentError,
+  StagehandLocatorError: Stagehand.StagehandLocatorError,
+  StagehandMissingArgumentError: Stagehand.StagehandMissingArgumentError,
+  StagehandNotInitializedError: Stagehand.StagehandNotInitializedError,
+  StagehandResponseBodyError: Stagehand.StagehandResponseBodyError,
+  StagehandResponseParseError: Stagehand.StagehandResponseParseError,
+  StagehandServerError: Stagehand.StagehandServerError,
+  StagehandShadowRootMissingError: Stagehand.StagehandShadowRootMissingError,
+  StagehandShadowSegmentEmptyError: Stagehand.StagehandShadowSegmentEmptyError,
+  StagehandShadowSegmentNotFoundError:
+    Stagehand.StagehandShadowSegmentNotFoundError,
+  StreamingCallbacksInNonStreamingModeError:
+    Stagehand.StreamingCallbacksInNonStreamingModeError,
+  StagehandSnapshotError: Stagehand.StagehandSnapshotError,
+  TimeoutError: Stagehand.TimeoutError,
+  UnsupportedAISDKModelProviderError:
+    Stagehand.UnsupportedAISDKModelProviderError,
+  UnsupportedModelError: Stagehand.UnsupportedModelError,
+  UnsupportedModelProviderError: Stagehand.UnsupportedModelProviderError,
+  XPathResolutionError: Stagehand.XPathResolutionError,
+  ZodSchemaValidationError: Stagehand.ZodSchemaValidationError,
+  ActTimeoutError: Stagehand.ActTimeoutError,
+  ObserveTimeoutError: Stagehand.ObserveTimeoutError,
+  ExtractTimeoutError: Stagehand.ExtractTimeoutError,
+  UnderstudyCommandException: Stagehand.UnderstudyCommandException,
+  StagehandSetExtraHTTPHeadersError:
+    Stagehand.StagehandSetExtraHTTPHeadersError,
+} as const;
+
+const errorTypes = Object.keys(publicErrorTypes) as Array<
+  keyof typeof publicErrorTypes
+>;
+
+describe("Stagehand public error types", () => {
+  describe("errors", () => {
+    it.each(errorTypes)("%s extends Error", (errorTypeName) => {
+      const ErrorClass = Stagehand[errorTypeName];
+      type ErrorClassType = typeof ErrorClass;
+      expectTypeOf<InstanceType<ErrorClassType>>().toExtend<Error>();
+      void ErrorClass; // Mark as used to satisfy ESLint
+    });
+  });
+});
diff --git a/packages/core/tests/unit/public-api/public-types.test.ts b/packages/core/tests/unit/public-api/public-types.test.ts
new file mode 100644
index 000000000..cf0fd6dcd
--- /dev/null
+++ b/packages/core/tests/unit/public-api/public-types.test.ts
@@ -0,0 +1,372 @@
+import { describe, expectTypeOf, it } from "vitest";
+import * as Stagehand from "@browserbasehq/stagehand";
+
+// Type-level manifest of all expected exported types
+// Since these types don't exist at runtime, we currently need to manually add new publicly exported types
+// to this list ourselves - it's not automatically going to catch changes like our export-surface.test.ts does.
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+type ExpectedExportedTypes = {
+  // Types from model.ts
+  AvailableModel: Stagehand.AvailableModel;
+  AvailableCuaModel: Stagehand.AvailableCuaModel;
+  ModelProvider: Stagehand.ModelProvider;
+  ClientOptions: Stagehand.ClientOptions;
+  ModelConfiguration: Stagehand.ModelConfiguration;
+  AnthropicJsonSchemaObject: Stagehand.AnthropicJsonSchemaObject;
+  AISDKProvider: Stagehand.AISDKProvider;
+  AISDKCustomProvider: Stagehand.AISDKCustomProvider;
+  LLMTool: Stagehand.LLMTool;
+  // Types from methods.ts
+  ActOptions: Stagehand.ActOptions;
+  ActResult: Stagehand.ActResult;
+  ExtractResult: Stagehand.ExtractResult<Stagehand.StagehandZodSchema>;
+  Action: Stagehand.Action;
+  HistoryEntry: Stagehand.HistoryEntry;
+  ExtractOptions: Stagehand.ExtractOptions;
+  ObserveOptions: Stagehand.ObserveOptions;
+  ObserveResult: Stagehand.ObserveResult;
+  V3FunctionName: Stagehand.V3FunctionName;
+  // Types from agent.ts
+  Tool: Stagehand.Tool;
+  AgentAction: Stagehand.AgentAction;
+  AgentResult: Stagehand.AgentResult;
+  AgentExecuteOptions: Stagehand.AgentExecuteOptions;
+  AgentType: Stagehand.AgentType;
+  AgentExecutionOptions: Stagehand.AgentExecutionOptions<Stagehand.AgentExecuteOptions>;
+  AgentHandlerOptions: Stagehand.AgentHandlerOptions;
+  ActionExecutionResult: Stagehand.ActionExecutionResult;
+  ToolUseItem: Stagehand.ToolUseItem;
+  AnthropicMessage: Stagehand.AnthropicMessage;
+  AnthropicContentBlock: Stagehand.AnthropicContentBlock;
+  AnthropicTextBlock: Stagehand.AnthropicTextBlock;
+  AnthropicToolResult: Stagehand.AnthropicToolResult;
+  ResponseItem: Stagehand.ResponseItem;
+  ComputerCallItem: Stagehand.ComputerCallItem;
+  FunctionCallItem: Stagehand.FunctionCallItem;
+  ResponseInputItem: Stagehand.ResponseInputItem;
+  AgentInstance: Stagehand.AgentInstance;
+  AgentProviderType: Stagehand.AgentProviderType;
+  AgentModelConfig: Stagehand.AgentModelConfig;
+  AgentConfig: Stagehand.AgentConfig;
+  AgentToolMode: Stagehand.AgentToolMode;
+  VariableValue: Stagehand.VariableValue;
+  Variables: Stagehand.Variables;
+  AgentCallbacks: Stagehand.AgentCallbacks;
+  AgentExecuteCallbacks: Stagehand.AgentExecuteCallbacks;
+  AgentStreamCallbacks: Stagehand.AgentStreamCallbacks;
+  AgentExecuteOptionsBase: Stagehand.AgentExecuteOptionsBase;
+  AgentStreamExecuteOptions: Stagehand.AgentStreamExecuteOptions;
+  ModelMessage: Stagehand.ModelMessage;
+  // Types from agent/tools
+  AgentTools: Stagehand.AgentTools;
+  AgentToolTypesMap: Stagehand.AgentToolTypesMap;
+  AgentUITools: Stagehand.AgentUITools;
+  AgentToolCall: Stagehand.AgentToolCall;
+  AgentToolResult: Stagehand.AgentToolResult;
+  // Types from logs.ts
+  LogLevel: Stagehand.LogLevel;
+  LogLine: Stagehand.LogLine;
+  Logger: Stagehand.Logger;
+  // Types from metrics.ts
+  StagehandMetrics: Stagehand.StagehandMetrics;
+  // Types from options.ts
+  V3Env: Stagehand.V3Env;
+  LocalBrowserLaunchOptions: Stagehand.LocalBrowserLaunchOptions;
+  V3Options: Stagehand.V3Options;
+  // Types from page.ts
+  AnyPage: Stagehand.AnyPage;
+  Page: Stagehand.Page;
+  PlaywrightPage: Stagehand.PlaywrightPage;
+  PatchrightPage: Stagehand.PatchrightPage;
+  PuppeteerPage: Stagehand.PuppeteerPage;
+  ConsoleListener: Stagehand.ConsoleListener;
+  LoadState: Stagehand.LoadState;
+  // Types from LLMClient.ts
+  ChatMessage: Stagehand.ChatMessage;
+  ChatMessageContent: Stagehand.ChatMessageContent;
+  ChatMessageImageContent: Stagehand.ChatMessageImageContent;
+  ChatMessageTextContent: Stagehand.ChatMessageTextContent;
+  ChatCompletionOptions: Stagehand.ChatCompletionOptions;
+  LLMResponse: Stagehand.LLMResponse;
+  CreateChatCompletionOptions: Stagehand.CreateChatCompletionOptions;
+  LLMUsage: Stagehand.LLMUsage;
+  LLMParsedResponse: Stagehand.LLMParsedResponse<Record<string, unknown>>;
+  // Types from zodCompat.ts
+  StagehandZodSchema: Stagehand.StagehandZodSchema;
+  StagehandZodObject: Stagehand.StagehandZodObject;
+  InferStagehandSchema: Stagehand.InferStagehandSchema<Stagehand.StagehandZodSchema>;
+  JsonSchemaDocument: Stagehand.JsonSchemaDocument;
+  // Types from utils.ts
+  JsonSchema: Stagehand.JsonSchema;
+  JsonSchemaProperty: Stagehand.JsonSchemaProperty;
+  // Types from cookies.ts
+  Cookie: Stagehand.Cookie;
+  CookieParam: Stagehand.CookieParam;
+  ClearCookieOptions: Stagehand.ClearCookieOptions;
+};
+
+describe("Stagehand public API types", () => {
+  describe("AnyPage", () => {
+    type ExpectedAnyPage =
+      | Stagehand.PlaywrightPage
+      | Stagehand.PuppeteerPage
+      | Stagehand.PatchrightPage
+      | Stagehand.Page;
+
+    it("matches expected type shape", () => {
+      expectTypeOf<Stagehand.AnyPage>().toEqualTypeOf<ExpectedAnyPage>();
+    });
+  });
+
+  describe("ActOptions", () => {
+    type ExpectedActOptions = {
+      model?: Stagehand.ModelConfiguration;
+      variables?: Stagehand.Variables;
+      timeout?: number;
+      page?: Stagehand.AnyPage;
+      serverCache?: boolean;
+    };
+
+    it("matches expected type shape", () => {
+      expectTypeOf<Stagehand.ActOptions>().toEqualTypeOf<ExpectedActOptions>();
+    });
+  });
+
+  describe("ActResult", () => {
+    type ExpectedActResult = {
+      success: boolean;
+      message: string;
+      actionDescription: string;
+      actions: Stagehand.Action[];
+      cacheStatus?: "HIT" | "MISS";
+    };
+
+    it("matches expected type shape", () => {
+      expectTypeOf<Stagehand.ActResult>().toEqualTypeOf<ExpectedActResult>();
+    });
+  });
+
+  describe("ExtractOptions", () => {
+    type ExpectedExtractOptions = {
+      model?: Stagehand.ModelConfiguration;
+      timeout?: number;
+      selector?: string;
+      page?: Stagehand.AnyPage;
+      serverCache?: boolean;
+    };
+
+    it("matches expected type shape", () => {
+      expectTypeOf<Stagehand.ExtractOptions>().toEqualTypeOf<ExpectedExtractOptions>();
+    });
+  });
+
+  describe("ObserveOptions", () => {
+    type ExpectedObserveOptions = {
+      model?: Stagehand.ModelConfiguration;
+      timeout?: number;
+      selector?: string;
+      page?: Stagehand.AnyPage;
+      serverCache?: boolean;
+    };
+
+    it("matches expected type shape", () => {
+      expectTypeOf<Stagehand.ObserveOptions>().toEqualTypeOf<ExpectedObserveOptions>();
+    });
+  });
+
+  describe("ObserveResult", () => {
+    it("is an Action array with optional cacheStatus", () => {
+      expectTypeOf<Stagehand.ObserveResult>().toExtend<Stagehand.Action[]>();
+      expectTypeOf<Stagehand.ObserveResult["cacheStatus"]>().toEqualTypeOf<
+        "HIT" | "MISS" | undefined
+      >();
+    });
+  });
+
+  describe("Action", () => {
+    type ExpectedAction = {
+      selector: string;
+      description: string;
+      method?: string;
+      arguments?: string[];
+    };
+
+    it("matches expected type shape", () => {
+      expectTypeOf<Stagehand.Action>().toEqualTypeOf<ExpectedAction>();
+    });
+  });
+
+  describe("AgentAction", () => {
+    // AgentAction is a separate type from Action, not an extension
+    // It has additional fields like type, reasoning, taskCompleted, etc.
+    it("has type field", () => {
+      type TestAction = { type: string } & Stagehand.AgentAction;
+      expectTypeOf<TestAction["type"]>().toEqualTypeOf<string>();
+    });
+  });
+
+  describe("AgentExecuteOptions", () => {
+    type ExpectedAgentExecuteOptions = {
+      instruction: string;
+      maxSteps?: number;
+      page?: Stagehand.AnyPage;
+      highlightCursor?: boolean;
+      messages?: Stagehand.ModelMessage[];
+      signal?: AbortSignal;
+      excludeTools?: string[];
+      output?: Stagehand.StagehandZodObject;
+      callbacks?: Stagehand.AgentExecuteCallbacks;
+      variables?: Stagehand.Variables;
+      toolTimeout?: number;
+    };
+
+    it("matches expected type shape", () => {
+      expectTypeOf<Stagehand.AgentExecuteOptions>().toEqualTypeOf<ExpectedAgentExecuteOptions>();
+    });
+  });
+
+  describe("AgentStreamExecuteOptions", () => {
+    type ExpectedAgentStreamExecuteOptions = {
+      instruction: string;
+      maxSteps?: number;
+      page?: Stagehand.AnyPage;
+      highlightCursor?: boolean;
+      messages?: Stagehand.ModelMessage[];
+      signal?: AbortSignal;
+      excludeTools?: string[];
+      output?: Stagehand.StagehandZodObject;
+      callbacks?: Stagehand.AgentStreamCallbacks;
+      variables?: Stagehand.Variables;
+      toolTimeout?: number;
+    };
+
+    it("matches expected type shape", () => {
+      expectTypeOf<Stagehand.AgentStreamExecuteOptions>().toEqualTypeOf<ExpectedAgentStreamExecuteOptions>();
+    });
+  });
+
+  describe("AgentExecutionOptions", () => {
+    type ExpectedAgentExecutionOptions<T = Stagehand.AgentExecuteOptions> = {
+      options: T;
+      logger: (message: Stagehand.LogLine) => void;
+      retries?: number;
+    };
+
+    it("matches expected type shape", () => {
+      expectTypeOf<
+        Stagehand.AgentExecutionOptions<Stagehand.AgentExecuteOptions>
+      >().toEqualTypeOf<
+        ExpectedAgentExecutionOptions<Stagehand.AgentExecuteOptions>
+      >();
+    });
+  });
+
+  describe("AgentResult", () => {
+    type ExpectedAgentResult = {
+      success: boolean;
+      message: string;
+      actions: Stagehand.AgentAction[];
+      completed: boolean;
+      metadata?: Record<string, unknown>;
+      usage?: {
+        input_tokens: number;
+        output_tokens: number;
+        reasoning_tokens?: number;
+        cached_input_tokens?: number;
+        inference_time_ms: number;
+      };
+      messages?: Stagehand.ModelMessage[];
+      output?: Record<string, unknown>;
+    };
+
+    it("matches expected type shape", () => {
+      expectTypeOf<Stagehand.AgentResult>().toEqualTypeOf<ExpectedAgentResult>();
+    });
+  });
+
+  describe("AgentConfig", () => {
+    type ExpectedAgentConfig = {
+      systemPrompt?: string;
+      integrations?: (unknown | string)[];
+      tools?: unknown;
+      cua?: boolean;
+      model?: string | Stagehand.AgentModelConfig<string>;
+      executionModel?: string | Stagehand.AgentModelConfig<string>;
+      stream?: boolean;
+      mode?: Stagehand.AgentToolMode;
+    };
+
+    it("matches expected type shape", () => {
+      expectTypeOf<Stagehand.AgentConfig>().toExtend<ExpectedAgentConfig>();
+    });
+  });
+
+  describe("AgentToolMode", () => {
+    type ExpectedAgentToolMode = "dom" | "hybrid" | "cua";
+
+    it("matches expected type shape", () => {
+      expectTypeOf<Stagehand.AgentToolMode>().toEqualTypeOf<ExpectedAgentToolMode>();
+    });
+  });
+
+  describe("HistoryEntry", () => {
+    type ExpectedHistoryEntry = {
+      method: "act" | "extract" | "observe" | "navigate" | "agent";
+      parameters: unknown;
+      result: unknown;
+      timestamp: string;
+    };
+
+    it("matches expected type shape", () => {
+      expectTypeOf<Stagehand.HistoryEntry>().toEqualTypeOf<ExpectedHistoryEntry>();
+    });
+  });
+
+  describe("Cookie", () => {
+    type ExpectedCookie = {
+      name: string;
+      value: string;
+      domain: string;
+      path: string;
+      expires: number;
+      httpOnly: boolean;
+      secure: boolean;
+      sameSite: "Strict" | "Lax" | "None";
+    };
+
+    it("matches expected type shape", () => {
+      expectTypeOf<Stagehand.Cookie>().toEqualTypeOf<ExpectedCookie>();
+    });
+  });
+
+  describe("CookieParam", () => {
+    type ExpectedCookieParam = {
+      name: string;
+      value: string;
+      url?: string;
+      domain?: string;
+      path?: string;
+      expires?: number;
+      httpOnly?: boolean;
+      secure?: boolean;
+      sameSite?: "Strict" | "Lax" | "None";
+    };
+
+    it("matches expected type shape", () => {
+      expectTypeOf<Stagehand.CookieParam>().toEqualTypeOf<ExpectedCookieParam>();
+    });
+  });
+
+  describe("ClearCookieOptions", () => {
+    type ExpectedClearCookieOptions = {
+      name?: string | RegExp;
+      domain?: string | RegExp;
+      path?: string | RegExp;
+    };
+
+    it("matches expected type shape", () => {
+      expectTypeOf<Stagehand.ClearCookieOptions>().toEqualTypeOf<ExpectedClearCookieOptions>();
+    });
+  });
+});
diff --git a/packages/core/tests/unit/public-api/runtime-utils.test.ts b/packages/core/tests/unit/public-api/runtime-utils.test.ts
new file mode 100644
index 000000000..e72c32cb4
--- /dev/null
+++ b/packages/core/tests/unit/public-api/runtime-utils.test.ts
@@ -0,0 +1,53 @@
+import { describe, expectTypeOf, it } from "vitest";
+import * as Stagehand from "@browserbasehq/stagehand";
+
+describe("Runtime Utils public API types", () => {
+  describe("injectUrls", () => {
+    type ExpectedInjectUrlsParams = [
+      unknown,
+      Array<string | number>,
+      Record<string, string>,
+    ];
+
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.injectUrls,
+      ).parameters.branded.toEqualTypeOf<ExpectedInjectUrlsParams>();
+    });
+  });
+
+  describe("isRunningInBun", () => {
+    type ExpectedIsRunningInBunParams = [];
+
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.isRunningInBun,
+      ).parameters.branded.toEqualTypeOf<ExpectedIsRunningInBunParams>();
+    });
+  });
+
+  describe("loadApiKeyFromEnv", () => {
+    type ExpectedLoadApiKeyFromEnvParams = [
+      string | undefined,
+      (logLine: Stagehand.LogLine) => void,
+    ];
+
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.loadApiKeyFromEnv,
+      ).parameters.branded.toEqualTypeOf<ExpectedLoadApiKeyFromEnvParams>();
+    });
+  });
+
+  describe("providerEnvVarMap", () => {
+    type ExpectedProviderEnvVarMap = Partial<
+      Record<string, string | Array<string>>
+    >;
+
+    it("maps providers to environment variable names", () => {
+      expectTypeOf<
+        typeof Stagehand.providerEnvVarMap
+      >().toExtend<ExpectedProviderEnvVarMap>();
+    });
+  });
+});
diff --git a/packages/core/tests/unit/public-api/schema-utils.test.ts b/packages/core/tests/unit/public-api/schema-utils.test.ts
new file mode 100644
index 000000000..9a58b4308
--- /dev/null
+++ b/packages/core/tests/unit/public-api/schema-utils.test.ts
@@ -0,0 +1,120 @@
+import { describe, expectTypeOf, it } from "vitest";
+import * as Stagehand from "@browserbasehq/stagehand";
+
+describe("Schema Utils public API types", () => {
+  describe("defaultExtractSchema", () => {
+    type ExpectedInferredType = { extraction: string };
+
+    it("infers to the correct type", () => {
+      expectTypeOf<
+        Stagehand.InferStagehandSchema<typeof Stagehand.defaultExtractSchema>
+      >().toEqualTypeOf<ExpectedInferredType>();
+    });
+  });
+
+  describe("getZodType", () => {
+    type ExpectedGetZodTypeParams = [Stagehand.StagehandZodSchema];
+
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.getZodType,
+      ).parameters.branded.toEqualTypeOf<ExpectedGetZodTypeParams>();
+    });
+  });
+
+  describe("isZod3Schema", () => {
+    type ExpectedIsZod3SchemaParams = [Stagehand.StagehandZodSchema];
+
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.isZod3Schema,
+      ).parameters.branded.toEqualTypeOf<ExpectedIsZod3SchemaParams>();
+    });
+  });
+
+  describe("isZod4Schema", () => {
+    type ExpectedIsZod4SchemaParams = [Stagehand.StagehandZodSchema];
+
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.isZod4Schema,
+      ).parameters.branded.toEqualTypeOf<ExpectedIsZod4SchemaParams>();
+    });
+  });
+
+  describe("jsonSchemaToZod", () => {
+    type ExpectedJsonSchemaToZodParams = [Stagehand.JsonSchema];
+
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.jsonSchemaToZod,
+      ).parameters.branded.toEqualTypeOf<ExpectedJsonSchemaToZodParams>();
+    });
+  });
+
+  describe("pageTextSchema", () => {
+    type ExpectedInferredType = { pageText: string };
+
+    it("infers to the correct type", () => {
+      expectTypeOf<
+        Stagehand.InferStagehandSchema<typeof Stagehand.pageTextSchema>
+      >().toEqualTypeOf<ExpectedInferredType>();
+    });
+  });
+
+  describe("toGeminiSchema", () => {
+    type ExpectedToGeminiSchemaParams = [Stagehand.StagehandZodSchema];
+
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.toGeminiSchema,
+      ).parameters.branded.toEqualTypeOf<ExpectedToGeminiSchemaParams>();
+    });
+  });
+
+  describe("toJsonSchema", () => {
+    type ExpectedToJsonSchemaParams = [Stagehand.StagehandZodSchema];
+
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.toJsonSchema,
+      ).parameters.branded.toEqualTypeOf<ExpectedToJsonSchemaParams>();
+    });
+  });
+
+  describe("transformSchema", () => {
+    type ExpectedTransformSchemaParams = [
+      Stagehand.StagehandZodSchema,
+      Array<string | number>,
+    ];
+
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.transformSchema,
+      ).parameters.branded.toEqualTypeOf<ExpectedTransformSchemaParams>();
+    });
+  });
+
+  describe("trimTrailingTextNode", () => {
+    type ExpectedTrimTrailingTextNodeParams = [string | undefined];
+
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.trimTrailingTextNode,
+      ).parameters.branded.toEqualTypeOf<ExpectedTrimTrailingTextNodeParams>();
+    });
+  });
+
+  describe("validateZodSchema", () => {
+    type ExpectedValidateZodSchemaParams = [
+      Stagehand.StagehandZodSchema,
+      unknown,
+    ];
+
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.validateZodSchema,
+      ).parameters.branded.toEqualTypeOf<ExpectedValidateZodSchemaParams>();
+    });
+  });
+});
diff --git a/packages/core/tests/unit/public-api/timeout-error-types.test.ts b/packages/core/tests/unit/public-api/timeout-error-types.test.ts
new file mode 100644
index 000000000..bc6debf65
--- /dev/null
+++ b/packages/core/tests/unit/public-api/timeout-error-types.test.ts
@@ -0,0 +1,101 @@
+import { describe, expect, it } from "vitest";
+import * as Stagehand from "@browserbasehq/stagehand";
+
+// ============================================================================
+// Public Timeout Error Types Runtime Tests
+// ============================================================================
+// These tests verify the runtime behavior of exported timeout error types,
+// complementing the type-level tests in public-error-types.test.ts
+
+describe("Public timeout error types runtime behavior", () => {
+  describe("ActTimeoutError", () => {
+    it("is exported and extends Error", () => {
+      const error = new Stagehand.ActTimeoutError(1000);
+      expect(error).toBeInstanceOf(Error);
+      expect(error).toBeInstanceOf(Stagehand.ActTimeoutError);
+      expect(error.name).toBe("ActTimeoutError");
+    });
+
+    it("contains timeout value in milliseconds in message", () => {
+      const error = new Stagehand.ActTimeoutError(500);
+      expect(error.message).toContain("500ms");
+    });
+
+    it("contains operation name in message", () => {
+      const error = new Stagehand.ActTimeoutError(100);
+      expect(error.message).toContain("act()");
+    });
+
+    it("extends TimeoutError", () => {
+      const error = new Stagehand.ActTimeoutError(1000);
+      expect(error).toBeInstanceOf(Stagehand.TimeoutError);
+    });
+  });
+
+  describe("ExtractTimeoutError", () => {
+    it("is exported and extends Error", () => {
+      const error = new Stagehand.ExtractTimeoutError(1000);
+      expect(error).toBeInstanceOf(Error);
+      expect(error).toBeInstanceOf(Stagehand.ExtractTimeoutError);
+      expect(error.name).toBe("ExtractTimeoutError");
+    });
+
+    it("contains timeout value in milliseconds in message", () => {
+      const error = new Stagehand.ExtractTimeoutError(1000);
+      expect(error.message).toContain("1000ms");
+    });
+
+    it("contains operation name in message", () => {
+      const error = new Stagehand.ExtractTimeoutError(100);
+      expect(error.message).toContain("extract()");
+    });
+
+    it("extends TimeoutError", () => {
+      const error = new Stagehand.ExtractTimeoutError(1000);
+      expect(error).toBeInstanceOf(Stagehand.TimeoutError);
+    });
+  });
+
+  describe("ObserveTimeoutError", () => {
+    it("is exported and extends Error", () => {
+      const error = new Stagehand.ObserveTimeoutError(1000);
+      expect(error).toBeInstanceOf(Error);
+      expect(error).toBeInstanceOf(Stagehand.ObserveTimeoutError);
+      expect(error.name).toBe("ObserveTimeoutError");
+    });
+
+    it("contains timeout value in milliseconds in message", () => {
+      const error = new Stagehand.ObserveTimeoutError(1500);
+      expect(error.message).toContain("1500ms");
+    });
+
+    it("contains operation name in message", () => {
+      const error = new Stagehand.ObserveTimeoutError(100);
+      expect(error.message).toContain("observe()");
+    });
+
+    it("extends TimeoutError", () => {
+      const error = new Stagehand.ObserveTimeoutError(1000);
+      expect(error).toBeInstanceOf(Stagehand.TimeoutError);
+    });
+  });
+
+  describe("TimeoutError (base class)", () => {
+    it("is exported and extends Error", () => {
+      const error = new Stagehand.TimeoutError("custom operation", 2000);
+      expect(error).toBeInstanceOf(Error);
+      expect(error).toBeInstanceOf(Stagehand.TimeoutError);
+    });
+
+    it("contains operation name and timeout in message", () => {
+      const error = new Stagehand.TimeoutError("custom operation", 2000);
+      expect(error.message).toContain("custom operation");
+      expect(error.message).toContain("2000ms");
+    });
+
+    it("extends StagehandError", () => {
+      const error = new Stagehand.TimeoutError("operation", 1000);
+      expect(error).toBeInstanceOf(Stagehand.StagehandError);
+    });
+  });
+});
diff --git a/packages/core/tests/unit/public-api/tool-type-export.test.ts b/packages/core/tests/unit/public-api/tool-type-export.test.ts
new file mode 100644
index 000000000..d68bf18b1
--- /dev/null
+++ b/packages/core/tests/unit/public-api/tool-type-export.test.ts
@@ -0,0 +1,34 @@
+import { describe, expectTypeOf, it, expect } from "vitest";
+import * as Stagehand from "@browserbasehq/stagehand";
+import { type Tool } from "ai";
+import { z } from "zod";
+
+/**
+ * Test to verify tool-related exports from Stagehand.
+ * Users should be able to create custom tools using the exported `tool` function
+ * without needing to install the ai package directly.
+ */
+describe("Tool exports from AI SDK", () => {
+  it("exports Tool type that matches AI SDK Tool type", () => {
+    expectTypeOf<Stagehand.Tool>().toEqualTypeOf<Tool>();
+  });
+
+  it("exports tool function", () => {
+    expect(typeof Stagehand.tool).toBe("function");
+  });
+
+  it("tool function can be used to define custom tools", () => {
+    const customTool = Stagehand.tool({
+      description: "A test tool",
+      inputSchema: z.object({
+        input: z.string(),
+      }),
+      execute: async ({ input }) => {
+        return { result: `Processed: ${input}` };
+      },
+    });
+
+    expect(customTool).toBeDefined();
+    expect(customTool.description).toBe("A test tool");
+  });
+});
diff --git a/packages/core/tests/unit/public-api/v3-core.test.ts b/packages/core/tests/unit/public-api/v3-core.test.ts
new file mode 100644
index 000000000..6987d2f31
--- /dev/null
+++ b/packages/core/tests/unit/public-api/v3-core.test.ts
@@ -0,0 +1,181 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import * as Stagehand from "@browserbasehq/stagehand";
+
+describe("V3 Core public API types", () => {
+  describe("Stagehand", () => {
+    type ExpectedShape = {
+      init: () => Promise<void>;
+      close: (opts?: { force?: boolean }) => Promise<void>;
+      act: (
+        input: string | Stagehand.Action,
+        options?: Stagehand.ActOptions,
+      ) => Promise<Stagehand.ActResult>;
+      extract: (...args: unknown[]) => Promise<unknown>;
+      observe: (...args: unknown[]) => Promise<Stagehand.Action[]>;
+      agent: (config?: Stagehand.AgentConfig) => {
+        execute: (
+          instructionOrOptions: string | Stagehand.AgentExecuteOptions,
+        ) => Promise<Stagehand.AgentResult>;
+      };
+      connectURL: () => string;
+      context: unknown;
+      metrics: Promise<Stagehand.StagehandMetrics>;
+      history: Promise<ReadonlyArray<Stagehand.HistoryEntry>>;
+      llmClient: Stagehand.LLMClient;
+      browserbaseSessionID: string | undefined;
+      browserbaseSessionURL: string | undefined;
+      browserbaseDebugURL: string | undefined;
+      experimental: boolean;
+      logInferenceToFile: boolean;
+      verbose: 0 | 1 | 2;
+      logger: (logLine: Stagehand.LogLine) => void;
+      isAgentReplayActive: () => boolean;
+      recordAgentReplayStep: (step: unknown) => void;
+    };
+
+    type StagehandInstance = InstanceType<typeof Stagehand.Stagehand>;
+
+    it("has correct public interface shape", () => {
+      expectTypeOf<StagehandInstance>().toExtend<ExpectedShape>();
+    });
+
+    it("act accepts Action as first parameter", () => {
+      const mockAction = {} as Stagehand.Action;
+      expectTypeOf<StagehandInstance["act"]>().toBeCallableWith(
+        mockAction,
+        {} as Stagehand.ActOptions,
+      );
+    });
+
+    it("extract accepts instruction and schema", () => {
+      const mockSchema = {} as Stagehand.StagehandZodSchema;
+      expectTypeOf<StagehandInstance["extract"]>().toBeCallableWith(
+        "instruction",
+        mockSchema,
+        {} as Stagehand.ExtractOptions,
+      );
+    });
+
+    it("observe accepts instruction and options", () => {
+      expectTypeOf<StagehandInstance["observe"]>().toBeCallableWith(
+        "instruction",
+        {} as Stagehand.ObserveOptions,
+      );
+    });
+
+    it("agent execute accepts page option", () => {
+      type AgentReturn = ReturnType<StagehandInstance["agent"]>;
+      const mockPage = {} as Stagehand.AnyPage;
+      expectTypeOf<AgentReturn["execute"]>().toBeCallableWith({
+        instruction: "test",
+        page: mockPage,
+      } satisfies Stagehand.AgentExecuteOptions);
+    });
+  });
+
+  describe("StagehandMetrics", () => {
+    type ExpectedStagehandMetrics = {
+      actPromptTokens: number;
+      actCompletionTokens: number;
+      actReasoningTokens: number;
+      actCachedInputTokens: number;
+      actInferenceTimeMs: number;
+      extractPromptTokens: number;
+      extractCompletionTokens: number;
+      extractReasoningTokens: number;
+      extractCachedInputTokens: number;
+      extractInferenceTimeMs: number;
+      observePromptTokens: number;
+      observeCompletionTokens: number;
+      observeReasoningTokens: number;
+      observeCachedInputTokens: number;
+      observeInferenceTimeMs: number;
+      agentPromptTokens: number;
+      agentCompletionTokens: number;
+      agentReasoningTokens: number;
+      agentCachedInputTokens: number;
+      agentInferenceTimeMs: number;
+      totalPromptTokens: number;
+      totalCompletionTokens: number;
+      totalReasoningTokens: number;
+      totalCachedInputTokens: number;
+      totalInferenceTimeMs: number;
+    };
+
+    it("matches the published metrics shape", () => {
+      expectTypeOf<Stagehand.StagehandMetrics>().toEqualTypeOf<ExpectedStagehandMetrics>();
+    });
+  });
+
+  describe("V3", () => {
+    // V3 is the same class as Stagehand, just re-exported with a different name.
+    // The public interface shape is already tested in the "Stagehand" test above.
+    it("is exported", () => {
+      expect(Stagehand.V3).toBeDefined();
+    });
+  });
+
+  describe("V3Evaluator", () => {
+    type V3EvaluatorInstance = InstanceType<typeof Stagehand.V3Evaluator>;
+
+    it("is exported", () => {
+      expect(Stagehand.V3Evaluator).toBeDefined();
+    });
+
+    it("has ask method", () => {
+      expectTypeOf<V3EvaluatorInstance["ask"]>().toExtend<
+        (options: unknown) => Promise<unknown>
+      >();
+    });
+
+    it("has batchAsk method", () => {
+      expectTypeOf<V3EvaluatorInstance["batchAsk"]>().toExtend<
+        (options: unknown) => Promise<unknown[]>
+      >();
+    });
+  });
+
+  describe("V3FunctionName", () => {
+    const expectedFunctionNames = [
+      "ACT",
+      "EXTRACT",
+      "OBSERVE",
+      "AGENT",
+    ] as const;
+
+    it("matches the known function name literals", () => {
+      expectTypeOf<Stagehand.V3FunctionName>().toExtend<
+        (typeof expectedFunctionNames)[number]
+      >();
+      void expectedFunctionNames; // Mark as used to satisfy ESLint
+    });
+  });
+
+  describe("connectToMCPServer", () => {
+    type ExpectedServerConfig =
+      | string
+      | URL
+      | { command: string; args?: string[]; env?: Record<string, string> }
+      | {
+          serverUrl: string | URL;
+          clientOptions?: unknown;
+          requestOptions?: unknown;
+        };
+
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.connectToMCPServer,
+      ).parameters.branded.toEqualTypeOf<[ExpectedServerConfig]>();
+    });
+  });
+
+  describe("LOG_LEVEL_NAMES", () => {
+    type ExpectedLOG_LEVEL_NAMES = Record<Stagehand.LogLevel, string>;
+
+    it("maps numeric levels to strings", () => {
+      expectTypeOf<
+        typeof Stagehand.LOG_LEVEL_NAMES
+      >().toExtend<ExpectedLOG_LEVEL_NAMES>();
+    });
+  });
+});
diff --git a/packages/core/tests/unit/safety-confirmation.test.ts b/packages/core/tests/unit/safety-confirmation.test.ts
new file mode 100644
index 000000000..25b7461c0
--- /dev/null
+++ b/packages/core/tests/unit/safety-confirmation.test.ts
@@ -0,0 +1,174 @@
+import { describe, it, expect, vi } from "vitest";
+import { OpenAICUAClient } from "../../lib/v3/agent/OpenAICUAClient.js";
+import { GoogleCUAClient } from "../../lib/v3/agent/GoogleCUAClient.js";
+import type {
+  SafetyCheck,
+  SafetyConfirmationHandler,
+} from "../../lib/v3/types/public/agent.js";
+import type { LogLine } from "../../lib/v3/types/public/logs.js";
+
+type LoggerMock = (message: LogLine) => void;
+
+const openAISafetyInvoker = (
+  OpenAICUAClient.prototype as unknown as {
+    handleSafetyConfirmation: (
+      this: OpenAICUAClient,
+      pendingSafetyChecks: SafetyCheck[],
+      logger: LoggerMock,
+    ) => Promise<SafetyCheck[] | undefined>;
+  }
+).handleSafetyConfirmation;
+
+const googleSafetyInvoker = (
+  GoogleCUAClient.prototype as unknown as {
+    handleSafetyConfirmation: (
+      this: GoogleCUAClient,
+      safetyDecision: unknown,
+      logger: LoggerMock,
+    ) => Promise<string | undefined>;
+  }
+).handleSafetyConfirmation;
+
+function createOpenAIClient(): OpenAICUAClient {
+  return new OpenAICUAClient(
+    "openai",
+    "openai/computer-use-preview",
+    "test instructions",
+    { apiKey: "test" },
+  );
+}
+
+function createGoogleClient(): GoogleCUAClient {
+  return new GoogleCUAClient(
+    "google",
+    "google/gemini-2.5-computer-use-preview-10-2025",
+    "test instructions",
+    { apiKey: "test" },
+  );
+}
+
+describe("Safety Confirmation Handler", () => {
+  describe("OpenAI-style (pending_safety_checks)", () => {
+    const mockChecks: SafetyCheck[] = [
+      {
+        id: "check-1",
+        code: "malicious_instructions",
+        message: "Potentially harmful action detected",
+      },
+    ];
+
+    it("returns checks when handler acknowledges", async () => {
+      const client = createOpenAIClient();
+      const handler: SafetyConfirmationHandler = vi.fn(async () => ({
+        acknowledged: true,
+      }));
+      client.setSafetyConfirmationHandler(handler);
+      const logger = vi.fn<LoggerMock>();
+      const result = await openAISafetyInvoker.call(client, mockChecks, logger);
+
+      expect(handler).toHaveBeenCalledWith(mockChecks);
+      expect(result).toEqual(mockChecks);
+    });
+
+    it("returns undefined when handler rejects", async () => {
+      const client = createOpenAIClient();
+      const handler: SafetyConfirmationHandler = vi.fn(async () => ({
+        acknowledged: false,
+      }));
+      client.setSafetyConfirmationHandler(handler);
+      const logger = vi.fn<LoggerMock>();
+      const result = await openAISafetyInvoker.call(client, mockChecks, logger);
+
+      expect(handler).toHaveBeenCalledWith(mockChecks);
+      expect(result).toBeUndefined();
+    });
+
+    it("auto-acknowledges when no handler is set", async () => {
+      const client = createOpenAIClient();
+      const logger = vi.fn<LoggerMock>();
+      const result = await openAISafetyInvoker.call(client, mockChecks, logger);
+      expect(result).toEqual(mockChecks);
+    });
+  });
+
+  describe("Google-style (safety_decision)", () => {
+    const mockDecision = {
+      decision: "require_confirmation",
+      explanation: "Cookie consent dialog detected",
+    };
+
+    it("returns 'true' when handler acknowledges", async () => {
+      const client = createGoogleClient();
+      const handler: SafetyConfirmationHandler = vi.fn(async () => ({
+        acknowledged: true,
+      }));
+      client.setSafetyConfirmationHandler(handler);
+      const logger = vi.fn<LoggerMock>();
+      const result = await googleSafetyInvoker.call(
+        client,
+        mockDecision,
+        logger,
+      );
+
+      expect(handler).toHaveBeenCalledWith([
+        {
+          id: "google-safety-decision",
+          code: "safety_decision",
+          message: JSON.stringify(mockDecision, null, 2),
+        },
+      ]);
+      expect(result).toBe("true");
+    });
+
+    it("returns undefined when handler rejects", async () => {
+      const client = createGoogleClient();
+      const handler: SafetyConfirmationHandler = vi.fn(async () => ({
+        acknowledged: false,
+      }));
+      client.setSafetyConfirmationHandler(handler);
+      const logger = vi.fn<LoggerMock>();
+      const result = await googleSafetyInvoker.call(
+        client,
+        mockDecision,
+        logger,
+      );
+
+      expect(handler).toHaveBeenCalled();
+      expect(result).toBeUndefined();
+    });
+
+    it("auto-acknowledges when no handler is set", async () => {
+      const client = createGoogleClient();
+      const logger = vi.fn<LoggerMock>();
+      const result = await googleSafetyInvoker.call(
+        client,
+        mockDecision,
+        logger,
+      );
+      expect(result).toBe("true");
+    });
+
+    it("handles string safety decisions", async () => {
+      const client = createGoogleClient();
+      const handler: SafetyConfirmationHandler = vi.fn(async () => ({
+        acknowledged: true,
+      }));
+      client.setSafetyConfirmationHandler(handler);
+      const logger = vi.fn<LoggerMock>();
+      const result = await googleSafetyInvoker.call(
+        client,
+        "Simple string decision",
+        logger,
+      );
+
+      expect(handler).toHaveBeenCalledWith([
+        {
+          id: "google-safety-decision",
+          code: "safety_decision",
+          message: "Simple string decision",
+        },
+      ]);
+      expect(result).toBe("true");
+    });
+  });
+});
diff --git a/packages/core/tests/unit/snapshot-a11y-resolvers.test.ts b/packages/core/tests/unit/snapshot-a11y-resolvers.test.ts
new file mode 100644
index 000000000..c15092408
--- /dev/null
+++ b/packages/core/tests/unit/snapshot-a11y-resolvers.test.ts
@@ -0,0 +1,402 @@
+import type { Protocol } from "devtools-protocol";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { a11yForFrame } from "../../lib/v3/understudy/a11y/snapshot/a11yTree.js";
+import type { AccessibilityTreeResult } from "../../lib/v3/types/private/index.js";
+import * as focusSelectors from "../../lib/v3/understudy/a11y/snapshot/focusSelectors.js";
+import { MockCDPSession } from "./helpers/mockCDPSession.js";
+import { executionContexts } from "../../lib/v3/understudy/executionContextRegistry.js";
+import { tryScopedSnapshot } from "../../lib/v3/understudy/a11y/snapshot/capture.js";
+import type {
+  FrameContext,
+  A11yOptions,
+} from "../../lib/v3/types/private/index.js";
+import type { Page } from "../../lib/v3/understudy/page.js";
+import * as domTree from "../../lib/v3/understudy/a11y/snapshot/domTree.js";
+import * as a11yTree from "../../lib/v3/understudy/a11y/snapshot/a11yTree.js";
+import * as logger from "../../lib/v3/logger.js";
+
+const stringType = "string" as Protocol.Accessibility.AXValueType;
+
+const baseAxNodes = (): Protocol.Accessibility.AXNode[] => [
+  {
+    nodeId: "1",
+    role: { type: stringType, value: "RootWebArea" },
+    backendDOMNodeId: 100,
+    childIds: ["2"],
+    ignored: false,
+  },
+  {
+    nodeId: "2",
+    role: { type: stringType, value: "link" },
+    name: { type: stringType, value: "Docs" },
+    backendDOMNodeId: 101,
+    parentId: "1",
+    childIds: [],
+    properties: [
+      {
+        name: "url",
+        value: { type: stringType, value: "https://example.com" },
+      },
+    ],
+    ignored: false,
+  },
+];
+
+const baseHandlers = {
+  "Accessibility.enable": async () => ({}),
+  "Runtime.enable": async () => ({}),
+  "DOM.enable": async () => ({}),
+};
+
+describe("a11yForFrame", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns full outline and url map when no focus selector is provided", async () => {
+    const session = new MockCDPSession({
+      ...baseHandlers,
+      "Accessibility.getFullAXTree": async () => ({ nodes: baseAxNodes() }),
+    });
+
+    const opts: A11yOptions = {
+      focusSelector: undefined,
+      experimental: false,
+      tagNameMap: { "enc-100": "#document", "enc-101": "a" },
+      scrollableMap: {},
+      encode: (backend) => `enc-${backend}`,
+    };
+
+    const result = await a11yForFrame(session, undefined, opts);
+
+    expect(result.scopeApplied).toBe(false);
+    expect(result.urlMap["enc-101"]).toBe("https://example.com");
+    expect(result.outline).toContain("Docs");
+  });
+
+  it("scopes the tree to the resolved focus selector target", async () => {
+    const nodes = baseAxNodes().map((n) =>
+      n.nodeId === "2"
+        ? {
+            ...n,
+            childIds: ["3"],
+          }
+        : n,
+    );
+    nodes.push({
+      nodeId: "3",
+      parentId: "2",
+      childIds: [],
+      role: { type: stringType, value: "StaticText" },
+      backendDOMNodeId: 102,
+      ignored: false,
+    });
+
+    let scopedOnce = false;
+    const session = new MockCDPSession({
+      ...baseHandlers,
+      "Accessibility.getFullAXTree": async (params) => {
+        if (params?.frameId && !scopedOnce) {
+          scopedOnce = true;
+          throw new Error("does not belong to the target");
+        }
+        return { nodes };
+      },
+      "DOM.describeNode": async () => ({
+        node: { backendNodeId: 101 },
+      }),
+    });
+
+    const resolveSpy = vi
+      .spyOn(focusSelectors, "resolveObjectIdForXPath")
+      .mockResolvedValue("object-1");
+
+    const opts: A11yOptions = {
+      focusSelector: "xpath=//a",
+      experimental: false,
+      tagNameMap: { "enc-101": "a" },
+      scrollableMap: {},
+      encode: (backend) => `enc-${backend}`,
+    };
+
+    const result = await a11yForFrame(session, "frame-1", opts);
+
+    expect(result.scopeApplied).toBe(true);
+    expect(result.outline).not.toContain("RootWebArea");
+    expect(resolveSpy).toHaveBeenCalled();
+    resolveSpy.mockRestore();
+  });
+
+  it("falls back to full tree when resolveObjectId throws", async () => {
+    const session = new MockCDPSession({
+      ...baseHandlers,
+      "Accessibility.getFullAXTree": async () => ({ nodes: baseAxNodes() }),
+    });
+    vi.spyOn(focusSelectors, "resolveObjectIdForCss").mockRejectedValue(
+      new Error("fail"),
+    );
+    const opts: A11yOptions = {
+      focusSelector: ".btn",
+      experimental: false,
+      tagNameMap: {},
+      scrollableMap: {},
+      encode: (backend) => `enc-${backend}`,
+    };
+
+    const result = await a11yForFrame(session, "frame-1", opts);
+    expect(result.scopeApplied).toBe(false);
+  });
+});
+
+describe("resolveObjectIdForXPath", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("evaluates in the target frame's main world when available", async () => {
+    vi.spyOn(executionContexts, "waitForMainWorld").mockResolvedValue(42);
+    vi.spyOn(executionContexts, "getMainWorld").mockReturnValue(undefined);
+    const session = new MockCDPSession({
+      "Runtime.evaluate": async (params) => {
+        expect(params?.contextId).toBe(42);
+        return { result: { objectId: "node-obj" } };
+      },
+    });
+
+    const objectId = await focusSelectors.resolveObjectIdForXPath(
+      session,
+      "//div",
+      "frame-1",
+    );
+    expect(objectId).toBe("node-obj");
+  });
+
+  it("returns null when evaluation throws or reports exception details", async () => {
+    vi.spyOn(executionContexts, "waitForMainWorld").mockRejectedValue(
+      new Error("missing"),
+    );
+    vi.spyOn(executionContexts, "getMainWorld").mockReturnValue(undefined);
+    const session = new MockCDPSession({
+      "Runtime.evaluate": async () => ({
+        result: {},
+        exceptionDetails: { exception: { description: "bad" } },
+      }),
+    });
+
+    const objectId = await focusSelectors.resolveObjectIdForXPath(
+      session,
+      "//div",
+      "frame-2",
+    );
+    expect(objectId).toBeNull();
+  });
+});
+
+describe("resolveObjectIdForCss", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns primary evaluation result when available", async () => {
+    vi.spyOn(executionContexts, "waitForMainWorld").mockResolvedValue(7);
+    const session = new MockCDPSession({
+      "Runtime.evaluate": async () => ({
+        result: { objectId: "primary-obj" },
+      }),
+    });
+    const objectId = await focusSelectors.resolveObjectIdForCss(
+      session,
+      ".btn",
+      "frame-1",
+    );
+    expect(objectId).toBe("primary-obj");
+  });
+
+  it("falls back to the pierce selector when the primary lookup fails", async () => {
+    let call = 0;
+    const session = new MockCDPSession({
+      "Runtime.evaluate": async (params) => {
+        call++;
+        if (call === 1) {
+          expect(String(params?.expression)).toContain("resolveCssSelector");
+          return { result: {} };
+        }
+        expect(String(params?.expression)).toContain(
+          "resolveCssSelectorPierce",
+        );
+        return { result: { objectId: "css-obj" } };
+      },
+    });
+
+    const objectId = await focusSelectors.resolveObjectIdForCss(
+      session,
+      ".btn",
+      undefined,
+    );
+    expect(objectId).toBe("css-obj");
+  });
+
+  it("returns null when both primary and fallback evaluations throw", async () => {
+    vi.spyOn(executionContexts, "waitForMainWorld").mockResolvedValue(11);
+    vi.spyOn(executionContexts, "getMainWorld").mockReturnValue(undefined);
+    const session = new MockCDPSession({
+      "Runtime.evaluate": async () => ({
+        result: {},
+        exceptionDetails: { exception: { description: "fail" } },
+      }),
+    });
+
+    const objectId = await focusSelectors.resolveObjectIdForCss(
+      session,
+      ".missing",
+      "frame-1",
+    );
+    expect(objectId).toBeNull();
+  });
+});
+
+describe("tryScopedSnapshot", () => {
+  const ordinal = (frameId: string) => (frameId === "frame-1" ? 0 : 1);
+  const context: FrameContext = {
+    rootId: "frame-1",
+    frames: ["frame-1", "frame-2"],
+    parentByFrame: new Map([
+      ["frame-1", null],
+      ["frame-2", "frame-1"],
+    ]),
+  };
+
+  const makePage = (session: MockCDPSession, overrides?: Partial<Page>): Page =>
+    ({
+      mainFrameId: () => "frame-1",
+      asProtocolFrameTree: () => ({
+        frame: { id: "frame-1" as Protocol.Page.FrameId },
+        childFrames: [{ frame: { id: "frame-2" as Protocol.Page.FrameId } }],
+      }),
+      listAllFrameIds: () => ["frame-1", "frame-2"],
+      getSessionForFrame: () => session,
+      getOrdinal: (fid: string) => ordinal(fid),
+      ...overrides,
+    }) as unknown as Page;
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns scoped snapshot when focus selector resolves via CSS hops", async () => {
+    const session = new MockCDPSession({});
+    const domMapsSpy = vi
+      .spyOn(domTree, "domMapsForSession")
+      .mockResolvedValue({
+        tagNameMap: { "1-10": "div" },
+        xpathMap: { "1-10": "/div[1]" },
+        scrollableMap: {},
+      });
+    const a11ySpy = vi.spyOn(a11yTree, "a11yForFrame").mockResolvedValue({
+      outline: "[1-10] div",
+      urlMap: { "1-10": "https://example.com" },
+      scopeApplied: true,
+    } as AccessibilityTreeResult);
+    vi.spyOn(focusSelectors, "resolveCssFocusFrameAndTail").mockResolvedValue({
+      targetFrameId: "frame-2",
+      tailSelector: ".btn-inner",
+      absPrefix: "/html/body/iframe[1]",
+    });
+
+    const result = await tryScopedSnapshot(
+      makePage(session),
+      { focusSelector: ".btn" },
+      context,
+      true,
+    );
+
+    expect(result).not.toBeNull();
+    expect(result?.combinedXpathMap["1-10"]).toBe(
+      "/html/body/iframe[1]/div[1]",
+    );
+    expect(domMapsSpy).toHaveBeenCalled();
+    expect(a11ySpy).toHaveBeenCalled();
+  });
+
+  it("returns null and logs fallback when scope is not applied", async () => {
+    const session = new MockCDPSession({});
+    vi.spyOn(domTree, "domMapsForSession").mockResolvedValue({
+      tagNameMap: { "1-10": "div" },
+      xpathMap: { "1-10": "/div[1]" },
+      scrollableMap: {},
+    });
+    vi.spyOn(a11yTree, "a11yForFrame").mockResolvedValue({
+      outline: "ignored",
+      urlMap: {},
+      scopeApplied: false,
+    } as AccessibilityTreeResult);
+    const loggerSpy = vi.spyOn(logger, "v3Logger").mockImplementation(() => {});
+
+    const result = await tryScopedSnapshot(
+      makePage(session),
+      { focusSelector: ".btn" },
+      context,
+      false,
+    );
+
+    expect(result).toBeNull();
+    expect(loggerSpy).toHaveBeenCalled();
+  });
+
+  it("returns null immediately when no focus selector is provided", async () => {
+    const result = await tryScopedSnapshot(
+      makePage(new MockCDPSession({})),
+      {},
+      context,
+      true,
+    );
+    expect(result).toBeNull();
+  });
+
+  it("supports XPath focus resolution branch", async () => {
+    const session = new MockCDPSession({});
+    vi.spyOn(domTree, "domMapsForSession").mockResolvedValue({
+      tagNameMap: { "1-10": "div" },
+      xpathMap: { "1-10": "/div[1]" },
+      scrollableMap: {},
+    });
+    vi.spyOn(a11yTree, "a11yForFrame").mockResolvedValue({
+      outline: "[1-10] div",
+      urlMap: {},
+      scopeApplied: true,
+    } as AccessibilityTreeResult);
+    vi.spyOn(focusSelectors, "resolveFocusFrameAndTail").mockResolvedValue({
+      targetFrameId: "frame-1",
+      tailXPath: "//div[1]",
+      absPrefix: "",
+    });
+
+    const result = await tryScopedSnapshot(
+      makePage(session),
+      { focusSelector: "xpath=//div" },
+      context,
+      true,
+    );
+
+    expect(result).not.toBeNull();
+    expect(result?.combinedXpathMap["1-10"]).toBe("/div[1]");
+  });
+
+  it("logs and returns null when resolver throws", async () => {
+    const session = new MockCDPSession({});
+    vi.spyOn(focusSelectors, "resolveCssFocusFrameAndTail").mockRejectedValue(
+      new Error("bad selector"),
+    );
+    const loggerSpy = vi.spyOn(logger, "v3Logger").mockImplementation(() => {});
+
+    const result = await tryScopedSnapshot(
+      makePage(session),
+      { focusSelector: ".bad" },
+      context,
+      true,
+    );
+
+    expect(result).toBeNull();
+    expect(loggerSpy).toHaveBeenCalled();
+  });
+});
diff --git a/packages/core/tests/unit/snapshot-a11y-tree-utils.test.ts b/packages/core/tests/unit/snapshot-a11y-tree-utils.test.ts
new file mode 100644
index 000000000..e3903ecc7
--- /dev/null
+++ b/packages/core/tests/unit/snapshot-a11y-tree-utils.test.ts
@@ -0,0 +1,331 @@
+import type { Protocol } from "devtools-protocol";
+import { describe, expect, it } from "vitest";
+import type {
+  A11yNode,
+  A11yOptions,
+} from "../../lib/v3/types/private/snapshot.js";
+import {
+  buildHierarchicalTree,
+  decorateRoles,
+  extractUrlFromAXNode,
+  isStructural,
+  removeRedundantStaticTextChildren,
+} from "../../lib/v3/understudy/a11y/snapshot/a11yTree.js";
+
+const axString = (value: string): Protocol.Accessibility.AXValue => ({
+  type: "string",
+  value,
+});
+
+const defaultOpts: A11yOptions = {
+  focusSelector: undefined,
+  experimental: false,
+  tagNameMap: {},
+  scrollableMap: {},
+  encode: (backendNodeId: number) => `enc-${backendNodeId}`,
+};
+
+const makeAxNode = (
+  overrides: Partial<Protocol.Accessibility.AXNode> = {},
+): Protocol.Accessibility.AXNode => ({
+  nodeId: overrides.nodeId ?? String(Math.random()),
+  backendDOMNodeId:
+    overrides.backendDOMNodeId ?? Math.floor(Math.random() * 1e6),
+  role: overrides.role ?? axString("generic"),
+  childIds: overrides.childIds ?? [],
+  parentId: overrides.parentId,
+  properties: overrides.properties ?? [],
+  name: overrides.name,
+  description: overrides.description,
+  value: overrides.value,
+  ignored: overrides.ignored ?? false,
+});
+
+describe("decorateRoles", () => {
+  it("marks scrollable DOM nodes with tag labels and encoded ids", () => {
+    const opts: A11yOptions = {
+      ...defaultOpts,
+      tagNameMap: {
+        "enc-1": "div",
+        "enc-2": "html",
+        "enc-3": "#document",
+        "enc-4": "#svg",
+      },
+      scrollableMap: { "enc-1": true, "enc-4": true },
+    };
+    const nodes = [
+      makeAxNode({
+        backendDOMNodeId: 1,
+        role: { type: "string", value: "region" },
+      }),
+      makeAxNode({
+        backendDOMNodeId: 2,
+        role: { type: "string", value: "generic" },
+      }),
+      makeAxNode({
+        backendDOMNodeId: 3,
+        role: { type: "string", value: "generic" },
+      }),
+      makeAxNode({
+        backendDOMNodeId: 4,
+        role: { type: "string", value: "generic" },
+      }),
+    ];
+
+    const decorated = decorateRoles(nodes, opts);
+    expect(decorated).toMatchObject([
+      { encodedId: "enc-1", role: "scrollable, div" },
+      { encodedId: "enc-2", role: "scrollable, html" },
+      { encodedId: "enc-3", role: "generic" },
+      { encodedId: "enc-4", role: "scrollable, svg" },
+    ]);
+  });
+
+  it("falls back when encoding fails", () => {
+    const opts: A11yOptions = {
+      ...defaultOpts,
+      encode: () => {
+        throw new Error("boom");
+      },
+    };
+    const nodes = [makeAxNode({ backendDOMNodeId: 4 })];
+    const decorated = decorateRoles(nodes, opts);
+    expect(decorated[0]?.encodedId).toBeUndefined();
+  });
+});
+
+describe("buildHierarchicalTree", () => {
+  const opts: A11yOptions = {
+    ...defaultOpts,
+    tagNameMap: { root: "div", child: "span" },
+  };
+
+  it("drops structural nodes without children or names", async () => {
+    const nodes: A11yNode[] = [
+      {
+        role: "generic",
+        name: "",
+        nodeId: "root",
+        encodedId: "root",
+        parentId: undefined,
+        childIds: ["child"],
+      },
+      {
+        role: "generic",
+        name: "",
+        nodeId: "child",
+        encodedId: "child",
+        parentId: "root",
+        childIds: [],
+      },
+    ];
+
+    const { tree } = await buildHierarchicalTree(nodes, opts);
+    expect(tree).toEqual([]);
+  });
+
+  it("promotes select/combobox tag names for structural nodes", async () => {
+    const nodes: A11yNode[] = [
+      {
+        role: "combobox",
+        name: "Select",
+        nodeId: "root",
+        encodedId: "root",
+        parentId: undefined,
+        childIds: ["child"],
+      },
+      {
+        role: "StaticText",
+        name: "Option",
+        nodeId: "child",
+        encodedId: "child",
+        parentId: "root",
+        childIds: [],
+      },
+    ];
+
+    const { tree } = await buildHierarchicalTree(nodes, {
+      ...opts,
+      tagNameMap: { root: "select" },
+    });
+    expect(tree[0]?.role).toBe("select");
+  });
+
+  it("drops structural parents with a single cleaned child while keeping it in place", async () => {
+    const nodes: A11yNode[] = [
+      {
+        role: "generic",
+        name: "",
+        nodeId: "root",
+        encodedId: "root",
+        parentId: undefined,
+        childIds: ["child"],
+      },
+      {
+        role: "StaticText",
+        name: "Ok",
+        nodeId: "child",
+        encodedId: "child",
+        parentId: "root",
+        childIds: [],
+      },
+    ];
+
+    const { tree } = await buildHierarchicalTree(nodes, opts);
+    expect(tree[0]?.role).toBe("StaticText");
+  });
+
+  it("drops structural parents entirely when all descendants are pruned", async () => {
+    const nodes: A11yNode[] = [
+      {
+        role: "generic",
+        name: "",
+        nodeId: "root",
+        encodedId: "root",
+        parentId: undefined,
+        childIds: ["child"],
+      },
+      {
+        role: "generic",
+        name: "",
+        nodeId: "child",
+        encodedId: "child",
+        parentId: "root",
+        childIds: [],
+      },
+    ];
+
+    const { tree } = await buildHierarchicalTree(nodes, opts);
+    expect(tree).toEqual([]);
+  });
+
+  it("renames structural nodes to their tag names when not combobox", async () => {
+    const nodes: A11yNode[] = [
+      {
+        role: "generic",
+        name: "Container",
+        nodeId: "root",
+        encodedId: "root",
+        parentId: undefined,
+        childIds: ["child-a", "child-b"],
+      },
+      {
+        role: "StaticText",
+        name: "A",
+        nodeId: "child-a",
+        encodedId: "child-a",
+        parentId: "root",
+        childIds: [],
+      },
+      {
+        role: "StaticText",
+        name: "B",
+        nodeId: "child-b",
+        encodedId: "child-b",
+        parentId: "root",
+        childIds: [],
+      },
+    ];
+
+    const { tree } = await buildHierarchicalTree(nodes, {
+      ...opts,
+      tagNameMap: { root: "section" },
+    });
+    expect(tree[0]?.role).toBe("section");
+  });
+
+  it("skips nodes with negative node ids early", async () => {
+    const nodes: A11yNode[] = [
+      {
+        role: "button",
+        name: "Hidden",
+        nodeId: "-1",
+        encodedId: "hidden",
+        parentId: undefined,
+        childIds: [],
+      },
+    ];
+
+    const { tree } = await buildHierarchicalTree(nodes, opts);
+    expect(tree).toEqual([]);
+  });
+});
+
+describe("isStructural", () => {
+  it("marks generic/none/InlineTextBox roles as structural", () => {
+    expect(isStructural("generic")).toBe(true);
+    expect(isStructural("none")).toBe(true);
+    expect(isStructural("InlineTextBox")).toBe(true);
+    expect(isStructural("button")).toBe(false);
+  });
+});
+
+describe("removeRedundantStaticTextChildren", () => {
+  it("removes static text children whose concatenated text equals the parent name", () => {
+    const parent: A11yNode = {
+      role: "button",
+      name: "HelloWorld",
+      nodeId: "root",
+    };
+    const children: A11yNode[] = [
+      { role: "StaticText", name: "Hello", nodeId: "c1" },
+      { role: "StaticText", name: "World", nodeId: "c2" },
+      { role: "button", name: "Child", nodeId: "c3" },
+    ];
+    const pruned = removeRedundantStaticTextChildren(parent, children);
+    expect(pruned).toEqual([{ role: "button", name: "Child", nodeId: "c3" }]);
+  });
+
+  it("keeps static text when combined text differs", () => {
+    const parent: A11yNode = {
+      role: "button",
+      name: "Hello World",
+      nodeId: "root",
+    };
+    const children: A11yNode[] = [
+      { role: "StaticText", name: "Hello", nodeId: "c1" },
+      { role: "StaticText", name: "Mars", nodeId: "c2" },
+    ];
+    expect(removeRedundantStaticTextChildren(parent, children)).toEqual(
+      children,
+    );
+  });
+  it("returns original children when parent name is empty", () => {
+    const parent: A11yNode = {
+      role: "button",
+      nodeId: "root",
+    };
+    const children: A11yNode[] = [
+      { role: "StaticText", name: "Hello", nodeId: "c1" },
+      { role: "StaticText", name: "World", nodeId: "c2" },
+    ];
+    expect(removeRedundantStaticTextChildren(parent, children)).toEqual(
+      children,
+    );
+  });
+});
+
+describe("extractUrlFromAXNode", () => {
+  it("returns trimmed URL string from node properties", () => {
+    const node = makeAxNode({
+      properties: [
+        { name: "busy", value: axString("bar") },
+        { name: "url", value: axString(" https://example.com ") },
+      ],
+    });
+    expect(extractUrlFromAXNode(node)).toBe("https://example.com");
+  });
+
+  it("returns undefined when url property missing or invalid", () => {
+    expect(
+      extractUrlFromAXNode(makeAxNode({ properties: [] })),
+    ).toBeUndefined();
+    expect(
+      extractUrlFromAXNode(
+        makeAxNode({
+          properties: [{ name: "url", value: { type: "number", value: 123 } }],
+        }),
+      ),
+    ).toBeUndefined();
+  });
+});
diff --git a/packages/core/tests/unit/snapshot-capture-orchestration.test.ts b/packages/core/tests/unit/snapshot-capture-orchestration.test.ts
new file mode 100644
index 000000000..50f4e5308
--- /dev/null
+++ b/packages/core/tests/unit/snapshot-capture-orchestration.test.ts
@@ -0,0 +1,472 @@
+import type { Protocol } from "devtools-protocol";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { CDPSessionLike } from "../../lib/v3/understudy/cdp.js";
+import type { Page } from "../../lib/v3/understudy/page.js";
+import type {
+  FrameContext,
+  SessionDomIndex,
+} from "../../lib/v3/types/private/index.js";
+import * as capture from "../../lib/v3/understudy/a11y/snapshot/capture.js";
+import * as a11yTree from "../../lib/v3/understudy/a11y/snapshot/a11yTree.js";
+import * as domTree from "../../lib/v3/understudy/a11y/snapshot/domTree.js";
+import * as focusSelectors from "../../lib/v3/understudy/a11y/snapshot/focusSelectors.js";
+import { MockCDPSession } from "./helpers/mockCDPSession.js";
+
+const makeProtocolFrame = (id: string): Protocol.Page.Frame =>
+  ({
+    id,
+    loaderId: `${id}-loader`,
+    url: "https://example.com",
+    securityOrigin: "https://example.com",
+    mimeType: "text/html",
+  }) as unknown as Protocol.Page.Frame;
+
+const makeFrameTree = (
+  id: string,
+  children: Protocol.Page.FrameTree[] = [],
+): Protocol.Page.FrameTree => ({
+  frame: makeProtocolFrame(id),
+  childFrames: children,
+});
+
+type PageStub = Pick<
+  Page,
+  | "mainFrameId"
+  | "asProtocolFrameTree"
+  | "listAllFrameIds"
+  | "getSessionForFrame"
+  | "getOrdinal"
+>;
+
+const makePage = (overrides: Partial<PageStub> = {}): Page => {
+  const defaultSession = new MockCDPSession({}, "default-session");
+  const base: PageStub = {
+    mainFrameId: () => "frame-1",
+    asProtocolFrameTree: () => makeFrameTree("frame-1"),
+    listAllFrameIds: () => ["frame-1"],
+    getSessionForFrame: () => defaultSession,
+    getOrdinal: () => 0,
+  };
+  return { ...base, ...overrides } as unknown as Page;
+};
+
+const makeSessionIndex = (): SessionDomIndex => ({
+  rootBackend: 100,
+  absByBe: new Map([
+    [100, "/"],
+    [101, "/html[1]"],
+    [102, "/html[1]/body[1]"],
+    [150, "/html[1]/body[1]/iframe[1]"],
+    [200, "/html[1]/body[1]/iframe[1]"],
+    [201, "/html[1]/body[1]/iframe[1]/div[1]"],
+  ]),
+  tagByBe: new Map([
+    [100, "#document"],
+    [101, "html"],
+    [102, "body"],
+    [150, "iframe"],
+    [200, "#document"],
+    [201, "div"],
+  ]),
+  scrollByBe: new Map([[201, true]]),
+  docRootOf: new Map([
+    [100, 100],
+    [101, 100],
+    [102, 100],
+    [150, 100],
+    [200, 200],
+    [201, 200],
+  ]),
+  contentDocRootByIframe: new Map([[150, 200]]),
+});
+
+beforeEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("buildFrameContext", () => {
+  it("indexes parent relationships from the frame tree", () => {
+    const frameTree = makeFrameTree("frame-1", [
+      makeFrameTree("frame-2", [makeFrameTree("frame-3")]),
+      makeFrameTree("frame-4"),
+    ]);
+    const page = makePage({
+      asProtocolFrameTree: () => frameTree,
+      listAllFrameIds: () => ["frame-1", "frame-2", "frame-3", "frame-4"],
+    });
+
+    const context = capture.buildFrameContext(page);
+
+    expect(context.rootId).toBe("frame-1");
+    expect(context.frames).toEqual([
+      "frame-1",
+      "frame-2",
+      "frame-3",
+      "frame-4",
+    ]);
+    expect(context.parentByFrame.get("frame-1")).toBeNull();
+    expect(context.parentByFrame.get("frame-2")).toBe("frame-1");
+    expect(context.parentByFrame.get("frame-3")).toBe("frame-2");
+    expect(context.parentByFrame.get("frame-4")).toBe("frame-1");
+  });
+});
+
+describe("buildSessionIndexes", () => {
+  it("deduplicates frames that share the same CDP session id", async () => {
+    const session = new MockCDPSession({}, "session-a");
+    const page = makePage({
+      // Every frame lookup returns the same session instance, so buildSessionIndexes
+      // should call buildSessionDomIndex only once and reuse the result.
+      getSessionForFrame: () => session,
+    });
+    const idx = makeSessionIndex();
+    const spy = vi
+      .spyOn(domTree, "buildSessionDomIndex")
+      .mockResolvedValue(idx);
+
+    const result = await capture.buildSessionIndexes(
+      page,
+      ["frame-1", "frame-2"],
+      true,
+    );
+
+    expect(spy).toHaveBeenCalledTimes(1); // only one DOM.getDocument per session id
+    expect(spy).toHaveBeenCalledWith(session, true);
+    expect(result.get("session-a")).toBe(idx);
+  });
+
+  it("builds indexes for sessions without ids using the 'root' key", async () => {
+    const sessionWithoutId: CDPSessionLike = {
+      id: undefined,
+      async send<R = unknown>(
+        _method: string,
+        _params?: Record<string, unknown>,
+      ): Promise<R> {
+        void _method;
+        void _params;
+        return {} as R;
+      },
+      on() {},
+      off() {},
+      async close() {},
+    };
+    const sessionWithId = new MockCDPSession({}, "child-session");
+    const page = makePage({
+      getSessionForFrame: (frameId: string) =>
+        frameId === "frame-1" ? sessionWithoutId : sessionWithId,
+    });
+
+    const idxA = makeSessionIndex();
+    const idxB = makeSessionIndex();
+    const spy = vi
+      .spyOn(domTree, "buildSessionDomIndex")
+      .mockResolvedValueOnce(idxA)
+      .mockResolvedValueOnce(idxB);
+
+    const result = await capture.buildSessionIndexes(
+      page,
+      ["frame-1", "frame-2"],
+      false,
+    );
+
+    // Verifies the helper invokes buildSessionDomIndex once for each unique session,
+    // keying anonymous sessions as "root" so downstream lookups remain stable.
+    expect(spy).toHaveBeenNthCalledWith(1, sessionWithoutId, false);
+    expect(spy).toHaveBeenNthCalledWith(2, sessionWithId, false);
+    expect(result.get("root")).toBe(idxA);
+    expect(result.get("child-session")).toBe(idxB);
+  });
+});
+
+describe("collectPerFrameMaps", () => {
+  it("builds per-frame xpath/tag maps and outlines from a shared session index", async () => {
+    const session = new MockCDPSession(
+      {
+        "DOM.getFrameOwner": async () => ({ backendNodeId: 150 }),
+      },
+      "session-a",
+    );
+    const page = makePage({
+      getSessionForFrame: () => session,
+      getOrdinal: (frameId: string) => (frameId === "frame-1" ? 0 : 1),
+    });
+    const context: FrameContext = {
+      rootId: "frame-1",
+      frames: ["frame-1", "frame-2"],
+      parentByFrame: new Map([
+        ["frame-1", null],
+        ["frame-2", "frame-1"],
+      ]),
+    };
+    const sessionIndex = makeSessionIndex();
+    const sessionToIndex = new Map([[session.id, sessionIndex]]);
+
+    vi.spyOn(a11yTree, "a11yForFrame").mockImplementation(
+      async (_sess, frameId) => ({
+        outline: `outline-${frameId}`,
+        urlMap: { [`url-${frameId}`]: `https://${frameId}.test` },
+        scopeApplied: false,
+      }),
+    );
+
+    const result = await capture.collectPerFrameMaps(
+      page,
+      context,
+      sessionToIndex,
+      { experimental: true },
+      true,
+      context.frames,
+    );
+
+    expect(result.perFrameOutlines).toEqual([
+      { frameId: "frame-1", outline: "outline-frame-1" },
+      { frameId: "frame-2", outline: "outline-frame-2" },
+    ]);
+    const rootMaps = result.perFrameMaps.get("frame-1");
+    expect(rootMaps?.xpathMap["0-100"]).toBe("/");
+    expect(rootMaps?.xpathMap["0-101"]).toBe("/html[1]");
+    expect(rootMaps?.xpathMap["0-102"]).toBe("/html[1]/body[1]");
+    const childMaps = result.perFrameMaps.get("frame-2");
+    expect(childMaps?.xpathMap["1-200"]).toBe("/");
+    expect(childMaps?.xpathMap["1-201"]).toBe("/div[1]");
+    expect(childMaps?.scrollableMap["1-201"]).toBe(true);
+    expect(childMaps?.urlMap).toEqual({
+      "url-frame-2": "https://frame-2.test",
+    });
+    expect(session.callsFor("DOM.getFrameOwner")).toHaveLength(1);
+  });
+
+  it("builds a missing session index on demand and memoizes it", async () => {
+    const session = new MockCDPSession({}, "new-session");
+    const page = makePage({
+      getSessionForFrame: () => session,
+      getOrdinal: () => 2,
+    });
+    const context: FrameContext = {
+      rootId: "frame-9",
+      frames: ["frame-9"],
+      parentByFrame: new Map([["frame-9", null]]),
+    };
+    const idx = makeSessionIndex();
+    const buildSpy = vi
+      .spyOn(domTree, "buildSessionDomIndex")
+      .mockResolvedValue(idx);
+    vi.spyOn(a11yTree, "a11yForFrame").mockResolvedValue({
+      outline: "outline",
+      urlMap: {},
+      scopeApplied: false,
+    });
+
+    const sessionToIndex = new Map<string, SessionDomIndex>();
+    const result = await capture.collectPerFrameMaps(
+      page,
+      context,
+      sessionToIndex,
+      undefined,
+      false,
+      context.frames,
+    );
+
+    expect(buildSpy).toHaveBeenCalledWith(session, false);
+    expect(sessionToIndex.get("new-session")).toBe(idx);
+    expect(result.perFrameMaps.get("frame-9")?.xpathMap["2-100"]).toBe("/");
+  });
+
+  it("skips frames that are not listed in the frameIds argument", async () => {
+    const session = new MockCDPSession({}, "session-a");
+    const page = makePage({
+      getSessionForFrame: () => session,
+      getOrdinal: (frameId: string) => (frameId === "frame-1" ? 0 : 1),
+    });
+    const context: FrameContext = {
+      rootId: "frame-1",
+      frames: ["frame-1", "frame-2"],
+      parentByFrame: new Map([
+        ["frame-1", null],
+        ["frame-2", "frame-1"],
+      ]),
+    };
+    const sessionIndex = makeSessionIndex();
+    const sessionToIndex = new Map([[session.id, sessionIndex]]);
+
+    const a11ySpy = vi.spyOn(a11yTree, "a11yForFrame").mockResolvedValue({
+      outline: "outline",
+      urlMap: {},
+      scopeApplied: false,
+    });
+
+    const result = await capture.collectPerFrameMaps(
+      page,
+      context,
+      sessionToIndex,
+      undefined,
+      true,
+      ["frame-1"],
+    );
+
+    expect(a11ySpy).toHaveBeenCalledTimes(1);
+    expect(result.perFrameMaps.has("frame-2")).toBe(false);
+    expect(result.perFrameOutlines.map((o) => o.frameId)).toEqual(["frame-1"]);
+  });
+});
+
+describe("captureHybridSnapshot", () => {
+  it("returns early when the scoped snapshot path succeeds", async () => {
+    const session = new MockCDPSession({}, "session-a");
+    const page = makePage({
+      getSessionForFrame: () => session,
+    });
+    const options = { focusSelector: "/html" };
+
+    vi.spyOn(focusSelectors, "resolveFocusFrameAndTail").mockResolvedValue({
+      targetFrameId: "frame-1",
+      tailXPath: "",
+      absPrefix: "",
+    });
+    const domMapsSpy = vi
+      .spyOn(domTree, "domMapsForSession")
+      .mockResolvedValue({
+        tagNameMap: { "0-100": "#document" },
+        xpathMap: { "0-100": "/" },
+        scrollableMap: {},
+      });
+    const a11ySpy = vi.spyOn(a11yTree, "a11yForFrame").mockResolvedValue({
+      outline: "scoped outline",
+      urlMap: { "0-100": "https://frame-1.test" },
+      scopeApplied: true,
+    });
+    const buildIndexSpy = vi
+      .spyOn(domTree, "buildSessionDomIndex")
+      .mockImplementation(() => {
+        throw new Error("should not build session index when scoped");
+      });
+
+    const result = await capture.captureHybridSnapshot(page, options);
+
+    expect(result.combinedTree).toBe("scoped outline");
+    expect(result.combinedUrlMap["0-100"]).toBe("https://frame-1.test");
+    expect(domMapsSpy).toHaveBeenCalled();
+    expect(a11ySpy).toHaveBeenCalled();
+    expect(buildIndexSpy).not.toHaveBeenCalled();
+  });
+
+  it("scoped snapshot still succeeds when iframe inclusion is disabled", async () => {
+    const session = new MockCDPSession({}, "session-a");
+    const page = makePage({
+      getSessionForFrame: () => session,
+    });
+    const options = { focusSelector: "/html", includeIframes: false };
+
+    vi.spyOn(focusSelectors, "resolveFocusFrameAndTail").mockResolvedValue({
+      targetFrameId: "frame-1",
+      tailXPath: "",
+      absPrefix: "",
+    });
+    const domMapsSpy = vi
+      .spyOn(domTree, "domMapsForSession")
+      .mockResolvedValue({
+        tagNameMap: { "0-100": "#document" },
+        xpathMap: { "0-100": "/" },
+        scrollableMap: {},
+      });
+    const a11ySpy = vi.spyOn(a11yTree, "a11yForFrame").mockResolvedValue({
+      outline: "scoped outline",
+      urlMap: { "0-100": "https://frame-1.test" },
+      scopeApplied: true,
+    });
+    const buildIndexSpy = vi
+      .spyOn(domTree, "buildSessionDomIndex")
+      .mockImplementation(() => {
+        throw new Error("should not build session index when scoped");
+      });
+
+    const result = await capture.captureHybridSnapshot(page, options);
+
+    expect(result.combinedTree).toBe("scoped outline");
+    expect(result.combinedUrlMap["0-100"]).toBe("https://frame-1.test");
+    expect(domMapsSpy).toHaveBeenCalled();
+    expect(a11ySpy).toHaveBeenCalled();
+    expect(buildIndexSpy).not.toHaveBeenCalled();
+  });
+
+  it("collects per-frame data and merges it when no scoped snapshot is available", async () => {
+    const session = new MockCDPSession(
+      {
+        "DOM.getFrameOwner": async () => ({ backendNodeId: 150 }),
+      },
+      "session-a",
+    );
+    const page = makePage({
+      asProtocolFrameTree: () =>
+        makeFrameTree("frame-1", [makeFrameTree("frame-2")]),
+      listAllFrameIds: () => ["frame-1", "frame-2"],
+      getSessionForFrame: () => session,
+      getOrdinal: (frameId: string) => (frameId === "frame-1" ? 0 : 1),
+    });
+
+    const idx = makeSessionIndex();
+    vi.spyOn(domTree, "buildSessionDomIndex").mockResolvedValue(idx);
+    vi.spyOn(a11yTree, "a11yForFrame").mockImplementation(
+      async (_sess, frameId) => ({
+        outline:
+          frameId === "frame-1"
+            ? "[0-150] iframe host"
+            : "[1-200] child subtree",
+        urlMap: { [`url-${frameId}`]: `https://${frameId}.test` },
+        scopeApplied: false,
+      }),
+    );
+
+    const snapshot = await capture.captureHybridSnapshot(page);
+
+    expect(snapshot.combinedTree).toContain("[1-200] child subtree");
+    expect(snapshot.combinedXpathMap["0-100"]).toBe("/");
+    expect(snapshot.combinedXpathMap["1-201"]).toBe(
+      "/html[1]/body[1]/iframe[1]/div[1]",
+    );
+    expect(snapshot.combinedUrlMap["url-frame-2"]).toBe("https://frame-2.test");
+    expect(snapshot.perFrame?.map((pf) => pf.frameId)).toEqual([
+      "frame-1",
+      "frame-2",
+    ]);
+  });
+
+  it("omits iframe frames when includeIframes is false", async () => {
+    const session = new MockCDPSession(
+      {
+        "DOM.getFrameOwner": async () => ({ backendNodeId: 150 }),
+      },
+      "session-a",
+    );
+    const page = makePage({
+      asProtocolFrameTree: () =>
+        makeFrameTree("frame-1", [makeFrameTree("frame-2")]),
+      listAllFrameIds: () => ["frame-1", "frame-2"],
+      getSessionForFrame: () => session,
+      getOrdinal: (frameId: string) => (frameId === "frame-1" ? 0 : 1),
+    });
+
+    const idx = makeSessionIndex();
+    vi.spyOn(domTree, "buildSessionDomIndex").mockResolvedValue(idx);
+    const a11ySpy = vi
+      .spyOn(a11yTree, "a11yForFrame")
+      .mockImplementation(async (_sess, frameId) => ({
+        outline:
+          frameId === "frame-1"
+            ? "[0-150] iframe host"
+            : "[1-200] child subtree",
+        urlMap: { [`url-${frameId}`]: `https://${frameId}.test` },
+        scopeApplied: false,
+      }));
+
+    const snapshot = await capture.captureHybridSnapshot(page, {
+      includeIframes: false,
+    });
+
+    expect(a11ySpy).toHaveBeenCalledTimes(1);
+    expect(session.callsFor("DOM.getFrameOwner")).toHaveLength(0);
+    expect(snapshot.perFrame?.map((pf) => pf.frameId)).toEqual(["frame-1"]);
+    expect(snapshot.combinedXpathMap["1-201"]).toBeUndefined();
+    expect(snapshot.combinedTree).not.toContain("[1-200] child subtree");
+  });
+});
diff --git a/packages/core/tests/unit/snapshot-cbor.test.ts b/packages/core/tests/unit/snapshot-cbor.test.ts
new file mode 100644
index 000000000..cb3270301
--- /dev/null
+++ b/packages/core/tests/unit/snapshot-cbor.test.ts
@@ -0,0 +1,223 @@
+import { describe, expect, it } from "vitest";
+import type { Protocol } from "devtools-protocol";
+
+import { captureHybridSnapshot } from "../../lib/v3/understudy/a11y/snapshot/index.js";
+import { MockCDPSession } from "./helpers/mockCDPSession.js";
+import type { Page } from "../../lib/v3/understudy/page.js";
+import { StagehandDomProcessError } from "../../lib/v3/types/public/sdkErrors.js";
+import { CDPSessionLike } from "../../lib/v3/understudy/cdp.js";
+
+type Handler = (params?: Record<string, unknown>) => Promise<unknown> | unknown;
+
+function createFakePage(session: CDPSessionLike): Page {
+  const frameTree: Protocol.Page.FrameTree = {
+    frame: {
+      id: "root" as Protocol.Page.FrameId,
+      loaderId: "root-loader" as Protocol.Network.LoaderId,
+      url: "http://fake",
+      domainAndRegistry: "fake",
+      securityOrigin: "http://fake",
+      mimeType: "text/html",
+      secureContextType: "Secure",
+      crossOriginIsolatedContextType: "NotIsolated",
+      gatedAPIFeatures: [],
+    },
+    childFrames: [],
+  };
+
+  return {
+    mainFrameId: () => "root",
+    asProtocolFrameTree: () => frameTree,
+    listAllFrameIds: () => ["root"],
+    getSessionForFrame: () => session,
+    getOrdinal: () => 0,
+  } as unknown as Page;
+}
+
+function completeDomTree(): Protocol.DOM.Node {
+  return {
+    nodeId: 1,
+    backendNodeId: 1,
+    nodeType: 9,
+    nodeName: "#document",
+    childNodeCount: 1,
+    children: [
+      {
+        nodeId: 2,
+        backendNodeId: 2,
+        nodeType: 1,
+        nodeName: "HTML",
+        childNodeCount: 1,
+        children: [
+          {
+            nodeId: 3,
+            backendNodeId: 3,
+            nodeType: 1,
+            nodeName: "BODY",
+            childNodeCount: 1,
+            children: [
+              {
+                nodeId: 4,
+                backendNodeId: 4,
+                nodeType: 1,
+                nodeName: "DIV",
+                childNodeCount: 0,
+                children: [],
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  } as Protocol.DOM.Node;
+}
+
+function truncatedDomTree(): Protocol.DOM.Node {
+  return {
+    nodeId: 1,
+    backendNodeId: 1,
+    nodeType: 9,
+    nodeName: "#document",
+    childNodeCount: 1,
+    children: [
+      {
+        nodeId: 2,
+        backendNodeId: 2,
+        nodeType: 1,
+        nodeName: "HTML",
+        childNodeCount: 1,
+        children: [],
+      },
+    ],
+  } as Protocol.DOM.Node;
+}
+
+function htmlWithChildren(): Protocol.DOM.Node {
+  return {
+    nodeId: 2,
+    backendNodeId: 2,
+    nodeType: 1,
+    nodeName: "HTML",
+    childNodeCount: 1,
+    children: [
+      {
+        nodeId: 3,
+        backendNodeId: 3,
+        nodeType: 1,
+        nodeName: "BODY",
+        childNodeCount: 1,
+        children: [
+          {
+            nodeId: 4,
+            backendNodeId: 4,
+            nodeType: 1,
+            nodeName: "DIV",
+            childNodeCount: 0,
+            children: [],
+          },
+        ],
+      },
+    ],
+  } as Protocol.DOM.Node;
+}
+
+function simpleAxNodes(): Protocol.Accessibility.AXNode[] {
+  const stringType: Protocol.Accessibility.AXValueType = "string";
+  return [
+    {
+      nodeId: "1",
+      role: { type: stringType, value: "RootWebArea" },
+      backendDOMNodeId: 2,
+      childIds: ["2"],
+      ignored: false,
+    },
+    {
+      nodeId: "2",
+      role: { type: stringType, value: "generic" },
+      name: { type: stringType, value: "Content" },
+      backendDOMNodeId: 4,
+      parentId: "1",
+      childIds: [] as string[],
+      ignored: false,
+    },
+  ];
+}
+
+const baseHandlers: Record<string, Handler> = {
+  "DOM.enable": async () => ({}),
+  "Runtime.enable": async () => ({}),
+  "Accessibility.enable": async () => ({}),
+  "Accessibility.getFullAXTree": async () => ({ nodes: simpleAxNodes() }),
+};
+
+function makeCborError(): Error {
+  return new Error("CBOR: stack limit exceeded");
+}
+
+describe("captureHybridSnapshot CBOR fallbacks", () => {
+  it("retries DOM.getDocument with reduced depths before succeeding", async () => {
+    let domCalls = 0;
+    const session = new MockCDPSession({
+      ...baseHandlers,
+      "DOM.getDocument": async (params) => {
+        domCalls += 1;
+        if (domCalls === 1) throw makeCborError();
+        expect(params?.depth).toBe(256);
+        return { root: completeDomTree() };
+      },
+    });
+
+    const page = createFakePage(session);
+    const snapshot = await captureHybridSnapshot(page);
+
+    expect(snapshot.combinedTree).toContain("html");
+    const depths = session
+      .callsFor("DOM.getDocument")
+      .map((c) => c.params?.depth);
+    expect(depths).toEqual([-1, 256]);
+  });
+
+  it("throws StagehandDomProcessError after all DOM.getDocument attempts fail", async () => {
+    const session = new MockCDPSession({
+      ...baseHandlers,
+      "DOM.getDocument": async () => {
+        throw makeCborError();
+      },
+    });
+
+    const page = createFakePage(session);
+    await expect(captureHybridSnapshot(page)).rejects.toThrow(
+      StagehandDomProcessError,
+    );
+  });
+
+  it("hydrates truncated nodes by retrying DOM.describeNode depths", async () => {
+    let domAttempts = 0;
+    let describeAttempts = 0;
+
+    const session = new MockCDPSession({
+      ...baseHandlers,
+      "DOM.getDocument": async (params) => {
+        domAttempts += 1;
+        if (domAttempts === 1) throw makeCborError();
+        expect(params?.depth).toBe(256);
+        return { root: truncatedDomTree() };
+      },
+      "DOM.describeNode": async (params) => {
+        describeAttempts += 1;
+        if (describeAttempts === 1) throw makeCborError();
+        expect(params?.depth).toBe(64);
+        return { node: htmlWithChildren() };
+      },
+    });
+
+    const page = createFakePage(session);
+    const snapshot = await captureHybridSnapshot(page);
+
+    const describeDepths = session
+      .callsFor("DOM.describeNode")
+      .map((c) => c.params?.depth);
+    expect(describeDepths).toEqual([-1, 64]);
+    expect(snapshot.combinedXpathMap["0-4"]).toBe("/html[1]/body[1]/div[1]");
+  });
+});
diff --git a/packages/core/tests/unit/snapshot-dom-session-builders.test.ts b/packages/core/tests/unit/snapshot-dom-session-builders.test.ts
new file mode 100644
index 000000000..a36cc3b69
--- /dev/null
+++ b/packages/core/tests/unit/snapshot-dom-session-builders.test.ts
@@ -0,0 +1,279 @@
+import type { Protocol } from "devtools-protocol";
+import { describe, expect, it } from "vitest";
+import {
+  buildSessionDomIndex,
+  domMapsForSession,
+  getDomTreeWithFallback,
+  hydrateDomTree,
+} from "../../lib/v3/understudy/a11y/snapshot/domTree.js";
+import { StagehandDomProcessError } from "../../lib/v3/types/public/sdkErrors.js";
+import { MockCDPSession } from "./helpers/mockCDPSession.js";
+
+let nextNodeId = 1;
+const makeDomNode = (
+  overrides: Partial<Protocol.DOM.Node> = {},
+): Protocol.DOM.Node => {
+  const nodeId = overrides.nodeId ?? nextNodeId++;
+  const backendNodeId = overrides.backendNodeId ?? nextNodeId++;
+  const nodeName = overrides.nodeName ?? "DIV";
+  const nodeType = overrides.nodeType ?? 1;
+  const children = overrides.children ?? [];
+  return {
+    nodeId,
+    backendNodeId,
+    nodeName,
+    nodeType,
+    localName: overrides.localName ?? nodeName.toLowerCase(),
+    nodeValue: overrides.nodeValue ?? "",
+    childNodeCount: overrides.childNodeCount ?? children.length,
+    children,
+    shadowRoots: overrides.shadowRoots,
+    contentDocument: overrides.contentDocument,
+    isScrollable: overrides.isScrollable,
+  };
+};
+
+const buildSampleDomTree = () => {
+  const iframeChild = makeDomNode({ nodeName: "P" });
+  const iframeBody = makeDomNode({
+    nodeName: "BODY",
+    children: [iframeChild],
+    isScrollable: true,
+  });
+  const iframeHtml = makeDomNode({ nodeName: "HTML", children: [iframeBody] });
+  const iframeDoc = makeDomNode({
+    nodeName: "#document",
+    nodeType: 9,
+    children: [iframeHtml],
+  });
+  const iframeElement = makeDomNode({
+    nodeName: "IFRAME",
+    contentDocument: iframeDoc,
+  });
+  const scrollDiv = makeDomNode({
+    nodeName: "DIV",
+    isScrollable: true,
+  });
+  const body = makeDomNode({
+    nodeName: "BODY",
+    children: [scrollDiv, iframeElement],
+  });
+  const html = makeDomNode({ nodeName: "HTML", children: [body] });
+  const root = makeDomNode({
+    nodeName: "#document",
+    nodeType: 9,
+    children: [html],
+  });
+  return {
+    root,
+    html,
+    body,
+    scrollDiv,
+    iframeElement,
+    iframeDoc,
+    iframeHtml,
+    iframeBody,
+    iframeChild,
+  };
+};
+
+describe("hydrateDomTree", () => {
+  it("expands truncated nodes by calling DOM.describeNode", async () => {
+    const child = makeDomNode({ nodeName: "DIV" });
+    const root = makeDomNode({
+      nodeName: "HTML",
+      childNodeCount: 1,
+      children: [],
+    });
+
+    const session = new MockCDPSession({
+      "DOM.describeNode": async () => ({
+        node: {
+          ...root,
+          children: [child],
+          childNodeCount: 1,
+        },
+      }),
+    });
+
+    await hydrateDomTree(session, root, true);
+    expect(root.children).toEqual([child]);
+  });
+
+  it("retries describeNode when CBOR errors occur before succeeding", async () => {
+    const child = makeDomNode({ nodeName: "DIV" });
+    const root = makeDomNode({
+      nodeName: "HTML",
+      childNodeCount: 1,
+      children: [],
+    });
+
+    let attempts = 0;
+    const session = new MockCDPSession({
+      "DOM.describeNode": async () => {
+        attempts++;
+        if (attempts === 1) throw new Error("CBOR: stack limit exceeded");
+        return { node: { ...root, children: [child], childNodeCount: 1 } };
+      },
+    });
+
+    await hydrateDomTree(session, root, true);
+    expect(attempts).toBe(2);
+    expect(root.children).toEqual([child]);
+  });
+
+  it("throws StagehandDomProcessError after exhausting describeNode retries", async () => {
+    const root = makeDomNode({
+      nodeName: "HTML",
+      childNodeCount: 1,
+      children: [],
+    });
+    const session = new MockCDPSession({
+      "DOM.describeNode": async () => {
+        throw new Error("CBOR: stack limit exceeded");
+      },
+    });
+
+    await expect(hydrateDomTree(session, root, true)).rejects.toBeInstanceOf(
+      StagehandDomProcessError,
+    );
+  });
+});
+
+describe("getDomTreeWithFallback", () => {
+  it("retries DOM.getDocument after CBOR errors and returns the hydrated root", async () => {
+    const root = makeDomNode({
+      nodeName: "#document",
+      nodeType: 9,
+      children: [],
+    });
+    const depths: number[] = [];
+    const session = new MockCDPSession({
+      "DOM.getDocument": async (params) => {
+        const depth = (params?.depth ?? 0) as number;
+        depths.push(depth);
+        if (depth === -1) throw new Error("CBOR: stack limit exceeded");
+        return { root };
+      },
+      "DOM.describeNode": async () => ({ node: root }),
+    });
+
+    const result = await getDomTreeWithFallback(session, true);
+    expect(result).toBe(root);
+    expect(depths).toEqual([-1, 256]);
+  });
+
+  it("propagates non-CBOR DOM.getDocument errors", async () => {
+    const session = new MockCDPSession({
+      "DOM.getDocument": async () => {
+        throw new Error("network fail");
+      },
+    });
+    await expect(getDomTreeWithFallback(session, false)).rejects.toThrow(
+      "network fail",
+    );
+  });
+
+  it("throws StagehandDomProcessError when all depth attempts hit CBOR limits", async () => {
+    const session = new MockCDPSession({
+      "DOM.getDocument": async () => {
+        throw new Error("CBOR: stack limit exceeded");
+      },
+    });
+    await expect(getDomTreeWithFallback(session, false)).rejects.toBeInstanceOf(
+      StagehandDomProcessError,
+    );
+  });
+});
+
+describe("buildSessionDomIndex", () => {
+  it("collects absolute paths, scrollability, and content-document metadata", async () => {
+    const tree = buildSampleDomTree();
+    const session = new MockCDPSession({
+      "DOM.enable": async () => ({}),
+      "DOM.getDocument": async () => ({ root: tree.root }),
+      "DOM.describeNode": async () => ({ node: tree.root }),
+    });
+
+    const index = await buildSessionDomIndex(session, true);
+
+    expect(index.rootBackend).toBe(tree.root.backendNodeId);
+    expect(index.absByBe.get(tree.body.backendNodeId)).toBe("/html[1]/body[1]");
+    expect(index.absByBe.get(tree.scrollDiv.backendNodeId)).toBe(
+      "/html[1]/body[1]/div[1]",
+    );
+    expect(index.scrollByBe.get(tree.scrollDiv.backendNodeId)).toBe(true);
+    expect(index.docRootOf.get(tree.iframeHtml.backendNodeId)).toBe(
+      tree.iframeDoc.backendNodeId,
+    );
+    expect(
+      index.contentDocRootByIframe.get(tree.iframeElement.backendNodeId),
+    ).toBe(tree.iframeDoc.backendNodeId);
+  });
+});
+
+describe("domMapsForSession", () => {
+  it("derives frame-relative xpath/tag/scrollable maps for a frame's document root", async () => {
+    const tree = buildSampleDomTree();
+    const session = new MockCDPSession({
+      "DOM.enable": async () => ({}),
+      "DOM.getDocument": async () => ({ root: tree.root }),
+      "DOM.getFrameOwner": async () => ({
+        backendNodeId: tree.iframeElement.backendNodeId,
+      }),
+      "DOM.describeNode": async () => ({ node: tree.root }),
+    });
+
+    const encode = (frameId: string, backendNodeId: number) =>
+      `${frameId}-${backendNodeId}`;
+    const maps = await domMapsForSession(
+      session,
+      "frame-A",
+      true,
+      encode,
+      true,
+    );
+
+    const iframeDocKey = `frame-A-${tree.iframeDoc.backendNodeId}`;
+    const iframeBodyKey = `frame-A-${tree.iframeBody.backendNodeId}`;
+    const iframeChildKey = `frame-A-${tree.iframeChild.backendNodeId}`;
+
+    expect(maps.tagNameMap[iframeDocKey]).toBe("#document");
+    expect(maps.xpathMap[iframeDocKey]).toBe("/");
+    expect(maps.xpathMap[iframeBodyKey]).toBe("/html[1]/body[1]");
+    expect(maps.xpathMap[iframeChildKey]).toBe("/html[1]/body[1]/p[1]");
+    expect(maps.scrollableMap[iframeBodyKey]).toBe(true);
+    expect(Object.keys(maps.tagNameMap)).not.toContain(
+      `frame-A-${tree.html.backendNodeId}`,
+    );
+  });
+
+  it("falls back to the root document when frame owner lookup fails", async () => {
+    const tree = buildSampleDomTree();
+    const session = new MockCDPSession({
+      "DOM.enable": async () => ({}),
+      "DOM.getDocument": async () => ({ root: tree.root }),
+      "DOM.getFrameOwner": async () => {
+        throw new Error("owner lookup failed");
+      },
+      "DOM.describeNode": async () => ({ node: tree.root }),
+    });
+
+    const encode = (frameId: string, backendNodeId: number) =>
+      `${frameId}-${backendNodeId}`;
+    const maps = await domMapsForSession(
+      session,
+      "frame-B",
+      false,
+      encode,
+      true,
+    );
+
+    expect(maps.xpathMap[`frame-B-${tree.html.backendNodeId}`]).toBe(
+      "/html[1]",
+    );
+    expect(maps.xpathMap[`frame-B-${tree.scrollDiv.backendNodeId}`]).toBe(
+      "/html[1]/body[1]/div[1]",
+    );
+  });
+});
diff --git a/packages/core/tests/unit/snapshot-dom-tree-utils.test.ts b/packages/core/tests/unit/snapshot-dom-tree-utils.test.ts
new file mode 100644
index 000000000..02000b1c2
--- /dev/null
+++ b/packages/core/tests/unit/snapshot-dom-tree-utils.test.ts
@@ -0,0 +1,128 @@
+import type { Protocol } from "devtools-protocol";
+import { describe, expect, it } from "vitest";
+import {
+  collectDomTraversalTargets,
+  findNodeByBackendId,
+  mergeDomNodes,
+  shouldExpandNode,
+} from "../../lib/v3/understudy/a11y/snapshot/domTree.js";
+
+let nextNodeId = 1;
+const makeNode = (
+  overrides: Partial<Protocol.DOM.Node> = {},
+): Protocol.DOM.Node => {
+  const base: Protocol.DOM.Node = {
+    nodeId: nextNodeId++,
+    backendNodeId: nextNodeId++,
+    nodeType: 1,
+    nodeName: "DIV",
+    localName: "div",
+    nodeValue: "",
+    childNodeCount:
+      overrides.childNodeCount ??
+      (overrides.children ? overrides.children.length : 0),
+  };
+  return { ...base, ...overrides };
+};
+
+describe("shouldExpandNode", () => {
+  it("returns true when declared children exceed realized children", () => {
+    const node = makeNode({
+      childNodeCount: 2,
+      children: [makeNode()],
+    });
+    expect(shouldExpandNode(node)).toBe(true);
+  });
+
+  it("returns false when all declared children are realized", () => {
+    const child = makeNode();
+    const node = makeNode({
+      childNodeCount: 1,
+      children: [child],
+    });
+    expect(shouldExpandNode(node)).toBe(false);
+  });
+});
+
+describe("mergeDomNodes", () => {
+  it("overrides structural fields with expanded node data", () => {
+    const originalChildren = [makeNode({ nodeName: "SPAN" })];
+    const target = makeNode({
+      childNodeCount: 1,
+      children: originalChildren,
+      shadowRoots: [makeNode({ nodeName: "shadow-old" })],
+      contentDocument: makeNode({ nodeName: "doc-old" }),
+    });
+    const source = makeNode({
+      childNodeCount: 3,
+      children: [makeNode({ nodeName: "DIV" })],
+      shadowRoots: [],
+      contentDocument: makeNode({ nodeName: "doc-new" }),
+    });
+
+    mergeDomNodes(target, source);
+
+    expect(target.childNodeCount).toBe(3);
+    expect(target.children).toEqual(source.children);
+    expect(target.shadowRoots).toEqual([]);
+    expect(target.contentDocument?.nodeName).toBe("doc-new");
+  });
+
+  it("preserves original structures when source omits them", () => {
+    const child = makeNode();
+    const target = makeNode({
+      childNodeCount: 1,
+      children: [child],
+    });
+    const source = makeNode({
+      childNodeCount: 5,
+    });
+
+    mergeDomNodes(target, source);
+
+    expect(target.childNodeCount).toBe(5);
+    expect(target.children).toEqual([child]);
+  });
+});
+
+describe("collectDomTraversalTargets", () => {
+  it("returns children, shadow roots, and content document in order", () => {
+    const childA = makeNode({ nodeName: "CHILD-A" });
+    const childB = makeNode({ nodeName: "CHILD-B" });
+    const shadow = makeNode({ nodeName: "SHADOW" });
+    const content = makeNode({ nodeName: "CONTENT" });
+
+    const node = makeNode({
+      children: [childA, childB],
+      shadowRoots: [shadow],
+      contentDocument: content,
+    });
+
+    const targets = collectDomTraversalTargets(node);
+    expect(targets).toEqual([childA, childB, shadow, content]);
+  });
+});
+
+describe("findNodeByBackendId", () => {
+  it("finds nodes nested within children and shadow roots", () => {
+    const target = makeNode({ backendNodeId: 999, nodeName: "TARGET" });
+    const root = makeNode({
+      children: [
+        makeNode({
+          children: [makeNode(), target],
+        }),
+      ],
+      shadowRoots: [makeNode()],
+    });
+
+    expect(findNodeByBackendId(root, 999)).toBe(target);
+  });
+
+  it("returns undefined when no node matches the backend id", () => {
+    const root = makeNode({
+      children: [makeNode()],
+      shadowRoots: [makeNode()],
+    });
+    expect(findNodeByBackendId(root, 123456)).toBeUndefined();
+  });
+});
diff --git a/packages/core/tests/unit/snapshot-focus-selectors-utils.test.ts b/packages/core/tests/unit/snapshot-focus-selectors-utils.test.ts
new file mode 100644
index 000000000..2cbbad255
--- /dev/null
+++ b/packages/core/tests/unit/snapshot-focus-selectors-utils.test.ts
@@ -0,0 +1,106 @@
+import type { Step } from "../../lib/v3/types/private/snapshot.js";
+import { describe, expect, it } from "vitest";
+import {
+  buildXPathFromSteps,
+  IFRAME_STEP_RE,
+  listChildrenOf,
+  parseXPathToSteps,
+} from "../../lib/v3/understudy/a11y/snapshot/focusSelectors.js";
+
+describe("parseXPathToSteps", () => {
+  it("records axis direction and normalized names", () => {
+    const steps = parseXPathToSteps(" //iframe[1]/div[2]//SPAN ");
+    expect(steps).toEqual([
+      { axis: "desc", raw: "iframe[1]", name: "iframe" },
+      { axis: "child", raw: "div[2]", name: "div" },
+      { axis: "desc", raw: "SPAN", name: "span" },
+    ]);
+  });
+
+  it("drops empty segments and returns [] for blank input", () => {
+    expect(parseXPathToSteps("   ")).toEqual([]);
+    expect(parseXPathToSteps("/ ")).toEqual([]);
+  });
+});
+
+describe("buildXPathFromSteps", () => {
+  it("reconstructs descendant and child hops as a string", () => {
+    const steps: ReadonlyArray<Step> = [
+      { axis: "child", raw: "iframe[1]", name: "iframe" },
+      { axis: "desc", raw: "div[@id='main']", name: "div" },
+      { axis: "child", raw: "span", name: "span" },
+    ];
+    expect(buildXPathFromSteps(steps)).toBe("/iframe[1]//div[@id='main']/span");
+  });
+
+  it("returns '/' for empty sequences", () => {
+    expect(buildXPathFromSteps([])).toBe("/");
+  });
+});
+
+describe("IFRAME_STEP_RE — frame boundary detection", () => {
+  it("matches both iframe and frame with optional index", () => {
+    expect(IFRAME_STEP_RE.test("iframe")).toBe(true);
+    expect(IFRAME_STEP_RE.test("iframe[1]")).toBe(true);
+    expect(IFRAME_STEP_RE.test("frame")).toBe(true);
+    expect(IFRAME_STEP_RE.test("frame[4]")).toBe(true);
+  });
+
+  it("does NOT match frameset", () => {
+    expect(IFRAME_STEP_RE.test("frameset")).toBe(false);
+    expect(IFRAME_STEP_RE.test("frameset[1]")).toBe(false);
+  });
+});
+
+describe("parseXPathToSteps — frameset XPaths", () => {
+  it("parses a frameset page XPath with frame[N] steps", () => {
+    const steps = parseXPathToSteps(
+      "/html[1]/frameset[1]/frame[4]/html[1]/body[1]/table[1]",
+    );
+    expect(steps).toEqual([
+      { axis: "child", raw: "html[1]", name: "html" },
+      { axis: "child", raw: "frameset[1]", name: "frameset" },
+      { axis: "child", raw: "frame[4]", name: "frame" },
+      { axis: "child", raw: "html[1]", name: "html" },
+      { axis: "child", raw: "body[1]", name: "body" },
+      { axis: "child", raw: "table[1]", name: "table" },
+    ]);
+    // frame[4] step should be detected as a frame boundary
+    const frameBoundaries = steps.filter((s) => IFRAME_STEP_RE.test(s.name));
+    expect(frameBoundaries).toHaveLength(1);
+    expect(frameBoundaries[0].raw).toBe("frame[4]");
+  });
+
+  it("detects iframe boundaries in standard iframe XPaths", () => {
+    const steps = parseXPathToSteps(
+      "/html[1]/body[1]/div[2]/iframe[1]/html[1]/body[1]/p[1]",
+    );
+    const frameBoundaries = steps.filter((s) => IFRAME_STEP_RE.test(s.name));
+    expect(frameBoundaries).toHaveLength(1);
+    expect(frameBoundaries[0].raw).toBe("iframe[1]");
+  });
+
+  it("does NOT detect frameset as a frame boundary", () => {
+    const steps = parseXPathToSteps("/html[1]/frameset[1]/frame[2]");
+    const frameBoundaries = steps.filter((s) => IFRAME_STEP_RE.test(s.name));
+    expect(frameBoundaries).toHaveLength(1);
+    // Only frame[2] matches, not frameset[1]
+    expect(frameBoundaries[0].raw).toBe("frame[2]");
+  });
+});
+
+describe("listChildrenOf", () => {
+  it("returns direct children whose parent matches the provided id", () => {
+    const parentByFrame = new Map<string, string | null>([
+      ["frame-1", null],
+      ["frame-2", "frame-1"],
+      ["frame-3", "frame-1"],
+      ["frame-4", "frame-2"],
+    ]);
+    expect(listChildrenOf(parentByFrame, "frame-1")).toEqual([
+      "frame-2",
+      "frame-3",
+    ]);
+    expect(listChildrenOf(parentByFrame, "frame-4")).toEqual([]);
+  });
+});
diff --git a/packages/core/tests/unit/snapshot-frame-merge.test.ts b/packages/core/tests/unit/snapshot-frame-merge.test.ts
new file mode 100644
index 000000000..b0a0e7805
--- /dev/null
+++ b/packages/core/tests/unit/snapshot-frame-merge.test.ts
@@ -0,0 +1,444 @@
+import { describe, expect, it } from "vitest";
+import type {
+  FrameContext,
+  FrameDomMaps,
+} from "../../lib/v3/types/private/index.js";
+import type { Page } from "../../lib/v3/understudy/page.js";
+import { MockCDPSession } from "./helpers/mockCDPSession.js";
+import {
+  computeFramePrefixes,
+  mergeFramesIntoSnapshot,
+} from "../../lib/v3/understudy/a11y/snapshot/capture.js";
+
+const makePage = (sessions: Record<string, MockCDPSession>): Page =>
+  ({
+    getSessionForFrame: (frameId: string) => sessions[frameId] ?? sessions.root,
+    getOrdinal: (frameId: string) =>
+      frameId === "frame-1" ? 0 : frameId === "frame-2" ? 1 : 2,
+  }) as unknown as Page;
+
+describe("computeFramePrefixes", () => {
+  it("derives prefixes from parent iframe xpaths within the same session", async () => {
+    const parentSession = new MockCDPSession({
+      "DOM.getFrameOwner": async () => ({ backendNodeId: 200 }),
+    });
+    const page = makePage({
+      "frame-1": parentSession,
+      "frame-2": parentSession,
+      root: parentSession,
+    });
+
+    const perFrameMaps = new Map<string, FrameDomMaps>([
+      [
+        "frame-1",
+        {
+          tagNameMap: {},
+          scrollableMap: {},
+          urlMap: {},
+          xpathMap: { "0-200": "/html[1]/body[1]/iframe[1]" },
+        },
+      ],
+    ]);
+
+    const context: FrameContext = {
+      rootId: "frame-1",
+      frames: ["frame-1", "frame-2"],
+      parentByFrame: new Map([
+        ["frame-1", null],
+        ["frame-2", "frame-1"],
+      ]),
+    };
+
+    const { absPrefix, iframeHostEncByChild } = await computeFramePrefixes(
+      page,
+      context,
+      perFrameMaps,
+      context.frames,
+    );
+
+    expect(absPrefix.get("frame-1")).toBe("");
+    expect(absPrefix.get("frame-2")).toBe("/html[1]/body[1]/iframe[1]");
+    expect(iframeHostEncByChild.get("frame-2")).toBe("0-200");
+  });
+
+  it("inherits the parent prefix when frame owner lookups fail (OOPIF)", async () => {
+    const parentSession = new MockCDPSession({
+      "DOM.getFrameOwner": async (params) => {
+        if (params?.frameId === "frame-2") return { backendNodeId: 200 };
+        if (params?.frameId === "frame-3") throw new Error("unavailable");
+        return {};
+      },
+    });
+    const page = makePage({
+      "frame-1": parentSession,
+      "frame-2": parentSession,
+      "frame-3": parentSession,
+      root: parentSession,
+    });
+
+    const perFrameMaps = new Map<string, FrameDomMaps>([
+      [
+        "frame-1",
+        {
+          tagNameMap: {},
+          scrollableMap: {},
+          urlMap: {},
+          xpathMap: { "0-200": "/iframe[1]" },
+        },
+      ],
+      [
+        "frame-2",
+        {
+          tagNameMap: {},
+          scrollableMap: {},
+          urlMap: {},
+          xpathMap: { "1-300": "/div[1]/iframe[1]" },
+        },
+      ],
+    ]);
+
+    const context: FrameContext = {
+      rootId: "frame-1",
+      frames: ["frame-1", "frame-2", "frame-3"],
+      parentByFrame: new Map([
+        ["frame-1", null],
+        ["frame-2", "frame-1"],
+        ["frame-3", "frame-2"],
+      ]),
+    };
+
+    const maps = await computeFramePrefixes(
+      page,
+      context,
+      perFrameMaps,
+      context.frames,
+    );
+
+    expect(maps.absPrefix.get("frame-2")).toBe("/iframe[1]");
+    expect(maps.absPrefix.get("frame-3")).toBe("/iframe[1]");
+  });
+
+  it("inherits parent prefix when iframe xpath mapping is missing", async () => {
+    const session = new MockCDPSession({
+      "DOM.getFrameOwner": async () => ({ backendNodeId: 999 }),
+    });
+    const page = makePage({
+      "frame-1": session,
+      "frame-2": session,
+      root: session,
+    });
+
+    const perFrameMaps = new Map<string, FrameDomMaps>([
+      [
+        "frame-1",
+        {
+          tagNameMap: {},
+          scrollableMap: {},
+          urlMap: {},
+          xpathMap: {},
+        },
+      ],
+    ]);
+
+    const context: FrameContext = {
+      rootId: "frame-1",
+      frames: ["frame-1", "frame-2"],
+      parentByFrame: new Map([
+        ["frame-1", null],
+        ["frame-2", "frame-1"],
+      ]),
+    };
+
+    const result = await computeFramePrefixes(
+      page,
+      context,
+      perFrameMaps as Map<string, FrameDomMaps>,
+      context.frames,
+    );
+    expect(result.absPrefix.get("frame-2")).toBe("");
+  });
+
+  it("does not compute prefixes for frames excluded from the scope", async () => {
+    const session = new MockCDPSession({
+      "DOM.getFrameOwner": async () => ({ backendNodeId: 200 }),
+    });
+    const page = makePage({
+      "frame-1": session,
+      "frame-2": session,
+      root: session,
+    });
+
+    const perFrameMaps = new Map<string, FrameDomMaps>([
+      [
+        "frame-1",
+        {
+          tagNameMap: {},
+          scrollableMap: {},
+          urlMap: {},
+          xpathMap: { "0-200": "/iframe[1]" },
+        },
+      ],
+    ]);
+
+    const context: FrameContext = {
+      rootId: "frame-1",
+      frames: ["frame-1", "frame-2"],
+      parentByFrame: new Map([
+        ["frame-1", null],
+        ["frame-2", "frame-1"],
+      ]),
+    };
+
+    const { absPrefix, iframeHostEncByChild } = await computeFramePrefixes(
+      page,
+      context,
+      perFrameMaps,
+      ["frame-1"],
+    );
+
+    expect(absPrefix.has("frame-2")).toBe(false);
+    expect(iframeHostEncByChild.has("frame-2")).toBe(false);
+  });
+});
+
+describe("mergeFramesIntoSnapshot", () => {
+  it("merges root and child maps, prefixing child xpaths and injecting subtrees", () => {
+    const context: FrameContext = {
+      rootId: "frame-1",
+      frames: ["frame-1", "frame-2"],
+      parentByFrame: new Map([
+        ["frame-1", null],
+        ["frame-2", "frame-1"],
+      ]),
+    };
+
+    const perFrameMaps = new Map<string, FrameDomMaps>([
+      [
+        "frame-1",
+        {
+          tagNameMap: {},
+          scrollableMap: {},
+          urlMap: { "0-10": "https://example.com" },
+          xpathMap: { "0-10": "/html[1]/body[1]" },
+        },
+      ],
+      [
+        "frame-2",
+        {
+          tagNameMap: {},
+          scrollableMap: {},
+          urlMap: { "1-20": "https://child.com" },
+          xpathMap: { "1-20": "/div[1]/span[1]" },
+        },
+      ],
+    ]);
+
+    const perFrameOutlines = [
+      { frameId: "frame-1", outline: "[0-10] body\n  [0-200] iframe" },
+      { frameId: "frame-2", outline: "[1-20] child" },
+    ];
+
+    const absPrefix = new Map<string, string>([
+      ["frame-1", ""],
+      ["frame-2", "/html[1]/body[1]/iframe[1]"],
+    ]);
+    const iframeHostEncByChild = new Map<string, string>([
+      ["frame-2", "0-200"],
+    ]);
+
+    const snapshot = mergeFramesIntoSnapshot(
+      context,
+      perFrameMaps,
+      perFrameOutlines,
+      absPrefix,
+      iframeHostEncByChild,
+      context.frames,
+    );
+
+    expect(snapshot.combinedXpathMap["0-10"]).toBe("/html[1]/body[1]");
+    expect(snapshot.combinedXpathMap["1-20"]).toBe(
+      "/html[1]/body[1]/iframe[1]/div[1]/span[1]",
+    );
+    expect(snapshot.combinedUrlMap["1-20"]).toBe("https://child.com");
+    expect(snapshot.combinedTree).toContain("[1-20] child");
+  });
+
+  it("skips frames without maps and handles missing iframe mappings", () => {
+    const context: FrameContext = {
+      rootId: "frame-1",
+      frames: ["frame-1", "frame-2"],
+      parentByFrame: new Map([
+        ["frame-1", null],
+        ["frame-2", "frame-1"],
+      ]),
+    };
+
+    const perFrameMaps = new Map<string, FrameDomMaps>([
+      [
+        "frame-1",
+        {
+          tagNameMap: {},
+          scrollableMap: {},
+          urlMap: {},
+          xpathMap: { "0-10": "/html[1]" },
+        },
+      ],
+    ]);
+
+    const perFrameOutlines = [
+      { frameId: "frame-1", outline: "[0-10] html" },
+      { frameId: "frame-2", outline: "[1-20] orphan" },
+    ];
+
+    const absPrefix = new Map<string, string>([
+      ["frame-1", ""],
+      ["frame-2", "/missing"],
+    ]);
+
+    const snapshot = mergeFramesIntoSnapshot(
+      context,
+      perFrameMaps,
+      perFrameOutlines,
+      absPrefix,
+      new Map(),
+      context.frames,
+    );
+
+    expect(snapshot.combinedXpathMap["1-20"]).toBeUndefined();
+    expect(snapshot.combinedTree).toBe("[0-10] html");
+  });
+
+  it("falls back to first outline when root frame outline is missing", () => {
+    const context: FrameContext = {
+      rootId: "frame-1",
+      frames: ["frame-1", "frame-2"],
+      parentByFrame: new Map([
+        ["frame-1", null],
+        ["frame-2", "frame-1"],
+      ]),
+    };
+
+    const perFrameMaps = new Map<string, FrameDomMaps>([
+      [
+        "frame-2",
+        {
+          tagNameMap: {},
+          scrollableMap: {},
+          urlMap: {},
+          xpathMap: {},
+        },
+      ],
+    ]);
+
+    const perFrameOutlines = [
+      { frameId: "frame-2", outline: "[child] frame2" },
+    ];
+
+    const snapshot = mergeFramesIntoSnapshot(
+      context,
+      perFrameMaps,
+      perFrameOutlines,
+      new Map([["frame-2", "/iframe[1]"]]),
+      new Map(),
+      context.frames,
+    );
+
+    expect(snapshot.combinedTree).toBe("[child] frame2");
+  });
+
+  it("overwrites duplicate iframe host entries when multiple children map to the same parent", () => {
+    const context: FrameContext = {
+      rootId: "frame-1",
+      frames: ["frame-1", "frame-2", "frame-3"],
+      parentByFrame: new Map([
+        ["frame-1", null],
+        ["frame-2", "frame-1"],
+        ["frame-3", "frame-1"],
+      ]),
+    };
+
+    const perFrameMaps = new Map<string, FrameDomMaps>([
+      [
+        "frame-1",
+        {
+          tagNameMap: {},
+          scrollableMap: {},
+          urlMap: {},
+          xpathMap: {},
+        },
+      ],
+    ]);
+
+    const perFrameOutlines = [
+      { frameId: "frame-1", outline: "[root] frame1\n  [0-200] iframe slot" },
+      { frameId: "frame-2", outline: "[child] frame2" },
+      { frameId: "frame-3", outline: "[child] frame3" },
+    ];
+
+    const snapshot = mergeFramesIntoSnapshot(
+      context,
+      perFrameMaps,
+      perFrameOutlines,
+      new Map([
+        ["frame-1", ""],
+        ["frame-2", ""],
+        ["frame-3", ""],
+      ]),
+      new Map([
+        ["frame-2", "0-200"],
+        ["frame-3", "0-200"],
+      ]),
+      context.frames,
+    );
+
+    expect(snapshot.combinedTree).toContain("[child] frame3");
+    expect(snapshot.combinedTree).not.toContain("[child] frame2");
+  });
+
+  it("only merges xpath and url maps for frames included in frameIds", () => {
+    const context: FrameContext = {
+      rootId: "frame-1",
+      frames: ["frame-1", "frame-2"],
+      parentByFrame: new Map([
+        ["frame-1", null],
+        ["frame-2", "frame-1"],
+      ]),
+    };
+
+    const perFrameMaps = new Map<string, FrameDomMaps>([
+      [
+        "frame-1",
+        {
+          tagNameMap: {},
+          scrollableMap: {},
+          urlMap: { "0-10": "https://root.test" },
+          xpathMap: { "0-10": "/html[1]" },
+        },
+      ],
+      [
+        "frame-2",
+        {
+          tagNameMap: {},
+          scrollableMap: {},
+          urlMap: { "1-20": "https://child.test" },
+          xpathMap: { "1-20": "/div[1]" },
+        },
+      ],
+    ]);
+
+    const perFrameOutlines = [{ frameId: "frame-1", outline: "[root] doc" }];
+
+    const snapshot = mergeFramesIntoSnapshot(
+      context,
+      perFrameMaps,
+      perFrameOutlines,
+      new Map([["frame-1", ""]]),
+      new Map(),
+      ["frame-1"],
+    );
+
+    expect(snapshot.combinedXpathMap["0-10"]).toBe("/html[1]");
+    expect(snapshot.combinedXpathMap["1-20"]).toBeUndefined();
+    expect(snapshot.perFrame?.map((pf) => pf.frameId)).toEqual(["frame-1"]);
+  });
+});
diff --git a/packages/core/tests/unit/snapshot-tree-format-utils.test.ts b/packages/core/tests/unit/snapshot-tree-format-utils.test.ts
new file mode 100644
index 000000000..3245cabbd
--- /dev/null
+++ b/packages/core/tests/unit/snapshot-tree-format-utils.test.ts
@@ -0,0 +1,116 @@
+import { describe, expect, it } from "vitest";
+import {
+  cleanText,
+  diffCombinedTrees,
+  formatTreeLine,
+  indentBlock,
+  injectSubtrees,
+  normaliseSpaces,
+} from "../../lib/v3/understudy/a11y/snapshot/treeFormatUtils.js";
+
+describe("formatTreeLine", () => {
+  it("includes encoded ids and indents children", () => {
+    const outline = formatTreeLine({
+      role: "section",
+      name: "Container",
+      encodedId: "frame-1",
+      nodeId: "ax-1",
+      children: [
+        {
+          role: "button",
+          name: "Submit",
+          nodeId: "ax-2",
+        },
+      ],
+    });
+
+    expect(outline).toBe(
+      "[frame-1] section: Container\n  [ax-2] button: Submit",
+    );
+  });
+});
+
+describe("injectSubtrees", () => {
+  it("nests child outlines under iframe encoded ids", () => {
+    const rootOutline = `[root] document\n  [iframe-1] iframe\n  [leaf] item`;
+    const iframeOutline = `[child-root] child\n  [nested-frame] iframe`;
+    const nestedOutline = `[nested-leaf] nested`;
+
+    const merged = injectSubtrees(
+      rootOutline,
+      new Map([
+        ["iframe-1", iframeOutline],
+        ["nested-frame", nestedOutline],
+      ]),
+    );
+
+    expect(merged).toBe(
+      `[root] document
+  [iframe-1] iframe
+    [child-root] child
+      [nested-frame] iframe
+        [nested-leaf] nested
+  [leaf] item`,
+    );
+  });
+
+  it("injects child outline only once when the same id repeats", () => {
+    const rootOutline = `[root] document
+  [iframe-1] iframe
+  [iframe-1] iframe`;
+    const iframeOutline = `[child-root] child`;
+
+    const merged = injectSubtrees(
+      rootOutline,
+      new Map([["iframe-1", iframeOutline]]),
+    );
+
+    expect(merged).toBe(
+      `[root] document
+  [iframe-1] iframe
+    [child-root] child
+  [iframe-1] iframe`,
+    );
+  });
+
+  it("returns the original outline when no encoded ids are matched", () => {
+    const outline = `[root] document\n  [leaf] item`;
+    expect(injectSubtrees(outline, new Map([["other", "[x] child"]]))).toBe(
+      outline,
+    );
+  });
+});
+
+describe("indentBlock", () => {
+  it("prefixes each line with the provided indent", () => {
+    expect(indentBlock("a\nb", "  ")).toBe("  a\n  b");
+    expect(indentBlock("", "  ")).toBe("");
+  });
+});
+
+describe("diffCombinedTrees", () => {
+  it("returns newly-added lines relative to previous outline", () => {
+    const prev = `[root] document\n  [child] a`;
+    const next = `[root] document\n  [child] a\n  [child-2] b`;
+    expect(diffCombinedTrees(prev, next)).toBe("[child-2] b");
+  });
+
+  it("normalizes indentation for added lines with stray spaces", () => {
+    const prev = `[root] document\n    [child] a`;
+    const next = `[root] document\n    [child] a\n        [child-2] b`;
+    expect(diffCombinedTrees(prev, next)).toBe("[child-2] b");
+  });
+});
+
+describe("cleanText", () => {
+  it("removes NBSP and private-use characters while collapsing spaces", () => {
+    const dirty = `Hello\u00A0\u00A0world\uE000 !`;
+    expect(cleanText(dirty)).toBe("Hello world !");
+  });
+});
+
+describe("normaliseSpaces", () => {
+  it("replaces whitespace runs with a single space", () => {
+    expect(normaliseSpaces("a   b\tc\nd")).toBe("a b c d");
+  });
+});
diff --git a/packages/core/tests/unit/snapshot-xpath-utils.test.ts b/packages/core/tests/unit/snapshot-xpath-utils.test.ts
new file mode 100644
index 000000000..0e8c47453
--- /dev/null
+++ b/packages/core/tests/unit/snapshot-xpath-utils.test.ts
@@ -0,0 +1,93 @@
+import type { Protocol } from "devtools-protocol";
+import { describe, expect, it } from "vitest";
+import {
+  buildChildXPathSegments,
+  joinXPath,
+  normalizeXPath,
+  prefixXPath,
+} from "../../lib/v3/understudy/a11y/snapshot/xpathUtils.js";
+import { relativizeXPath } from "../../lib/v3/understudy/a11y/snapshot/domTree.js";
+
+describe("prefixXPath", () => {
+  it("treats root prefixes as no-op", () => {
+    expect(prefixXPath("/", "/div[1]")).toBe("/div[1]");
+    expect(prefixXPath("/", "//div[1]")).toBe("//div[1]");
+  });
+
+  it("handles descendant hops and blank children", () => {
+    expect(prefixXPath("/html/body", "//slot[1]")).toBe("/html/body//slot[1]");
+    expect(prefixXPath("/html/body", "/")).toBe("/html/body");
+    expect(prefixXPath("/html/body/", "")).toBe("/html/body");
+  });
+});
+
+describe("normalizeXPath", () => {
+  it("strips prefixes, trims whitespace, and enforces absolute roots", () => {
+    expect(normalizeXPath("   xpath=/html/body/ ")).toBe("/html/body");
+    expect(normalizeXPath("div/span")).toBe("/div/span");
+    expect(normalizeXPath("")).toBe("");
+    expect(normalizeXPath()).toBe("");
+  });
+});
+
+describe("relativizeXPath", () => {
+  it("returns '/' when paths match exactly", () => {
+    expect(relativizeXPath("/html/body", "/html/body")).toBe("/");
+  });
+
+  it("omits duplicate prefixes and preserves descendant hops", () => {
+    expect(relativizeXPath("/html/body", "/html/body/div[2]")).toBe("/div[2]");
+    expect(relativizeXPath("/html/body", "/html/body//shadow-root[1]")).toBe(
+      "//shadow-root[1]",
+    );
+  });
+
+  it("falls back to absolute paths outside of the base document", () => {
+    expect(relativizeXPath("/html/body", "/head")).toBe("/head");
+    expect(relativizeXPath("/", "/html/body")).toBe("/html/body");
+  });
+});
+
+describe("buildChildXPathSegments", () => {
+  it("produces positional selectors for each node type", () => {
+    const makeNode = (
+      nodeType: number,
+      nodeName: string,
+      override?: Partial<Protocol.DOM.Node>,
+    ): Protocol.DOM.Node => ({
+      nodeId: 1,
+      backendNodeId: 1,
+      localName: nodeName.toLowerCase(),
+      nodeValue: "",
+      ...override,
+      nodeType,
+      nodeName,
+    });
+
+    const nodes: Protocol.DOM.Node[] = [
+      makeNode(1, "DIV"),
+      makeNode(1, "DIV"),
+      makeNode(1, "svg:path"),
+      makeNode(3, "#text"),
+      makeNode(8, "#comment"),
+    ];
+
+    expect(buildChildXPathSegments(nodes)).toEqual([
+      "div[1]",
+      "div[2]",
+      "*[name()='svg:path'][1]",
+      "text()[1]",
+      "comment()[1]",
+    ]);
+  });
+});
+
+describe("joinXPath", () => {
+  it("joins base and steps while preserving special hops", () => {
+    expect(joinXPath("", "div[1]")).toBe("/div[1]");
+    expect(joinXPath("/", "span[1]")).toBe("/span[1]");
+    expect(joinXPath("/html/body", "//")).toBe("/html/body//");
+    expect(joinXPath("/html//", "slot[1]")).toBe("/html//slot[1]");
+    expect(joinXPath("/html/body", "")).toBe("/html/body");
+  });
+});
diff --git a/packages/core/tests/unit/timeout-handlers.test.ts b/packages/core/tests/unit/timeout-handlers.test.ts
new file mode 100644
index 000000000..d30e09682
--- /dev/null
+++ b/packages/core/tests/unit/timeout-handlers.test.ts
@@ -0,0 +1,1115 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { ActHandler } from "../../lib/v3/handlers/actHandler.js";
+import { ExtractHandler } from "../../lib/v3/handlers/extractHandler.js";
+import { ObserveHandler } from "../../lib/v3/handlers/observeHandler.js";
+import type { Page } from "../../lib/v3/understudy/page.js";
+import type { ClientOptions } from "../../lib/v3/types/public/model.js";
+import type { LLMClient } from "../../lib/v3/llm/LLMClient.js";
+import { createTimeoutGuard } from "../../lib/v3/handlers/handlerUtils/timeoutGuard.js";
+import { waitForDomNetworkQuiet } from "../../lib/v3/handlers/handlerUtils/actHandlerUtils.js";
+import { captureHybridSnapshot } from "../../lib/v3/understudy/a11y/snapshot/index.js";
+import {
+  ActTimeoutError,
+  ExtractTimeoutError,
+  ObserveTimeoutError,
+} from "../../lib/v3/types/public/sdkErrors.js";
+import {
+  act as actInference,
+  extract as extractInference,
+  observe as observeInference,
+} from "../../lib/inference.js";
+import { V3FunctionName } from "../../lib/v3/types/public/methods.js";
+
+vi.mock("../../lib/v3/handlers/handlerUtils/timeoutGuard", () => ({
+  createTimeoutGuard: vi.fn(),
+}));
+
+vi.mock("../../lib/v3/handlers/handlerUtils/actHandlerUtils", () => ({
+  waitForDomNetworkQuiet: vi.fn(),
+  performUnderstudyMethod: vi.fn(),
+}));
+
+vi.mock("../../lib/v3/understudy/a11y/snapshot", () => ({
+  captureHybridSnapshot: vi.fn(),
+  diffCombinedTrees: vi.fn(),
+}));
+
+vi.mock("../../lib/inference", () => ({
+  act: vi.fn(),
+  extract: vi.fn(),
+  observe: vi.fn(),
+}));
+
+describe("ActHandler timeout guard", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("throws ActTimeoutError when timeout expires before snapshot", async () => {
+    const waitForDomNetworkQuietMock = vi.mocked(waitForDomNetworkQuiet);
+    waitForDomNetworkQuietMock.mockResolvedValue(undefined);
+
+    const captureHybridSnapshotMock = vi.mocked(captureHybridSnapshot);
+    captureHybridSnapshotMock.mockResolvedValue({
+      combinedTree: "",
+      combinedXpathMap: {},
+      combinedUrlMap: {},
+    });
+
+    // Make createTimeoutGuard return a guard that throws on call #2
+    vi.mocked(createTimeoutGuard).mockImplementation(
+      (timeoutMs, errorFactory) => {
+        let calls = 0;
+        return vi.fn(() => {
+          calls += 1;
+          if (calls >= 2) {
+            throw errorFactory
+              ? errorFactory(timeoutMs!)
+              : new ActTimeoutError(timeoutMs!);
+          }
+        });
+      },
+    );
+
+    const handler = buildActHandler();
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    await expect(
+      handler.act({
+        instruction: "do something",
+        page: fakePage,
+        timeout: 5,
+      }),
+    ).rejects.toThrow(ActTimeoutError);
+
+    // Verify pre-timeout helper ran
+    expect(waitForDomNetworkQuietMock).toHaveBeenCalledTimes(1);
+    // Verify snapshot was NOT called (timeout fired before it)
+    expect(captureHybridSnapshotMock).not.toHaveBeenCalled();
+  });
+
+  it("throws ActTimeoutError when timeout expires before LLM call", async () => {
+    const waitForDomNetworkQuietMock = vi.mocked(waitForDomNetworkQuiet);
+    waitForDomNetworkQuietMock.mockResolvedValue(undefined);
+
+    const captureHybridSnapshotMock = vi.mocked(captureHybridSnapshot);
+    captureHybridSnapshotMock.mockResolvedValue({
+      combinedTree: "tree content",
+      combinedXpathMap: {},
+      combinedUrlMap: {},
+    });
+
+    const actInferenceMock = vi.mocked(actInference);
+
+    // Throw on call #3 (after snapshot but before LLM)
+    vi.mocked(createTimeoutGuard).mockImplementation(
+      (timeoutMs, errorFactory) => {
+        let calls = 0;
+        return vi.fn(() => {
+          calls += 1;
+          if (calls >= 3) {
+            throw errorFactory
+              ? errorFactory(timeoutMs!)
+              : new ActTimeoutError(timeoutMs!);
+          }
+        });
+      },
+    );
+
+    const handler = buildActHandler();
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    await expect(
+      handler.act({
+        instruction: "do something",
+        page: fakePage,
+        timeout: 5,
+      }),
+    ).rejects.toThrow(ActTimeoutError);
+
+    // Snapshot should have been called
+    expect(captureHybridSnapshotMock).toHaveBeenCalledTimes(1);
+    // LLM inference should NOT have been called
+    expect(actInferenceMock).not.toHaveBeenCalled();
+  });
+
+  it("throws ActTimeoutError with correct message format", async () => {
+    const waitForDomNetworkQuietMock = vi.mocked(waitForDomNetworkQuiet);
+    waitForDomNetworkQuietMock.mockResolvedValue(undefined);
+
+    const timeoutMs = 100;
+
+    vi.mocked(createTimeoutGuard).mockImplementation((ms, errorFactory) => {
+      return vi.fn(() => {
+        throw errorFactory ? errorFactory(ms!) : new ActTimeoutError(ms!);
+      });
+    });
+
+    const handler = buildActHandler();
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    try {
+      await handler.act({
+        instruction: "do something",
+        page: fakePage,
+        timeout: timeoutMs,
+      });
+      throw new Error("Expected ActTimeoutError to be thrown");
+    } catch (error) {
+      expect(error).toBeInstanceOf(ActTimeoutError);
+      expect((error as ActTimeoutError).message).toContain("act()");
+      expect((error as ActTimeoutError).message).toContain(`${timeoutMs}ms`);
+      expect((error as ActTimeoutError).name).toBe("ActTimeoutError");
+    }
+  });
+});
+
+describe("ActHandler two-step timeout", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("throws ActTimeoutError during step 2; step 2 action does not run", async () => {
+    const waitForDomNetworkQuietMock = vi.mocked(waitForDomNetworkQuiet);
+    waitForDomNetworkQuietMock.mockResolvedValue(undefined);
+
+    const captureHybridSnapshotMock = vi.mocked(captureHybridSnapshot);
+    captureHybridSnapshotMock.mockResolvedValue({
+      combinedTree: "tree content",
+      combinedXpathMap: { "1-0": "/html/body/button" },
+      combinedUrlMap: {},
+    });
+
+    const { performUnderstudyMethod } = await import(
+      "../../lib/v3/handlers/handlerUtils/actHandlerUtils.js"
+    );
+    const performUnderstudyMethodMock = vi.mocked(performUnderstudyMethod);
+    performUnderstudyMethodMock.mockResolvedValue(undefined);
+
+    const actInferenceMock = vi.mocked(actInference);
+    // First call returns a two-step action
+    actInferenceMock.mockResolvedValueOnce({
+      element: {
+        elementId: "1-0",
+        description: "click button",
+        method: "click",
+        arguments: [],
+      },
+      twoStep: true,
+      prompt_tokens: 100,
+      completion_tokens: 50,
+      inference_time_ms: 500,
+    } as ReturnType<typeof actInference> extends Promise<infer T> ? T : never);
+
+    const diffCombinedTreesMock = vi.mocked(
+      (await import("../../lib/v3/understudy/a11y/snapshot/index.js"))
+        .diffCombinedTrees,
+    );
+    diffCombinedTreesMock.mockReturnValue("diff tree");
+
+    // Timeout fires after step 1 completes, during step 2 snapshot
+    // ensureTimeRemaining calls: 1=before wait, 2=after wait/before snap1, 3=before LLM1,
+    // 4=before action1, 5=inside takeDeterministicAction, 6=performUnderstudy,
+    // 7=before snap2 (this one should throw)
+    let callCount = 0;
+    vi.mocked(createTimeoutGuard).mockImplementation(
+      (timeoutMs, errorFactory) => {
+        return vi.fn(() => {
+          callCount += 1;
+          if (callCount >= 7) {
+            throw errorFactory
+              ? errorFactory(timeoutMs!)
+              : new ActTimeoutError(timeoutMs!);
+          }
+        });
+      },
+    );
+
+    const handler = buildActHandler();
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    await expect(
+      handler.act({
+        instruction: "click then type",
+        page: fakePage,
+        timeout: 50,
+      }),
+    ).rejects.toThrow(ActTimeoutError);
+
+    // Step 1 action should have been executed
+    expect(performUnderstudyMethodMock).toHaveBeenCalledTimes(1);
+    // Step 2 LLM call should NOT have happened
+    expect(actInferenceMock).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("ActHandler self-heal timeout", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("throws ActTimeoutError during self-heal snapshot; no retry action executes", async () => {
+    const waitForDomNetworkQuietMock = vi.mocked(waitForDomNetworkQuiet);
+    waitForDomNetworkQuietMock.mockResolvedValue(undefined);
+
+    const captureHybridSnapshotMock = vi.mocked(captureHybridSnapshot);
+    captureHybridSnapshotMock.mockResolvedValue({
+      combinedTree: "tree content",
+      combinedXpathMap: { "1-0": "/html/body/button" },
+      combinedUrlMap: {},
+    });
+
+    const { performUnderstudyMethod } = await import(
+      "../../lib/v3/handlers/handlerUtils/actHandlerUtils.js"
+    );
+    const performUnderstudyMethodMock = vi.mocked(performUnderstudyMethod);
+    // First call fails, triggering self-heal
+    performUnderstudyMethodMock.mockRejectedValueOnce(
+      new Error("Element not found"),
+    );
+
+    const actInferenceMock = vi.mocked(actInference);
+    actInferenceMock.mockResolvedValue({
+      element: {
+        elementId: "1-0",
+        description: "click button",
+        method: "click",
+        arguments: [],
+      },
+      twoStep: false,
+      prompt_tokens: 100,
+      completion_tokens: 50,
+      inference_time_ms: 500,
+    } as ReturnType<typeof actInference> extends Promise<infer T> ? T : never);
+
+    // Timeout during self-heal snapshot (call 7 or later)
+    let callCount = 0;
+    vi.mocked(createTimeoutGuard).mockImplementation(
+      (timeoutMs, errorFactory) => {
+        return vi.fn(() => {
+          callCount += 1;
+          // Timeout during self-heal snapshot call
+          if (callCount >= 7) {
+            throw errorFactory
+              ? errorFactory(timeoutMs!)
+              : new ActTimeoutError(timeoutMs!);
+          }
+        });
+      },
+    );
+
+    const handler = buildActHandler({ selfHeal: true });
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    await expect(
+      handler.act({
+        instruction: "click button",
+        page: fakePage,
+        timeout: 50,
+      }),
+    ).rejects.toThrow(ActTimeoutError);
+
+    // First action attempt should have been tried
+    expect(performUnderstudyMethodMock).toHaveBeenCalledTimes(1);
+    // First LLM call should have happened
+    expect(actInferenceMock).toHaveBeenCalledTimes(1);
+    // Self-heal snapshot should have been started (call happened)
+    expect(captureHybridSnapshotMock).toHaveBeenCalled();
+  });
+
+  it("throws ActTimeoutError during self-heal LLM inference; no retry action executes", async () => {
+    const waitForDomNetworkQuietMock = vi.mocked(waitForDomNetworkQuiet);
+    waitForDomNetworkQuietMock.mockResolvedValue(undefined);
+
+    const captureHybridSnapshotMock = vi.mocked(captureHybridSnapshot);
+    captureHybridSnapshotMock.mockResolvedValue({
+      combinedTree: "tree content",
+      combinedXpathMap: { "1-0": "/html/body/button" },
+      combinedUrlMap: {},
+    });
+
+    const { performUnderstudyMethod } = await import(
+      "../../lib/v3/handlers/handlerUtils/actHandlerUtils.js"
+    );
+    const performUnderstudyMethodMock = vi.mocked(performUnderstudyMethod);
+    // First call fails, triggering self-heal
+    performUnderstudyMethodMock.mockRejectedValueOnce(
+      new Error("Element not found"),
+    );
+
+    const actInferenceMock = vi.mocked(actInference);
+    actInferenceMock.mockResolvedValueOnce({
+      element: {
+        elementId: "1-0",
+        description: "click button",
+        method: "click",
+        arguments: [],
+      },
+      twoStep: false,
+      prompt_tokens: 100,
+      completion_tokens: 50,
+      inference_time_ms: 500,
+    } as ReturnType<typeof actInference> extends Promise<infer T> ? T : never);
+
+    // Timeout during self-heal LLM inference (call 8)
+    let callCount = 0;
+    vi.mocked(createTimeoutGuard).mockImplementation(
+      (timeoutMs, errorFactory) => {
+        return vi.fn(() => {
+          callCount += 1;
+          // Timeout during self-heal LLM call
+          if (callCount >= 8) {
+            throw errorFactory
+              ? errorFactory(timeoutMs!)
+              : new ActTimeoutError(timeoutMs!);
+          }
+        });
+      },
+    );
+
+    const handler = buildActHandler({ selfHeal: true });
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    await expect(
+      handler.act({
+        instruction: "click button",
+        page: fakePage,
+        timeout: 50,
+      }),
+    ).rejects.toThrow(ActTimeoutError);
+
+    // Self-heal snapshot was captured
+    expect(captureHybridSnapshotMock).toHaveBeenCalledTimes(2);
+    // Only one LLM inference (the retry inference was aborted by timeout)
+    expect(actInferenceMock).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("ExtractHandler timeout guard", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("throws ExtractTimeoutError when timeout expires before snapshot", async () => {
+    const captureHybridSnapshotMock = vi.mocked(captureHybridSnapshot);
+    captureHybridSnapshotMock.mockResolvedValue({
+      combinedTree: "tree content",
+      combinedXpathMap: {},
+      combinedUrlMap: {},
+    });
+
+    const extractInferenceMock = vi.mocked(extractInference);
+
+    // Throw immediately on first call
+    vi.mocked(createTimeoutGuard).mockImplementation(
+      (timeoutMs, errorFactory) => {
+        return vi.fn(() => {
+          throw errorFactory
+            ? errorFactory(timeoutMs!)
+            : new ExtractTimeoutError(timeoutMs!);
+        });
+      },
+    );
+
+    const handler = buildExtractHandler();
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    await expect(
+      handler.extract({
+        instruction: "extract title",
+        page: fakePage,
+        timeout: 5,
+      }),
+    ).rejects.toThrow(ExtractTimeoutError);
+
+    // Snapshot should NOT have been called
+    expect(captureHybridSnapshotMock).not.toHaveBeenCalled();
+    // LLM inference should NOT have been called
+    expect(extractInferenceMock).not.toHaveBeenCalled();
+  });
+
+  it("throws ExtractTimeoutError when timeout expires before LLM call", async () => {
+    const captureHybridSnapshotMock = vi.mocked(captureHybridSnapshot);
+    captureHybridSnapshotMock.mockResolvedValue({
+      combinedTree: "tree content",
+      combinedXpathMap: {},
+      combinedUrlMap: {},
+    });
+
+    const extractInferenceMock = vi.mocked(extractInference);
+
+    // Throw on call #2 (after snapshot but before LLM)
+    vi.mocked(createTimeoutGuard).mockImplementation(
+      (timeoutMs, errorFactory) => {
+        let calls = 0;
+        return vi.fn(() => {
+          calls += 1;
+          if (calls >= 2) {
+            throw errorFactory
+              ? errorFactory(timeoutMs!)
+              : new ExtractTimeoutError(timeoutMs!);
+          }
+        });
+      },
+    );
+
+    const handler = buildExtractHandler();
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    await expect(
+      handler.extract({
+        instruction: "extract title",
+        page: fakePage,
+        timeout: 5,
+      }),
+    ).rejects.toThrow(ExtractTimeoutError);
+
+    // Snapshot should have been called
+    expect(captureHybridSnapshotMock).toHaveBeenCalledTimes(1);
+    // LLM inference should NOT have been called
+    expect(extractInferenceMock).not.toHaveBeenCalled();
+  });
+
+  it("throws ExtractTimeoutError with correct message format", async () => {
+    const timeoutMs = 200;
+
+    vi.mocked(createTimeoutGuard).mockImplementation((ms, errorFactory) => {
+      return vi.fn(() => {
+        throw errorFactory ? errorFactory(ms!) : new ExtractTimeoutError(ms!);
+      });
+    });
+
+    const handler = buildExtractHandler();
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    try {
+      await handler.extract({
+        instruction: "extract title",
+        page: fakePage,
+        timeout: timeoutMs,
+      });
+      throw new Error("Expected ExtractTimeoutError to be thrown");
+    } catch (error) {
+      expect(error).toBeInstanceOf(ExtractTimeoutError);
+      expect((error as ExtractTimeoutError).message).toContain("extract()");
+      expect((error as ExtractTimeoutError).message).toContain(
+        `${timeoutMs}ms`,
+      );
+      expect((error as ExtractTimeoutError).name).toBe("ExtractTimeoutError");
+    }
+  });
+
+  it("stops LLM and post-processing when timeout expires", async () => {
+    const captureHybridSnapshotMock = vi.mocked(captureHybridSnapshot);
+    captureHybridSnapshotMock.mockResolvedValue({
+      combinedTree: "tree content",
+      combinedXpathMap: {},
+      combinedUrlMap: { "1-0": "https://example.com" },
+    });
+
+    const extractInferenceMock = vi.mocked(extractInference);
+
+    // Allow snapshot but timeout before LLM
+    vi.mocked(createTimeoutGuard).mockImplementation(
+      (timeoutMs, errorFactory) => {
+        let calls = 0;
+        return vi.fn(() => {
+          calls += 1;
+          if (calls >= 2) {
+            throw errorFactory
+              ? errorFactory(timeoutMs!)
+              : new ExtractTimeoutError(timeoutMs!);
+          }
+        });
+      },
+    );
+
+    const handler = buildExtractHandler();
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    await expect(
+      handler.extract({
+        instruction: "extract links",
+        page: fakePage,
+        timeout: 5,
+      }),
+    ).rejects.toThrow(ExtractTimeoutError);
+
+    // Post-processing (URL injection) never runs because LLM was never called
+    expect(extractInferenceMock).not.toHaveBeenCalled();
+  });
+});
+
+describe("ObserveHandler timeout guard", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("throws ObserveTimeoutError when timeout expires before snapshot", async () => {
+    const captureHybridSnapshotMock = vi.mocked(captureHybridSnapshot);
+    captureHybridSnapshotMock.mockResolvedValue({
+      combinedTree: "tree content",
+      combinedXpathMap: {},
+      combinedUrlMap: {},
+    });
+
+    const observeInferenceMock = vi.mocked(observeInference);
+
+    // Throw immediately on first call
+    vi.mocked(createTimeoutGuard).mockImplementation(
+      (timeoutMs, errorFactory) => {
+        return vi.fn(() => {
+          throw errorFactory
+            ? errorFactory(timeoutMs!)
+            : new ObserveTimeoutError(timeoutMs!);
+        });
+      },
+    );
+
+    const handler = buildObserveHandler();
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    await expect(
+      handler.observe({
+        instruction: "find buttons",
+        page: fakePage,
+        timeout: 5,
+      }),
+    ).rejects.toThrow(ObserveTimeoutError);
+
+    // Snapshot should NOT have been called
+    expect(captureHybridSnapshotMock).not.toHaveBeenCalled();
+    // LLM inference should NOT have been called
+    expect(observeInferenceMock).not.toHaveBeenCalled();
+  });
+
+  it("throws ObserveTimeoutError when timeout expires before LLM call", async () => {
+    const captureHybridSnapshotMock = vi.mocked(captureHybridSnapshot);
+    captureHybridSnapshotMock.mockResolvedValue({
+      combinedTree: "tree content",
+      combinedXpathMap: {},
+      combinedUrlMap: {},
+    });
+
+    const observeInferenceMock = vi.mocked(observeInference);
+
+    // Throw on call #2 (after snapshot but before LLM)
+    vi.mocked(createTimeoutGuard).mockImplementation(
+      (timeoutMs, errorFactory) => {
+        let calls = 0;
+        return vi.fn(() => {
+          calls += 1;
+          if (calls >= 2) {
+            throw errorFactory
+              ? errorFactory(timeoutMs!)
+              : new ObserveTimeoutError(timeoutMs!);
+          }
+        });
+      },
+    );
+
+    const handler = buildObserveHandler();
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    await expect(
+      handler.observe({
+        instruction: "find buttons",
+        page: fakePage,
+        timeout: 5,
+      }),
+    ).rejects.toThrow(ObserveTimeoutError);
+
+    // Snapshot should have been called
+    expect(captureHybridSnapshotMock).toHaveBeenCalledTimes(1);
+    // LLM inference should NOT have been called
+    expect(observeInferenceMock).not.toHaveBeenCalled();
+  });
+
+  it("throws ObserveTimeoutError with correct message format", async () => {
+    const timeoutMs = 150;
+
+    vi.mocked(createTimeoutGuard).mockImplementation((ms, errorFactory) => {
+      return vi.fn(() => {
+        throw errorFactory ? errorFactory(ms!) : new ObserveTimeoutError(ms!);
+      });
+    });
+
+    const handler = buildObserveHandler();
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    try {
+      await handler.observe({
+        instruction: "find buttons",
+        page: fakePage,
+        timeout: timeoutMs,
+      });
+      throw new Error("Expected ObserveTimeoutError to be thrown");
+    } catch (error) {
+      expect(error).toBeInstanceOf(ObserveTimeoutError);
+      expect((error as ObserveTimeoutError).message).toContain("observe()");
+      expect((error as ObserveTimeoutError).message).toContain(
+        `${timeoutMs}ms`,
+      );
+      expect((error as ObserveTimeoutError).name).toBe("ObserveTimeoutError");
+    }
+  });
+
+  it("aborts result processing when timeout expires", async () => {
+    const captureHybridSnapshotMock = vi.mocked(captureHybridSnapshot);
+    captureHybridSnapshotMock.mockResolvedValue({
+      combinedTree: "tree content",
+      combinedXpathMap: { "1-0": "/html/body/button" },
+      combinedUrlMap: {},
+    });
+
+    const observeInferenceMock = vi.mocked(observeInference);
+
+    // Timeout before LLM call
+    vi.mocked(createTimeoutGuard).mockImplementation(
+      (timeoutMs, errorFactory) => {
+        let calls = 0;
+        return vi.fn(() => {
+          calls += 1;
+          if (calls >= 2) {
+            throw errorFactory
+              ? errorFactory(timeoutMs!)
+              : new ObserveTimeoutError(timeoutMs!);
+          }
+        });
+      },
+    );
+
+    const handler = buildObserveHandler();
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    await expect(
+      handler.observe({
+        instruction: "find all interactive elements",
+        page: fakePage,
+        timeout: 5,
+      }),
+    ).rejects.toThrow(ObserveTimeoutError);
+
+    // Result mapping/processing never happens
+    expect(observeInferenceMock).not.toHaveBeenCalled();
+  });
+});
+
+describe("No-timeout success paths", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("act() completes successfully without timeout and records metrics", async () => {
+    const waitForDomNetworkQuietMock = vi.mocked(waitForDomNetworkQuiet);
+    waitForDomNetworkQuietMock.mockResolvedValue(undefined);
+
+    const captureHybridSnapshotMock = vi.mocked(captureHybridSnapshot);
+    captureHybridSnapshotMock.mockResolvedValue({
+      combinedTree: "tree content",
+      combinedXpathMap: { "1-0": "/html/body/button" },
+      combinedUrlMap: {},
+    });
+
+    const { performUnderstudyMethod } = await import(
+      "../../lib/v3/handlers/handlerUtils/actHandlerUtils.js"
+    );
+    const performUnderstudyMethodMock = vi.mocked(performUnderstudyMethod);
+    performUnderstudyMethodMock.mockResolvedValue(undefined);
+
+    const actInferenceMock = vi.mocked(actInference);
+    actInferenceMock.mockResolvedValue({
+      element: {
+        elementId: "1-0",
+        description: "click button",
+        method: "click",
+        arguments: [],
+      },
+      twoStep: false,
+      prompt_tokens: 100,
+      completion_tokens: 50,
+      reasoning_tokens: 10,
+      cached_input_tokens: 5,
+      inference_time_ms: 500,
+    } as ReturnType<typeof actInference> extends Promise<infer T> ? T : never);
+
+    // No timeout - guard never throws
+    vi.mocked(createTimeoutGuard).mockImplementation(() => {
+      return vi.fn(() => {
+        // No-op - never throws
+      });
+    });
+
+    const metricsCallback = vi.fn();
+    const handler = buildActHandler({ onMetrics: metricsCallback });
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    const result = await handler.act({
+      instruction: "click button",
+      page: fakePage,
+      // No timeout specified
+    });
+
+    expect(result.success).toBe(true);
+    expect(metricsCallback).toHaveBeenCalledWith(
+      V3FunctionName.ACT,
+      100,
+      50,
+      10,
+      5,
+      500,
+    );
+  });
+
+  it("extract() completes successfully without timeout and records metrics", async () => {
+    const captureHybridSnapshotMock = vi.mocked(captureHybridSnapshot);
+    captureHybridSnapshotMock.mockResolvedValue({
+      combinedTree: "tree content",
+      combinedXpathMap: {},
+      combinedUrlMap: {},
+    });
+
+    const extractInferenceMock = vi.mocked(extractInference);
+    extractInferenceMock.mockResolvedValue({
+      title: "Test Title",
+      metadata: { completed: true, progress: "100%" },
+      prompt_tokens: 200,
+      completion_tokens: 100,
+      reasoning_tokens: 20,
+      cached_input_tokens: 10,
+      inference_time_ms: 800,
+    } as ReturnType<typeof extractInference> extends Promise<infer T>
+      ? T
+      : never);
+
+    // No timeout - guard never throws
+    vi.mocked(createTimeoutGuard).mockImplementation(() => {
+      return vi.fn(() => {
+        // No-op - never throws
+      });
+    });
+
+    const metricsCallback = vi.fn();
+    const handler = buildExtractHandler({ onMetrics: metricsCallback });
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    const result = await handler.extract({
+      instruction: "extract title",
+      page: fakePage,
+      // No timeout specified
+    });
+
+    expect(result).toHaveProperty("title", "Test Title");
+    expect(metricsCallback).toHaveBeenCalledWith(
+      V3FunctionName.EXTRACT,
+      200,
+      100,
+      20,
+      10,
+      800,
+    );
+  });
+
+  it("observe() completes successfully without timeout and records metrics", async () => {
+    const captureHybridSnapshotMock = vi.mocked(captureHybridSnapshot);
+    captureHybridSnapshotMock.mockResolvedValue({
+      combinedTree: "tree content",
+      combinedXpathMap: { "1-0": "/html/body/button" },
+      combinedUrlMap: {},
+    });
+
+    const observeInferenceMock = vi.mocked(observeInference);
+    observeInferenceMock.mockResolvedValue({
+      elements: [
+        {
+          elementId: "1-0",
+          description: "Submit button",
+        },
+      ],
+      prompt_tokens: 150,
+      completion_tokens: 75,
+      reasoning_tokens: 15,
+      cached_input_tokens: 8,
+      inference_time_ms: 600,
+    } as ReturnType<typeof observeInference> extends Promise<infer T>
+      ? T
+      : never);
+
+    // No timeout - guard never throws
+    vi.mocked(createTimeoutGuard).mockImplementation(() => {
+      return vi.fn(() => {
+        // No-op - never throws
+      });
+    });
+
+    const metricsCallback = vi.fn();
+    const handler = buildObserveHandler({ onMetrics: metricsCallback });
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    const result = await handler.observe({
+      instruction: "find buttons",
+      page: fakePage,
+      // No timeout specified
+    });
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toHaveProperty("description", "Submit button");
+    expect(metricsCallback).toHaveBeenCalledWith(
+      V3FunctionName.OBSERVE,
+      150,
+      75,
+      15,
+      8,
+      600,
+    );
+  });
+
+  it("act() with zero timeout behaves as no timeout", async () => {
+    const waitForDomNetworkQuietMock = vi.mocked(waitForDomNetworkQuiet);
+    waitForDomNetworkQuietMock.mockResolvedValue(undefined);
+
+    const captureHybridSnapshotMock = vi.mocked(captureHybridSnapshot);
+    captureHybridSnapshotMock.mockResolvedValue({
+      combinedTree: "tree content",
+      combinedXpathMap: { "1-0": "/html/body/button" },
+      combinedUrlMap: {},
+    });
+
+    const { performUnderstudyMethod } = await import(
+      "../../lib/v3/handlers/handlerUtils/actHandlerUtils.js"
+    );
+    const performUnderstudyMethodMock = vi.mocked(performUnderstudyMethod);
+    performUnderstudyMethodMock.mockResolvedValue(undefined);
+
+    const actInferenceMock = vi.mocked(actInference);
+    actInferenceMock.mockResolvedValue({
+      element: {
+        elementId: "1-0",
+        description: "click button",
+        method: "click",
+        arguments: [],
+      },
+      twoStep: false,
+      prompt_tokens: 100,
+      completion_tokens: 50,
+      inference_time_ms: 500,
+    } as ReturnType<typeof actInference> extends Promise<infer T> ? T : never);
+
+    // When timeout is 0 or negative, createTimeoutGuard returns a no-op
+    vi.mocked(createTimeoutGuard).mockImplementation((timeoutMs) => {
+      if (!timeoutMs || timeoutMs <= 0) {
+        return vi.fn(() => {
+          // No-op
+        });
+      }
+      return vi.fn(() => {
+        throw new ActTimeoutError(timeoutMs);
+      });
+    });
+
+    const handler = buildActHandler();
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    const result = await handler.act({
+      instruction: "click button",
+      page: fakePage,
+      timeout: 0, // Zero timeout should be treated as "no timeout"
+    });
+
+    expect(result.success).toBe(true);
+  });
+
+  it("act() with negative timeout behaves as no timeout", async () => {
+    const waitForDomNetworkQuietMock = vi.mocked(waitForDomNetworkQuiet);
+    waitForDomNetworkQuietMock.mockResolvedValue(undefined);
+
+    const captureHybridSnapshotMock = vi.mocked(captureHybridSnapshot);
+    captureHybridSnapshotMock.mockResolvedValue({
+      combinedTree: "tree content",
+      combinedXpathMap: { "1-0": "/html/body/button" },
+      combinedUrlMap: {},
+    });
+
+    const { performUnderstudyMethod } = await import(
+      "../../lib/v3/handlers/handlerUtils/actHandlerUtils.js"
+    );
+    const performUnderstudyMethodMock = vi.mocked(performUnderstudyMethod);
+    performUnderstudyMethodMock.mockResolvedValue(undefined);
+
+    const actInferenceMock = vi.mocked(actInference);
+    actInferenceMock.mockResolvedValue({
+      element: {
+        elementId: "1-0",
+        description: "click button",
+        method: "click",
+        arguments: [],
+      },
+      twoStep: false,
+      prompt_tokens: 100,
+      completion_tokens: 50,
+      inference_time_ms: 500,
+    } as ReturnType<typeof actInference> extends Promise<infer T> ? T : never);
+
+    vi.mocked(createTimeoutGuard).mockImplementation((timeoutMs) => {
+      if (!timeoutMs || timeoutMs <= 0) {
+        return vi.fn(() => {
+          // No-op
+        });
+      }
+      return vi.fn(() => {
+        throw new ActTimeoutError(timeoutMs);
+      });
+    });
+
+    const handler = buildActHandler();
+    const fakePage = {
+      mainFrame: vi.fn().mockReturnValue({}),
+    } as unknown as Page;
+
+    const result = await handler.act({
+      instruction: "click button",
+      page: fakePage,
+      timeout: -100, // Negative timeout should be treated as "no timeout"
+    });
+
+    expect(result.success).toBe(true);
+  });
+});
+
+interface BuildActHandlerOptions {
+  selfHeal?: boolean;
+  onMetrics?: (
+    functionName: V3FunctionName,
+    promptTokens: number,
+    completionTokens: number,
+    reasoningTokens: number,
+    cachedInputTokens: number,
+    inferenceTimeMs: number,
+  ) => void;
+}
+
+function buildActHandler(options: BuildActHandlerOptions = {}): ActHandler {
+  const defaultClientOptions = {} as ClientOptions;
+  const fakeClient = {
+    type: "openai",
+    modelName: "gpt-4o",
+    clientOptions: defaultClientOptions,
+  } as LLMClient;
+  const resolveLlmClient = vi.fn().mockReturnValue(fakeClient);
+
+  return new ActHandler(
+    fakeClient,
+    "gpt-4o",
+    defaultClientOptions,
+    resolveLlmClient,
+    undefined,
+    false,
+    options.selfHeal ?? false,
+    options.onMetrics,
+    undefined,
+  );
+}
+
+interface BuildExtractHandlerOptions {
+  onMetrics?: (
+    functionName: V3FunctionName,
+    promptTokens: number,
+    completionTokens: number,
+    reasoningTokens: number,
+    cachedInputTokens: number,
+    inferenceTimeMs: number,
+  ) => void;
+}
+
+function buildExtractHandler(
+  options: BuildExtractHandlerOptions = {},
+): ExtractHandler {
+  const defaultClientOptions = {} as ClientOptions;
+  const fakeClient = {
+    type: "openai",
+    modelName: "gpt-4o",
+    clientOptions: defaultClientOptions,
+  } as LLMClient;
+  const resolveLlmClient = vi.fn().mockReturnValue(fakeClient);
+
+  return new ExtractHandler(
+    fakeClient,
+    "gpt-4o",
+    defaultClientOptions,
+    resolveLlmClient,
+    undefined,
+    false,
+    false,
+    options.onMetrics,
+  );
+}
+
+interface BuildObserveHandlerOptions {
+  onMetrics?: (
+    functionName: V3FunctionName,
+    promptTokens: number,
+    completionTokens: number,
+    reasoningTokens: number,
+    cachedInputTokens: number,
+    inferenceTimeMs: number,
+  ) => void;
+}
+
+function buildObserveHandler(
+  options: BuildObserveHandlerOptions = {},
+): ObserveHandler {
+  const defaultClientOptions = {} as ClientOptions;
+  const fakeClient = {
+    type: "openai",
+    modelName: "gpt-4o",
+    clientOptions: defaultClientOptions,
+  } as LLMClient;
+  const resolveLlmClient = vi.fn().mockReturnValue(fakeClient);
+
+  return new ObserveHandler(
+    fakeClient,
+    "gpt-4o",
+    defaultClientOptions,
+    resolveLlmClient,
+    undefined,
+    false,
+    false,
+    options.onMetrics,
+  );
+}
diff --git a/packages/core/tests/unit/understudy-command-exception.test.ts b/packages/core/tests/unit/understudy-command-exception.test.ts
new file mode 100644
index 000000000..43876679a
--- /dev/null
+++ b/packages/core/tests/unit/understudy-command-exception.test.ts
@@ -0,0 +1,68 @@
+import { describe, expect, it } from "vitest";
+import {
+  UnderstudyCommandException,
+  StagehandError,
+} from "../../lib/v3/types/public/sdkErrors.js";
+
+describe("UnderstudyCommandException", () => {
+  it("extends StagehandError", () => {
+    const err = new UnderstudyCommandException("test");
+    expect(err).toBeInstanceOf(StagehandError);
+    expect(err).toBeInstanceOf(Error);
+  });
+
+  it("has the correct name", () => {
+    const err = new UnderstudyCommandException("test");
+    expect(err.name).toBe("UnderstudyCommandException");
+  });
+
+  it("preserves the message", () => {
+    const err = new UnderstudyCommandException("something broke");
+    expect(err.message).toBe("something broke");
+  });
+
+  it("stores the original error as cause when provided", () => {
+    const original = new Error("root cause");
+    const err = new UnderstudyCommandException("wrapper message", original);
+
+    expect(err.cause).toBe(original);
+    expect((err.cause as Error).message).toBe("root cause");
+    expect((err.cause as Error).stack).toBeDefined();
+  });
+
+  it("stores non-Error cause values", () => {
+    const err = new UnderstudyCommandException("failed", "string cause");
+    expect(err.cause).toBe("string cause");
+  });
+
+  it("has undefined cause when none is provided", () => {
+    const err = new UnderstudyCommandException("no cause");
+    expect(err.cause).toBeUndefined();
+  });
+
+  it("generates its own stack trace", () => {
+    const err = new UnderstudyCommandException("test");
+    expect(err.stack).toBeDefined();
+    expect(err.stack).toContain("UnderstudyCommandException");
+  });
+
+  it("preserves the original stack via cause for debugging", () => {
+    function deepFunction() {
+      throw new Error("deep error");
+    }
+
+    let original: Error;
+    try {
+      deepFunction();
+    } catch (e) {
+      original = e as Error;
+    }
+
+    const wrapped = new UnderstudyCommandException(original!.message, original);
+
+    // The wrapper has its own stack
+    expect(wrapped.stack).toBeDefined();
+    // The original stack is accessible via cause
+    expect((wrapped.cause as Error).stack).toContain("deepFunction");
+  });
+});
diff --git a/packages/core/tests/unit/xpath-parser.test.ts b/packages/core/tests/unit/xpath-parser.test.ts
new file mode 100644
index 000000000..4b0e12b82
--- /dev/null
+++ b/packages/core/tests/unit/xpath-parser.test.ts
@@ -0,0 +1,355 @@
+import { describe, expect, it } from "vitest";
+import {
+  applyPredicates,
+  parseXPathSteps,
+  type XPathPredicate,
+} from "../../lib/v3/dom/locatorScripts/xpathParser.js";
+
+describe("parseXPathSteps", () => {
+  describe("basic tag parsing", () => {
+    it("parses a simple absolute path", () => {
+      expect(parseXPathSteps("/html/body/div")).toEqual([
+        { axis: "child", tag: "html", predicates: [] },
+        { axis: "child", tag: "body", predicates: [] },
+        { axis: "child", tag: "div", predicates: [] },
+      ]);
+    });
+
+    it("lowercases tag names", () => {
+      const steps = parseXPathSteps("/HTML/BODY");
+      expect(steps[0].tag).toBe("html");
+      expect(steps[1].tag).toBe("body");
+    });
+
+    it("treats wildcard correctly", () => {
+      const steps = parseXPathSteps("//*");
+      expect(steps).toEqual([{ axis: "desc", tag: "*", predicates: [] }]);
+    });
+  });
+
+  describe("axes", () => {
+    it("distinguishes child (/) from descendant (//)", () => {
+      const steps = parseXPathSteps("/html//div/span");
+      expect(steps).toEqual([
+        { axis: "child", tag: "html", predicates: [] },
+        { axis: "desc", tag: "div", predicates: [] },
+        { axis: "child", tag: "span", predicates: [] },
+      ]);
+    });
+
+    it("handles leading //", () => {
+      const steps = parseXPathSteps("//div");
+      expect(steps[0].axis).toBe("desc");
+    });
+  });
+
+  describe("positional indices", () => {
+    it("parses positional index", () => {
+      const steps = parseXPathSteps("/div[1]/span[3]");
+      expect(steps[0]).toMatchObject({
+        tag: "div",
+        predicates: [{ type: "index", index: 1 }],
+      });
+      expect(steps[1]).toMatchObject({
+        tag: "span",
+        predicates: [{ type: "index", index: 3 }],
+      });
+    });
+
+    it("clamps index to minimum 1", () => {
+      const steps = parseXPathSteps("/div[0]");
+      expect(steps[0].predicates[0]).toMatchObject({
+        type: "index",
+        index: 1,
+      });
+    });
+
+    it("keeps multiple positional predicates in order", () => {
+      const steps = parseXPathSteps("//div[2][3]");
+      expect(steps[0].predicates).toEqual([
+        { type: "index", index: 2 },
+        { type: "index", index: 3 },
+      ]);
+    });
+  });
+
+  describe("attribute predicates", () => {
+    it("parses single attribute predicate with single quotes", () => {
+      const steps = parseXPathSteps("//img[@alt='Stagehand']");
+      expect(steps).toEqual([
+        {
+          axis: "desc",
+          tag: "img",
+          predicates: [{ type: "attrEquals", name: "alt", value: "Stagehand" }],
+        },
+      ]);
+    });
+
+    it("parses single attribute predicate with double quotes", () => {
+      const steps = parseXPathSteps('//img[@alt="Stagehand"]');
+      expect(steps[0].predicates).toEqual([
+        { type: "attrEquals", name: "alt", value: "Stagehand" },
+      ]);
+    });
+
+    it("parses multiple attribute predicates", () => {
+      const steps = parseXPathSteps("//div[@class='foo'][@id='bar']");
+      expect(steps[0].predicates).toEqual([
+        { type: "attrEquals", name: "class", value: "foo" },
+        { type: "attrEquals", name: "id", value: "bar" },
+      ]);
+    });
+
+    it("parses attribute predicate combined with positional index", () => {
+      const steps = parseXPathSteps("//div[@class='item'][2]");
+      expect(steps[0]).toMatchObject({
+        tag: "div",
+        predicates: [
+          { type: "attrEquals", name: "class", value: "item" },
+          { type: "index", index: 2 },
+        ],
+      });
+    });
+
+    it("parses attribute with hyphenated name", () => {
+      const steps = parseXPathSteps("//div[@data-testid='submit']");
+      expect(steps[0].predicates).toEqual([
+        { type: "attrEquals", name: "data-testid", value: "submit" },
+      ]);
+    });
+
+    it("parses attribute with empty value", () => {
+      const steps = parseXPathSteps("//input[@value='']");
+      expect(steps[0].predicates).toEqual([
+        { type: "attrEquals", name: "value", value: "" },
+      ]);
+    });
+
+    it("parses attribute value containing closing bracket", () => {
+      const steps = parseXPathSteps("//div[@title='array[0]']");
+      expect(steps[0].predicates).toEqual([
+        { type: "attrEquals", name: "title", value: "array[0]" },
+      ]);
+    });
+
+    it("parses attribute value containing multiple brackets", () => {
+      const steps = parseXPathSteps("//div[@data-json='[1,2,3]']");
+      expect(steps[0].predicates).toEqual([
+        { type: "attrEquals", name: "data-json", value: "[1,2,3]" },
+      ]);
+    });
+
+    it("parses attribute value containing a closing bracket", () => {
+      // The step splitter should ignore ] characters inside quotes.
+      const steps = parseXPathSteps("//div[@title='a]b']/span");
+      expect(steps).toEqual([
+        {
+          axis: "desc",
+          tag: "div",
+          predicates: [{ type: "attrEquals", name: "title", value: "a]b" }],
+        },
+        { axis: "child", tag: "span", predicates: [] },
+      ]);
+    });
+
+    it("parses attribute existence predicates", () => {
+      const steps = parseXPathSteps("//iframe[@data-test]");
+      expect(steps[0].predicates).toEqual([
+        { type: "attrExists", name: "data-test" },
+      ]);
+    });
+
+    it("parses attribute contains predicates", () => {
+      const steps = parseXPathSteps("//iframe[contains(@src,'checkout')]");
+      expect(steps[0].predicates).toEqual([
+        { type: "attrContains", name: "src", value: "checkout" },
+      ]);
+    });
+
+    it("parses attribute starts-with predicates", () => {
+      const steps = parseXPathSteps("//button[starts-with(@id,'save-')]");
+      expect(steps[0].predicates).toEqual([
+        { type: "attrStartsWith", name: "id", value: "save-" },
+      ]);
+    });
+  });
+
+  describe("text predicates", () => {
+    it("parses text equality", () => {
+      const steps = parseXPathSteps("//button[text()='Submit']");
+      expect(steps[0].predicates).toEqual([
+        { type: "textEquals", value: "Submit" },
+      ]);
+    });
+
+    it("parses text contains", () => {
+      const steps = parseXPathSteps("//div[contains(text(),'Welcome')]");
+      expect(steps[0].predicates).toEqual([
+        { type: "textContains", value: "Welcome" },
+      ]);
+    });
+
+    it("parses normalize-space on text", () => {
+      const steps = parseXPathSteps(
+        "//div[normalize-space(text())='Hello world']",
+      );
+      expect(steps[0].predicates).toEqual([
+        { type: "textEquals", value: "Hello world", normalize: true },
+      ]);
+    });
+  });
+
+  describe("boolean predicates", () => {
+    it("parses and predicates", () => {
+      const steps = parseXPathSteps("//div[@a='x' and @b='y']");
+      expect(steps[0].predicates).toEqual([
+        {
+          type: "and",
+          predicates: [
+            { type: "attrEquals", name: "a", value: "x" },
+            { type: "attrEquals", name: "b", value: "y" },
+          ],
+        },
+      ]);
+    });
+
+    it("parses operators without surrounding whitespace", () => {
+      const steps = parseXPathSteps("//div[not(@x)and@y='z']");
+      expect(steps[0].predicates).toEqual([
+        {
+          type: "and",
+          predicates: [
+            { type: "not", predicate: { type: "attrExists", name: "x" } },
+            { type: "attrEquals", name: "y", value: "z" },
+          ],
+        },
+      ]);
+    });
+
+    it("parses or predicates", () => {
+      const steps = parseXPathSteps("//div[@a='x' or @b='y']");
+      expect(steps[0].predicates).toEqual([
+        {
+          type: "or",
+          predicates: [
+            { type: "attrEquals", name: "a", value: "x" },
+            { type: "attrEquals", name: "b", value: "y" },
+          ],
+        },
+      ]);
+    });
+
+    it("parses not predicates", () => {
+      const steps = parseXPathSteps("//button[not(@disabled)]");
+      expect(steps[0].predicates).toEqual([
+        { type: "not", predicate: { type: "attrExists", name: "disabled" } },
+      ]);
+    });
+
+    it("does not treat @and as a boolean operator", () => {
+      const steps = parseXPathSteps("//div[@and='x' and @y='z']");
+      expect(steps[0].predicates).toEqual([
+        {
+          type: "and",
+          predicates: [
+            { type: "attrEquals", name: "and", value: "x" },
+            { type: "attrEquals", name: "y", value: "z" },
+          ],
+        },
+      ]);
+    });
+  });
+
+  describe("multi-step with predicates", () => {
+    it("parses complex path with mixed predicates", () => {
+      const steps = parseXPathSteps(
+        "/html/body//div[@class='container']/ul/li[3]",
+      );
+      expect(steps).toEqual([
+        { axis: "child", tag: "html", predicates: [] },
+        { axis: "child", tag: "body", predicates: [] },
+        {
+          axis: "desc",
+          tag: "div",
+          predicates: [
+            { type: "attrEquals", name: "class", value: "container" },
+          ],
+        },
+        { axis: "child", tag: "ul", predicates: [] },
+        { axis: "child", tag: "li", predicates: [{ type: "index", index: 3 }] },
+      ]);
+    });
+  });
+
+  describe("edge cases", () => {
+    it("returns empty array for empty string", () => {
+      expect(parseXPathSteps("")).toEqual([]);
+    });
+
+    it("strips xpath= prefix", () => {
+      const steps = parseXPathSteps("xpath=//div");
+      expect(steps).toEqual([{ axis: "desc", tag: "div", predicates: [] }]);
+    });
+
+    it("strips XPATH= prefix (case-insensitive)", () => {
+      const steps = parseXPathSteps("XPATH=//div");
+      expect(steps).toEqual([{ axis: "desc", tag: "div", predicates: [] }]);
+    });
+
+    it("handles forward slashes inside attribute values", () => {
+      const steps = parseXPathSteps("//a[@href='/api/endpoint']");
+      expect(steps).toEqual([
+        {
+          axis: "desc",
+          tag: "a",
+          predicates: [
+            { type: "attrEquals", name: "href", value: "/api/endpoint" },
+          ],
+        },
+      ]);
+    });
+
+    it("handles URL attribute values with multiple slashes", () => {
+      const steps = parseXPathSteps(
+        "//a[@data-url='http://example.com/path/to/page']",
+      );
+      expect(steps).toEqual([
+        {
+          axis: "desc",
+          tag: "a",
+          predicates: [
+            {
+              type: "attrEquals",
+              name: "data-url",
+              value: "http://example.com/path/to/page",
+            },
+          ],
+        },
+      ]);
+    });
+
+    it("handles whitespace", () => {
+      const steps = parseXPathSteps("  //div  ");
+      expect(steps.length).toBe(1);
+      expect(steps[0].tag).toBe("div");
+    });
+  });
+});
+
+describe("applyPredicates", () => {
+  const makeElement = (id: string): Element => {
+    return {
+      localName: "div",
+      getAttribute: (name: string) => (name === "id" ? id : null),
+    } as unknown as Element;
+  };
+
+  it("applies positional predicates sequentially", () => {
+    const elements = ["a", "b", "c", "d"].map(makeElement);
+    const predicates: XPathPredicate[] = [
+      { type: "index", index: 2 },
+      { type: "index", index: 3 },
+    ];
+    expect(applyPredicates(elements, predicates)).toEqual([]);
+  });
+});
diff --git a/packages/core/tests/unit/xpath-resolver.test.ts b/packages/core/tests/unit/xpath-resolver.test.ts
new file mode 100644
index 000000000..a54af6325
--- /dev/null
+++ b/packages/core/tests/unit/xpath-resolver.test.ts
@@ -0,0 +1,105 @@
+import { JSDOM } from "jsdom";
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import {
+  countXPathMatches,
+  resolveXPathAtIndex,
+} from "../../lib/v3/dom/locatorScripts/xpathResolver.js";
+
+type DomGlobals = {
+  window: Window & typeof globalThis;
+  document: Document;
+  Node: typeof Node;
+  NodeFilter: typeof NodeFilter;
+  Element: typeof Element;
+  HTMLElement: typeof HTMLElement;
+  Document: typeof Document;
+  DocumentFragment: typeof DocumentFragment;
+  ShadowRoot: typeof ShadowRoot;
+  XPathResult: typeof XPathResult;
+};
+
+const globalRef = globalThis as typeof globalThis & Partial<DomGlobals>;
+const originalGlobals: Partial<DomGlobals> = {
+  window: globalRef.window,
+  document: globalRef.document,
+  Node: globalRef.Node,
+  NodeFilter: globalRef.NodeFilter,
+  Element: globalRef.Element,
+  HTMLElement: globalRef.HTMLElement,
+  Document: globalRef.Document,
+  DocumentFragment: globalRef.DocumentFragment,
+  ShadowRoot: globalRef.ShadowRoot,
+  XPathResult: globalRef.XPathResult,
+};
+
+let dom: JSDOM;
+
+const installDomGlobals = () => {
+  const win = dom.window;
+  globalRef.window = win as unknown as Window & typeof globalThis;
+  globalRef.document = win.document;
+  globalRef.Node = win.Node as unknown as typeof Node;
+  globalRef.NodeFilter = win.NodeFilter as unknown as typeof NodeFilter;
+  globalRef.Element = win.Element as unknown as typeof Element;
+  globalRef.HTMLElement = win.HTMLElement as unknown as typeof HTMLElement;
+  globalRef.Document = win.Document as unknown as typeof Document;
+  globalRef.DocumentFragment =
+    win.DocumentFragment as unknown as typeof DocumentFragment;
+  globalRef.ShadowRoot = win.ShadowRoot as unknown as typeof ShadowRoot;
+  globalRef.XPathResult = win.XPathResult as unknown as typeof XPathResult;
+};
+
+const restoreDomGlobals = () => {
+  for (const [key, value] of Object.entries(originalGlobals)) {
+    if (value === undefined) {
+      delete (globalRef as Record<string, unknown>)[key];
+    } else {
+      (globalRef as Record<string, unknown>)[key] = value;
+    }
+  }
+};
+
+describe("xpathResolver composed traversal", () => {
+  beforeAll(() => {
+    dom = new JSDOM("<!doctype html><html><body></body></html>");
+    installDomGlobals();
+  });
+
+  afterAll(() => {
+    dom.window.close();
+    restoreDomGlobals();
+  });
+
+  beforeEach(() => {
+    document.body.innerHTML = "";
+  });
+
+  it("counts matches across light + shadow DOM without double counting", () => {
+    document.body.innerHTML =
+      '<div id="light-1"></div>' +
+      '<shadow-host id="host"></shadow-host>' +
+      '<div id="light-2"></div>';
+
+    const host = document.getElementById("host") as HTMLElement;
+    const shadow = host.attachShadow({ mode: "open" });
+    shadow.innerHTML = '<div id="shadow-1"></div><div id="shadow-2"></div>';
+
+    expect(countXPathMatches("//div")).toBe(4);
+  });
+
+  it("resolves nth over composed tree in document-order DFS", () => {
+    document.body.innerHTML =
+      '<div id="light-1"></div>' +
+      '<shadow-host id="host"></shadow-host>' +
+      '<div id="light-2"></div>';
+
+    const host = document.getElementById("host") as HTMLElement;
+    const shadow = host.attachShadow({ mode: "open" });
+    shadow.innerHTML = '<div id="shadow-1"></div><div id="shadow-2"></div>';
+
+    expect(resolveXPathAtIndex("//div", 0)?.id).toBe("light-1");
+    expect(resolveXPathAtIndex("//div", 1)?.id).toBe("shadow-1");
+    expect(resolveXPathAtIndex("//div", 2)?.id).toBe("shadow-2");
+    expect(resolveXPathAtIndex("//div", 3)?.id).toBe("light-2");
+  });
+});
diff --git a/packages/core/tests/unit/zod-enum-compatibility.test.ts b/packages/core/tests/unit/zod-enum-compatibility.test.ts
new file mode 100644
index 000000000..5a654b295
--- /dev/null
+++ b/packages/core/tests/unit/zod-enum-compatibility.test.ts
@@ -0,0 +1,142 @@
+import { describe, expect, it } from "vitest";
+import * as z3 from "zod/v3";
+import { z as z4 } from "zod";
+import { SupportedUnderstudyAction } from "../../lib/v3/types/private/handlers.js";
+
+/**
+ * Tests for Zod v3/v4 compatibility with the SupportedUnderstudyAction enum.
+ *
+ * This test ensures that z.enum() works correctly with both Zod v3 and v4.
+ * The key issue is that z.enum() in Zod v3 does NOT accept TypeScript enums directly -
+ * it only accepts string literal tuples. For TypeScript enums, you need to use
+ * Object.values() to convert the enum to an array first.
+ *
+ * In Zod v4, z.enum() was updated to accept TypeScript enums directly, but for
+ * backwards compatibility, we should use Object.values() which works with both.
+ *
+ * See PR #1613: https://github.com/browserbase/stagehand/pull/1613
+ */
+describe("SupportedUnderstudyAction enum Zod compatibility", () => {
+  const testInput = {
+    elementId: "1-2",
+    method: "click",
+    arguments: [] as string[],
+  };
+
+  const invalidInput = {
+    elementId: "1-2",
+    method: "invalidMethod",
+    arguments: [] as string[],
+  };
+
+  it("Object.values(SupportedUnderstudyAction) produces correct array for z.enum()", () => {
+    const enumValues = Object.values(
+      SupportedUnderstudyAction,
+    ) as unknown as readonly [string, ...string[]];
+
+    expect(enumValues).toContain("click");
+    expect(enumValues).toContain("fill");
+    expect(enumValues).toContain("type");
+    expect(enumValues).toContain("press");
+    expect(enumValues).toContain("scrollTo");
+    expect(enumValues).toContain("nextChunk");
+    expect(enumValues).toContain("prevChunk");
+    expect(enumValues).toContain("selectOptionFromDropdown");
+    expect(enumValues).toContain("hover");
+    expect(enumValues).toContain("doubleClick");
+    expect(enumValues).toContain("dragAndDrop");
+    expect(enumValues.length).toBe(11);
+  });
+
+  it("Zod v3 z.enum() with Object.values(SupportedUnderstudyAction) works correctly", () => {
+    const enumValues = Object.values(
+      SupportedUnderstudyAction,
+    ) as unknown as readonly [string, ...string[]];
+
+    const schema = z3.z.object({
+      elementId: z3.z.string(),
+      method: z3.z.enum(enumValues),
+      arguments: z3.z.array(z3.z.string()),
+    });
+
+    // Valid input should pass
+    const validResult = schema.safeParse(testInput);
+    expect(validResult.success).toBe(true);
+    if (validResult.success) {
+      expect(validResult.data.method).toBe("click");
+    }
+
+    // Invalid input should fail
+    const invalidResult = schema.safeParse(invalidInput);
+    expect(invalidResult.success).toBe(false);
+  });
+
+  it("Zod v4 z.enum() with Object.values(SupportedUnderstudyAction) works correctly", () => {
+    const enumValues = Object.values(
+      SupportedUnderstudyAction,
+    ) as unknown as readonly [string, ...string[]];
+
+    const schema = z4.object({
+      elementId: z4.string(),
+      method: z4.enum(enumValues),
+      arguments: z4.array(z4.string()),
+    });
+
+    // Valid input should pass
+    const validResult = schema.safeParse(testInput);
+    expect(validResult.success).toBe(true);
+    if (validResult.success) {
+      expect(validResult.data.method).toBe("click");
+    }
+
+    // Invalid input should fail
+    const invalidResult = schema.safeParse(invalidInput);
+    expect(invalidResult.success).toBe(false);
+  });
+
+  it("Zod v3 z.enum() with raw TypeScript enum throws error on parse", () => {
+    // This demonstrates the bug that PR #1613 would introduce
+    // In Zod v3, z.enum() does NOT accept TypeScript enums directly
+    // The schema creation might succeed, but parsing will fail
+
+    const schema = z3.z.object({
+      elementId: z3.z.string(),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      method: z3.z.enum(SupportedUnderstudyAction as any),
+      arguments: z3.z.array(z3.z.string()),
+    });
+
+    // This should throw an error because the enum is not iterable
+    expect(() => schema.safeParse(testInput)).toThrow("object is not iterable");
+  });
+
+  it("Zod v4 z.enum() with raw TypeScript enum works (but not v3 compatible)", () => {
+    // Zod v4 allows passing TypeScript enums directly to z.enum()
+    // But this approach is NOT backwards compatible with v3
+
+    const schema = z4.object({
+      elementId: z4.string(),
+      method: z4.enum(SupportedUnderstudyAction),
+      arguments: z4.array(z4.string()),
+    });
+
+    // In v4, this works fine
+    const validResult = schema.safeParse(testInput);
+    expect(validResult.success).toBe(true);
+  });
+
+  it("All SupportedUnderstudyAction values are valid enum options", () => {
+    const enumValues = Object.values(
+      SupportedUnderstudyAction,
+    ) as unknown as readonly [string, ...string[]];
+
+    // Test with both v3 and v4 schemas
+    const v3Schema = z3.z.enum(enumValues);
+    const v4Schema = z4.enum(enumValues);
+
+    for (const action of enumValues) {
+      expect(v3Schema.safeParse(action).success).toBe(true);
+      expect(v4Schema.safeParse(action).success).toBe(true);
+    }
+  });
+});
diff --git a/packages/core/tsconfig.json b/packages/core/tsconfig.json
new file mode 100644
index 000000000..2f7bf6dde
--- /dev/null
+++ b/packages/core/tsconfig.json
@@ -0,0 +1,21 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "../../",
+    "rootDir": ".",
+    "outDir": "./dist/esm",
+    "allowJs": true,
+    "paths": {
+      "@browserbasehq/stagehand": ["packages/core/lib/v3/index.ts"],
+      "@browserbasehq/stagehand/*": ["packages/core/lib/*"],
+      "*": ["node_modules/*", "packages/core/lib/types/*"],
+      "@/*": ["./*"]
+    }
+  },
+  "include": [
+    "lib/**/*.ts",
+    "tests/**/*.ts",
+    "lib/v3/cli.js"
+  ],
+  "exclude": ["node_modules", "dist", "lib/v3/dom/gen*.ts"]
+}
diff --git a/packages/core/vitest.cjs.config.mjs b/packages/core/vitest.cjs.config.mjs
new file mode 100644
index 000000000..272027953
--- /dev/null
+++ b/packages/core/vitest.cjs.config.mjs
@@ -0,0 +1,17 @@
+import { defineConfig } from "vitest/config";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const rootDir = path.dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      "@browserbasehq/stagehand": path.join(rootDir, "dist", "cjs", "index.js"),
+    },
+  },
+  test: {
+    environment: "node",
+    include: ["**/dist/cjs/tests/unit/**/*.test.js"],
+  },
+});
diff --git a/packages/core/vitest.config.ts b/packages/core/vitest.config.ts
new file mode 100644
index 000000000..e58b40314
--- /dev/null
+++ b/packages/core/vitest.config.ts
@@ -0,0 +1,17 @@
+import { defineConfig } from "vitest/config";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const rootDir = path.dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      "@browserbasehq/stagehand": path.join(rootDir, "dist", "esm", "index.js"),
+    },
+  },
+  test: {
+    environment: "node",
+    include: ["**/dist/esm/tests/unit/**/*.test.js"],
+  },
+});
diff --git a/packages/core/vitest.esm.config.mjs b/packages/core/vitest.esm.config.mjs
new file mode 100644
index 000000000..e58b40314
--- /dev/null
+++ b/packages/core/vitest.esm.config.mjs
@@ -0,0 +1,17 @@
+import { defineConfig } from "vitest/config";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const rootDir = path.dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      "@browserbasehq/stagehand": path.join(rootDir, "dist", "esm", "index.js"),
+    },
+  },
+  test: {
+    environment: "node",
+    include: ["**/dist/esm/tests/unit/**/*.test.js"],
+  },
+});
diff --git a/packages/docs/.gitignore b/packages/docs/.gitignore
new file mode 100644
index 000000000..7dfb1d142
--- /dev/null
+++ b/packages/docs/.gitignore
@@ -0,0 +1,3 @@
+node_modules
+downloads
+.DS_Store
\ No newline at end of file
diff --git a/packages/docs/README.md b/packages/docs/README.md
new file mode 100644
index 000000000..d81eb1df0
--- /dev/null
+++ b/packages/docs/README.md
@@ -0,0 +1,32 @@
+# Mintlify Starter Kit
+
+Click on `Use this template` to copy the Mintlify starter kit. The starter kit contains examples including
+
+- Guide pages
+- Navigation
+- Customizations
+- API Reference pages
+- Use of popular components
+
+### Development
+
+Install dependencies with pnpm
+
+```
+pnpm install
+```
+
+Run the following command at the root of your documentation (where mint.json is)
+
+```
+pnpm mintlify dev
+```
+
+### Publishing Changes
+
+Install our Github App to auto propagate changes from your repo to your deployment. Changes will be deployed to production automatically after pushing to the default branch. Find the link to install on your dashboard.
+
+#### Troubleshooting
+
+- Mintlify dev isn't running - Run `mintlify install` it'll re-install dependencies.
+- Page loads as a 404 - Make sure you are running in a folder with `mint.json`
diff --git a/packages/docs/docs.json b/packages/docs/docs.json
new file mode 100644
index 000000000..ff654bf3b
--- /dev/null
+++ b/packages/docs/docs.json
@@ -0,0 +1,476 @@
+{
+  "$schema": "https://mintlify.com/docs.json",
+  "theme": "willow",
+  "name": "🤘 Stagehand",
+  "colors": {
+    "primary": "#B88100",
+    "light": "#FFC83C",
+    "dark": "#FFC83C"
+  },
+  "favicon": "/images/favicon.svg",
+  "seo": {
+    "indexing": "all",
+    "metatags": {
+      "og:type": "website",
+      "og:site_name": "Stagehand Docs"
+    }
+  },
+  "openapi": "https://app.stainless.com/api/spec/documented/stagehand/openapi.documented.yml",
+  "navigation": {
+    "versions": [
+      {
+        "version": "v3",
+        "dropdowns": [
+          {
+            "dropdown": "TypeScript",
+            "icon": "code",
+            "pages": [
+              "v3/first-steps/introduction"
+            ],
+            "groups": [
+              {
+                "group": "First Steps",
+                "pages": [
+                  "v3/first-steps/introduction",
+                  "v3/first-steps/quickstart",
+                  "v3/first-steps/installation",
+                  "v3/first-steps/ai-rules"
+                ]
+              },
+              {
+                "group": "The Basics",
+                "pages": [
+                  "v3/basics/agent",
+                  "v3/basics/act",
+                  "v3/basics/extract",
+                  "v3/basics/observe",
+                  "v3/basics/evals"
+                ]
+              },
+              {
+                "group": "Configuration",
+                "pages": [
+                  "v3/configuration/browser",
+                  "v3/configuration/observability",
+                  "v3/configuration/logging",
+                  "v3/configuration/models"
+                ]
+              },
+              {
+                "group": "Best Practices",
+                "pages": [
+                  "v3/best-practices/caching",
+                  "v3/best-practices/cost-optimization",
+                  "v3/best-practices/deterministic-agent",
+                  "v3/best-practices/using-multiple-tabs",
+                  "v3/best-practices/deployments",
+                  "v3/best-practices/history",
+                  "v3/best-practices/computer-use",
+                  "v3/best-practices/agent-fallbacks",
+                  "v3/best-practices/prompting-best-practices",
+                  "v3/best-practices/mcp-integrations",
+                  "v3/best-practices/speed-optimization"
+                ]
+              },
+              {
+                "group": "Integrations",
+                "pages": [
+                  {
+                    "group": "MCP Server",
+                    "pages": [
+                      "v3/integrations/mcp/introduction",
+                      "v3/integrations/mcp/setup",
+                      "v3/integrations/mcp/tools",
+                      "v3/integrations/mcp/configuration"
+                    ]
+                  },
+                  {
+                    "group": "CrewAI",
+                    "pages": [
+                      "v3/integrations/crew-ai/introduction",
+                      "v3/integrations/crew-ai/configuration"
+                    ]
+                  },
+                  {
+                    "group": "Langchain",
+                    "pages": [
+                      "v3/integrations/langchain/introduction",
+                      "v3/integrations/langchain/configuration"
+                    ]
+                  },
+                  {
+                    "group": "Next.js + Vercel",
+                    "pages": [
+                      "v3/integrations/vercel/introduction",
+                      "v3/integrations/vercel/configuration"
+                    ]
+                  },
+                  {
+                    "group": "Convex",
+                    "pages": [
+                      "v3/integrations/convex/introduction",
+                      "v3/integrations/convex/configuration"
+                    ]
+                  },
+                  "v3/integrations/playwright",
+                  "v3/integrations/puppeteer",
+                  "v3/integrations/selenium"
+                ]
+              },
+              {
+                "group": "Reference",
+                "pages": [
+                  "v3/references/stagehand",
+                  "v3/references/agent",
+                  "v3/references/act",
+                  "v3/references/extract",
+                  "v3/references/observe",
+                  "v3/references/context",
+                  "v3/references/page",
+                  "v3/references/locator",
+                  "v3/references/deeplocator",
+                  "v3/references/response"
+                ]
+              },
+              {
+                "group": "Migration Guides",
+                "pages": [
+                  "v3/migrations/v2",
+                  "v3/migrations/python"
+                ]
+              }
+            ]
+          },
+          {
+            "dropdown": "Python",
+            "icon": "code",
+            "pages": [
+              "v3/sdk/python"
+            ],
+            "groups": [
+              {
+                "group": "SDK Reference",
+                "pages": [
+                  "v3/sdk/python"
+                ]
+              },
+              {
+                "group": "API Reference",
+                "openapi": {
+                  "source": "https://app.stainless.com/api/spec/documented/stagehand/openapi.documented.yml",
+                  "directory": "v3/api-reference/python"
+                },
+                "pages": [
+                  "POST /v1/sessions/start",
+                  "POST /v1/sessions/{id}/navigate",
+                  "POST /v1/sessions/{id}/act",
+                  "POST /v1/sessions/{id}/observe",
+                  "POST /v1/sessions/{id}/extract",
+                  "POST /v1/sessions/{id}/agentExecute",
+                  "POST /v1/sessions/{id}/end",
+                  "GET /v1/sessions/{id}/replay"
+                ]
+              }
+            ]
+          },
+          {
+            "dropdown": "Java",
+            "icon": "code",
+            "pages": [
+              "v3/sdk/java"
+            ],
+            "groups": [
+              {
+                "group": "SDK Reference",
+                "pages": [
+                  "v3/sdk/java"
+                ]
+              },
+              {
+                "group": "API Reference",
+                "openapi": {
+                  "source": "https://app.stainless.com/api/spec/documented/stagehand/openapi.documented.yml",
+                  "directory": "v3/api-reference/java"
+                },
+                "pages": [
+                  "POST /v1/sessions/start",
+                  "POST /v1/sessions/{id}/navigate",
+                  "POST /v1/sessions/{id}/act",
+                  "POST /v1/sessions/{id}/observe",
+                  "POST /v1/sessions/{id}/extract",
+                  "POST /v1/sessions/{id}/agentExecute",
+                  "POST /v1/sessions/{id}/end",
+                  "GET /v1/sessions/{id}/replay"
+                ]
+              }
+            ]
+          },
+          {
+            "dropdown": "Go",
+            "icon": "code",
+            "pages": [
+              "v3/sdk/go"
+            ],
+            "groups": [
+              {
+                "group": "SDK Reference",
+                "pages": [
+                  "v3/sdk/go"
+                ]
+              },
+              {
+                "group": "API Reference",
+                "openapi": {
+                  "source": "https://app.stainless.com/api/spec/documented/stagehand/openapi.documented.yml",
+                  "directory": "v3/api-reference/go"
+                },
+                "pages": [
+                  "POST /v1/sessions/start",
+                  "POST /v1/sessions/{id}/navigate",
+                  "POST /v1/sessions/{id}/act",
+                  "POST /v1/sessions/{id}/observe",
+                  "POST /v1/sessions/{id}/extract",
+                  "POST /v1/sessions/{id}/agentExecute",
+                  "POST /v1/sessions/{id}/end",
+                  "GET /v1/sessions/{id}/replay"
+                ]
+              }
+            ]
+          },
+          {
+            "dropdown": "Ruby",
+            "icon": "code",
+            "pages": [
+              "v3/sdk/ruby"
+            ],
+            "groups": [
+              {
+                "group": "SDK Reference",
+                "pages": [
+                  "v3/sdk/ruby"
+                ]
+              },
+              {
+                "group": "API Reference",
+                "openapi": {
+                  "source": "https://app.stainless.com/api/spec/documented/stagehand/openapi.documented.yml",
+                  "directory": "v3/api-reference/ruby"
+                },
+                "pages": [
+                  "POST /v1/sessions/start",
+                  "POST /v1/sessions/{id}/navigate",
+                  "POST /v1/sessions/{id}/act",
+                  "POST /v1/sessions/{id}/observe",
+                  "POST /v1/sessions/{id}/extract",
+                  "POST /v1/sessions/{id}/agentExecute",
+                  "POST /v1/sessions/{id}/end",
+                  "GET /v1/sessions/{id}/replay"
+                ]
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "version": "v2",
+        "groups": [
+          {
+            "group": "First Steps",
+            "pages": [
+              "v2/first-steps/introduction",
+              "v2/first-steps/quickstart",
+              "v2/first-steps/installation",
+              "v2/first-steps/ai-rules"
+            ]
+          },
+          {
+            "group": "The Basics",
+            "pages": [
+              "v2/basics/agent",
+              "v2/basics/act",
+              "v2/basics/extract",
+              "v2/basics/observe"
+            ]
+          },
+          {
+            "group": "Configuration",
+            "pages": [
+              "v2/configuration/browser",
+              "v2/configuration/observability",
+              "v2/configuration/logging",
+              "v2/configuration/models",
+              "v2/configuration/evals"
+            ]
+          },
+          {
+            "group": "Best Practices",
+            "pages": [
+              "v2/best-practices/caching",
+              "v2/best-practices/cost-optimization",
+              "v2/best-practices/using-multiple-tabs",
+              "v2/best-practices/working-with-iframes",
+              "v2/best-practices/deployments",
+              "v2/best-practices/computer-use",
+              "v2/best-practices/contributing",
+              "v2/best-practices/playwright-interop",
+              "v2/best-practices/build-agent",
+              "v2/best-practices/agent-fallbacks",
+              "v2/best-practices/prompting-best-practices",
+              "v2/best-practices/mcp-integrations",
+              "v2/best-practices/speed-optimization"
+            ]
+          },
+          {
+            "group": "Integrations",
+            "pages": [
+              {
+                "group": "MCP Server",
+                "pages": [
+                  "v2/integrations/mcp/introduction",
+                  "v2/integrations/mcp/setup",
+                  "v2/integrations/mcp/tools",
+                  "v2/integrations/mcp/configuration"
+                ]
+              },
+              {
+                "group": "CrewAI",
+                "pages": [
+                  "v2/integrations/crew-ai/introduction",
+                  "v2/integrations/crew-ai/configuration"
+                ]
+              },
+              {
+                "group": "Langchain",
+                "pages": [
+                  "v2/integrations/langchain/introduction",
+                  "v2/integrations/langchain/configuration"
+                ]
+              },
+              {
+                "group": "Next.js + Vercel",
+                "pages": [
+                  "v2/integrations/vercel/introduction",
+                  "v2/integrations/vercel/configuration"
+                ]
+              }
+            ]
+          },
+          {
+            "group": "Reference",
+            "pages": [
+              "v2/references/stagehand",
+              "v2/references/act",
+              "v2/references/extract",
+              "v2/references/observe",
+              "v2/references/agent"
+            ]
+          }
+        ]
+      }
+    ],
+    "global": {
+      "anchors": [
+        {
+          "anchor": "Discord",
+          "href": "https://stagehand.dev/discord",
+          "icon": "discord"
+        },
+        {
+          "anchor": "GitHub",
+          "href": "https://github.com/browserbase/stagehand",
+          "icon": "github"
+        },
+        {
+          "anchor": "Changelog",
+          "href": "https://github.com/browserbase/stagehand/releases",
+          "icon": "scroll"
+        }
+      ]
+    }
+  },
+  "logo": {
+    "light": "/logo/light_logo.png",
+    "dark": "/logo/dark_logo.png",
+    "href": "https://stagehand.dev"
+  },
+  "navbar": {
+    "links": [
+      {
+        "label": "Discord",
+        "href": "https://stagehand.dev/discord"
+      },
+      {
+        "label": "Support",
+        "href": "mailto:support@browserbase.com"
+      }
+    ]
+  },
+  "footer": {
+    "socials": {
+      "discord": "https://stagehand.dev/discord",
+      "x": "https://x.com/stagehanddev",
+      "github": "https://github.com/browserbase/stagehand",
+      "linkedin": "https://linkedin.com/company/browserbasehq"
+    }
+  },
+  "integrations": {
+    "posthog": {
+      "apiKey": "phc_hmwkFrlc9UVrdE1jyG8AEKoCQCSr8dScjsRpKoLBEiV",
+      "apiHost": "https://us.i.posthog.com"
+    }
+  },
+  "contextual": {
+    "options": [
+      "copy",
+      "chatgpt",
+      "claude",
+      "view"
+    ]
+  },
+  "redirects": [
+    {
+      "source": "/first-steps/:slug*",
+      "destination": "/v3/first-steps/:slug*"
+    },
+    {
+      "source": "/basics/:slug*",
+      "destination": "/v3/basics/:slug*"
+    },
+    {
+      "source": "/configuration/:slug*",
+      "destination": "/v3/configuration/:slug*"
+    },
+    {
+      "source": "/best-practices/:slug*",
+      "destination": "/v3/best-practices/:slug*"
+    },
+    {
+      "source": "/integrations/mcp/:slug*",
+      "destination": "/v3/integrations/mcp/:slug*"
+    },
+    {
+      "source": "/integrations/crew-ai/:slug*",
+      "destination": "/v3/integrations/crew-ai/:slug*"
+    },
+    {
+      "source": "/integrations/langchain/:slug*",
+      "destination": "/v3/integrations/langchain/:slug*"
+    },
+    {
+      "source": "/integrations/vercel/:slug*",
+      "destination": "/v3/integrations/vercel/:slug*"
+    },
+    {
+      "source": "/integrations/convex/:slug*",
+      "destination": "/v3/integrations/convex/:slug*"
+    },
+    {
+      "source": "/references/:slug*",
+      "destination": "/v3/references/:slug*"
+    },
+    {
+      "source": "/migrations/:slug*",
+      "destination": "/v3/migrations/:slug*"
+    }
+  ]
+}
diff --git a/packages/docs/favicon.svg b/packages/docs/favicon.svg
new file mode 100644
index 000000000..2d18ca7f1
--- /dev/null
+++ b/packages/docs/favicon.svg
@@ -0,0 +1,13 @@
+<svg width="40" height="40" viewBox="0 0 40 40" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_1005_777)">
+<rect width="40" height="40" fill="#FFC83C"/>
+<path d="M40 0H0V39.1042H40V0Z" fill="#FFC83C"/>
+<path d="M28.2317 10.1157C28.2317 8.86018 27.0391 7.83838 25.7836 7.83838C24.528 7.83838 23.4096 8.86018 23.4096 10.1157L23.4068 14.2225C23.0177 13.9776 22.56 13.8334 22.0673 13.8334C21.2554 13.8334 20.536 14.2183 20.0755 14.8132C19.6192 14.1707 18.8703 13.7508 18.0221 13.7508C17.5266 13.7508 17.0647 13.8964 16.6755 14.1441V12.61C16.6755 11.3545 15.4844 10.2305 14.2288 10.2305C12.9733 10.2305 11.6953 11.3545 11.6953 12.61V22.3927C11.6953 22.4977 11.7037 22.5999 11.7107 22.6545L11.7079 22.7735C11.7079 27.4542 15.1736 31.2628 19.8543 31.2628C27.0503 31.2628 28.2989 24.6995 28.2989 19.8256L28.2345 10.1143L28.2317 10.1157Z" fill="white"/>
+<path d="M28.2317 10.1157C28.2317 8.86018 27.0391 7.83838 25.7836 7.83838C24.528 7.83838 23.4096 8.86018 23.4096 10.1157L23.4068 14.2225C23.0177 13.9776 22.56 13.8334 22.0673 13.8334C21.2554 13.8334 20.536 14.2183 20.0755 14.8132C19.6192 14.1707 18.8703 13.7508 18.0221 13.7508C17.5266 13.7508 17.0647 13.8964 16.6755 14.1441V12.61C16.6755 11.3545 15.4844 10.2305 14.2288 10.2305C12.9733 10.2305 11.6953 11.3545 11.6953 12.61V22.3927C11.6953 22.4977 11.7037 22.5999 11.7107 22.6545L11.7079 22.7735C11.7079 27.4542 15.1736 31.2628 19.8543 31.2628C27.0503 31.2628 28.2989 24.6995 28.2989 19.8256L28.2345 10.1143L28.2317 10.1157ZM20.7306 16.3543C20.7306 15.6167 21.3296 15.0176 22.0673 15.0176C22.8049 15.0176 23.404 15.6167 23.404 16.3543V17.8408H21.6292C21.3128 17.8408 21.0105 17.9052 20.7306 18.0172V16.3543ZM16.6839 16.2717C16.6839 15.5341 17.283 14.935 18.0207 14.935C18.7583 14.935 19.3574 15.5341 19.3574 16.2717V18.1936C19.3574 18.9312 18.7569 19.5303 18.0207 19.5303C17.2844 19.5303 16.6839 18.9312 16.6839 18.1936V16.2717ZM26.9047 23.0198C26.9047 23.0198 26.9047 23.0268 26.9047 23.0296C26.6836 24.5175 26.2973 25.7871 25.7416 26.8173C24.5546 29.0218 22.6286 30.0926 19.8515 30.0926C15.9449 30.0926 12.8823 26.8845 12.8753 22.7875L12.8781 22.6825V22.5845L12.8683 22.5019C12.8669 22.4865 12.8627 22.4389 12.8627 22.3927V12.61C12.8627 12.0334 13.5765 11.4007 14.226 11.4007C14.8755 11.4007 15.5026 12.0222 15.5026 12.61V16.2143C15.5026 16.2339 15.4998 16.2521 15.4998 16.2717V18.1936C15.4998 19.5863 16.628 20.7145 18.0207 20.7145C18.477 20.7145 18.9011 20.5899 19.2706 20.3771C19.2706 20.3715 19.2706 20.3659 19.2706 20.3603C19.3196 20.8502 19.5212 21.3164 19.8557 21.6845C20.1889 22.0498 20.6298 22.2962 21.1071 22.3927C20.1315 23.1612 19.6038 24.26 19.6038 25.6037C19.6038 25.9271 19.8655 26.1888 20.1889 26.1888C20.5122 26.1888 20.7739 25.9271 20.7739 25.6037C20.7739 23.3418 22.7728 22.6559 23.9639 22.4487C24.5434 22.3479 24.5336 21.8944 24.5252 21.8049C24.521 21.7503 24.4622 21.2674 23.8729 21.2674H21.5536C21.2373 21.2674 20.9321 21.133 20.7194 20.8978C20.5024 20.6599 20.4016 20.3505 20.4324 20.0272C20.487 19.4575 21.0119 19.0124 21.6278 19.0124H24.4174C24.4552 19.0194 24.4944 19.0236 24.535 19.0236C25.3706 19.0236 25.9977 19.2616 26.398 19.7305C26.9621 20.3897 27.1371 21.5277 26.9033 23.0198H26.9047ZM24.7044 17.859C24.6666 17.8492 24.6274 17.845 24.5868 17.8436V16.3543C24.5868 16.3081 24.5826 16.2633 24.5798 16.2185V10.1157C24.5798 9.53625 25.1537 9.00995 25.7836 9.00995C26.4134 9.00995 27.0601 9.54745 27.0601 10.1241L27.1175 18.7926C26.5254 18.2048 25.715 17.8926 24.703 17.8604L24.7044 17.859Z" fill="black"/>
+</g>
+<defs>
+<clipPath id="clip0_1005_777">
+<rect width="40" height="40" fill="white"/>
+</clipPath>
+</defs>
+</svg>
diff --git a/packages/docs/images/CI.png b/packages/docs/images/CI.png
new file mode 100644
index 000000000..48726b4eb
Binary files /dev/null and b/packages/docs/images/CI.png differ
diff --git a/packages/docs/images/agent.gif b/packages/docs/images/agent.gif
new file mode 100644
index 000000000..e2889e0e8
Binary files /dev/null and b/packages/docs/images/agent.gif differ
diff --git a/packages/docs/images/checks-passed.png b/packages/docs/images/checks-passed.png
new file mode 100644
index 000000000..3303c7736
Binary files /dev/null and b/packages/docs/images/checks-passed.png differ
diff --git a/docs/media/chunks.png b/packages/docs/images/chunks.png
similarity index 100%
rename from docs/media/chunks.png
rename to packages/docs/images/chunks.png
diff --git a/packages/docs/images/claude-code-mcp.png b/packages/docs/images/claude-code-mcp.png
new file mode 100644
index 000000000..d4d8ba6fe
Binary files /dev/null and b/packages/docs/images/claude-code-mcp.png differ
diff --git a/packages/docs/images/dark_license.svg b/packages/docs/images/dark_license.svg
new file mode 100644
index 000000000..53cad9f27
--- /dev/null
+++ b/packages/docs/images/dark_license.svg
@@ -0,0 +1,11 @@
+<svg width="117" height="29" viewBox="0 0 117 29" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M3 0.5H74.5V28.5H3C1.61929 28.5 0.5 27.3807 0.5 26V3C0.5 1.61929 1.61929 0.5 3 0.5Z" fill="white"/>
+<path d="M3 0.5H74.5V28.5H3C1.61929 28.5 0.5 27.3807 0.5 26V3C0.5 1.61929 1.61929 0.5 3 0.5Z" stroke="#635943"/>
+<path d="M9.51914 9.06H10.7231V17.852H15.6791V19H9.51914V9.06ZM17.6337 17.964H20.6157V12.616H17.7737V11.58H21.7917V17.964H24.3537V19H17.6337V17.964ZM20.5037 9.046H21.7357V10.418H20.5037V9.046ZM29.3042 19.168C28.6229 19.168 28.0209 19.0093 27.4982 18.692C26.9849 18.3747 26.5882 17.922 26.3082 17.334C26.0282 16.746 25.8882 16.0647 25.8882 15.29C25.8882 14.5153 26.0282 13.834 26.3082 13.246C26.5882 12.658 26.9849 12.2053 27.4982 11.888C28.0209 11.5707 28.6229 11.412 29.3042 11.412C30.1349 11.412 30.8209 11.636 31.3622 12.084C31.9129 12.532 32.2629 13.1667 32.4122 13.988L31.1802 14.072C31.0682 13.5867 30.8442 13.2087 30.5082 12.938C30.1815 12.6673 29.7802 12.532 29.3042 12.532C28.6229 12.532 28.0862 12.7793 27.6942 13.274C27.3115 13.7593 27.1202 14.4313 27.1202 15.29C27.1202 16.1487 27.3115 16.8253 27.6942 17.32C28.0862 17.8053 28.6229 18.048 29.3042 18.048C29.7989 18.048 30.2142 17.9033 30.5502 17.614C30.8955 17.3247 31.1242 16.9093 31.2362 16.368L32.4682 16.452C32.3095 17.2827 31.9455 17.9453 31.3762 18.44C30.8162 18.9253 30.1255 19.168 29.3042 19.168ZM37.6287 19.168C36.9381 19.168 36.3361 19.0093 35.8227 18.692C35.3094 18.3747 34.9127 17.9267 34.6327 17.348C34.3621 16.76 34.2267 16.074 34.2267 15.29C34.2267 14.5153 34.3621 13.834 34.6327 13.246C34.9127 12.658 35.3047 12.2053 35.8087 11.888C36.3127 11.5707 36.9007 11.412 37.5727 11.412C38.2167 11.412 38.7861 11.566 39.2807 11.874C39.7847 12.1727 40.1721 12.616 40.4427 13.204C40.7227 13.792 40.8627 14.492 40.8627 15.304V15.654H35.4587C35.4961 16.438 35.7014 17.0353 36.0747 17.446C36.4574 17.8473 36.9754 18.048 37.6287 18.048C38.1047 18.048 38.4967 17.9407 38.8047 17.726C39.1221 17.502 39.3461 17.194 39.4767 16.802L40.7367 16.9C40.5407 17.5813 40.1627 18.132 39.6027 18.552C39.0521 18.9627 38.3941 19.168 37.6287 19.168ZM39.5747 14.618C39.5187 13.9273 39.3134 13.4093 38.9587 13.064C38.6041 12.7093 38.1421 12.532 37.5727 12.532C36.9941 12.532 36.5181 12.7093 36.1447 13.064C35.7807 13.4187 35.5521 13.9367 35.4587 14.618H39.5747ZM43.0413 11.58H44.1193L44.1473 12.91C44.3339 12.4153 44.6279 12.042 45.0293 11.79C45.4306 11.538 45.8973 11.412 46.4293 11.412C47.2413 11.412 47.8573 11.6733 48.2773 12.196C48.7066 12.7187 48.9213 13.3953 48.9213 14.226V19H47.7453V14.562C47.7453 13.862 47.6193 13.3347 47.3673 12.98C47.1246 12.6253 46.7279 12.448 46.1773 12.448C45.5893 12.448 45.1133 12.6347 44.7493 13.008C44.3946 13.372 44.2173 13.89 44.2173 14.562V19H43.0413V11.58ZM54.4318 19.168C53.8065 19.168 53.2558 19.0607 52.7798 18.846C52.3131 18.622 51.9445 18.3233 51.6738 17.95C51.4031 17.5673 51.2491 17.138 51.2118 16.662L52.4438 16.578C52.5185 17.0447 52.7238 17.4087 53.0598 17.67C53.3958 17.922 53.8531 18.048 54.4318 18.048C54.9918 18.048 55.4211 17.9687 55.7198 17.81C56.0185 17.642 56.1678 17.3947 56.1678 17.068C56.1678 16.844 56.1165 16.6667 56.0138 16.536C55.9111 16.396 55.7198 16.2793 55.4398 16.186C55.1691 16.0833 54.7585 15.9853 54.2078 15.892C53.4985 15.7707 52.9385 15.612 52.5278 15.416C52.1265 15.22 51.8371 14.982 51.6598 14.702C51.4918 14.422 51.4078 14.072 51.4078 13.652C51.4078 12.9893 51.6551 12.4527 52.1498 12.042C52.6445 11.622 53.3351 11.412 54.2218 11.412C55.0898 11.412 55.7758 11.636 56.2798 12.084C56.7931 12.532 57.1105 13.1013 57.2318 13.792L55.9998 13.876C55.9158 13.4653 55.7151 13.1387 55.3978 12.896C55.0898 12.6533 54.6931 12.532 54.2078 12.532C53.6851 12.532 53.2885 12.6347 53.0178 12.84C52.7471 13.0453 52.6118 13.316 52.6118 13.652C52.6118 13.904 52.6725 14.1047 52.7938 14.254C52.9151 14.394 53.1018 14.5107 53.3538 14.604C53.6151 14.688 53.9838 14.772 54.4598 14.856C55.2251 14.9773 55.8178 15.1313 56.2378 15.318C56.6578 15.5047 56.9518 15.738 57.1198 16.018C57.2878 16.2887 57.3718 16.6387 57.3718 17.068C57.3718 17.712 57.0965 18.2253 56.5458 18.608C55.9951 18.9813 55.2905 19.168 54.4318 19.168ZM62.8123 19.168C62.1217 19.168 61.5197 19.0093 61.0063 18.692C60.493 18.3747 60.0963 17.9267 59.8163 17.348C59.5457 16.76 59.4103 16.074 59.4103 15.29C59.4103 14.5153 59.5457 13.834 59.8163 13.246C60.0963 12.658 60.4883 12.2053 60.9923 11.888C61.4963 11.5707 62.0843 11.412 62.7563 11.412C63.4003 11.412 63.9697 11.566 64.4643 11.874C64.9683 12.1727 65.3557 12.616 65.6263 13.204C65.9063 13.792 66.0463 14.492 66.0463 15.304V15.654H60.6423C60.6797 16.438 60.885 17.0353 61.2583 17.446C61.641 17.8473 62.159 18.048 62.8123 18.048C63.2883 18.048 63.6803 17.9407 63.9883 17.726C64.3057 17.502 64.5297 17.194 64.6603 16.802L65.9203 16.9C65.7243 17.5813 65.3463 18.132 64.7863 18.552C64.2357 18.9627 63.5777 19.168 62.8123 19.168ZM64.7583 14.618C64.7023 13.9273 64.497 13.4093 64.1423 13.064C63.7877 12.7093 63.3257 12.532 62.7563 12.532C62.1777 12.532 61.7017 12.7093 61.3283 13.064C60.9643 13.4187 60.7357 13.9367 60.6423 14.618H64.7583Z" fill="#100D0D"/>
+<mask id="path-3-inside-1_2074_1452" fill="white">
+<path d="M75 0H114C115.657 0 117 1.34315 117 3V26C117 27.6569 115.657 29 114 29H75V0Z"/>
+</mask>
+<path d="M75 0H114C115.657 0 117 1.34315 117 3V26C117 27.6569 115.657 29 114 29H75V0Z" fill="#FFDC83"/>
+<path d="M75 -1H114C116.209 -1 118 0.790861 118 3H116C116 1.89543 115.105 1 114 1H75V-1ZM118 26C118 28.2091 116.209 30 114 30H75V28H114C115.105 28 116 27.1046 116 26H118ZM75 29V0V29ZM114 -1C116.209 -1 118 0.790861 118 3V26C118 28.2091 116.209 30 114 30V28C115.105 28 116 27.1046 116 26V3C116 1.89543 115.105 1 114 1V-1Z" fill="#635943" mask="url(#path-3-inside-1_2074_1452)"/>
+<path d="M85.044 10.67V19H83.84V9.06H85.66L87.2 15.976L88.74 9.06H90.56V19H89.356V10.67L87.732 17.88H86.668L85.044 10.67ZM92.5145 17.852H94.9925V10.208H92.5145V9.06H98.6745V10.208H96.1965V17.852H98.6745V19H92.5145V17.852ZM103.387 10.208H100.349V9.06H107.629V10.208H104.591V19H103.387V10.208Z" fill="#100D0D"/>
+</svg>
diff --git a/packages/docs/images/dark_npm.svg b/packages/docs/images/dark_npm.svg
new file mode 100644
index 000000000..346fdbcb7
--- /dev/null
+++ b/packages/docs/images/dark_npm.svg
@@ -0,0 +1,11 @@
+<svg width="109" height="29" viewBox="0 0 109 29" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M3 0.5H41.5V28.5H3C1.61929 28.5 0.5 27.3807 0.5 26V3C0.5 1.61929 1.61929 0.5 3 0.5Z" fill="white"/>
+<path d="M3 0.5H41.5V28.5H3C1.61929 28.5 0.5 27.3807 0.5 26V3C0.5 1.61929 1.61929 0.5 3 0.5Z" stroke="#635943"/>
+<path d="M9.7522 11.58H10.8302L10.8582 12.91C11.0449 12.4153 11.3389 12.042 11.7402 11.79C12.1415 11.538 12.6082 11.412 13.1402 11.412C13.9522 11.412 14.5682 11.6733 14.9882 12.196C15.4175 12.7187 15.6322 13.3953 15.6322 14.226V19H14.4562V14.562C14.4562 13.862 14.3302 13.3347 14.0782 12.98C13.8355 12.6253 13.4389 12.448 12.8882 12.448C12.3002 12.448 11.8242 12.6347 11.4602 13.008C11.1055 13.372 10.9282 13.89 10.9282 14.562V19H9.7522V11.58ZM17.9227 11.58H19.0147L19.0287 12.77C19.2527 12.3313 19.5607 11.9953 19.9527 11.762C20.3541 11.5287 20.8067 11.412 21.3107 11.412C22.0201 11.412 22.6127 11.5893 23.0887 11.944C23.5647 12.2893 23.9194 12.756 24.1527 13.344C24.3861 13.932 24.5027 14.5807 24.5027 15.29C24.5027 15.9993 24.3861 16.648 24.1527 17.236C23.9194 17.824 23.5647 18.2953 23.0887 18.65C22.6127 18.9953 22.0201 19.168 21.3107 19.168C20.8254 19.168 20.3821 19.0653 19.9807 18.86C19.5887 18.6547 19.2947 18.3747 19.0987 18.02V21.1H17.9227V11.58ZM21.1987 18.048C21.8427 18.048 22.3467 17.8053 22.7107 17.32C23.0841 16.8347 23.2707 16.158 23.2707 15.29C23.2707 14.422 23.0841 13.7453 22.7107 13.26C22.3467 12.7747 21.8427 12.532 21.1987 12.532C20.5454 12.532 20.0321 12.77 19.6587 13.246C19.2854 13.7127 19.0987 14.394 19.0987 15.29C19.0987 16.186 19.2807 16.872 19.6447 17.348C20.0181 17.8147 20.5361 18.048 21.1987 18.048ZM25.7573 11.58H26.8353L26.8633 12.672C26.9939 12.2707 27.1853 11.9627 27.4373 11.748C27.6893 11.524 27.9879 11.412 28.3333 11.412C29.0986 11.412 29.5653 11.8973 29.7333 12.868C29.8546 12.4107 30.0553 12.056 30.3353 11.804C30.6153 11.5427 30.9466 11.412 31.3293 11.412C31.9266 11.412 32.3606 11.622 32.6313 12.042C32.9019 12.462 33.0373 13.148 33.0373 14.1V19H31.8613V14.24C31.8613 13.596 31.7913 13.1387 31.6513 12.868C31.5113 12.588 31.2919 12.448 30.9933 12.448C30.6853 12.448 30.4379 12.602 30.2513 12.91C30.0739 13.2087 29.9853 13.6613 29.9853 14.268V19H28.8093V14.24C28.8093 13.6053 28.7393 13.148 28.5993 12.868C28.4686 12.588 28.2493 12.448 27.9413 12.448C27.6333 12.448 27.3859 12.602 27.1993 12.91C27.0219 13.2087 26.9333 13.6613 26.9333 14.268V19H25.7573V11.58Z" fill="#100D0D"/>
+<mask id="path-3-inside-1_2074_1447" fill="white">
+<path d="M42 0H106C107.657 0 109 1.34315 109 3V26C109 27.6569 107.657 29 106 29H42V0Z"/>
+</mask>
+<path d="M42 0H106C107.657 0 109 1.34315 109 3V26C109 27.6569 107.657 29 106 29H42V0Z" fill="#FFDC83"/>
+<path d="M42 -1H106C108.209 -1 110 0.790861 110 3H108C108 1.89543 107.105 1 106 1H42V-1ZM110 26C110 28.2091 108.209 30 106 30H42V28H106C107.105 28 108 27.1046 108 26H110ZM42 29V0V29ZM106 -1C108.209 -1 110 0.790861 110 3V26C110 28.2091 108.209 30 106 30V28C107.105 28 108 27.1046 108 26V3C108 1.89543 107.105 1 106 1V-1Z" fill="#635943" mask="url(#path-3-inside-1_2074_1447)"/>
+<path d="M50.756 11.58H52.044L54.2 17.796L56.356 11.58H57.644L54.942 19H53.458L50.756 11.58ZM59.2345 17.852H62.3705V11.636H59.7665V10.6H61.1105C61.6425 10.6 62.0205 10.4833 62.2445 10.25C62.4779 10.0167 62.5945 9.62 62.5945 9.06H63.5745V17.852H65.9545V19H59.2345V17.852ZM70.1491 17.32H71.8291V19H70.1491V17.32ZM79.3556 19.224C78.4036 19.224 77.6289 18.972 77.0316 18.468C76.4343 17.9547 76.0983 17.278 76.0236 16.438L77.2836 16.354C77.3489 16.9047 77.5636 17.3247 77.9276 17.614C78.2916 17.9033 78.7676 18.048 79.3556 18.048C80.0089 18.048 80.5269 17.8473 80.9096 17.446C81.2923 17.0447 81.4836 16.4987 81.4836 15.808C81.4836 15.108 81.2969 14.5573 80.9236 14.156C80.5503 13.7453 80.0369 13.54 79.3836 13.54C78.9823 13.54 78.6043 13.638 78.2496 13.834C77.8949 14.03 77.6383 14.3007 77.4796 14.646H76.1916L76.8496 9.06H82.1416V10.236H77.9556L77.5916 13.232C77.8249 12.9613 78.1189 12.756 78.4736 12.616C78.8283 12.4667 79.1876 12.392 79.5516 12.392C80.1769 12.392 80.7323 12.5413 81.2176 12.84C81.7029 13.1293 82.0763 13.5353 82.3376 14.058C82.6083 14.5713 82.7436 15.1547 82.7436 15.808C82.7436 16.4707 82.5989 17.0633 82.3096 17.586C82.0203 18.0993 81.6189 18.5007 81.1056 18.79C80.5923 19.0793 80.0089 19.224 79.3556 19.224ZM86.9381 17.32H88.6181V19H86.9381V17.32ZM96.1727 19.224C95.454 19.224 94.8333 19.0187 94.3107 18.608C93.788 18.188 93.382 17.5907 93.0927 16.816C92.8127 16.032 92.6727 15.108 92.6727 14.044C92.6727 12.98 92.8127 12.056 93.0927 11.272C93.382 10.488 93.788 9.886 94.3107 9.466C94.8427 9.046 95.4633 8.836 96.1727 8.836C96.882 8.836 97.498 9.046 98.0207 9.466C98.5527 9.886 98.9587 10.488 99.2387 11.272C99.528 12.056 99.6727 12.98 99.6727 14.044C99.6727 15.108 99.528 16.032 99.2387 16.816C98.9587 17.5907 98.5573 18.188 98.0347 18.608C97.512 19.0187 96.8913 19.224 96.1727 19.224ZM96.1727 18.048C96.8727 18.048 97.4187 17.6887 97.8107 16.97C98.212 16.2513 98.4127 15.276 98.4127 14.044C98.4127 13.1013 98.296 12.3033 98.0627 11.65L94.8707 17.46C95.2347 17.852 95.6687 18.048 96.1727 18.048ZM93.9327 14.044C93.9327 14.9773 94.0493 15.7707 94.2827 16.424L97.4747 10.614C97.12 10.2127 96.686 10.012 96.1727 10.012C95.4727 10.012 94.922 10.376 94.5207 11.104C94.1287 11.8227 93.9327 12.8027 93.9327 14.044Z" fill="#100D0D"/>
+</svg>
diff --git a/packages/docs/images/dark_slack.svg b/packages/docs/images/dark_slack.svg
new file mode 100644
index 000000000..b04096033
--- /dev/null
+++ b/packages/docs/images/dark_slack.svg
@@ -0,0 +1,27 @@
+<svg width="254" height="29" viewBox="0 0 254 29" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M3 0.5H85.5V28.5H3C1.61929 28.5 0.5 27.3807 0.5 26V3C0.5 1.61929 1.61929 0.5 3 0.5Z" fill="white"/>
+<path d="M3 0.5H85.5V28.5H3C1.61929 28.5 0.5 27.3807 0.5 26V3C0.5 1.61929 1.61929 0.5 3 0.5Z" stroke="#635943"/>
+<g clip-path="url(#clip0_2074_1457)">
+<mask id="mask0_2074_1457" style="mask-type:luminance" maskUnits="userSpaceOnUse" x="12" y="6" width="16" height="17">
+<path d="M28 6.5H12V22.5H28V6.5Z" fill="white"/>
+</mask>
+<g mask="url(#mask0_2074_1457)">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M17.8406 6.53941C17.6312 6.5396 17.4239 6.58104 17.2305 6.66137C17.0371 6.74169 16.8614 6.85932 16.7135 7.00754C16.5656 7.15576 16.4483 7.33167 16.3684 7.52521C16.2885 7.71876 16.2475 7.92615 16.2477 8.13555C16.2475 8.34493 16.2886 8.55229 16.3685 8.74581C16.4484 8.93932 16.5657 9.11519 16.7136 9.26338C16.8616 9.41157 17.0372 9.52917 17.2306 9.60947C17.4239 9.68978 17.6312 9.73121 17.8406 9.73141H19.4335V8.13555C19.4337 7.92615 19.3927 7.71876 19.3128 7.52521C19.2329 7.33167 19.1156 7.15576 18.9677 7.00754C18.8197 6.85932 18.6441 6.74169 18.4507 6.66137C18.2573 6.58104 18.05 6.5396 17.8406 6.53941ZM17.8406 10.7957H13.5929C13.3835 10.7959 13.1762 10.8373 12.9829 10.9176C12.7895 10.9979 12.6138 11.1155 12.4659 11.2637C12.318 11.4119 12.2007 11.5878 12.1208 11.7813C12.0409 11.9748 11.9998 12.1822 12 12.3916C11.9998 12.601 12.0408 12.8084 12.1207 13.0019C12.2006 13.1955 12.3179 13.3713 12.4658 13.5196C12.6137 13.6678 12.7894 13.7854 12.9828 13.8657C13.1762 13.9461 13.3835 13.9875 13.5929 13.9877H17.8406C18.05 13.9875 18.2573 13.9461 18.4507 13.8657C18.6441 13.7854 18.8197 13.6678 18.9677 13.5196C19.1156 13.3713 19.2329 13.1955 19.3128 13.0019C19.3927 12.8084 19.4337 12.601 19.4335 12.3916C19.4337 12.1822 19.3926 11.9748 19.3127 11.7813C19.2327 11.5878 19.1155 11.4119 18.9675 11.2637C18.8197 11.1155 18.644 10.9979 18.4506 10.9176C18.2573 10.8373 18.05 10.7959 17.8406 10.7957Z" fill="#100D0D"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M27.9286 12.3916C27.9288 12.1822 27.8877 11.9748 27.8078 11.7813C27.7279 11.5878 27.6106 11.4119 27.4627 11.2637C27.3147 11.1155 27.1391 10.9979 26.9457 10.9176C26.7523 10.8373 26.5451 10.7959 26.3357 10.7957C26.1263 10.7959 25.9191 10.8373 25.7257 10.9176C25.5323 10.9979 25.3567 11.1155 25.2087 11.2637C25.0608 11.4119 24.9435 11.5878 24.8636 11.7813C24.7837 11.9748 24.7426 12.1822 24.7428 12.3916V13.9877H26.3357C26.5451 13.9875 26.7524 13.9461 26.9458 13.8657C27.1392 13.7854 27.3149 13.6678 27.4627 13.5196C27.6107 13.3713 27.7279 13.1955 27.8079 13.0019C27.8878 12.8084 27.9288 12.601 27.9286 12.3916ZM23.6809 12.3916V8.13555C23.6811 7.92615 23.6401 7.71876 23.5602 7.52521C23.4803 7.33167 23.363 7.15576 23.2151 7.00754C23.0671 6.85932 22.8915 6.74169 22.6981 6.66137C22.5047 6.58104 22.2974 6.5396 22.088 6.53941C21.8786 6.5396 21.6713 6.58104 21.4779 6.66137C21.2845 6.74169 21.1089 6.85932 20.9609 7.00754C20.813 7.15576 20.6957 7.33167 20.6158 7.52521C20.5359 7.71876 20.4949 7.92615 20.4951 8.13555V12.3916C20.4949 12.601 20.5359 12.8084 20.6158 13.0019C20.6957 13.1955 20.813 13.3713 20.9609 13.5196C21.1089 13.6678 21.2845 13.7854 21.4779 13.8657C21.6713 13.9461 21.8786 13.9875 22.088 13.9877C22.2974 13.9875 22.5047 13.9461 22.6981 13.8657C22.8915 13.7854 23.0671 13.6678 23.2151 13.5196C23.363 13.3713 23.4803 13.1955 23.5602 13.0019C23.6401 12.8084 23.6811 12.601 23.6809 12.3916Z" fill="#100D0D"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M22.088 22.5C22.2974 22.4998 22.5047 22.4583 22.6981 22.3781C22.8915 22.2977 23.0671 22.1801 23.2151 22.0319C23.363 21.8837 23.4803 21.7077 23.5602 21.5142C23.6401 21.3207 23.6811 21.1133 23.6809 20.9039C23.6811 20.6945 23.6401 20.4871 23.5601 20.2936C23.4801 20.1001 23.3629 19.9242 23.2149 19.776C23.0671 19.6279 22.8914 19.5103 22.698 19.4299C22.5047 19.3496 22.2974 19.3082 22.088 19.308H20.4951V20.9039C20.4949 21.1133 20.5359 21.3207 20.6158 21.5142C20.6957 21.7077 20.813 21.8837 20.9609 22.0319C21.1089 22.1801 21.2845 22.2977 21.4779 22.3781C21.6713 22.4583 21.8786 22.4998 22.088 22.5ZM22.088 18.2437H26.3357C26.5451 18.2435 26.7523 18.2021 26.9457 18.1218C27.1391 18.0415 27.3147 17.9239 27.4627 17.7757C27.6106 17.6275 27.7279 17.4516 27.8078 17.2581C27.8877 17.0646 27.9288 16.8572 27.9286 16.6479C27.9288 16.4385 27.8878 16.2311 27.8079 16.0375C27.7279 15.8439 27.6107 15.6681 27.4627 15.5199C27.3149 15.3716 27.1392 15.254 26.9458 15.1737C26.7524 15.0933 26.5451 15.0519 26.3357 15.0517H22.088C21.8786 15.0519 21.6713 15.0933 21.4779 15.1737C21.2845 15.254 21.1089 15.3716 20.9609 15.5199C20.813 15.6681 20.6957 15.8439 20.6158 16.0375C20.5359 16.2311 20.4949 16.4385 20.4951 16.6479C20.4949 16.8572 20.5359 17.0646 20.6159 17.2581C20.6959 17.4516 20.8131 17.6275 20.9611 17.7757C21.1089 17.9239 21.2846 18.0415 21.478 18.1218C21.6713 18.2021 21.8786 18.2435 22.088 18.2437Z" fill="#100D0D"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M12 16.6479C11.9998 16.8572 12.0409 17.0646 12.1208 17.2581C12.2007 17.4516 12.318 17.6275 12.4659 17.7757C12.6138 17.9239 12.7895 18.0415 12.9829 18.1218C13.1762 18.2021 13.3835 18.2435 13.5929 18.2437C13.8023 18.2435 14.0096 18.2021 14.2029 18.1218C14.3963 18.0415 14.5719 17.9239 14.7198 17.7757C14.8678 17.6275 14.985 17.4516 15.065 17.2581C15.1449 17.0646 15.186 16.8572 15.1858 16.6479V15.0517H13.5929C13.3835 15.0519 13.1761 15.0933 12.9827 15.1737C12.7893 15.254 12.6136 15.3717 12.4657 15.5199C12.3178 15.6682 12.2005 15.8441 12.1206 16.0377C12.0407 16.2313 11.9997 16.4384 12 16.6479ZM16.2477 16.6479V20.9039C16.2475 21.1133 16.2885 21.3207 16.3684 21.5142C16.4483 21.7077 16.5656 21.8837 16.7135 22.0319C16.8615 22.1801 17.0371 22.2977 17.2305 22.3781C17.4239 22.4583 17.6312 22.4998 17.8406 22.5C18.05 22.4998 18.2573 22.4583 18.4507 22.3781C18.6441 22.2977 18.8197 22.1801 18.9677 22.0319C19.1156 21.8837 19.2329 21.7077 19.3128 21.5142C19.3927 21.3207 19.4337 21.1133 19.4335 20.9039V16.6481C19.4337 16.4387 19.3927 16.2313 19.3128 16.0378C19.2329 15.8443 19.1156 15.6683 18.9677 15.5201C18.8197 15.3719 18.6441 15.2543 18.4507 15.1739C18.2573 15.0937 18.05 15.0522 17.8406 15.052C17.6312 15.0522 17.4239 15.0937 17.2305 15.1739C17.0371 15.2543 16.8615 15.3719 16.7135 15.5201C16.5656 15.6683 16.4483 15.8443 16.3684 16.0378C16.2885 16.2313 16.2475 16.4385 16.2477 16.6479Z" fill="#100D0D"/>
+</g>
+</g>
+<path d="M36.3677 19.224C35.677 19.224 35.0563 19.084 34.5057 18.804C33.9643 18.5147 33.5303 18.1133 33.2037 17.6C32.877 17.0867 32.6857 16.494 32.6297 15.822L33.8897 15.738C33.983 16.4753 34.249 17.0447 34.6877 17.446C35.1263 17.8473 35.6957 18.048 36.3957 18.048C37.0863 18.048 37.6137 17.9173 37.9777 17.656C38.351 17.3947 38.5377 17.0213 38.5377 16.536C38.5377 16.2 38.463 15.92 38.3137 15.696C38.1643 15.4627 37.889 15.2433 37.4877 15.038C37.0957 14.8327 36.517 14.6227 35.7517 14.408C35.0423 14.2027 34.4777 13.9833 34.0577 13.75C33.647 13.5167 33.3437 13.2367 33.1477 12.91C32.961 12.574 32.8677 12.1587 32.8677 11.664C32.8677 11.1133 32.9983 10.6233 33.2597 10.194C33.5303 9.76467 33.913 9.43333 34.4077 9.2C34.9117 8.95733 35.4997 8.836 36.1717 8.836C37.161 8.836 37.9543 9.13 38.5517 9.718C39.149 10.2967 39.5037 11.0573 39.6157 12L38.3557 12.084C38.2717 11.4493 38.043 10.9453 37.6697 10.572C37.2963 10.1987 36.7877 10.012 36.1437 10.012C35.5277 10.012 35.0377 10.1613 34.6737 10.46C34.3097 10.7493 34.1277 11.132 34.1277 11.608C34.1277 11.9253 34.193 12.182 34.3237 12.378C34.4637 12.574 34.697 12.7467 35.0237 12.896C35.3597 13.0453 35.8543 13.2133 36.5077 13.4C37.329 13.6333 37.973 13.89 38.4397 14.17C38.9157 14.4407 39.261 14.7673 39.4757 15.15C39.6903 15.5327 39.7977 16.004 39.7977 16.564C39.7977 17.0773 39.653 17.5393 39.3637 17.95C39.0743 18.3513 38.6683 18.664 38.1457 18.888C37.6323 19.112 37.0397 19.224 36.3677 19.224ZM44.5102 11.048C44.5102 10.7493 44.4262 10.516 44.2582 10.348C44.0902 10.18 43.8569 10.096 43.5582 10.096H41.8082V9.06H43.6142C44.2955 9.06 44.8089 9.23733 45.1542 9.592C45.5089 9.93733 45.6862 10.4507 45.6862 11.132V17.964H48.2482V19H41.5282V17.964H44.5102V11.048ZM52.0227 19.168C51.3134 19.168 50.7254 18.9813 50.2587 18.608C49.7921 18.2347 49.5587 17.7493 49.5587 17.152C49.5587 16.5267 49.7454 16.0367 50.1187 15.682C50.4921 15.3273 51.0894 15.0707 51.9107 14.912L54.4027 14.408C54.4027 13.7827 54.2627 13.316 53.9827 13.008C53.7027 12.6907 53.2921 12.532 52.7507 12.532C52.2467 12.532 51.8454 12.644 51.5467 12.868C51.2574 13.092 51.0567 13.4233 50.9447 13.862L49.6987 13.764C49.8387 13.0453 50.1747 12.476 50.7067 12.056C51.2481 11.6267 51.9294 11.412 52.7507 11.412C53.6467 11.412 54.3421 11.6827 54.8367 12.224C55.3314 12.756 55.5787 13.4933 55.5787 14.436V17.516C55.5787 17.684 55.6114 17.8007 55.6767 17.866C55.7514 17.9313 55.8681 17.964 56.0267 17.964H56.5027V19C56.3534 19.0187 56.1481 19.028 55.8867 19.028C55.4761 19.028 55.1494 18.944 54.9067 18.776C54.6734 18.5987 54.5194 18.3233 54.4447 17.95C54.2394 18.314 53.9174 18.608 53.4787 18.832C53.0401 19.056 52.5547 19.168 52.0227 19.168ZM52.1347 18.132C52.8721 18.132 53.4321 17.9453 53.8147 17.572C54.2067 17.1987 54.4027 16.6947 54.4027 16.06V15.416L52.1347 15.864C51.6401 15.9573 51.2901 16.0973 51.0847 16.284C50.8887 16.4707 50.7907 16.7227 50.7907 17.04C50.7907 17.3853 50.9074 17.656 51.1407 17.852C51.3834 18.0387 51.7147 18.132 52.1347 18.132ZM61.5933 19.168C60.9119 19.168 60.3099 19.0093 59.7873 18.692C59.2739 18.3747 58.8773 17.922 58.5973 17.334C58.3173 16.746 58.1773 16.0647 58.1773 15.29C58.1773 14.5153 58.3173 13.834 58.5973 13.246C58.8773 12.658 59.2739 12.2053 59.7873 11.888C60.3099 11.5707 60.9119 11.412 61.5933 11.412C62.4239 11.412 63.1099 11.636 63.6513 12.084C64.2019 12.532 64.5519 13.1667 64.7013 13.988L63.4693 14.072C63.3573 13.5867 63.1333 13.2087 62.7973 12.938C62.4706 12.6673 62.0693 12.532 61.5933 12.532C60.9119 12.532 60.3753 12.7793 59.9833 13.274C59.6006 13.7593 59.4093 14.4313 59.4093 15.29C59.4093 16.1487 59.6006 16.8253 59.9833 17.32C60.3753 17.8053 60.9119 18.048 61.5933 18.048C62.0879 18.048 62.5033 17.9033 62.8393 17.614C63.1846 17.3247 63.4133 16.9093 63.5253 16.368L64.7573 16.452C64.5986 17.2827 64.2346 17.9453 63.6653 18.44C63.1053 18.9253 62.4146 19.168 61.5933 19.168ZM66.8518 9.06H68.0278V15.57L71.6398 11.58H73.2078L70.2818 14.73L73.3478 19H71.9198L69.4838 15.528L68.0278 17.068V19H66.8518V9.06Z" fill="#100D0D"/>
+<mask id="path-8-inside-1_2074_1457" fill="white">
+<path d="M86 0H251C252.657 0 254 1.34315 254 3V26C254 27.6569 252.657 29 251 29H86V0Z"/>
+</mask>
+<path d="M86 0H251C252.657 0 254 1.34315 254 3V26C254 27.6569 252.657 29 251 29H86V0Z" fill="#FFDC83"/>
+<path d="M86 -1H251C253.209 -1 255 0.790861 255 3H253C253 1.89543 252.105 1 251 1H86V-1ZM255 26C255 28.2091 253.209 30 251 30H86V28H251C252.105 28 253 27.1046 253 26H255ZM86 29V0V29ZM251 -1C253.209 -1 255 0.790861 255 3V26C255 28.2091 253.209 30 251 30V28C252.105 28 253 27.1046 253 26V3C253 1.89543 252.105 1 251 1V-1Z" fill="#635943" mask="url(#path-8-inside-1_2074_1457)"/>
+<path d="M97.85 19.224C96.8607 19.224 96.072 18.9113 95.484 18.286C94.896 17.6607 94.588 16.8253 94.56 15.78L95.736 15.668C95.764 16.48 95.9507 17.082 96.296 17.474C96.6413 17.8567 97.1593 18.048 97.85 18.048C99.2407 18.048 99.936 17.2547 99.936 15.668V9.06H101.14V15.668C101.14 16.7693 100.841 17.6373 100.244 18.272C99.656 18.9067 98.858 19.224 97.85 19.224ZM106.595 19.168C105.913 19.168 105.316 19.0093 104.803 18.692C104.299 18.3747 103.907 17.9267 103.627 17.348C103.347 16.76 103.207 16.074 103.207 15.29C103.207 14.506 103.347 13.8247 103.627 13.246C103.907 12.658 104.299 12.2053 104.803 11.888C105.316 11.5707 105.913 11.412 106.595 11.412C107.267 11.412 107.859 11.5707 108.373 11.888C108.886 12.2053 109.283 12.658 109.563 13.246C109.843 13.8247 109.983 14.506 109.983 15.29C109.983 16.074 109.843 16.76 109.563 17.348C109.283 17.9267 108.886 18.3747 108.373 18.692C107.859 19.0093 107.267 19.168 106.595 19.168ZM106.595 18.048C107.276 18.048 107.803 17.8053 108.177 17.32C108.559 16.8253 108.751 16.1487 108.751 15.29C108.751 14.4313 108.559 13.7593 108.177 13.274C107.803 12.7793 107.276 12.532 106.595 12.532C105.913 12.532 105.381 12.7747 104.999 13.26C104.625 13.7453 104.439 14.422 104.439 15.29C104.439 16.158 104.625 16.8347 104.999 17.32C105.381 17.8053 105.913 18.048 106.595 18.048ZM111.909 17.964H114.891V12.616H112.049V11.58H116.067V17.964H118.629V19H111.909V17.964ZM114.779 9.046H116.011V10.418H114.779V9.046ZM120.528 11.58H121.606L121.634 12.91C121.82 12.4153 122.114 12.042 122.516 11.79C122.917 11.538 123.384 11.412 123.916 11.412C124.728 11.412 125.344 11.6733 125.764 12.196C126.193 12.7187 126.408 13.3953 126.408 14.226V19H125.232V14.562C125.232 13.862 125.106 13.3347 124.854 12.98C124.611 12.6253 124.214 12.448 123.664 12.448C123.076 12.448 122.6 12.6347 122.236 13.008C121.881 13.372 121.704 13.89 121.704 14.562V19H120.528V11.58ZM140.173 19.168C139.491 19.168 138.894 19.0093 138.381 18.692C137.877 18.3747 137.485 17.9267 137.205 17.348C136.925 16.76 136.785 16.074 136.785 15.29C136.785 14.506 136.925 13.8247 137.205 13.246C137.485 12.658 137.877 12.2053 138.381 11.888C138.894 11.5707 139.491 11.412 140.173 11.412C140.845 11.412 141.437 11.5707 141.951 11.888C142.464 12.2053 142.861 12.658 143.141 13.246C143.421 13.8247 143.561 14.506 143.561 15.29C143.561 16.074 143.421 16.76 143.141 17.348C142.861 17.9267 142.464 18.3747 141.951 18.692C141.437 19.0093 140.845 19.168 140.173 19.168ZM140.173 18.048C140.854 18.048 141.381 17.8053 141.755 17.32C142.137 16.8253 142.329 16.1487 142.329 15.29C142.329 14.4313 142.137 13.7593 141.755 13.274C141.381 12.7793 140.854 12.532 140.173 12.532C139.491 12.532 138.959 12.7747 138.577 13.26C138.203 13.7453 138.017 14.422 138.017 15.29C138.017 16.158 138.203 16.8347 138.577 17.32C138.959 17.8053 139.491 18.048 140.173 18.048ZM148.049 19.168C147.312 19.168 146.724 18.9207 146.285 18.426C145.847 17.922 145.627 17.2313 145.627 16.354V11.58H146.803V16.032C146.803 16.7507 146.929 17.2827 147.181 17.628C147.443 17.964 147.839 18.132 148.371 18.132C148.95 18.132 149.407 17.9453 149.743 17.572C150.079 17.1893 150.247 16.6667 150.247 16.004V11.58H151.423V19H150.303V17.796C150.098 18.2347 149.804 18.5753 149.421 18.818C149.039 19.0513 148.581 19.168 148.049 19.168ZM154.022 17.964H155.954V12.616H154.022V11.58H156.934L157.018 13.008C157.27 12.056 157.862 11.58 158.796 11.58H160.322V12.644H158.81C158.268 12.644 157.853 12.8073 157.564 13.134C157.274 13.4513 157.13 13.9133 157.13 14.52V17.964H159.482V19H154.022V17.964ZM173.947 19.168C173.265 19.168 172.663 19.0093 172.141 18.692C171.627 18.3747 171.231 17.922 170.951 17.334C170.671 16.746 170.531 16.0647 170.531 15.29C170.531 14.5153 170.671 13.834 170.951 13.246C171.231 12.658 171.627 12.2053 172.141 11.888C172.663 11.5707 173.265 11.412 173.947 11.412C174.777 11.412 175.463 11.636 176.005 12.084C176.555 12.532 176.905 13.1667 177.055 13.988L175.823 14.072C175.711 13.5867 175.487 13.2087 175.151 12.938C174.824 12.6673 174.423 12.532 173.947 12.532C173.265 12.532 172.729 12.7793 172.337 13.274C171.954 13.7593 171.763 14.4313 171.763 15.29C171.763 16.1487 171.954 16.8253 172.337 17.32C172.729 17.8053 173.265 18.048 173.947 18.048C174.441 18.048 174.857 17.9033 175.193 17.614C175.538 17.3247 175.767 16.9093 175.879 16.368L177.111 16.452C176.952 17.2827 176.588 17.9453 176.019 18.44C175.459 18.9253 174.768 19.168 173.947 19.168ZM182.145 19.168C181.464 19.168 180.867 19.0093 180.353 18.692C179.849 18.3747 179.457 17.9267 179.177 17.348C178.897 16.76 178.757 16.074 178.757 15.29C178.757 14.506 178.897 13.8247 179.177 13.246C179.457 12.658 179.849 12.2053 180.353 11.888C180.867 11.5707 181.464 11.412 182.145 11.412C182.817 11.412 183.41 11.5707 183.923 11.888C184.437 12.2053 184.833 12.658 185.113 13.246C185.393 13.8247 185.533 14.506 185.533 15.29C185.533 16.074 185.393 16.76 185.113 17.348C184.833 17.9267 184.437 18.3747 183.923 18.692C183.41 19.0093 182.817 19.168 182.145 19.168ZM182.145 18.048C182.827 18.048 183.354 17.8053 183.727 17.32C184.11 16.8253 184.301 16.1487 184.301 15.29C184.301 14.4313 184.11 13.7593 183.727 13.274C183.354 12.7793 182.827 12.532 182.145 12.532C181.464 12.532 180.932 12.7747 180.549 13.26C180.176 13.7453 179.989 14.422 179.989 15.29C179.989 16.158 180.176 16.8347 180.549 17.32C180.932 17.8053 181.464 18.048 182.145 18.048ZM186.9 11.58H187.978L188.006 12.672C188.137 12.2707 188.328 11.9627 188.58 11.748C188.832 11.524 189.131 11.412 189.476 11.412C190.241 11.412 190.708 11.8973 190.876 12.868C190.997 12.4107 191.198 12.056 191.478 11.804C191.758 11.5427 192.089 11.412 192.472 11.412C193.069 11.412 193.503 11.622 193.774 12.042C194.045 12.462 194.18 13.148 194.18 14.1V19H193.004V14.24C193.004 13.596 192.934 13.1387 192.794 12.868C192.654 12.588 192.435 12.448 192.136 12.448C191.828 12.448 191.581 12.602 191.394 12.91C191.217 13.2087 191.128 13.6613 191.128 14.268V19H189.952V14.24C189.952 13.6053 189.882 13.148 189.742 12.868C189.611 12.588 189.392 12.448 189.084 12.448C188.776 12.448 188.529 12.602 188.342 12.91C188.165 13.2087 188.076 13.6613 188.076 14.268V19H186.9V11.58ZM195.294 11.58H196.372L196.4 12.672C196.531 12.2707 196.722 11.9627 196.974 11.748C197.226 11.524 197.525 11.412 197.87 11.412C198.636 11.412 199.102 11.8973 199.27 12.868C199.392 12.4107 199.592 12.056 199.872 11.804C200.152 11.5427 200.484 11.412 200.866 11.412C201.464 11.412 201.898 11.622 202.168 12.042C202.439 12.462 202.574 13.148 202.574 14.1V19H201.398V14.24C201.398 13.596 201.328 13.1387 201.188 12.868C201.048 12.588 200.829 12.448 200.53 12.448C200.222 12.448 199.975 12.602 199.788 12.91C199.611 13.2087 199.522 13.6613 199.522 14.268V19H198.346V14.24C198.346 13.6053 198.276 13.148 198.136 12.868C198.006 12.588 197.786 12.448 197.478 12.448C197.17 12.448 196.923 12.602 196.736 12.91C196.559 13.2087 196.47 13.6613 196.47 14.268V19H195.294V11.58ZM206.811 19.168C206.074 19.168 205.486 18.9207 205.047 18.426C204.608 17.922 204.389 17.2313 204.389 16.354V11.58H205.565V16.032C205.565 16.7507 205.691 17.2827 205.943 17.628C206.204 17.964 206.601 18.132 207.133 18.132C207.712 18.132 208.169 17.9453 208.505 17.572C208.841 17.1893 209.009 16.6667 209.009 16.004V11.58H210.185V19H209.065V17.796C208.86 18.2347 208.566 18.5753 208.183 18.818C207.8 19.0513 207.343 19.168 206.811 19.168ZM212.867 11.58H213.945L213.973 12.91C214.16 12.4153 214.454 12.042 214.855 11.79C215.257 11.538 215.723 11.412 216.255 11.412C217.067 11.412 217.683 11.6733 218.103 12.196C218.533 12.7187 218.747 13.3953 218.747 14.226V19H217.571V14.562C217.571 13.862 217.445 13.3347 217.193 12.98C216.951 12.6253 216.554 12.448 216.003 12.448C215.415 12.448 214.939 12.6347 214.575 13.008C214.221 13.372 214.043 13.89 214.043 14.562V19H212.867V11.58ZM221.038 17.964H224.02V12.616H221.178V11.58H225.196V17.964H227.758V19H221.038V17.964ZM223.908 9.046H225.14V10.418H223.908V9.046ZM233.605 19C232.886 19 232.349 18.832 231.995 18.496C231.64 18.16 231.463 17.6467 231.463 16.956V12.616H229.013V11.58H231.463V9.62H232.639V11.58H235.593V12.616H232.639V16.956C232.639 17.3013 232.718 17.558 232.877 17.726C233.035 17.8847 233.278 17.964 233.605 17.964H235.593V19H233.605ZM238.639 20.064H239.493C239.745 20.064 239.932 20.022 240.053 19.938C240.184 19.8633 240.286 19.7373 240.361 19.56L240.627 18.86H240.221L237.463 11.58H238.751L241.005 17.768L243.119 11.58H244.407L241.397 19.938C241.257 20.3393 241.047 20.6333 240.767 20.82C240.487 21.0067 240.1 21.1 239.605 21.1H238.639V20.064Z" fill="#100D0D"/>
+<defs>
+<clipPath id="clip0_2074_1457">
+<rect width="16" height="16" fill="white" transform="translate(12 6.5)"/>
+</clipPath>
+</defs>
+</svg>
diff --git a/packages/docs/images/determinism.svg b/packages/docs/images/determinism.svg
new file mode 100644
index 000000000..35a4cea87
--- /dev/null
+++ b/packages/docs/images/determinism.svg
@@ -0,0 +1,2 @@
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1044.52734375 467.8006869612069" width="2089.0546875" height="935.6013739224138"><!-- svg-source:excalidraw --><metadata></metadata><defs><symbol id="image-aa1b51a5a56b73096388e3f04e434974ae7b55a8f9571012d44d6a17bdfed96ab885ddcfbf9de8e98411a6343ea5f623"><image href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABaAAAAGHCAYAAABGRvVVAAAAAXNSR0IArs4c6QAAIABJREFUeF7svQe4NUXVrTvOvb+ioAKigKiICRMqiDkjZjFhzjlnxQwYUMyooGIEMUdUzIgBUcyCCbMYUEwYABXkv+fcHr9zHCbN2nv3WqtD9erRz7PZ38fXofqt6urqUbPG/F/wZgLtE/hfAPSjs/9/a1xmCwA7ANgewMUAbA1g2/i5MIALpZ/zA/gvAP8PgE0A8Jz/BvDfAM6Kn9MB/CV+TonffwRwUvz8FsBvAJy2Rnn+3/T//w+A/90+Hp/RBEzABEzABEzABEzABEzABEzABEzABEzABKZBgCKhNxNog4AEZ4rDFIYp3uaNQvJlAVwKwJUBXA3AFQBsFQLz5m0UYoNzUKSm8EyRmqL09wEcD+BHAH4N4EQAZ9TOwfvhvfF+9NNDUX0JEzABEzABEzABEzABEzABEzABEzABEzABExg/AQvQ46/DIe+A7YcCLbd6hPMlAFwRwPUBXAfA5UN8Pu86BZZwXY+eVjtdr71mwVt/zr9ZTpV1VhEoTDMy+gQARwP4WgjSf67tzAhsnnetiO4h68PXNgETMAETMAETMAETMAETMAETMAETMAETMIGiCFiALqo6RlEYic51e4pNAVwdwK0AXBvArmGnUb8p2mVwyyJzE4G5DTizhGn+P14/W2/oWoyI/k4I0p8MQZqWH9p0jMXoNmrH5zABEzABEzABEzABEzABEzABEzABEzABE1g5AhagV65KO7shWVFksZW2GTcHcFMAuwO4Uu3q9E+W6DvLF7qzwi5w4rrFhu5Xp+J9U4z+TBXVfSSAL4b3tMR07m/P6AXA+xATMAETMAETMAETMAETMAETMAETMAETMIHVJWABenXrto07mxXtzEjn3SLS+c4AaLWRNwnUdQG3jfL0fQ4K6Pyp23dQaP5x5WN9eBXp/VEAX00FY1S0/aL7rilfzwRMwARMwARMwARMwARMwARMwARMwARMoEgCFqCLrJbBCyVLCtllsEA7AbgvgLsAuFwqofyQN/JYHvymWiiABGn6QGsjo+MAvAvAEQB+UROjcxR4C0XwKUzABEzABEzABEzABEzABEzABEzABEzABExgPAQsQI+nrvooqSKeFcW8GYA7VKLq/SPqeZMohETVVYhyXoSrIpzJIYvRpwD4MIBDAHw9WXRwHyVYXOR6PsYETMAETMAETMAETMAETMAETMAETMAETMAERknAAvQoq631Qtf9nbeNaGcKz1dNV6OIWrqXc+twNjhhttvIiQy/BOCNAN4D4Kw4B//dEdF915CvZwImYAImYAImYAImYAImYAImYAImYAImMBgBC9CDoS/iwvWI5x0APBrAgwFsFSWcerTzPBWlJIQ5Mvx4AAeHEH2qheh5cHpfEzABEzABEzABEzABEzABEzABEzABEzCBsROwAD32Glys/HWP58sDeAyA+wG4cJxS0c4UU73NT6DO72cV2wMBvBXAaUmIlt3J/FfwESZgAiZgAiZgAiZgAiZgAiZgAiZgAiZgAiZQOAEL0IVXUAfFow2ERM+tQ3h+bE14nqq3cwe4/6/lhuw5fgjg5QDeCeDMZGnCSHNvJmACJmACJmACJmACJmACJmACJmACJmACJrBSBCxAr1R1rnszimSm0Hk+ABSd+XOpOIqitIXn7toDueekhUxS+HwAH49L2h+6O/Y+swmYgAmYgAmYgAmYgAmYgAmYgAmYgAmYwEAELEAPBL7Hy9Z9nm8fwufOFp57rIWzLyVPbUVEf6gSpvcF8P0kRNuWY5Cq8UVNwARMwARMwARMwARMwARMwARMwARMwATaJmABum2iZZ2PEc2ydrgigBcC2DMJzxKnyyr1NEqTI86ZnPClAF4N4HQAjoaeRhvwXZqACZiACZiACZiACZiACZiACZiACZjAyhOwAL26VSyv5/OG1QajbDcH8H/ix8kFy6h7CtGKhj4OwNMAHBVFy37dZZTWpTABEzABEzABEzABEzABEzABEzABEzABEzCBOQhYgJ4D1kh2pbAskfmalej8ykrQvGGUPYudI7mdSRST9cW6+S8A/w3gFdVdPxfAGSFO25JjEs3AN2kCJmACJmACJmACJmACJmACJmACJmACq0fAAvRq1WmOmGWCQVpuXChETf6b67vs+qZdiiLTvwXgiQC+FPXGupOdStl34dKZgAmYgAmYgAmYgAmYgAmYgAmYgAmYgAmYQBCwILkaTYH1SIGZ0bOXBfAqAHvErTnqeVx1zGhoCs2sz7OqojMS+kUR1W5LjnHVpUtrAiZgAiZgAiZgAiZgAiZgAiZgAiZgApMnYAF6/E0gJxq8A4CDAWwXIibr13U8zjrOEwdHAHgkgJOTTcc478qlNgETMAETMAETMAETMAETMAETMAETMAETmBQBi5Pjrm5FxNI7eJ8qAnrvsHBw1PO461Wlz9HQvwDwYABHRx3L53s17tR3YQImYAImYAImYAImYAImYAImYAImYAImsJIELECPt1olPm8D4BAAt03JB+UjPN67c8kzAU0o/BPAUwG8zr7QbiAmYAImYAImYAImYAImYAImYAImYAImYAJjIGABegy1dO4yMuKZfs+7ADgMwFWdaHCcFTlHqXNUOwXox1dR7/x/2YJljtN5VxMwARMwARMwARMwARMwARMwARMwARMwARPonoAF6O4Zt3kF1hcFRwqPd4rI5y3j74yIXoWN1hLa1vrzeveZ27T+vCrtPFtyfDgsOf4aCQvZJryZgAmYgAmYgAmYgAmYgAmYgAmYgAmYgAmYQFEEVkWYKwpqR4VRQsH/HQnpDoqEdGP2e5bAzHvSnymkt90ueX5FC4tj29foqNpnnlZ1/g0A9wBwopMT9onf1zIBEzABEzABEzABEzABEzABEzABEzABE2hKYMwiXNN7XIX9svj8PAD7jtjvmWIwfxjJvZZX9b8AnA7gNAB/B/BnAKfE/zsDwFkAzgyh+nwRAXwBAFvEz0Xi92YA+P/Ps0YjUNQwyzG2Z4EWLLRiofi8ZxURf7xF6FV41H0PJmACJmACJmACJmACJmACJmACJmACJrBaBMYmuq0W/WZ3Q3GU0cH8YdTzY0PAlSjd7CzD7aXoZtmH5JJQSP4DgBMA/ADATwD8BsDv4of/tui2KYBt42cHAPy5PICrAdgxhOl8btlb8P+NRZBWJDR50ZKFEdHyB1+Um48zARMwARMwARMwARMwARMwARMwARMwARMwgdYIWIBuDWUnJ5L4zN9vqMTZh4wk2WDdUkNwKJh+C8BxAL4N4FgAPwfAiOe1tnl9nGXlkf2j87kp0F44EjdeF8CuAK4F4BK1ArCsY7DrkAj9p4iE/pJF6E6eRZ/UBEzABEzABEzABEzABEzABEzABEzABExgAQIWoBeA1tMhEp8pmL61ig6+d4jP/HuJm6K0KT7nMjI696sAjgLwOQC/DPuM+j3I+1nn0e9F7zWLx2rnFGtnCdO07NgJwB4AbgDg2jV7kOwfvWh5ujxOIjTtSu4C4LNzitBNEjeu1VfMShRZZ7zWZECXTHxuEzABEzABEzABEzABEzABEzABEzABEzCBAghYgC6gEmYUIUf9HgbgvgWLzxQXKYBm0ZnWGV8B8B4AjMj9be0eta8ipfsUKMVWNhuzROldAOxeWYPcPaKjVXxFRa/lXT1ka5IITe9sCulHzxCh5xHl27yX7Pctq5M+67zNe/G5TMAETMAETMAETMAETMAETMAETMAETMAE5iBgAXoOWD3tmhMOvgnAQwu13ZCQyMhlbhST6UH8dgBHhJezkGmfHN3cE85GlxFzCqVM7pe3mwC4a/zQU5pb/d4bXaSHnSRCM2njrcLmhAkYJbKvJfryvs8fP5tXXuNbAdgyfpjIkYke+bNJStZI/26yYlJIit7/AHBqJIykHQj/zkSR/1znvrMvePbg7gGVL2ECJmACJmACJmACJmACJmACJmACJmACJtAHAQvQfVBufg0JchQMXw3g8QVGPtfFVwqQ7wdwCIAvpFtVhPHYhMUsimYva/pG3xPAgwBcM+5T/y6BvXlNd7enRGgmc7wFgB+nS50XwKUBXCZ++OftI1HjxeI3kzcuG+FNYZpi9B+rCZSTYjKCUfC/jkSTTDb5+xl2KHVBelkblu4o+8wmYAImYAImYAImYAImYAImYAImYAImYAKNCFiAboSpt51oTUHxbm8A+xUmPteFZ4qLjHZmlHYWOSnGjk10Xq+C6/fDKODbxOTAbkmI5h+XFW7bamgSoX8EYH8AO0ayRfpcU0hnVHOTrS4A1yOo6wkim/QnFO0pTtOm5bsRNX9CJe6zrExImTcJ0qVGzjdh6H1MwARMwARMwARMwARMwARMwARMwARMYNIEmghGkwbU481LfH4YgDeGbYKiiHssxsxLSdDkP54S0c4HJZsNCa8UF1d147NCMTpbdFCIfkr4RfO+S0pWSNF2vedbthyyH2H585+Xrcd6Mkn+ne1krWhxtismqDwWwOcry5PvA/hprRB8RuwhvWzN+HgTMAETMAETMAETMAETMAETMAETMAET6JGABegeYa9zKYpyFARvB+DDIdS1KQYuepcSESkc/hvAWwAcUCVF/FmckIIgRedVFp7r7BSVm+057lzxeVay5siC/aLs2zgu101OQCixuY1rzHsORVFngTonKdT5GCX97Uim+IkqISSjpOk1rW3VIu3n5ej9TcAETMAETMAETMAETMAETMAETMAETGAUBCxAD19NEp+vAuCLYZFA4XBoO4cson66io59XpXY7iuBy+Lff6KFWUcSopnsj9Hrz64i2LeLSF1F/Q7fysovQd1mox4p/QMARwH4ZERIc0KEm1YJ5AmB8u/WJTQBEzABEzABEzABEzABEzABEzABEzCBiRCwAD1sRUvApC/vMQCuHILmkOIzhTxFy/4qInvflcQ+/nFKEc9NWogmEbjvJSrx+TlV8r2HxoEl2XI0uZdS9sk+4nUrGnqOM/ElVwt8KxXYEyOl1J7LYQImYAImYAImYAImYAImYAImYAImYAJBwAL0cE1BEbQswYcqIe32YcOxlkduHyXNUc+022AyxN/HhbPI2kdZxniNzIh2Kq8AcIWIhub9+HlbvFZlJ0LbF23/qhJCfg3AYZX9yccA/Dn+YQqe5IuT9JEmYAImYAImYAImYAImYAImYAImYAIm0CMBC2I9wq5dSkkHKfLuF8ntsrjWd8kkPv8OwBMjwpRlUDn7Ls9Yr6focQqmW4Z1yePiZkrxhh4rW5V7lhh9YrTZQwH8KHbUJA+5ezMBEzABEzABEzABEzABEzABEzABEzABExiAgAXoAaAn7+BbRuSmkrANUR/ZcuMjAJ4AgNYbjOa1r+7i7SNHQzNJ4UEALl5AlPvid1Tekdk3WisHzghrjteFrQ1LbSG6vLpziUzABEzABEzABEzABEzABEzABEzABCZCYAjBcyJo17xNMd8WwDdClBwq6aAicnl9Js97cZTadhvttFJ5F5PzZavkhG+sEk3erJ1T+yw1AposyRY2RwB4LYAjY19bc7jZmIAJmIAJmIAJmIAJmIAJmIAJmIAJmEDPBCxA9ww8IospSH4QwJ4DRsT+d9hr0OP54QA+GpHZJOIkg+22C9mY8PcLAdCSY5PEu92rTftsSl6YhehPAngJgKPTBIuj+6fdTnz3JmACJmACJmACJmACJmACJmACJmACPRGwAN0T6LgMIzApfD0CwOsLEJ+/DeBeAH6ShPF+iUzjajkS+jwAKIjuHm1BUbnTINHvXWbPbT53hwPYH8BxSYi2P3S/deKrmYAJmIAJmIAJmIAJmIAJmIAJmIAJTIyABej+Klzi8xUAfBPAZnHpvutAotzHADywisY9xYkGO2sEde9hiv20OrlKZ1f0iesE6hHR9Ijm5M9Lq4mgky1Eu8GYgAmYgAmYgAmYgAmYgAmYgAmYgAmYQLcE+hY/u72bcs9OzmLN6FcmH8zRmX2UnEIcr0kbiDcDeHQlhp6VEiL2UYapXKMuPF+vuvHnRr2TAevCz16/raEuRJ8U0dAHJxHathz91omvZgImYAImYAImYAImYAImYAImYAImMAECFsH6qWQl9aPX8hsGEp8pwDEK+0AAT4jbVlR2PxSmcZWcwPHiAJ4B4JEh/M9KlDcNKuXcZV2I/kL1PO4D4Et+JsqpJJfEBEzABEzABEzABEzABEzABEzABExgdQhYgO6+LinyUvS6ZFhvXCT+3pf3bxbcmIiNgqjKxH/z1g4B1SdF5k0BPArAXpXdw7Zx+r4j3tu5q9U9C9u+JmWYkPNV1XPxfACnhR+6o6FXt+59ZyZgAiZgAiZgAiZgAiZgAiZgAiZgAj0SsADdPWxFGb8NwP0GiH6W8PlyAE+1+Nx6hdftNm5XCZj7AdglrkRxk1HRftZaR9/KCfPEwPGVAP0UAJ+LM3uFQCuIfRITMAETMAETMAETMAETMAETMAETMIEpE7Ao1m3tS8DaDcBRSdTq9qpnn13immw3KIQ6srM9+tluY2cAewO4S5ye7CVOt3dFn6kLAtkfnfX2wuoi9Ozm/8913MW1fU4TMAETMAETMAETMAETMAETMAETMAETWGkCFqC7rV4K0OcB8EUA1+45+pmRt0w4eAiAhzjyudWKzqLkVgCeBuBxAM4foqWsHVq9qE/WOYE8acAo6McA+FE8R/w3W9Z0XgW+gAmYgAmYgAmYgAmYgAmYgAmYgAmYwKoRsADdXY1KpHwogDf1LD4r8vkTAO6Yop4toC1X35xQ4DNDvhT3HwTgWQB2iNPa53k5viUcnT3T/wjg8QDeGwWzJUcJNeQymIAJmIAJmIAJmIAJmIAJmIAJmIAJjIqABehuqotc+XNBAN8CcJkeEw/SYoNC2XEAbl4JaH+Jv/P/e1uMQN3nefeqPp8D4EZJeJY4vdgVfFRpBPJkwv7VpMM+MZFjS47SasrlMQETMAETMAETMAETMAETMAETMAETKJqABehuqkciFa0ZXtJj9DOjN1mnfwpx9McWn5eu4Cw47hg+z0wmyc0+z0vjLfoEnLTRZNJHAXA1A6OiLUIXXW0unAmYgAmYgAmYgAmYgAmYgAmYgAmYQEkELEC3XxtiunVEIW/bU/SzrAN4fdpufMxC2VKVmxM2bg7gSQCeAGCLifo8z7JvmUL/wfumnzq93E8AcC8A3w0LFv5/byZgAiZgAiZgAiZgAiZgAiZgAiZgAiZgAusQmIKA1HcDUHTksyuR6gU9Rj/LMoBWAbyuozQXq/ns88wz3Duinq8Up1s1n2cKrBKX6yKzIurXshfRpIf2y8TVtyiCeLHaKOco1fsfANwXwFEWocupHJfEBEzABEzABEzABEzABEzABEzABEygXAIWoNutGyUp2wrA9wBcLHxj+f+73CSOfQrAbcJ2IwuLXV57Vc7NZ4GivaJabxA+z7dIwvPYfZ7VJvRb99ykDmlHkQVq+WI3PTbbWYxVlNZzdlbYcbzNz1qT6vc+JmACJmACJmACJmACJmACJmACJmACUyZgAbrd2h/C+1nC3u8BXB/AL+37PHel5mjx7QEwev1BYbug5I1dTyLMXeiGB1A0llc177O+/TMSVZ4C4EQAvwFwMoDfhZf4PwCcGT91Afq8AM5X+ZyfHwAtZ2g3w59LRuLNiwDYMpJx1q9LrkqYOSa2KjNZPBHAgTFxURfoG1aPdzMBEzABEzABEzABEzABEzABEzABEzCB1SZgAbq9+iVLilKbRfTzDj15Pysq8+4A3m/rjbkqVMInxUOKqI8BsBeAbeIsEhvnOmkBO7NNcKtHbP8bwG8BHA/g2+Fp/IsqmvckAH/uoNz0y5YYfUUAVwewa/w/8s6byjxLJO+gaEudUhHk5Ltv9czt50jopXj6YBMwARMwARMwARMwARMwARMwARMwgRUmYAG6vcpVFO0DALy1Z+uNd4YvrX2fm9Vn3ed5zxASKZByoxg6NrsNReDWrTF+BeALAL4J4NiYHKGFRH2TLUYbfYIipRU9nq/FNkoxmtH6FKNvBuDytcIoYrvkyOgsQr+4ihB/pkXoZg+f9zIBEzABEzABEzABEzABEzABEzABE5gWgTbEpmkRm323Eu8orn0+xDWKb11Gc8p6408ArhGWCSzHLNHPdfQfAhJnFW1LbnsDuHMAGpvwnD2dc1tjdPOXK4H3o5Un+NcAnFprAOKg9tKVX7ieCwrJOWFhLs4FAOxYCeR7VGWm3/YN0z9KVC91MkD3RPYvAfAMi9DuakzABEzABEzABEzABEzABEzABEzABEzgnAQsQLfTIhR5fFMAn41Tdh29KXuIBwM41NYbG1Zkjg7fDsBTK6/jR4T1Ro5m3fBEBewgX+f/SmX5eTXxcWQl5r4rop3PSP/GtqgEmV2JzfNgUXl0HzqW/dHOMSFwJwBXTSdlckjWYWl9VhahXxgTGiynPaHnaRHe1wRMwARMwARMwARMwARMwARMwARMYGUJlCbmjBW0xM23AbhfWDh0Gf0s3+ejw8KA3Bz5PLv1KPqWQiGT5j0sIlUvEbuL5RjaXhY7WV5aaRwD4M0APlklxftbugmK0xJBc/LA0u4zR0lTZNZ2nmjb96n8qu8AYPNUX3WbkaHvKdcLI+opRNsOZ+ha8fVNwARMwARMwARMwARMwARMwARMwASKIGABevlqUGQpBc3jAGwVp+yKrcQuCqe7A/hSim5d/m5W5wx1u43bVRMD+1RC7XWSkFmqtUO9FurC8z8r32T6ftNrnL7O2jTpMdbo2+xDLZsU3hs9oh8E4IEALlaoEJ3r6NFVIsuDAXASIIvqq/N0+U5MwARMwARMwARMwARMwARMwARMwARMoCGBrkTShpdfid0U6fgYAK/pMfqZ0dZMeOhIy3M2o7rwTBsHCs93i90UKd61RUobjbsuPP8VAOud4uaP4wK637GKzmtx0n2JAffj5A5F6EcBuGwSokuZSJC9Cct+LwDv9fPZxmPgc5iACZiACZiACZiACZiACZiACZiACYyZgAXo5WtPDL8S0bXyZl7+zOc+gxIPMgJ2FwA/tcB1DkiKRuf/3BrAkwA8FgAT3XHrsm7aru9c1n8AOATAAZUA+8u4kAT0KVivSGBWVPSW4d9NIXr7JER3aXvTtH71jJ4J4FaVjcgX/Yw2Ref9TMAETMAETMAETMAETMAETMAETMAEVpGABejlalWCJ8VgCtD0GObWFVf5FTMClsv8Hf38H95ZjCUTJmZ8VmVRsUNh4mST1pYTIvLP76va1f4AvhsH8/5yVHCTc67KPnyueP+ytaAdx+Pih5MMpSST1OTB7wAwMSknivLkyKrUh+/DBEzABEzABEzABEzABEzABEzABEzABDYk0JVQuuGFR74DxST9/LsSxJh4bL8Qxuj72sWmRHJ/B7BrZb9xYgjdU4iAXYtn3W6DntjPBXDDOIBCJQXLMbTzut3Gl6uI7X0BfM7C87mqv17vVw9We8aeJSSWVBm+CeAWAE6Nsk35ee2iX/Q5TcAETMAETMAETMAETMAETMAETMAECicwBmGuBITZY7butUuG3wpLjC4tHiRovT48cKcc/VwXIJmk7pmRqI7thay0TwntZ6MyZMH01wBeBOBNyU98qhHPG3GrW3PcJdixPZTg9c0JEE5I0Qv6njEZsmpe3RvVkf/dBEzABEzABEzABEzABEzABEzABExg4gQsQM9uAOSiHwmaeU8KXDuF6Mwl9jfquB1RgGR5zoro5+9NeEk/RUdZLWwO4Anh9bxF1EEJ0a9Nm4P8glm39Hl+beVX/XIAf4oTTHmSoSlD7pfbxEXDsuShhbQHidBPB/DSEKRlITLPPXpfEzABEzABEzABEzABEzABEzABEzABExglAQvQ56y2uses/vUSAHYGcFsA1wNwKQBMhNbXJlH1gwDuOlHxuR71fO+wXbhCVIKEvr7qZJnr1O02WK/PA8CJBW4Wnhejy2hjibv3AHBgJKMcclJCkyX8fevKHuYo1+9ileujTMAETMAETMAETMAETMAETMAETMAExknAAvTZVg0UqfJGYZOC0c0j6pgJz/LG/SkqyQu6qxYg72een+X5TFyzXt6url/CebMgywkAirX01eU2Jp9nljeLofQH5r18LO6F92mLhuVanFYukCMnihhVfruBLTlkzfMbANcFcLL925erZB9tAiZgAiZgAiZgAiZgAiZgAiZgAiYwHgJTFqDr/rGste0B3AHAHgBuBuA8qSol+NbtObqubYlX3w8hnDYcWZTu+vpDnj8Lz5cE8AwADw8bgxI8fudhk4Xn34cdw+sq7+ozY0KB53KCunmIrr+v2g6fcyam3Cd2HyoaWtc9vIp0p1e1Jxvaq2ufyQRMwARMwARMwARMwARMwARMwARMoGACUxOgc2I6CcqbArgTAC7Zp+h8gVRfikYdMqGdhCt5yE7BnoGioQTZ81aeyI8BwPvfZmARcZFHOQvl/wbw5kiUd1KcbAr1uQi3No7J3tB3q9rPwQC2qkWht3GdpueQTczjALzGVhxNsXk/EzABEzABEzABEzABEzABEzABEzCBMROYigAtATnbGzCJIEVneglfZoboTGFw6E3JB/9W2TRcE8DPV9z/ue7zzGj05wC4xgiF57rP86fiXr5u4bnXxyq3KT5D7wLAJKJDeIbLD5oJJ28Qnt+egOi1OfhiJmACJmACJmACJmACJmACJmACJmACfROYggCdE5ORL72DHx2/NwvgEqZly9F3Pax1PUY/s0yfBnCbFRefsxB3tRBr90zCc2l1s14byeLmCVW9PR/Ae5PwbJ/n/p8w9QNMKPq+SCY6hB2Hrnl0rLggCQnT/VPxFU3ABEzABEzABEzABEzABEzABEzABEygYwKrLEBnQZN/ps3GIyOpoLBSDBrSXmOj6pX/80MBvGVFl+znetoawF4AHhVWKGP2ef4rgFeE1cLfo52xrdnneaNji37+AAAgAElEQVRW392/q61tGZHQTOo5RCS0ROgnAnj1ij7X3dWiz2wCJmACJmACJmACJmACJmACJmACJjAqAqsoQFNkkv0B7+9eIWjeMGpG/1Z6RG2237g6gF+vWAR0TgLJOntIlZDvmQB2iHoaIjp10YdXEc2ybTkMwP6VvctP4oS2WViUbPvHsd2xvs4H4N0xMdW3CK2I51MBXBvAT1fs2W6/1nxGEzABEzABEzABEzABEzABEzABEzCB0RJYJQE6C5qskNsCeBqAm9SE5xK8nZs0GIlin4x7UV1RvBrzxvtgHfD+uO1e/ee5ADRBINuRMbRN1gXLS3sHbl+s7m2/6l6Oir/zPm23UV5rlQh9HgDvAHD3ASKhNcFyOIC7hgCtxKjlEXOJTKA5AfXduQ9f68/rnbX+rst/15/H/j5sTtV7moAJmIAJmIAJmIAJmIAJmMCICYxB5GuCN/s8Xw/AswDsEQeOzcZB9yuBilHBLw6RU6JtEyYl7pPriYng9gZw/1RPbI9jaZM5avbEiHg+JARnCpz29S2xBZ5dJonQbJP0hL7zQCI0y0F7oCNsxVF2g3HpzkVAfbUmf/l3vrf6tBniJJ+eZfW5FqXdWE3ABEzABEzABEzABEzABEygMAJjEfvWwpatDS5effzuA+BhteXs/Dgd83YNAMeNfIl+jgS+EAB63z4JwBZJqB1LPWVrkNMBHAjgAACnRCOTGDLmNjeVsquuNgXwkfCH79P6RR7vPwRwHQD/8MTFVJreKO+Tz4sm19aL1md/fwEATPJLv/WLVP3khQFsFb/5b5sA4AqE88YPxyKc1Pt3+vlX9a74W/Stf4nf9Nb/J4DTqnwB7H/X2nJZvQpllM3NhTYBEzABEzABEzABEzABE1glAmMVoJU4UB/BTC7IaFqK0PJ4HovVxqz2JP/nHwPYGcAZERk8tsiuui3KfaOerhA3PSa7jbrPM/2DX1DZN5wQ92K7jXH2jBKhKZQdCeCaEcXZV/8hwfsZAF7iKOhxNqIVLbX677UiiykeX6xaQXDl+OH7d9sqYe4l4zf/jSJ02xu9039TTTb/Nv2m3z774p+FMF1/V+acDxak264Rn88ETMAETMAETMAEpk2g9PxiuXY8Fp52Wx307scoQGd7A0YNUgS8+QgFzfUqXvYObw+LirFF1dYnCG4UwvMtR1hP9QmNr4TPM725uVl4HrQLa+Xier4uFT7e2ycrlVYusM5JOADg88IIeiYbPTn+3qeNQdf36POPg4AskPhb/V4uORPE7lLZxXBVztUA7BQC9Pk3uL26X/M8E6l1P+n1xix8bzJimmL09wF8N35zBRFF67xpgmnWfY6jtlxKEzABEzABEzABEzABEzCBVSFQqh1tq7rE2ARoeQhz6S4jBhn1zCgsiThju5+1HhZFRdKm4lUj83/OtigULFhPD4l7GJsfd7Zj+HV4cb8ZwFmxFJ311+oDuSq95wjvQ+32upFEkrYc3ProU9TOaOfyBEdBj7D1jLfIGuhwEqaeY+CyAK4NYLf4zchmWmnM2uT9nEXsrgZROSJbYjaf31nPKvvn34UY/XkAXwPw7bC70X0oYsXRIONtxy65CZiACZiACZiACQxBQIFMVwVwg6RLDVGWptf8QAQ/Keik6XHezwSWJtCHuLJ0IdOHJT82GSVIUfamceI+PVvbuJeNziH7Dd4XP/yPGYn/c45MvyCAx4TP89YjrKc8oUFf3oPD55nRqdyyyL5Rffrfx0NAE1z3AvCuHq04JKLRamdXAPSEHtuqh/HUsktKAvJIzqIz7TI4eN49VhXxz/Rtzhv7xtw/1iOUh6SbI601Mchnur7x+Tq+stv5WLxfaeehTat3LEYPWZO+tgmYgAmYgAmYgAmUT0DjYI5BPwpgj/KL/D8lVJCjNY0yKkz1wPbzzAh2nPUN02dppUkyJ8/DAZzYliXwGATo/GA8Niw3No9orbWinvqsnLavpcrmkvzLxZLikmenFOWmD/67RzJILs/mNiafZ0XWKSHiB8Nu4ztxL7bbaLu1l3c+idCvqJbtPzn6mT5eAJpIo7f4vVOyt3nsCsqj6RKVRGCWuMoVRLTTuAuA28afc5kpUOeoZv7bGMYNuod6tHR9zMCkhoyMpqUSPxz+kG6e+9qio6QW7LKYgAmYgAmYgAmYQDkEFDB06bB947i65I16Dce3XA14vbSS29+bw9aa9AfmtWPgY2kbvxW/11aAXOkfkqoMRmEdBICRidxWLeo5NzJ2DOzMvhHLnktrgCpP3eeZS7WfXXVod0h1NBYz/rrPMwXnfSuv0yPiXixElNoK2y+X2jVtfj4N4MY9+UFLKPt3DAjYBvn8KNFq+3fqM06FQL2v5n3vCOBuVSTwnSLxpljkyN+x9N/z1GMWpMVFx/+leud+IoToDwPgs8hNftGOip6HtPc1ARMwARMwARMwgdUmoEBJRq3uPxKNiuNZfl/STeBYr+wuooFK83wwgDdGBDS1iCE3BcWeDuD6key9lRXapQrQ+YP5mgDeEpFZY4qmXbTBSFw/FAAbYYnRzzkq/eKxVOBh4cddjyJelENfx+XJjN8DeFE8+LRDqEd391UmX2dYAnk2mxNB8r3tur9UW3xbtczlAW3NMg6L0lcfkADbK/tq2WywXd8GwIOqAScTwtIqSRvbXl2QHbDovV2a7yuNK7TyhRc/AQCTAB8eSQ35/2zP0Vu1+EImYAImYAImYAImUDQBaTSMev5KJOkeQ5AkvwsoeL66Wmn/RAvQRbQxCdDMm6Z8YyUJ0MyR9YO2tImuBZVFajR76dBv5AAA9KYcwwO9yP3Wj2GCOza4vSqBgDYAJXnzZEH2/AAeAeBpAC4WNzGmOso+pmeG6PwSAL+NeymJexvtyueYj4Dq//4ADuup/9HkDb2WrgXgRyF6OdHlfHU39b3rEc/04b8vgAeGx7P4cAAqL+ipM+P9ayVMFuJp0UGvaC6H48eFNr8f3GJMwARMwARMwARMYLoEZM3JxINHB4YczFAqGUW2Mkn3lSrLyVMLDXgslV8X5bIA3QXVhufMYd0vrTLVPzWOky1Fw9OMejfNStFL+f0xQ5UTRQ11c7luaJD+vJjpY3nGFJlet9v4eHUDz62SBnwzwLID4P3YC2mollbOdSUyvS/sCvroh/T8vwEAfaBaWepSDlKXpEMCdeGZq1MeGtH09Kbjpv5vFe012kSrZIvZ//1TYQVGv2i9HyxEt0nd5zIBEzABEzABEzCBcRDQGJCWCVwJPrZAPH4LMO8Q8w9JAB0H+dUrpQXogepUQguXBTP0nALsmITNNrBpRoofv7sB+GIhEdCqG0aiv6xK1PSouNkxLduuC8/fDxH9A3Ev9nluowWv1jnY7tlutgVwHABGkvLvXc5uS9g6LWyHfmURerUaVQd3Uxeet4sldVzGJfsY9dVaxdJBMVbylLME+8/GskUmLeSm/sArFVayCfimTMAETMAETMAETOAcBKSNXKTKp3I8AAZ99BGo1FY1KODpI5EPpkTL17budQznsQA9QC1pBulSAN4B4IbhW5mjjwYoVu+XlAD9NwDXCe/JoSMg1SGxg2UkKIVxJWNScqbeQc15wTyR8acQD+h7RFP1WQm65jy9d19hAuqb5MnUx+BCM+hM6smEFo6yXOEGtuSt5fcDxWZGzT++sozYJs47pknCJVF0fnidJVfPcKUWJ4q5aSmmV890XhW+gAmYgAmYgAmYgAkMRkBjvvtEzpAxRT8TmjQn2j7uBOAXtuEYrC3xwhage8Yv4Gz8TPhz+ZEtYWgTl8StXwPYpRIS/jJwZyA/7vNVnrT82Kb4rBmzNu+7q3MpIo0iDV8MTOxIQe/EJBjw/09lU/Rj9lnXS8iiyexWIGbk8/nq5yY99E/qB34C4OoAlBDTdTSVJ3Xj+8wTZ0x+Qj/+JwPYIQ6d2uqhjYm1t0dmyz9z6eILw7NdQvSU3ivtkfWZTMAETMAETMAETKB8AgoA+XQk9h6bAE3C+t5UwJNtOIZrdxage2SvyD4m3PpwlQiOS4fHJHC2jUodwY9jNooshlwSoc71VQCeAEAJEtu+77bPV7fboHD4HADHxIWm5PPM9qPnbD0B0xYka7dCPQfXiERkbD9dWxloZvquVeK4DzoKuu0uYtTnyxHxnBSk+Hm9uCO+M/jvJSYYHjX0GYXPHxt/B/DKSJpM+xzZ93jSaNVq3fdjAiZgAiZgAiYwZQL6LrwygG8AOH/AGNvYW+NY2kzyO+LfcR8eu/bfui1A98RcH9G022Dk80V7iCzs6dYWvow6gm8D2HVg71fVz/UBfCEEjTEIG1kU+GmIM4dFjUxNZK1bN2wREZIXqyLBGTVJoeSXVfTkyQC4BIeb/UxnP75ieXDYHHQ90y0hkQnPmPRTE1EeFCzcvY7+wPxsXqJ6X+4TSQa1wkNR0aO/0RHdQH2y84SoF45puNk+Z0SV6aKagAmYgAmYgAmYwAYENLbjOPz5Iw+e5DiWPzeNQD2PW4dp/hage+AuyLsDeH/lybtl4eKzPI+7/sCXqPWZWM4xpP+zBK8jANy+8Pphk83Lok8Nn2dGpP11gj7P2YuUQjMTet4hXi708s4ztBQ6KdQfCeA9AL6ahBO1+x66hOIvoYjGS0ayCYr5XSckJJQzw4aDqyKG7A+Kr6AVL2AeEN4rvIcpQtcF0BXHUOzt1euBuSyeUWVF/629oYutMxfMBEzABEzABEzABBYhcJ74HmQUdB/5gRYpY5NjpD29CcDDHTjRBFkn+1iA7gTr2SfVh/SNAHysWrJ6oYIfXHYo/MnJELuMfNS5PwRgzwEFJwldV6yES0Zjc2mJLAE6bh5zn76eEJF+nPsB+GESUqfix8l6o7is+2VihKdVKwyuNoPqrPrk0hvaPdAn+/sWos9FTc8FZ7s5691lX8CLa0Czd0Tye1Z67u5h9Adkr2dm2Oazef+4q67b3+jhDXADOe8AV5fQl5vvc26eQBqgQnxJEzABEzABEzABE2iJgL7FblnZVtD/WStTx2a/IRz61uRq6J0B/NHj1ZZaynynsQA9H6+59hbcawLg0nJGY5Y4a5Q/InmDf45OhhGiL6siRSnMdlFuCQrvrRIa3XPADkD19Jiqjl7Tg9A2VyOKndnhk5cmBxi5S59nRvJyy1HAi5x/TMdkkYrlpo8TRdKbx01IpJdAXb+3+kQLrTlY7wdE27d48h9iGlxsA+A7YRvUZRS0+oNvVu2aVjiMVudmG44xPZ2LlzULlneOVR2MwB/7YHdxIuM5MueyeENMBHJljieRxlOHLqkJmIAJmIAJmIAJZAIaxx0C4EGFaiTz1pi+N+8HgCv4PFadl+Dy+1uAXp7hzDOoMe8UYi4TDpYWwVUXnn9eeea+NbLc88/cfgCgq+UW4vE2AA8YsAOQ/cabATykQG+j3G5OAvAiAFw6wiSJU/Mwzi8JilPPDF9YLg2qt+eNHu36MvJfAHhFlRz0jdEGpsZ2Fi/x7isKmnVCMYte+V8fsE/YqO3439sloIEInzn2b1zJwG3KSXrbJdz92XL/+73ol/kMO0Fh9+x9BRMwARMwARMwARNok4ACQ7YOPYiBlKWuEJ/nvqWrMIjvVinv0Dzn8L7LEbAAvRy/mUfrgd0ewOcBXKYw8bku1PEj8bVhR/CPuCMKT5tFttMdO46ApvD7sALEJnpRM4q2i2jvRZoZO0hF+54RdUSBlMtGuE1pxi6LweerIpUfC2AvAIzO5bbM5E5diD6m4v48AJ9NnKfqDy3xiHYIxwO4cMde0KrHlwN46sTa+CJ9xCoco37s8tXzzKSXzJUw72TSKnBYhXvIK3UYAU1LjrfEjdmSYxVq2PdgAiZgAiZgAiYwBQIan1OjYXBWKfrIsuwlolNboUsBgy09Rl2W6nzHW4Cej9eGe2vZOsVbzqzQHmAZcWzDC86xQ11o+1pYD9BqQ8vd2dlI0OM9HAeAwkAXnU4JRvCKfmbHc2xllXKdju51jmr6H9bZi5uJESmI0p+a25TsNlgv/FH7vGPFZl8A10jtdC2rjXmYc9+66PWusPZgQrypcc/sNAA5KIT/LvsznfuEqGP6dNuCY96WPI792ffyh8/d7QC8HgATDXbZvsZBZvylzHXIen1KFdX+T08ojb9ifQcmYAImYAImYAKTIKBvcAbo3XTFxudaYUk7U67ynVJQXwmN1wJ0i7WQP6gp6t6joCXE+YOQVgP0dj60sjA4M+6fDYH7aFaIv6ckQLPjoSC/64ACdN3nmcuYKTwzUd7UBFA+S6wTCc9XrQA8N5JVkgXbalvCc70LyM/K3wFQeH0lgL/EjlObJdX9sg6+USWGO2/yh26x+/yfU0lspvDMxK28ngcFbVMe/nyaqGV9Px7Aq1JCUU2CDl9Kl2AZAqxbecZ/DsC9Afwh8hioX1/m/D7WBEzABEzABEzABEygfQL69rt66CP89uM21uSDdUIKrGTA0y4A+N2poMT2afqMdQIWoFtsE4L5kvCwLMG/MidwOh0Al7bTboOJBrnNiqbVA2gBusXGscGpsuj5JwBsQ0zmxDrLExv9lWi4K2XBkX5Tz6hsRx5Rtd0LhKDRZSK8fNe5Tn4aM6TvTKKKBJbhSPV3ZfUTjMZntGpOiNl2KdRv0oKD/ZUF6LYJD3s+DWrZr9FS6Ek9P9fD3v30rq7nmStJKEJzJY+f6em1A9+xCZiACZiACZjAOAhonPbCSpx91opFP6sGFHR568jX5rFpf23TAnRLrAVSPjn86GJDHnKmKAtoFI72BsCo2rWEZ6GwAH12cr+Wmseap8m2D2wzh1XtZr8q0+yvUj2xHqewZZ9nPk8PjJfepePmh1iaX49KZyQfo9K/2OA5WqU600v57gDe2/EqAc1KkzX9gL2tDgGJz5sDYEbtPTtezbA65MZ9JxKhTwFwfwCfcCT0uCvUpTcBEzABEzABE1hJAtlOlkEDXVmxDg1PY9O3VrrLgxwc0Wt1WIBuAbc+qmlk/oUqevX8KWq1hdPPfYrs9XwSgKcDoJ8ttyb+wRaguxeg637cnwph86tz1NPcDaPQA5RoUUI7ZyLpyXTdJDx3ZbfRFImSEPL5Yd0xGcOLK5H8l6m+VnmiQH0Co9A5ibVDh5mQNSN9GoArA2Af5mVRTVtquftpEoPZtN8P4MZhsTP0RG25xFarZJpYOiuSDnOyNVt/rdbd+m5MwARMwARMwARMYHwENDbjilcGMPa18rhvUvreZHDETgB+7+/N3qrAAvSSqDVLxIiurwC4YsfRgRsVNycL/EAk//l1+OXyWEXcrnceC9DdCdB14ZmZV19QtRt6hnOj0DoVa4e68HyViNK/Z7CoJwXcqO338e91q5SXAnhdJNhadasUCYi0TXhyh/722TuWbYER114W1Ufr7u4aqr+LAzi8ioC9doftp7u78JmXJZDHJ48GcHDDSfFlr+vjTcAETMAETMAETMAENiagwEraTtI6bYgVyBuXsp09NC59OIA3eXVeO1AbnMUCdANI6+2iD2slHRzyIdW1mW2efj2vjoLPK95MVYD+ejXTd40OJxDyxzc9uFk/B1Zi3qlJfG4yQbBkky3i8JzIbysAT4xkZBcaiR9s9nf/fvhDM6qTW5NVBkVUwpyFUD9yEwCfT8d2YTMkvhS797IAPWdNlbW72s2OAD5cTShcyeJzWRXUc2lyXoqnADhghfvMntH6ciZgAiZgAiZgAiawMAFpQNsBYII+BlgqUnjhkxZ8ILUzahJ0MLhF3OtUtJghq8UC9BL0Be/xISYOmXRQ4vPxkbCNYqqEIX3wNb3VqQrQXwOwawcCdI7kZT1x6fGLAPxswQmCpvVY4n7Z55nC1AMiySD9pbjpRdCFqNk2j3o0+0fDOuS4Fa9X9nu04ehytYcma+i1fbNoF7bhaLsFd3++LD5/EsBlLD53D30EV8irHJhklkl3NZ4aQfFdRBMwARMwARMwARNYOQIaiz0WwEErHv3MypNG9u+w/qSONm/g5so1gh5uyAL0gpAVwXnVasbkywA2jRmUvoWz/CH3IQBcQsDo2mW8FacqQLcdAV0XKBk1ygR2RyeBUt7CCzbD0RxWt9vYLcRaRtOOTXiuQ88TDGfEsvKXVRNBJ6+gEK1+j4LR03oQE0+P5Bf05cpR86Np+BMuqAZw2wM4EsAVemgvE8Y9ulvP78cnAXiVRejR1aELbAImYAImYAImsFoEOH6nVnH9CMrj31d5UxAngwPpIGABuvvatgC9AGOKaWychHcUgBt0EDXbpFjZ0mG/qgz7tiR4WYBe3gM6W7H8JBLWHZrqRx/fTep5zPvUhWdGOjPi7cFJeNY+Y75Pieh6Sf82otyZrJBJt3Lk95jvUy8MJor8eNyI7q3t+9KSrz3iWhag2ybc3flUV9sA+DSAq08giqI7mqt75jyB/ohI7upI6NWtb9+ZCZiACZiACZhAmQQkvHI1OIPyuvq+K+3upadxZfrOkdeJZZzXQaC0+yq5PBagF6gdPaB7V0I0hd8hrDf0sHDJAJdJ0Di9LZHLAnQ7nS69nbl8hdGwf29pcmCB5jrYITmhIj2k2E7p57tFEp9XbVa1HvXOF/hzAdB+gNvY/aHVN1wYwHcAXKLDyTdN4pAfVw5YmBrsUZ7rwhKf+cyz3V/P4vNc/Ka2M8cySuB6r0jI6+iTqbUC368JmIAJmIAJmMCQBDT2Ym4OrkwbMq9ZnxwUDMGx6B0BfCw0Nd6/t24IWICek6s+rq8F4BgA50kfT3OeauHd1SFQ4LxflTjviJaXC1iAXkyA1kwZP6jfDWB/AD+MWl7GEmXhhjLQgRITZE3BDLr7hGcwi8QJG77k+rar6RNHXYhme3g+gB8lIXqsLzb1gYdXIvSdOxygaGLvfdVzdI+W+7g+28KUrqVnn/fMhIO3H2iCdmjmGszqN8uTIymyn7n6wfw7cxz6Xvq4vlY7/AvAbWLpp0XoPsj7GiZgAiZgAiZgAlMnkINHvh05W/JK+1XnI23tPQAYDOG8Q93WuAXoOfjqo5APKZNjDRHZpQfkTwDuGuWgCM5l/m1tFqDnF6Cz+PyQSDTI+pia8MxnQ8Iqn4/nALhVNMwpCM/1ZzBH9zEK/kAAr4iI+Lo9SVvPb9fnURQ3I9p5P13NkGvg883K6uiGAM70gKDrql36/BINXwfgUfFe4vtpVTdNNPE3+762heOcI2BVrIrWagt63v8IgLkBOFln251VfXJ8XyZgAiZgAiZgAqUQ0Pj9TpVtHnOKTUl8Zh0oEILf6lcBQCtNi9DdtU4L0HOw1cP5yEg01pXwslaRdD0mN2MHweX9XSxLtwC9mABNbuy4LhqiHP8+1ijXOR6L/9k1R6sx6dgzATw0CfCrLp5sxCv3FT8N6563x0FkNyZPcNX1dSIBa1d1q8HA3wBcDcBvLEht1MwG/Xe9i55dPfcvWNGVDjmyWf3eLOicIGZ75W+237+EpxwtszhZzMm4TapVMueNH9oSbVlN6NDaZrvKUuvi8e+zJrQ02dnVczdkI1I/eUIVBc1EtRSjLUIPWSO+tgmYgAmYgAmYwKoT0FiL4jNtKChAr5pN5kZ1qDHo48NCtQuNbaMyTOXfLUA3rGn52V4MACPytg3RqC+Dds1EnRJLVL/R4ZJ0C9CLC9B/BbADANqjTGHmLPuObwqAkzNPB7B1PFd9T9I0fJwH2a1uy/G5iBD/UpRmLNHyGqRsBYD90KU7nClXv8cI6C932OcN0iBW6KKalKBVCpev8blXRPDYb1Oiswbj2TronwC+B4CJS/ibvuj8M98D/6gSrp4x582T42YALhD+6lcGsAuAHQHwz5zcy5smOFeFNe9N7wwmr6SFC7nnSPA5kXp3EzABEzABEzABEzCBNQjou+4yAGi/wRwuU4uAzuPPYwHcKBhMQcsZ4sGwAN2Quj6w3wDg4R0uO59VHHUCjK69Q9hudDkrYwF6OQGaIsHpKy5A1+0jOFtKuw2KJdz6tttQtGzDx3nQ3eSNLbuSt0ZE9K+iVGPwPtVg5chKGL5Fh/2hxKgHAzjUAvSg7Xati6u97gSAkykX6nlytisomjCqi7u0hjgaANs+RedfbmCBpb5ylj1Htm5Sv7DW/WwD4HIxKL55rArgahtt7HNZ1r4mxbvirvcHxzgvjQnNLsc7Xd6Hz20CJmACJmACJmACJRPQOJ6JB5mAcOrBYxybXzsCTr0Kr5uWawG6AVc9mNcH8IX0kddHEjVFX/HjkiLfpzqy3cgYpipAM5qTAuois34SQBn5tuoCdBZIr1oJ7c+LZHRsQ31HPur50AoFebE2eKwH3yW3My41fyWA18TkBQtX8ktPL46uMyVrELRf9VzuawF68DZbL4DETkbs8t3I/nPsA9f6SgXeM0VnJsPkPX4t7DQyCz4P3CQi54SD+c/rVWB9PCHBmr8VBZyP58oDRmgw6vwGEbHCf59V/uIaToMCqR3x/sh+DBNzDW7Lu5iACZiACZiACZhAMQQ03qQOco0FdZBibmbJglBv45j+VZWtKgV5jz2XBLrG4RagN+Cqh5IfdZ8NX8K+PrDzh+QDI7FdH5FAFqDnjyKbggCt5HO8V1psPKXy6Hx0LBfPUb3ddFXnPGtdZGHEOUUwbn2L4Mvcb/0+6H363CoBwvvjpNniZJnrtH2sXsj3BUAv60UmbZqUSX3tOytrA17LA4Em1PrZJ6+CYBT/A2Llg8TYfkrR3lVk8yDPO9pr8Dn8YEQ7MwmmNu1T94RurzTnPlOOxK57xjMy+i4A7h9WHTy6fj9dlq2Lc0u456QuhXb2jSVPynXBwOc0ARMwARMwARMwga4I6LuK4yxaQ/LvfQRYdnU/y55X37O/CDGe7gMeey5L9dzHW4DegKkeTH7cfSD5wfTxcEp8YVKn/XuIfBYKC9AWoPNjIeFD7ZHJBZ+V/Ej7mpBRmfL1mJDzZWHPcLNKfMTzArIAACAASURBVN4HwM6x45iF6I+FLQcTjXLL4n/7r4H5z6iX8a6xRKkrCxTVNa0dODjyIGD+uurqiHpSXkUNdHW9rs5bnwRi5uu3Vf3bIeHnrOtKdC7Fj1j9ci7P+QDsGQlgmcSPW9+Tg23Wk57/b1UfRjeukttyEqAU/m3ep89lAiZgAiZgAiZgAn0T0HfVgQAeN/JAkrbYSYSm9ne4g5/awnqO81iAXgerRGZmq+eyBHpcdhXpVy+GPrzeAeB+PQsvFqAtQLM91n2e6TvK6Fwu9+bWt8CbhRQKEW+JiRkKRtqYCPFhVfKvZ0SiUJVzLJl8eY9adcF7fDOAF1eC0klxg6VEAGvAwqSstCeQ72/bE3Pqb38I4JphfeCEEJ2MBeY6qer/KgCYrIOrD2Z5HM910gF2zpNZv4uJrIMA/CHKkiffBihe40vK+5mTAOq7b1s9L08L4XaI/rpx4TfYUXXEiUbeTyl9YFv35/OYgAmYgAmYgAmYQN8E9D3FpINcZbZd2Li1/S3X930tez2NOz8C4E49a3DLln0sx1uAXqem9KFDQeuNPXpbSnT5JoCbVEl4/hVlbOoluWzjswBtATp/5O8Y/rv3DpGpb+G5HqH4yaqBUwhXdDA7MZWJv7nRh/uZAB4C4DzxQh2TP3RdGGMyLvZB7Ask9G2UtGzZfmC943MfQQHyah1NzqkvZKQ7E0JQiHcUdJc1u/G51f7YR3w+JqT6mpjduHTN9sje8ZzoeROAl6SJHvYps3yXm519uL3qk4b8+12j/+YEOre+V6wsS0P9P+/lVgCOch+wLFIfbwImYAImYAImMHECfdkpjg2z9LZTAXCl78897my9Ci1Ar4FUsz/nB8Dln1cIEavrDPMSleh7eMOILuxbcJmiAM0HgYLm1JMQZquHC4YBP034txhIxM1iCaNgmfDwvfHMsqx1L9S6AHO9sAvZI4kv2Uu19R61xRPWhXf2Q4yGphUQtyFtOdRH8DcTo96yI2FL1h4cBFy3SrjGNtB3f9hila7EqTRo4LPIxJBjEzRzedl2n5Mms4Z8ptpsHOoHZVehvvzpALhKpO9JxGXvTRMc/AhgP3BKnLCvSflly+/jTcAETMAETMAETKAUAjmY6YhK67q97TfOUTX6VnhyleT7lV5913qztQC9BlLNCj0cwBs6iu6rXzoLTkwmxOReQyw3tQA9vQjo+lLze1Yvor2rJFxcYs+tb8EiX+8vkY321QAoRNZF5lmPcP1+GAVIoSlHAY5FiK4nE/tQFdX9wpgYG1KIVt9Ev1zaBHXhASwBmu2Bkwm0QhqiT2z9zTvSE4r9dQB8MepiLM8R2xLbEQc9nOClX/xr02ROfTJrpFV0jmLX+0pmN6eVBf3yuY0pcl0fA7Ql4qo09wOr0EJ9DyZgAiZgAiZgAn0TUDAPk1h/J4IT+i5DydfTmPPbsQLX+UfarS0L0DN45uhn2mBcMT7UuvaRVWNn8iNaBwz1gWUBejoCNOua7UzeodePKGP6PQ8hPGexlX9+a/g8M/JNYqtsNpp0hTmicbOI6H4igK0GiuhuUua19qn7Q9Or9uXJr7bv/oLWJmdVgxbagzy1IwE6i2S7pwzN87SBZZj72LMJSMxkO/tCTAiMRcBUpCzvgWV/LIAfNJzMWoU2kIVo/nmvaiXB86sVFUxaOKYIdrW3W4QVR9993iq0Bd+DCZiACZiACZjAtAlo/PTsKjDjBYUEJOSx+tC1o7Jw3Mmk3scMqMsNzaKL61uAnkFVD+W9ALyrp4cyLzG9FoC/RbmGWGJqAXoaAnT+eK97JueEf110PPVz1u0mGF3JiGWKRRKel5l9zPd6mbDleFCycxhTArUsGNETmbYcXKXBSQRZBPXhD62XBxM+vqhDIUuR1XsCYPS3rttHu/Q1ziagZ4iWPAd0WN9tM9e7lX0MJ2y4suPfE21H2b6GA2p6X192hHX5vZgAoSe+/Lzbbjc+nwmYgAmYgAmYgAmsGgEFWm4C4KvVt9XVRzQO7LMu9P3JgK/H2wKyVfQWoGs49VDy95fiI6frCCF9QPGatwPAJGtDRvZMVYDm8v6dF5xwkFUAl3ZTzD09ouuGmEDYqIegCKE2R4/zx0QE69ZxYN9Rjfn5OjFmYhn5zHLM8nne6P7W+vd6tPeNQ+TWcvS+bUYWvQ8el+0E+HcOIParlgl9oiXBvknZ9PJ4JICDF3xumlxHA4AHAKDdx5B9Y5PyruI+6jM4ecN+khmzuXWdE2FZlupbTgPwiCqXw7tTufuYpFm2/F0cn/vBi0VyU3rkj6X/U50ygpuTlO4PumglPqcJmIAJmIAJmMAqEtC46aYAPlvAeF4ayq9DP7lSlEma3FB1oHL9PtwQ/l6wtjMUo0WvawG6Rk5L9rnc+9M9PZT6oHoLgIcW8EE1VQF61ZMQ1n2R7xI+qJz55Na3AMHraWk4BfsDI7KSCaaa+Dwv2ullDrwOI6GfFZGA4tC13c6iZa8fV/eHfmcI0T+OHbsUZ+orRfSibuvedB4J0PTjZ8Rml/fUdtlX5XyKnH1fZV1xt5FESqjd0L7n3pFokAMe9jslTgz23Vb0HJ03PPYfNcA7YJF71mqZM6rJenqRnxDvi6lOKCzC0MeYgAmYgAmYgAlMk4DG9MypQcvXrgMtN6Is/eH1IYh/oMOgpo3KMus7m7yY6+gd/gadF9+a+1uArqHRQ/l+AExc1vVDKV/XPwJggiDOsgy9pHSqAvSqRkDXxVxavNDz6Y4DCc910fSD4Uf63R5E0/y4ZyFzyyrBITPdPgHABePFx31Lj/DU/eTJA0Z7Usxn1l6J+WwDbQs04sd29OHot7qYrZaQyEj91/nl39rLv+mJVM+clD0yDirdskZt5jgAtG75pdvNzOrOlhzyASzJg2+tNqpxGS15WL/5Ppq2a+9nAiZgAiZgAiZgAlMiII3notX4id/d2xYg9mrlNfNPHQuAkdAX6fC7cp761vf1xwHcwQEP86Bbd18L0AlPzgjKD9cL9ND49dA9OpaxlxDdZwF6fuGxVAuO3J4uHiIr2xqTT2mioy+RtW4bwQSfzwXATp1bThjYWg/X4ESZEZf97AvgngOJ8w2Ku+4uecKMkZ+05TisI77idptk/bFs+WcdLzGREwQU1UvoI7u4zxLPKaFZllTX7WFSdlkOai+00OIqD07uus2sTTVPUD4OwKvTuKeLCaVl65fH53eXExK2QdTnMAETMAETMAETWHUCGg8/EMChBYzppYNx5e61K53iVACKzNZ4fsg6UVDGmQCuCuBnDnpopTosQCeM9YygXUc/6/wU4q4XM1BDRz8ThwXo8QvQ2eeZYjOtXZgsjiI0t67bdr13ytf7HYCXVrOuXGrDDl0iV9sRuvP0kPUo8VtX5XpevAzFS9Yd85x3iH3rCR0/XxWCQj8TO3JrS+jXhB09tOUh1sX9agDC9vsSi4ldIF7znHon0n9bvux9TVgtcqNqK2zzd4qBrKNjNyaZ+z9a3TCpqVZnlSpC653yNQA3jHca79T2KhvXt/cwARMwARMwAROYLoHPVLnOGHHctx6wlj7A7zt+53HTd2UpK/LEiAFqDOxyUMvyz40F6GAo0ZUZQb9TJSu6Qg9LEjTrc9sCEg/mpmQBerwCdF1IZXIpJmq6ZlRw3z7PEpUpAp0F4LUhPp+cxFCWqZRN4hrLzb6AYszTBxTul+GS2VOYo8f8iyrP61+1xF7C3m4APrdMQTc4VqIiLQL294u/Q9LnPLUmhi4EgJOkTEDIwWCpArQGiEzIyWS+f3FbmbutaEDISGja+PT9vpi3wBpDMZKHKz38UTAvQe9vAiZgAiZgAiYwBQL6brtKZSfx7eqbijlAusrfMw9PjjV3Df1NOgbLd7UetLgm5dRYk5YlXAnKHCTcHPDQhN7sfSxAJzGGDeyWVeP6VA8PpD6WeS1+LPOBK0WIswA9v8gytAVHXXhmp03B7u5JeNY+i3cXzY+s+zx/ojqUUbj02ebWVhRu8xLNt2cWMi4G4GnVUn5al/BlnYXd+c46zN55dvvPlcf1KwAcBOAfSUxcJPpcjNhnKmFrF3coAXqvKLtFpi4on/uc4kzrE7aZoaMk1rtrle178Q5nLgVHPi/WTjQofGZM+JSwBHKtO1GU9o/i48UfBYvVuY8yARMwARMwARNYbQIa1z+/GtPvU8C4XkEOXKHLqGdqKSwjx52ljUElNrOcX3DAw9IPigXoJIjxQXhT2BV0/dElqw0uHf1KYQ3ZAvS4BOgstDCpAIU6RrCdPzpzfqSzQ+9jq9s/cDUBX3SHj0R4zozqoj6jyGnLwRUL3NhHkGupS9Tr9Z0FRNYLlxExASS3RSYENJAhD/l4d9HG1BezTb+msL6yi/st4Zyy8Nk8IhIuWXD0syITuKriJgB+6jayVBPK/R6fNyb/LHnyQfX/sPAN1KB2KQg+2ARMwARMwARMwARWhEBe6X88gCsWEF2sseVjY4U0x28c0/Hn8gCYj22zHoJCm1SxynoIgIf4O6MJsnX3sQCdPI8vDOD7lf8hIx67XJKgRvwxALdP11+6Nls6gQXocQjQ2S7iPADuH1HPl04CKR/wvrYsUvwhEsZRwGCkbQk+z4tyqAvRe1YnYjQ3kxFw63qyatFyzzquPkFA4ZgWLd+KndleWI9NlhVJgL5zTDB01WeKL+1QOEHoCOg2W8Tsc4nxkwAcULAAqQhYRr7St51RFG4fy7cP9dc80xGxSqtUEVptgAlsOEn4z7j9Jn3Y8qR8BhMwARMwARMwARMom4DGxhwrf7JjnasJCX0z/h3AlSvLS+aHkv6k3x+tLABpJVrC+FPBDkxsfnUAXGmpcja5X+9zTgIWoNMH692qh+B9Hc8I5SSDNH9nsqTSPpgtQJctQNcFUS4HYWQuo+kliPYZmZstKf4dycro1duW13ApnXZO7HjB6uXzyLDmuEgUsIQXZFNWuc7+FQkhmRiSL1RuTfqkvhLUSYC2z2vT2l1uP0X0bxHRB9sXHP2sZ45JVulx7ujX5eo+H61xwJaVuE9f7R07HhstU3J9GKgdNOm/lrmejzUBEzABEzABEzCBsRDQuOhtAO4bom6fQWp1Thq/vxvAvWu2eVqVS13uvYUI0Cy/yvxgAIf6m2Oppm8BOokt74iHoEvLAjVeCs8UDkucPbEAXa4AnT+smSiTPs/3SwJonz7P9Z6HPsAUwmkpIxFTXtBL9VKFHZzr4LIAnlWJ7Q9KPu5D1sG8qLJo/msALwbwxpR8jOdbyx96VsKyLqxeJEDTz/z9fuHPW8Vz76/2nRPRdVGvcxesdoDaxevCJmKe6P1lrz2V49UWGFnMRKNcCpmjo0vhIB/BEwBcu0ocy0k1bo6CLqWGzlkOtaG6fdWs+lprZc2sY3OAR5l37lKVQCD3YU3a4HplXut4t8USanq1ytB2v6k26vfkarWTWXcjq87tADCR3lYDR0Cr7bFcd6xyeDDSWd7PLH8OgKBdCANhFGgwZG1prEkNb/dCNbwh+cxz7ckL0GrkfBi5DP1SHTdyPUCc1flAw0jDeSq0jX0tQJcnQOfoW/qyPjF+GKVYt1Voow00OYcGLd8E8CIAH6k9O4sktmty3RL2qUeh3zjE95tG4cbkD11vP4x23BfAZ+Je1hL29PJgIgv6fHcVAa7z3grAkRagO23+6vuZbJPea1cqNPpZbeLrMZFLC45VnOzqtLIbnlzP+SNipURXz3nD4szcLX/M3DW87R0FvQzR9o6dJZp0mXA7TwBrjGIxsL36HNuZ6u2Pf+f4rOuN12EfVG+DFvu6Jr865899WZftlt+XmkixKL067SfficZDXLl7cMc6VxOC0sJ+AWDnKnfV6XFQ7h9V5oMA0CO6hLGnJsS52nvXsO11wvMmNX7ufSYvQKuBU9z4VMcNXA8ckySx4c564BarxnaPmqoATSGVvj6LzLKpU/przNSxbtuIbq8LnfcMz14mD+A2ZIcs700Kz3yp0feZ2yIJ7dptwf2dTR83ajNc1kRB9nKpfvLgrr+SzX+lLOLwaEYbU4j+0Rr1qpeHEpV14YWt54q/rx9WABaW5q/bpkeILUU81v8ifWHTay26n9rpmdEmGB3hAeCiNJsdp2edk+Z3Gfi9s1aJ9S5kpHZpkSn1KMlm1LvZqw8BTOOWtUSTTSs//4tHFNY2MWailRUDQfibkfabAOBEGPNb8N3C550fffx9SrXq4U/VR+mfY9zxWwD0ZdT/q5Nj/6A+wmJ0N+2qlLNmwXk90W7b1N6Y94d/Zx4gtkH+sI2y7akd8v7UBs+K3CZsf3+JH/qXcgzM/8cftsdZG/tSTfrz3/t4Hkupm0XLMZX+U21XAUf1iTq2HfabW1crFRnJeon4M//OBPTniz6TCeh5DvaX7Du5Ioh95t+ijf4m7PbYXtlu2YbrW26nbqOLttxyjtN3KCN3adfZ5Ur/Jnet8RqtH5++RjCmvke4qu3Y0FSU+6rJNbraR2V/QXzv+5t0MdIWoONj6lUAntDxh5UaLQUqNtxSG60F6OEjoBU9oUgNim9MFnfLeM61DGTogZkEwlMBvBrAKwAwoQC3KYlC+V75EfMYAE+pEjEyWp1biULeWq8MTSywbbEuKTCzXjm5wk39lu6Zvvlc0dGlAM0JnetW1/nBxNrVYq/1xY7KfclREVk85ATXWnehMj05Ep2W+h5drBbKPEofxPzo5QoJfgSz7y/hY0DEcqThjeKDxW2jv/akMUs9iS1FEQoluwC4VrXyb6dYaSjBr60SnhYCNEUVTpoyoICrOE5MuQ10LVkKedVEW/SHP4/yntSjmzmJwfbHJFcMMLkaACbq5sQHhWZOdrS5caxCsY/5NH4ey92/A4BJUjlRQlEwb/wIZztc5RWDbfJdxXNpgqzedjkZx3ZLAY595+UBcLKEbbeNbz8m7D05fr4f70z1mUwer03ipfvLcbY+jYMY+EiLTPk+t9GGFiGisRrHCvyuo/vArLGaysd/Oyb2LeGbRN/zHGdwXMMVmG0EHC7CcszHTFqAVuNm58rBKpcBdCUU6YFjp87rcGBSqkBnAXr+D+s2I6BzR3zJ8BhmciVZIeRlWSV0PvmZ+WEVNfLCKmHVu2oCxRQG1/VodUap7w3gPlFJOfFfCfW2XhnqthxctcHEkm9Pk3Tq0xhxeJOOJu/Utvgxdx0A9Kkutd8svU43Kp/6nesB+FKhXr9qD1+oysgkvl4uulGttvfvah9chcOkMXmiqr2rLHcmfZwcBoBJS7N11XJnXu5ovrvzcvzlzrb40YqKa/N9rPvK52Q0Hu2oOGHO8S5FPwqB9Y3Pr6L8Zn0M5/+3VhSeJkLWmgyhwMLxPT9yObH27eQRzvLMKv/ihH1knwQ0kZAjRfn/uAKNOXboXX+VEJ45ETJry+LvWoJMtieYdQ61TQmJs/ah2EeRj2I0xRS+w06qRUC7LZ6bHJkoGrfPtlW/FuuWAnGb9i31+mY743fD7UNwZvvdYY2bVjkW6Tf1varnp34JegR/I1aFM2KWEyra3EaHbIWLXVtjN+b4YbRxF8FC85RM47QvxzihPmmdzyWR8kkADujoO3OesmtfPUO3iefEwQ7zU5y0AK0Gw4iMr8WSKzWq+VGuf4Qe+E9Ug+E94uO+zY+ANstrAXoYAVofUGwXXEJFW4unxow367eEmb+12lldsPxsteNzQ8jSR95UZs/rQjSXg5MFlz2pHsdky5GXavHDibYc/HjixggiDlQZUdTF5F22LWIECCOyPdPcZm9/zg8L9jFvqYR+Zngurb/J1hs3iOhGT0Z00xbWOqvGTEfER3JpbUTlZhQiI8e41LiE/oKrSJgngNGPQ0WNcwzKaE8mLv7wkivw9I7L73S+Czi2pXhC8W/LWiPK+2qpOXdpKwqrPhmVA0xyUTiZynE4xWjmOaCtAjdH+fXblyx6tVn1xA9ZTnjwZ7cQ72ifkbf6+DNbdSxallnHzZoUnRU0QlsE5jBgXgu2R1pJaXOE/tmBBpxI5GpCPqdD9Z18z/GbjPX0tCWDIGb1nRw/09qKfSdXuypCle2hy3Y7q8+sM6adDO/7Q1UQyCdTf2khus1eo9tzsc3RUogTC5fp6FttnjvQuPHx1Tck/Z0lRM46h8b4XMXCALcLzHOhDvfVKnQG29F60wL0/LAnLUDr5vmxzY/uLmeFJKTwWocW3lgtQM8/0FkmArput3GnsNtg5BC3Uj/yZ3U3OcqXz9MhkaDwl7HzlDrpPKHAvobP/jNTRMNY65Xlflu0UX5E0UOOH3tdTN6JET/UGAFdSkTj/K/aso/QII/LO/khTE/BLiYUlqGgtsCEp88q/B26zH2WfKzayY4x8cSPgSwmllB2tROKFoyYGeqdk4VvTshSlC1hYzLJNy6YzLU+ucr74cTq/SOTPfsNbYpulmDYltA8L8Pst1uP+KMYzWh+5rFgZLQ27jeVCfN5eQ61/yybAk5EcoL/HjHhlMumyGa12aHaX34e1KZkF6J/4xJuRka/p8oP9NFYITv1tqh+m+96rqosYePE6x0XfKfM6ju5QoQC+22TXR/vUxGh60XUd8lDz069nbK/5Ooiim60NuLmvrLLmlj+3HqOqCtwEkGrNYbqD/WdyGAiBn9yFch6gSR59Qn7R/b1JXw76z44QUNrJ34HOyBmvvY6aQFajeVN1UNAi4OuGrUaKo3+ubyGiVJKiMpZq6lYgO5PgM4zf1ym+rxKAOKLQoOQsUTK1ttSfpaYjIVCwOuqSAb6NEqwKHUFwHxd6MZ7ZwGEH+gURh5V+SpfMFkIDBXZsXHpz7lHFiXpZ/jptNR93nM12V/t6PCIEBlKTGpS1jHvI66ajC1NfJbdAyeyuCyVyXQUvTNm7mMsu9oK31VcDVFaW8mTVhRHtVS570RKeYzHCDImuu5qjNmkHTFxGicKHxYTw+tFHc06X/644rF7xnuM9kv6SJTAVvK4ReJKjjLkRCqtpA6OiFSykriS7R2acPY+7RJQW1I90P/21tGOaReVx0581ocS7ea9a72/2B5zW6TdAcdVDIqi/YH6ramNfXS/XAVK64Ah+04Fp30QwN0XEKBz30krIn7jMfqTEyjaSm27mkjMYjQ1DIrQzPsjIXre98m8z4v3X4yA2l4p4i3bOdsScwfRzq2JaFsX0Uuxf1OfxO/51y/QLyxWo6tz1KQFaFYjB85clsCZmK4+pPTyen+8vJo8cEM2MQvQ3QvQeTDJRBMcZEmUzFHEQ7aDZa9dt+Wg/x2Tb743TjylaNZ69AN9CZmMlLO53Ep5oTap83q9Njlm0X30gn9ZLH2c2kfYotzmPU7PIq1VmMAt267Me64u9te7meLZmz3Q6wJx43NK8LlQRMtfqsOxU+NC1XZUH0VxlD6DQ/QbWYDm0mWKZkOKKBKgGWxBcaupYFBfycN3FsUTJsbSpuWoQ0VVLdJO1hIAudqGy4I5TrEQvQjZdo6pj5loU0BbOgqA2RdXwl1pKzHmobBWW2QuBrZFRujLKmaIvmyee2lrX90nLS9eMnDfqW/4D0TC7aZ1UG/DnLTjKkhOomvcLw/7MfSd9ck7BtVxNc3Lwyd6asFFbbX1rs6T7StOSEFPQ7Y1BWTScoaBRU2fJTKiDQ51hBJsRFgejXuOje8m1WPfwQ5dtZ+uzztZAVofB2zI3+vY/1kfz5olaTrw77ry1zq/BejuBOgczcGOlxGHz4gOVR1afZnoUO2grevmZYc8Jz/Gn199kH81LjClJVz1aB4uvaMQzUzA+YU25AChab3X67XpcfPsJ8GGH55vmHOwMs91pryvBoDMkE2xTsnCSmmDGuQxOzv9ESkKOfp52BarNsMJAX6AdjV5v+hdqt/g6raHD9RvrIIAnT8O6a3LqHdOUI1RPFmvLWnCQoIR9+VH5YETnTBf9Llr47i6aMfgoMcAuHe1ko6TXhonSewq5T3Vxr3zHGqLeRUBJ0UYbcqoU255Uqit65Z2nrEL0Lnv5LiFeWBukdov/zjWb716EMovwiaFlou6L68cGf6JKi2Bn8aJXMnIICwmZm3qBiAxff+YxOnSMrdpzUloZm4PrmZgouN5BPWm11nV/SYrQKuR3C2WAnTli6PZnn9EJnB21I6APnsQyXoo4SORDwIzpdPLZ5GP6Y08oNnJ8l61HJjeX88JQUUD6j6XrQ6xVDZHdlNE4pIVRjbQymFqg5b8AcFl0ZycYqTHxdMAdayD0zZflnoWb14JH/RR9cu9TbrnfO5kqVDCwC7fpdrAXQFwCazbQPttYN4zSvw5XyRw5sdESVHzajO/AnCNKmKXkVpNP3TmZbHW/mMWoPP7iUEa+wG4V0qezfHOqr6fKJxkIZpJ4tg3UpCe2jilrWeh6Xly384o5ycAoGc5I980Ts510/S8Y92v3haPDqGPyTPVFlfVq3ysAnSeQOHqVgYYsR3zG7OPoI0+23pdiP54rOZlsrgpBRb1ybzptTQxx3bHfoN2RUOuwGK59W3BiHmu+p5nLF9qoIzu6aUAnj7nPTWty1Xdb7ICNEUfimCclaQQ2NVHtz6EGO3JDmAM21QjoDl7RR/mNgVo1jc/5jQbfLlob8yayq1v64VZ9gl9v5Ty9U4OEZpRdPRhnEJkR+4D8guYCeAoQjPal8LOqlixLNrnaVKH7YLP5c9GMHm36L0OfRyfO0YYL9r/dVX+7OfLCAP1o17i1hXx5udV31Wqb7gi5+8AgB/G+T3c/C4X33OsAnR+Jz2kWhHBiCMlF1xkbLQ4wWGPzGMzfivQH5oWYvQ/tbjSbt3kpfvMjfGksHnZKi4j39BVi3ZuSrE+Fnx7fLsyoGlVbQ/GKEDn4DJGO78qJcfs+zuradtqY7/8Xcn8HHuFzZO+f9V+27iWz9GMgGz1rhWrjYfuOzVm53PAVVTUxOYRoNWWeB4K6szvUULQg8ZE9ELnah1GdXtrRmCyArQ+1vmi7gAAIABJREFUDmiEzijorl4OY5wdmaoA3XYEdLZa2RzAkwE8tlrWeeGBks/lNs6M7/RSop/jJgOUR4ktlHyF7DkZRKGA25Q+8OrR8fSHI4vbBYsx+ms2e/2sv5de7GynnLw7fYAoxjbuo+RzaABICxj6TfLvEv6HLrdsNjiQpu8ncyjMO2Ad+h5W+fr6oOFkGSdvr7Tg5G1XjPS+o98xfY/7Xnk2RgFazxcFZ3rP8rnj1tX4uKu6b/O8+d75kUlxhd6VGqd4qflytHOfzjHPi6qVLleNU05deK6TzZMiTFbIyPzXJiFmldri2ARolZffNJyoYj+hVa/8PbQAuNxT2uzo3Fdywu6JAGhP4HFbM35t7iXmtJF6XAHvcH3PfSMsJxex0dM9yfqtlHGJ+mX6Wn+4ttq9zTpdtXNNUoDWh4E+nK7c0YdT/oBm8oEPzZH4ZciGNlUBuq0IaC4dpFimTul+4Vl0xYEExdxJcynyAQBeU0WZ/D0SCe07oNhZX5LGJfb0h2Zi0Kl94NX9ofkyY90wKnWKIoAm75iAh1nD+xaQhuyD+7q2BnRcYr93hyuBFrkfDViZo4FRHPyQceTzIiS7O0YDSH7g8EOnlA8C3rEmUmjxRIsQvu/6tOEYkwCdl43THux1AC4b9Tkly4O1npT6hDlFPyYTO83iysKdS25ztB6jHdt9LDxvyLO+ivFTES3+0xUL3BiTAK2yss/kas6bRS1OacWIGm5un0xqze/fk9xPbvhct7mDvpW2iJWN1CSGbosaG3JSgn72i0xK6L62iwTYFy3gvvK3OQNaGdTX5zizzXbT97kmLUBz0PPzFAHa9gylPoAo+vEDWsulSv+ItgC9eBJCLj9ip0jx7CYhIGow0nckaxZ32eYODf84tsO6uMtIJwpQijzpu6zZ645+6RQzKJT/OfkxrlJ0x3odvaJQWX+bxccFo+fpJzfLQqXvl0Zf15MAzQ9T+uiVnry1Ly5tXUf9PO2omORo50IGc7o/DVgpbnLCbJEBa1usfJ7ZBNSG2DdxpcI2BUXQs8T66LpzRKb02YeMRYDO5WSyN753mYi0pMmEUp6/bIXAgAUmuORqMrYr8ip9bF8KxzyZTIucV0Yi7qnbjs1TP3l8//tYYfnuOMEqTNaPRYDWO+XG1aQdrVG2j++/qUQ9r9VmNX4/AQCDaX7kMfw8j/dS+2oFMblz5eDQ4rO0MOojTHa+TC409QuHxeRGCTYcuj8GHjKg9TcWoRu130kK0Ho500PmmEaYFttJD/13AOwSpxjDANUC9OICNAXTm4ZoSP9EvQhY/fI3Xqw1NT+qHq3DWWhGOH4uCc958Ko/bxoWIUwOQEEhf8A3v/pye+aP3l/HUjYuodZLRgLsclcZx9FZcOOglhMEbFPyMl31yDS91O9ZLe9/rwXI1hut3oOMsD++sCWiWj3yu3h3sl/lNob3Z+sVVfgJ1U8xCQvfHV3l01gEg8rCCQxOZPQpzIxBgOZzxh9+CDAq6dEDvfcXqdshj9E45dTKE5qi/TtS/+k+av2aUX9xgWqC/WWR84JHeMJjsRadudFzmJP1Z67AeKl0AVpjFP5mlO8bIlmm2/HZ7VjvX37L3THGmQ4kWOw5n+cojT2OqOzRbl9A36qANtpT0A1gmTagY5mYnslYS7EM1HP/lJjE7zPYYZ62UdK+kxSg1YAfGFGhXc0OqUG+K5aWLfPQ9dloLEAvLhZz4MekaVz6MsSguu5XSI84zsqrja/lu5Q7y0tXCTqfXc1S3r+KmGZ0ZI5O7qMd1gV0JhygLYcE9ClFG+VlqmTPKAsmTVVU/ap7JDL5E61rlpkx76PNjvEaeubpVUghoKv34CJs1I9xJQQzyI/l3bnIvY79GCW7YQKWr0UCVd5T2yvKFuGkNv3DygLt6pF4uq/lkaUL0Mz9wPEKregYTcRVUH2vfFqkTks5Jo+16PnK97LamyJ5SylrKeVQP853OgMLrj9A/pFSWLRZjmz3SEuOB1STSX8cecRpyQI0x076TqGlACP4uZU0hmqzfS1zLvWTtMK6bdgrejy3DNH1j9Uk++UiN8eFChBp9VzIinaZ+s+5R7hyk+POEiZ9VAYmV2SSRa3Y9oT02u11kgK0bpqDRgptXTVenZcZnTkzvcxD1113de4zW4BeXIAWzb4/5PLAh8tA6FH4isjYzjI1ifyqJ8O7QQi/JViI8B4YZURB/WcBeSzPUxvPbt0f+r7xwctBBreu+rA2yr7IOdSejwNwnZ6Fo0XKO7Zj+Kyrn6fHdglREpmhPqhZ91zqzrJa1Cm3laktHVWtKtu9oP5I0TFsO0zuyv6kybuwDdIlC9CHxEcpkyNzdcmtCotcb4N/H+fQxyXrmhP9THZJr/q+2lgf99jGNfJEOpeFM0GZrOqmblXQBl+eIwdu/LiyRLpr2CKNdZxcsgBNiyI+55x0YsJwRUOXMOnaVntq8zz6PmEk9G4OKGkT7bnOpeeGq9G4Km3ob0N9y/0qbP5ow7FsEIA0PD1/Q9+jKkHfLdcLW0OPA9Zv6pMWoCloMelFV0tG9VAwqQuXCoxlIGABejkBus8lIXXPvA/EoIi+W9xkATLPLFxd7GQk9LMAXGEgsTOL+UqieFDlecflr/UI4U7f7AWcPNfnhSPL9OOrCAwKCavkD60++fUAHjWivrOAJtKoCBoYbQuAFlFbFxAloYLrvfmliPRnW5in/2oEwDu1SkBjG06MUYgr5YOAN6myPD0+yPpaGlmqAE3f4jfFO4P+kLeICT6udvI2P4Es/H06khAx4eVYxvvz3/F8R0iUIyeOVRiMw/9XUh8x3x2VvbfGTrSvuhuAY0caCV2iAM0k6Vwpwu8uJghnQEzfwUZlt761S6fnnXZvtE/gtxw3j+3ar1E+Owzc4KqvoaPy1R/xm539fxvjL32/cCUNv184IVTCpjaue/UYYP1amZwAnQdDXKrEyI8uBkISIbnEkZE3TNAzlsZoAXo5AbqPjrAuNnLpM2fi2aa5LSI818udz0GBk5H8XA5Pe5G85K+P+81CAv/MCA/6Wr8z3e9U/aGvFCs5lEG+b8uULupfg6YHh01SG4OWLso51nPqXXS76v30sQIGqZmj6p59DS04XPfltzJ9EDCqkVHGTPA89IePqGl8x3ZOH8q1bKjaplyqAM3l+XxvUixltHpXARht8yz9fOL4xfC5PMWR0P83EpzPAm0K2KcPMXYsve20XT71eZwIYQ4NfheM7T1aogB9eCTU2ydWh666BV7b7VJ9JL2JuRJC32wWodshrW/2m1Q2EJ+Nib6ho/KlhTEqmPYUbUUFa3z1icr67TYd6Xjz1orGvL+MZIucZFk22nveMoxp/0kK0Hwg6Hv3ZQDX6Kjh5obIZcT042rrweu6gU1VgGY286sW9OG8Vj3nCRMua6F/65vDz1FL69tcrp4nTnYMofteUbi+Z//rwjtXFnAwSAGe25T9oRnJRlGe/Q23sQ6O8+TdzpE9eyx9Z9d9c1vn1zN9QEwsdTEJu0xZ6aPPbNIcyLnulyHZ37FqU4yA5mSYEsf2V4LZV1J/8qdoU0xo2cdHQWkCtD7+HxTjXiZltPjcbutUP8pvC9oa/XXC/Zf6bUan0WOcQmjf48V2a3dcZ1Nb/GcVJXjnym/7yBEFQZF0iQL0W0PMf4/b8sIPA/O6cLUNv1UYRT6WwLyFb7jHA9Xnvi5Wjg79flcfRK9mWnqyPG2NvdRumAD0bQXpNrpnrpTgCjO377UfgMkJ0HpAueT4GwC276jhqhFSGGOiDXlEjWGmb6oCNJesXK2j9tDGOyj7jHFQSR89is9/iJN32dHVrS5uHVYf1x1IiM7WI1xlQAH+RQCY6CIPXtvgXvo52KdxIxN+7D2smox4ZkQh8v+XJi5uxDP7P+/qJXob4Vro35U47pgYGJbSRlSOT1bvZ0ZnaxvDe3Ohilihg/T+YZQxs533aUW1EUaVhUlc2eb7mNQoTYAWg59XNimXLXics1Fdlv7v+uj/AoA9APyjp/ZWEpcsPr87IsItPvdfQxpLMS/MnSIqssvvhDbvsCQBWn3nSbECdLO40aGjS9vk3de5tAKC7JiUkNH5fbyP+7q/oa6j8caWlQ0Uky5vU8AYTON5+lG/vOVVGLpfWlHSYeBihYxpdM8fBXAHt+11H4fJCtCXDu+YC3b0kGoQyuUB/JAey0ufrWWqAnSpEdD1qF9+3D8/ljpLbOVAsw+RJvtDU+ykRcIzKpuES0U307eQla93crzkmICRonTdy3qogUFf1819DF/GT6mSUD4mVnuofXCf0jf1nUwSy+h2D07brTHx5OQrJ2FL9H9mdOZrWh6wtkvRZ6sTyB9A/CDYrpAPApZT4heTTnOiso/l6KUJ0Lm+SpocWMUnKY//udScCcv6sn4ZmqfeL5tWKw7eF98/Q0fiDc1kyOtLhGY0Pi13aJE0hu/RkgToIetvFa+dE9Ndu/pO4eokvi/bXLm7itzWuyeNaZiziStOhn7H6/qcgOXK8hM7+JbTu4bBeI8sJNhK931a2HD8tIP7XpW2PVkBmr6p/EhSJFjbM5kacHHJDpc89vHB01ajtABdhgd0XXimQE7h+SNR0W34PC/aZvIAlgLW02LJDz866okRF71G0+NmceLyLgr1Euin4g9dj1TfJZa5MfpFQoz2acq37/0kljN56+dG8rHUN6Nlrqd3EfnSB7YUr14N3M6IbNn0effkwzI13f+xqq+uEzzPe2eaqKT3JCO0+xBgShWgh/4wnbfuxrq/vgEOAfCQlvJylM5CFnB8x7w3om4tPg9fa+r/fg2A/rBjsLYqUYBWkE/besHwLaT/EqhNHhqBTH28k/u/y/6uqJWwH0+5zdgPD7WpfvkdTgugtqw38v2ozdwovhXJQByGum9eV+88Jb52255dG5MToNUQuLT7mx1+fOvh2z8ShFmAPncDFCNmZGdm9iEeUnWKrJ+SIqCzKMRs1vRqZWQvxZkufJ4X7axznVHsZCJELjuR2Kko5EXPP89xsyLFn1Mt//xunGRIwX6e+2hj37oQTQGadcOsyEPUTdN7UrvnMnH683MWmVsf0f1Nyzj2/fTM5kQ6Qw5UxVN1z6hsRsV4Gx8BjXMeWlkA8b1eyuSGyvGzaFuMBuzigyjXWKkC9Pha1XhLrA/RvSvf0xcONMbti57GpXxXM/CGkXgWn/uiv/F19L3FCOibjmBsVaIAvTFl7zEPAb2XaenIYIghNIB5ylvqvpr4v0KscGCOM25DTpSov6H3P1fCsG75Pmhz0/3RU/wr8c1YwphTZfhOREGThbdzE5isAH3zyvuSCcy6aqw675Mj+/OYOlZHQA83i1b3NuZHPJcMU4TmVmI7qoude4Y/NP20ufWdDC97ZXP5DxMy0H+KiUBLZdjVy0krPPhRSN+6RwHYK/zBeM2+LVM2uk+V550A7juylSMb3Vsp/67+nT7LHPiX0gYkVnCVByeOSuzrSqnDUsuhtkWLsx8AOH8BS0HJShNY/H2tmGzuun1ZgC61lfZXrjwpfo/0Ib6KH6T6mFRiW4vP/bWzplfSu55J9JhIvOs+sGm5Zu1nAXoZeuM4Vu3xe5UXNPMJMcBqKlZFbdaQnhUmdXxeAWN66V+/idWMf+lwwl/3Tp/plxZw73m8yT/frJrwYz6IkvvaNtviPOearACtRDldC9BMCMYEaWNqfFMUoDmDxiSE9Crqqk2s92DWo3c5G0wRhkksufFB5cu65EjQnAyPYic9mfhSYDKEIcTOLKxxySFFaAr69GMsKYp8ng570X1z/0O/btYL+yb6eGvAV8LSJU0e/L56Hm8fz+SY+s5F66ev49S3bwLgR1Wk2g4D9Xf1+8392q1ictj13ler6OY6jEjhR+UQ79NZd6T3wX0AvKuHMZkF6G7a1djOqnfaqZGQ/IQVtBbShyRzTtC7v++gg7G1iSHLq4mBZ0VwS6nvWQvQQ7aS/q6t9/LjARzUw3u5vzvr50qKAuZkP/WCnQoYc6lOuWr7sR3XqaK/GfRwPADmdeM2ZPQ3r69+9vUR+FVqP9tPK519lckK0IxG4CxwVx9HOi9nmXmdMTU+C9D9RUDXhWf6ktO2hZnDubHdjM2/OLf1S0aSwkekZ6BPD+I6X4oi9Idm9Kf49pXAcciOXi9kvqwVfUVxiDYMzETNrZQs9eo7OWlw48o/k7Po9gJup/WIIwepX42o+BI8YVXnnHigTQxXK3RtkdAOUZ+lTkD9P6NRONFVSiSkPoo4EclydT0mswDtZ0ME1PZo+7dblTPjnysU6afniMnWPxTv6j6t19zK5iOgMTHfucwDwei8EsdXFqDnq9ex7q1Vv1zlS9u9P8eNlBxsVRJrPSdc1c/ANW5DBxOpj6HVz5d6GGup//pg+E3zfTu0raC+q/5QrXy6MoAuo8BLao/zlGWyAvQDwqesq+XH+qDeo1rySVP4rj925qn0jfa1AN1PB56tIk4Jn+dXVx/HtI2o21psVGel/Xu9/DeoCkgPYr4khxA764kRGQFHT0ZGI3Gbkj90jlTnvXOSjNH29A/j1tWk3DxtVP0yRdJbxDPB4z0onYfiuffVe+guVaTEB6KutRpguTMvd7Tqm0kndy/0g3i5O5zO0RpU3j0SkZXQn+idw/b/2XgPdS26WICeTptvcqfq42gJxkjhMX0TrHV/eoYuX72nv1zlKbloIeOHJvUx5X1yrg1aEv0tvjk0Ti6BjQXoEmqhnzKob3wmgBevSN/YD7mzJ4+YzPGBBVhQqC65opzf/Vxx3PW3m/qKuwJ4fyG2b/lbmvVymNv1uR6JyQrQTHr3hg4fVs1+jNFc3wJ0twK0Im4lerJjekGVtOUX8XiuwoeJeposRPPP964i4piQ54qxQ99LNbMYwiWxBwKg6K9Z965Fib4GJU2uk/2hN49I9cdFVGwJ0dAayHA1ANvNlCYJmtTfIvvohc/lt5yAOav6TfuhoTfVNSep6GG3Sn3g0Gz7vr760MtEQpwLFfJBoL7/RADMT3B6x1H2FqD7bnnlX0/9HJMCf2Tk/VxOAPX5sBfpKqCnr5qtT3CvNeGdl3cPvdR7UTaqK35/UCAp7Z1rAXrRmh3fcXo3nxQ2mJoQccDJ+nWpMca2AOijfZECJgDVrzyjygHykp76FXG4AACuIqfNZAkrO6VvHJlWGpc0yTd0T2EBOh6QtivCAvTGRNVR0ZeXEwJDDIDUcfXhAV23g/hi9bJg0oCjA9UYfJ43rtXZe2Rhl4LEkwA8oRJ/t4zd+/5wydejIEFbjrclGwrNXi56v2M6Lj93u1YeWq8AcJOB6qXOre5XqBfWmPiWVFb1dxT1mZ267+duLRYqB+1gaI8zxLugpHoae1kkyjAL+FB5FeoMNSaj/cH1q6WaLFuXE44WoDduxU0Evo3PMp49tOqN9lLXS1ZDY/wo1buYk/icuC7lXTJPa9CYXH0D3zvzbjxWtmbsT4Ze/t60/Co361ETIl32h03Lpf0sQM9LbNz7q//g6hCuEvEYcOP6VB/80MhvNHQfnMdYHPcxqK6vPkXt5WVVcMFeBVm/kQmjwHeOvDt98di49Qy/x2QF6K4fWAvQGzfuKQnQ+cXw81hmxCUzijSdguBZt+W4XERD37+2/K+vAXwegJN/fUJgShG3rBveLwVfTsYwQpaR6poUWeTDbOMeYOM98gciP5LGZme08R32t4cEMdbl18NvrwR7BL0rTwPACZCf9jho7Y/+tK6kQTYn9e5XkDil9s4Epx+L/o19XhebBej/UM05FmT30yRqVMlx9VvjhybHdlGfbZ1TY8G3AnjQSIUWfezfuVpNcHhBH/tN6kjtcS2f6jOr1WBnAOAKOdrh/SstI2fSZia54ooxJv063xpeoxtdo0k5+9hH/eHPAFy7Cgz5e0He5Bag+2gB5VxDk3PHRfJirs5zHpD160d8aCt2swLGWdIzPhqTWixfX5OrGnOyH6MdFL9dS4iC9urOtdvwZAXoBwN4S4cPrBr+GCO6bMHRXhRD9h7mYJbRIowwpefz2H2eFx261O+bL05Ggueo2z6T2GRLFN4TJwboQ/aTuMEpzcRnW44bRlZqztwOacmhjyQmc6BfoZMSLvbkqV/nCgRGJmxV2ACNGawZFciPf394LFbHpRylPpORkXznlZKIUJYzirLqckXFVAXonDRZ7/pZ7ZL9Om1Q+LzrI40C36ZVImb+XmtTtOl65y7lOZhVjsznNpVP5mdGNuGmMcLWAOjzuV28R/oKHFikbjPzPJnOSU++d34Q+UA45mMytN8C4L8pSEGR+pqoZ7/B9yfv/dIAdgxbOU6gyl5O5WR7Lbmt6tl7ZSW6P7mgtmgB+j8tKK8SmSWojX1CLj/Puj8mxzwq2qL6+0We+1U+RoIrI43ZD5dgpadvNQYdvGPAydVjYxKD5RkqeCr3/ywD3zEUxzmhWX+uV7mdrndvkxWgGXVJ76uulizoQbxHlQHzfQM+iIs07KkK0N+uEnPt1JKHUt1ug8b4zw9/ItbJlETNtdpgToZHHvShezoAJrTh1rfomfuCv8ZEwWsiKkSRW33N5i7y3LZ5jNrnFiEgcUDBbaiIWdUNB6X8aNekgT3imte6BqzMyEz7gVIiBCROMini3TqOSm1Oy3suQ0D9x24AmFhyqH6jfg9qa32ILVMToFnH/Klnn/9Vlej2xwAYZcmkv7Sf4CQis8JzQoB1ki0QeDwnyehrSS/Hy1bJLK9UWWTRU/wqADZJlTqWSNN6O9TzwH5Yk25j+SjVs12ajdOs/qo+Duc+tFyj7d2nqoS3xwDgxHZbIhc9SNlmOUahiHbj1F5LFaK1woDPIgWS7xYiQk9RgJ616mM9AS3bv+TVJWMVpeWZ+/bqOX2Av5PXHYLp+dgfAJM3dqVlNR0H6h3++5iE42qKvgNJxOTRVULc1xbARO90sbmVJ1bO0ZwmK0DvWXkTfrDDDyMNMB8C4JCRdaQWoJeLgM7RXt+oHjcm1vpEPHZTsnVo+uLKnkgXDv+mx8ZSxyFEz1x/P4z64yQStynVX54koV/3SyMybaiBTn0pU5fRi03b7pj2U33SfuCIggqueqUPO1dCuF4LqpwFi6I+nZOJtHvhRFZJyyHZ/u/Y8QfSVATovMqLzYUe25zMp8DHyQeutqDIt+xGywOKe1evIr7Yh1G4pSitre+Exsvej/q9p1WJf+lbOYagBJVR309DjQWasM9lowcnl6kz6Iht8k+1E/C+9LxKBNQu9UnuLO5l0U8TMPnUnDhhENJ9YyKF/9Z3YMU8rGhxxmerz6Xza5VvKgK0JknWipJnu5INDCcJyIWTcIx4zZNxmSP7wjH5kednjRz4vmCi4D8WMhnS5Bnqc5+s0fBdyxUYQ0/y67uZ/t1cYTaE17GuuX0kwKaeMDQX9fl8bpXwdQg2fbbPptearADN2elPd9g41egp3HAJ6hgGl2o0FqCXE6DJ8eRKrOPMJBMs0lMuR/s2fTintF/dloOR6PQgvnsMhvtmUfeH5gQCI9i/FgWZihCdI79vDYC+ldsMNLOsgTr71t0jemlM/Wrfbbh+Pb3sn1h5WDICtBTxQO/KewNgVJ3rdOiWsvz1NYagncL/z95ZRt2SFFk7/gwOjbu7M/gM7u7OAIPr4O4M7u7uNoNNMw2DOzTu7u7u8Oer5+vY3Ozq876nqk5aVWWtddft26ckMzIyMnJnxI5PeARrDRsBtYGDRaJpU2ZQLB2A7gPP0BcQuQb/I5G94SUwRPLu/93XOIF8Wn/CSD/dy6EGEfbYDdYmok/Dzd7uWpz2DeI8hY6NNGoix2remGpMiE4n5Rvwn3GpjXoj1Et8b7IP2YMRDKJL2T+6N5Yd6APSei+6eiMvvk1Ef416KmAcALqGWhtLB6A3RcQTNUrGyKGeLcJ/A8aKqoiDFIBnuMcBn5mL+OMc9J7b/5w8yELZlAGQ1qrt/nb5pTfsImlf0/zBjQLV3IDilbla+nBfdg57etmOTvM9BcdNa2hNGToan18Ea33u6PDdZ2b8N6wWgKYKOkTlqTZFMqKAVg+ZWVRXA6DHO9UyMPzNCeBjPc2UKdsAleGGqw9EX8apMNigldjshJsZTnif5wcLcASuZWwZExYKoi+I6MEpJDqhBK+r7PUXOu7MC3uRIKVhD9eydd7JxoUxBHwGhC4xfvtJng0UfJw1gzDr1Jxpvda6B8ctdryGAw+t09A/AAT9JmEU9FIB6D6ogR/9bM8ohM+ZK6zhoPunadGBp0JwTwCefoVW6NZmRm0XQJkaAb5N/deceIqDkzXbPs1nfFuitlPtnXbRk9DGAMyw/yIDI9TJXP5CqK+i+DiOj/M9nOu8Bpsoeast8Kdewu11Pxp8l7EZ++xSAeg+8MwBFNki/MGWQhEz9YI7HxoVDubIUqB+C5fGsbbDor1sIu3k4IjsgbZ/PqKUQhokZFSa61hrwee9kDj7jFKXgsM4lCZwrJZ1Svb1to4jtEzPA9muMEW8wPenpbnMtUfg0O9fnLs7il+GQ6CJC4BClEaqkyMpG0LFMZ6TsjUAejoAjTNxfLe8jDl6ECu6opRBL/FdJjxzlYXsXk7/UNJZD79NkRroKJ7rBZTWEt0u2wk3JyA0RSNLgJj9TXtzUIfNUC2ir/SowRJj12+p1l841wGRao8CHCbpdhcS0LyER5+UzJL2WyMifYMm4nzdBpdI6CjO5YYhXyIAHW7mKKrzaF8LBLAx5rEA522zSIfV4fdO7xRe+NyMa410B2G/BAxRoBrgCK7sGugP+rLXHCFrgCww6FAEsG4bpxy/hxlrAHhQOVEEi6sG/6wfWIHteXpQKKsGWYYHS9fswMs3FQb/lgZA6+CDfnF9xFPyoQIlMjK8dIAX0sL051GYJaKxC/eagNEc/LL2EinLNQeaIq0x1AmgqCd0OS1a9MDoyxafwgM2aqCZkG93f/dprMm5AAAgAElEQVQJSu7JNC+O7lkvFIWtAYSWjN7rB0RNp1cIQGvyEv3CaQ2OVAoQWpv7/+mMxDUaAL3RB9WEhKbiNoWcHRkBTl12KUIYpliQmsjpCVcDn6dvP5QmSbQNdCY1ABhhG0hDhd/7f72La6DlkGPB4g4IfZUC4xJG5UDFwYJe0uGZruH5npSd42+op0iTq2E+hRHtnDYDxDTHLJ9epPyS5uQ9neO2Bn3TOo3eXcqLkTUAepgWyKeFj5Qo2CeZ2e/90dKH7QJsBIRT/I02YlO4atiA7iXlvh+cSh+HjfLmu9Qm1nwi7mqYy2qpfGzWDUBTADeCBEL6sF36HvPZEIgGICSQAZpG0bEIPIn5zTHv0jzhkOEihQNolgRAh/Pl/T7uZAZBqcGl4LhNPOJjxo97xWeOvdYFAE2NjfP4/0iBeYxt5373az5AlUrh8ebfH5CWZFFLoT3ZX3z385vZVyoYLwV81lKgMdR15iUHK7UUe405b8e+a3UUHHKkTuLchCdN5JxqwSGl5qLBqMwBkGwR0NMjoDnJPnUDUsbaoY33yzjd109Va9n09FOQiWAg1ZMFRQ6gNsJRBFHZS2RD4aAjyug6BSKhpQtksVzQI+VLpotWNkRHaI5sOgeupNiSmlkDKKNxfLvzuIZURrXLtLVvfwloo4R9IJ22Bn2jxdIxgDSKy6ba3C4pAlrzFIocNr5E72mty0VpMGS+hUA0PKkP6rKU8B8UDa3owyHvynWP9gQELRAZ+/XKoqA1PwD1KeQnPu9c8tkGVMkfgeoQwAF9rD3jNDxkUE2GEEgvKVuBf1fufKu3JrSP2/q4BAA6HNNv+D6BDDRR+6UMWulniFCPgbo62ENlWdRKyaHDTlGYplqjt+lgjb/rYO2DfsCKjpUcR/kGBLZcsZK1K8zY+bTzptcwlpLVY7raYPcraFtrkAVtWB0ArU0BPHE40aT9ptgY6Z0sOgAkcA7WGNmwSRHXCkBjqEgxnKIPYQR0A6DjmLdaAWj1LuSHJqUbHkwWFqXTLdlpki0jc+C1HZ0RKZu5KR1qSvuKo/Hp3iKbDj0QINLJEmX+jO2BdIbiljdvDtlY8VV9v2wEoBoFwKasqyk6KLtxp44uC3qQVGDVEgDokDuUAoOAZfiypSOet+lF6GuTpQMVXqniudvayu+yg8/s/Ic7VrZXkB4TiUjGUS2BALInFBqE+/tVlUY97zX+YYT2rZzSjXtL03FofMnsoyBhqYykuQPQ4Xr3YudNZ28gYDjnwV24F7m2mb3IufJrWZP7c0Tt+oCZcfBVSgeH2O6c92gcwZSIpBdfbsnMCY3VjbtimByu1LLv1TyDW511qzRPNnoiWVGwmZo34AZr1u3VAtBMEip1Ep2cwqEKiazZgMHtVsvE3GYw1wpAx6LgaAD0Ng0b9nvtALR6EdqPb3kUDg4eNiAnJ+Ywqca7i00+fSQS+nUdyETETE4QWuBIGDk2l0O+eKMw7E2Syyk9wo703xou6QtcsvDHqVBiDW1rbdhNArnozsa2kroC6NkjPEI2lc7NHYAOo/egmnqoC3pOfixtxcZQxJhod/ggc65RQ3VTsv6tt5Uix4pSHPqOFPdprNnAk6XCVTLaTn3URp6aKzfwNH3mMWM7hyxT9UPUC7Qb3nKKXNfAWy5ObShsoJor4VfNGYDWnuBnTgmDf8yVMuJ52/xH11RMnPottImAhBpBaLUJ+REkyDxfM1CnsdU8hLqH2kil1zKNE5RHZFXC113CVmzSfeEHHO5B81qLngsb5GCcIonKzto2f5f4++oAaC0CLBA4pNdNOIml8JzgcZI3J8edSQLPK1HBZ0g0eZfKAd0A6Dimci4ANL3t03K8zzfsHHJx1R4xNnXE5GxgK6g6j2Ob4kBvr/bpW3BT3nBGNnaqvKc+F6akfaGS6Gf6ovG7u5k9OWE06lS5teemS0A6R9HST1QYdU/GCnQSqfyyOQPQOtzjbyLFkdVcD1PlR5y8izqiJgs8qDnXqKEzSG0iNZdMqlR6ObQ93CcdhorhCpXITfsq+MfZxBMJmCqLYYysdrlX7edQ7AEJ96RD29iPyC+hi3MFoCU7uHDxSck4U7BGDYcj0rULdxQORIfiu2uuD9WP1PdJTsx16pWwjyqhg6n7Oeb9YWAgBYBPlQiXGdMmHZa90A/Qahojyet4zkvNYUsN3Oda58EfoYGrSWZjxj7GvasEoNXpp3gBiFSnSFK023l61VwUba0R0I2CI4ZJifeOOQHQ6nWYsozzREoSmwpSbgREh8VB4kmr3JtCoIk0XWhscm7wxbdNxe9WkHCzHmiM2HTAHVeDI0ZL1Y6bOJ/4XNbIcrNtPl+WH3FMpzubSm8Vu8fy9+CvR+9SRezMFYAO1zCKQxM9NHeAT3aFwxCijkh/zblGDdHhkLbvXBWk54bcz6yrukqme0s3mcPQfjGWc9dNgX+yQ0SmXquwfmpdJrKR7AFod3JHoM4RgJZN4VDkemb200r1U3MGgJx1UNmaQ+xUrnu0TlNU9FmVyjGXLPiO5gNBk4CXtUT00jYKOnNIkMqXmipntYfMEjJMUmF9Y9qnwxVsKlHjP6hQbmP6s8u9qwSgNZHv5pW8U03kGiJ8pyhHA6DHpxk2Dugpmrb/M3MEoNWj0Kb8xu0MEZ7QRYTORHyplXmjbCogEyA0G/1UdrXfw7Dg6yX8u9qolpFGfV/V+FANnUj1XGMzVBJE11HEpAHQQyVW/33yI9gEkBFykcKgiiQme3Fwl+F1df+fKcCVuQLQks89fN1aSvaObAs0RBTTO32FdlB2GVoJaiuUAldDfmK4lQGqagDs1QY4n+HVLSWfFNY3PMiHM191GkpRnkgXqc1AjYbca/PcAGjp5sc8W+DXleunqKce6/zUNczvcF4JLKROA1k4tYGbKWzAXu/UoR/7Ggo6U9i59HjJPnzei+f+rcAh1bYx6FNISY4lD1Fps8aOeg/UfchtW7fJLdfvqwSgZchI33pzQklLyT7q1UpTbHJSNL8B0A2ATqFXY98ZG4BW0Q+MfY6rT8vx5Y579JEeFS0QWvfkaE/qb2i8Ltc5JBSwwc7yJ8diL1urjftaF/S9xljy+DfXvxoAaB3a0Ra4Jtl0r3mTkXp+lni/fAnsQW6O+L36K1tBxA7cttLD2OnRcwSgtel/qhccXAr4LF2QHSTy6N0d7c9BFRR964MutJF9CYcjpVL3ZYcB6ckMrCFNX/P26V1E7p0XSmu2KcpRhwG57bfS6wkouHwBTvI5AdAhGIf/+5MZ+DLSq6N4htI5KzuQ03xH/5BpqnU697ya8r2whsuXAns85V2xntH4PLgDUB9e8WGLuM93qfEVS2Z6j+zFoWZGVupaA6ZWDUCfzlPjU50wS8lYjEj54+85gNANgG4AdGyDO+V9sQFotYGFEx1PNe/7fe0D0fCuQcvxIb+xZGGSKeOy3zP97JJcKU/YWsb0cw5m/nVmxYhij0P/fRqX23s6Y00ANJETpJzDmdgA6NSakPf90rvU9TbG9Eq6Dy81zn+qyJ25AdDaUL7DzK7oAtWh7Rj51n6v/ApS5KkdQB9zHUpvk41Alj+ZGYDQNwvZRM3bR5kZnNSlo+1CagM4Yfn3EnVTfin94xCCIKlSsteBHFl75/XixTnX57kA0FpPiHjmIB26vbkEQKidUCiwL+HfpQ48+rZRcv22F49NtU5vs8k1/K41654d+Pz4gjZBstA6xT4LbIvgqpy2YcyYqF33NTOKnZeyp2GbZVspiE2NOIJU52Izxsh+272rBKBDbkJOkyhOkoITU6cafI8UY6pIz0HJGgA9HpxsFBzbTM3432MB0HJk4BEjoofTdC7AUTlc41s3/gnawcWCyLdfYGZUM8bB4pqDbRjSa/Xj5WZ244wLvhyLm5rZyxYkzyEy33aPxgQwAVChJgD6z2Z2RudCm8MB7TZZt98PSEBpvqRwMy9zHUjtNwbSfYACCtL9MVFgwJwAaB3gESTxr2b23Yo3lDHml3wLIr2Jpq1hU6p+ST8f6BlTuf0CZSwRHf7Jbi09beH1Qn4T68T5HezILZMYOjf0HQJMAH0/4pGFObLINrVP8+KuZsZcySn3OQDQCi5hfDjQen1mGQ3Vqf3uk5zf2BVMvEZFtjA8jMMGwae9Rv9Qc581i/otF6hgjGQXwLTIjqj5kj09k2dZHsMbW8qmSlbyhZ/Q+aD3Wri/tZd+rBqARjGJ9uD0L5UDKiWjsjEb/5wL+FSj0ADoBkBP1Z2Yz8UCoDUHSWmF9/MubvDh2ONKNff3kkX4vZ85CP1c54cOuRdjyjLnu5Q2TPExTnbPnGkDK7lyqAiwRMQEV+zU+pyyjPUtrTsP7caClLncOr+pH9pgEGF1ii7lH670NW4wYo1xje+RDYfHkWJCNQDQ0rvveYGt3yXSu7kB0NhtqrITrb4kbt1N86Lm9HPZZiiJiNBX0eJc65jWCsAoQKnSh5WSx709+m8Oe6hdbXGpQ/x+u0XDQbbeRTODJHMAoKWbApHmaDclZw53ADg5NOYqDdCFFG0cisKtXWuU7a7zfb/nNT5E1zM+ObN392qX/LhS/PBj5S29ERVcDfsfrav4oWdNGAgxVlY5718lAI2ANakVAUEovAxvzAGQkpHeQlrjHDbYDYBuAHTMOTD1XbEBaKJxX+mNoUgeKTlQEhwpSOfMlYrbp+WgkMN/dmm3b/D2leJ+nDpW/edkX9m0cMiHbc2R2id7e6MuqpbiSWvYrA4ZM82lWlKqdTCATvyiK3J06pU6YEPGbs73SO8eY2b3qezg40fu+P82kV82FwBamzGAZwDoOYIoU+aI1gZSYClKqHoFpYEX2UYOUC9kZnBX5lzHtFnHFwGELklREnJlXnzB1Bub/Cf6zvhTwFV0cbl1UyAgh3Tny0zDUTsALd38opldsFvfiNCfK5erZF0TQBf6iAoeymkHp6wpKZ5Rn3WIXxo8ld4TkQ513hwi0yVD/BvRbuWi4NxPJyRLsicoLrk2/V4tAK2O39rMnpfwlF8LOPxQRAIS8Vg7CL1WAPozviGdEvHRKDjiL72xAWgquVNZHsAZ7iou+Kse5lx7/Ls0PzS8f0Spkvqqg7K5ch1q/EglpkhFDsdJETtEXgMscFKfK3Is/gyI90aNBfxx8MjlGIttrZfNBAg8Q1eJHd7T2tfGbX1qvx9eAtI7bOyDKtM7fDHSMlNF3s8BgBb1BiA8WSPfKVBsrOSc0Ybv+R0F0K0qidCXH0LbHuL+Sa6NqcBnUt4BvqHhmOIPxxpT6SdZqu9dWQSk7Mf7Pfq41Jqt797CzF6c8YBqLgA0gWXiT0ZWc7yQNXPtWmb2usJzPpSfbM9tzAwbncsO1jKGsgHH7Q4DwSfIFCxpj8O1CVo1IqDnEJWuNiJHiuqesgI5hrKEuuc6M5FlzLmxWgBaCsnJJWkNCCIVDzQDhiHh9EWnHEqrizmYsd61VgAaw3S2iYapAdCxtO/Ae1IA0Jx+8l4BzeIXxPEiAvkc/nkBmbkiTrTR4nt/8UMx+KF/GADRc3NulSpG9DNRPLm4y+SgXbn75ltWuKhvmomaS09xCppSm9mwbSEVAoezRBA1ADq+HS35RukdtC8crNWkdwQFUBPgV4n0bg4AtMaDtY/xWdsGX5lG1IEBcGWDmiNTZ9uc1LhQKJPU61yH0PKNCMyBFqwkZY5kAA0I/tkcgI5t4zrmd83FW3q9kFK2U9/FdyaII9caXTMALZkc4sErc89Y1JjCj8s+mHWxNNAZAnSiMF1Ldo7shA4GwI5eXYn/pD0ztZTIHJqLz6B2Pr3LurxjJbLUHog6JNBwQMeRy76OWYtS3btaADoEWb9hZqTkpwCgGTg5cc/uIqDvMIMJ2wDoRsGRyuCMeW9KAFoHQKHjiPMFJQcRoicMgOhctByhw8V/ExlK1V5O/onYniM/tBZ9Dvo+kKnKtjYHgM9UkUducprG6N+S7tVceqavQaU2s5sA6G+58yUdbxHry9E86d39vaBaTXr3ey+wBgVMCqe/dgBah54ccpJKCyDPtbb5pzUKEJ6I45p0lI0paydp/jkAWOksayeRnaVkIR2EhgQAnui/HP2vyfJuikZPtUfdr9/6JnaCTKVcB8W1AtDSTf6GYu7DM9jTD9FryVs+YsnDJ7VXbYDCiwLaKmo8pD9LuEf2mIOOKxW0x5JlSDtDQBG2YC4+g+wpfOJw2ucKLtumh5Kpahys6ZBltQA0SqHJTdo7QEUqZ0sL+Le79JazzyDVODcA/YIu0pOIixInaeorC1uj4NhmKvP+ngOADk+aFWEMHy3ODulF6IXAy1ycUdgL2kL/uShGxOaYTSGXTsXnAhRoXueif5BcADRxkuDXLmFb8s6W/b+muQTdFLY21Vo3ps9yvL7u6yJgQwogcEyb2r1xJSC9o8o3GR01RFXJHyPT5FQJadFqB6BlA6iF8NgV20it6yfw6D8Fo+Ra7/eacRofpZ+n3phKX0nzBvCmiHAJwBN5qO/QAVx3heCzdEJjQqQhNCQl1m3pAN+GhxvwJoc/VSsArTF4u5ldfkE+i/YV8L7D/15q7of2UAA0oDhRq6ltYFzvZ7e3CTA9o2fnHL2CMZH/BqUiWW057MBuUjzwtGwpcuXQiIPdEva03x+1gX0+B1rsg7jmsr/fZXxWDUBr8mhzlPLET8acUyz4opgEtabUa6IezQ0fPIkpNo6aeKT6/Ycv5LmpSRoAvYv5SPtsTgCanogyQvOSk1IionAytSlSoaK0PT/s7Uq7VQQ2mzHSpL/gH58LEK2T5uO4PYF/C3uYcoMv2/JkM7v7ijew0lPNJbJwbleJ46U1hQwkDmZbBHQOq5L3G9I7ChASxZTCjxjbI/licI5z2PjzRCBCzQB0v5CQapOsNVNEe4FHdhtAovVr2piKHzL14ZzmKlzYZF2VlAF6yJ/LBkX4at0vjbU/Y+6vBYSVLrBXfkImILCWvofjpSKD+K5wtjI3lwKKyr5AQ0RQAH+XBqGFycA9Dgf5nADPMfN8073qKwfEZMKmxKfGtBWAlNpJX5rhvkpz9W5m9qTCa9wmu3KRDm/4yIr0vAHQXWr4pc3sbUEV7DGTcei9LOAsWi/yYic1G1ItRBRrO9SNTYqNo5waCsPdoBCo1gDooRqc/77cALR6KGBUm/EbdYs/hfTgqS0BRMt2oKuk5D61Kw4EsKrU8TlQTMjeEVWODUy9uZW9gsbknGb2y0QgU/5ZMe2LmktP62RxpwzyH9JKbW4ofHYW5z5PDbIMaVe7J54EpHc5C5Fua730jsJ7p0toG2oGoGV/4UO884o2PHvphqi4OJAgE+5YFYAvWsN+7NQHrP0pL0XcUVzqpgUBD+kmlF1E3HKtIRpsPxDqkl1R5XcXPMAT+EUNo+tl8qVqBKA1J8lmxq/8QyZZpJz3ene4Xr3TcZEU+/4xfZHevcLMbrKidUpjgf9EbQJqE9UwFsxJsjEIygqpaMaMacl7JVeCoMiMrWGdF6aAbOdC0xtrDFcNQIcnfqkrjMp4iG+vZkBEcuFv0v6vkAiwCHneHmFmFMjSgp4LVGsAdCxTEv89pQDoEIgWCE01eDbqd/XIAO7J7RCEoC28uURrERnAPKr5QAtZMc8UCU3RV6LLU4PQej+O6ytdRrkzLOLPimlv1Fzi1J/T/9SyH9JKAYE/MDPSDHNxSw5pW7snjgSkd2RukLJZk95xgEd21xqLEDL3sIVQFK2RX3c/sI+14t8KArBqW0h9AAAJIJuKBzmk3YN+A2qa3P6N+i0bAQj+shn4NnEs5ea3aLyhRfmkmUETUyIqNaTLgi8+x1pdIwAt3WSvih+Vaj6m1Kn93i2Zk61E1lLpqFt9XwUwlybvvcZC4wDtDoCvsBLtoUroh2zAbc0MKr+5Rv5rrfsvp3eqwSeVbNkLEV0OPriGg9dVA9AMsAwaqTTXdKcrVdExKfrNzOyllTtWUown+kLLQgAfbsoLxxdQjWqvXDkoBhoAnXJEd3t3aQBarQ/BXapDkxJFOpgOSUJwdbceb3+6zw8NDx2g+Jcrtyeaz9hATs/fmpGGg29BfbTm6FrNJW0sanC6tJH+iUeiQomw5jHaPvvnd4f0riZqg1DviLz/TSK9qzUCWnP//c4rq0PWtUaZ9td5aB9YV0sAff0Znov6QPugC5sZB8SlrpAa5p87uijWhrWATptkLhuCDwr3cmneUvQRmwlFQ+pxqRGAVuFWfFiihGum0pwyh7Ve37ALCnhVwUMotV0A9Nq44KX7qtlS+iBAayGH9WQCp6Itm6KzY58RrnT1gOs8JR3k0PZprefwGwys9qCyof3a777VA9BSRlLDX5g4Qkep9Dj+RDToqtHxl/JfrTuR+Z/EzngfVIMj+2HOhZMaiG4AdAwzkuYdtQDQ9A49YU4ogvYSna14kG/g+T2kyUgjjcO/VRyJyOin3YYAmhBOymtftMShDeUR1EcpgVA5TUTrsJn9WoZNU46xn/INzSUyTR6QWO5D26fxAQAkwmtJ6axDZbD0+6R38Ibeo4KIKuQdRt6freOI/91KAeh7doXmCDCYayRT7LkjX/DIHhXORrtUFHAfgCFa6/pBFlHsPYN0gLWBNSLlurzfuOm7a0u5308m8unYh7EfKwVGyW5ClwhtYmpfszYAWrbg+2Z23pmDcHvpmw4VyFB8nwedlTyIk66LBz/1oUfsNWXK+9TH43u9nxMlxl+GtFF2WVzccx4HRZFT1JHsL2jYSq/zIYZAwNSVE/mkQ8Y65z0NgHZnC2eTFKejuvRTpDqElBNUu/zEDE5QKUQIV85pMkQsKhIH4/Z3M3uOV2eHtkRAdOxCJA2Azmluxn2rJgBaLReAKj28ZVc87X6+iGkRSZVBsUl6cgx+b2ZX9CiZmp2DMLWMCBKuFLZWspJ8iFp/7IrBFskdGgToEEoBDKEO5yoGN87qtLtjSoCsKdbyWiJ5QgAaHk/SybGdKSLva42ARgaMCeB7jkjGmPqU+l2ykxR9Ys0oBfapn7KRHJ5yiJqK+kA+wxs8E7RUvwUEsAFnI760CNMp+is/mLofZLuVWrulE8wNCnWmPriqDYCW3JVRV7OfPUXP5Itjc07W2YHPmtnxCoOfawSgpfdkygP41gCOCpu56kLssmTMnvDeBW3qpv0Qazw0HF9dQcDU6gFogR/8TZEHil6kXOD1bgp9EHVd8yKmSQr3LYXPUsolnIjhdygihpF4bgf0/dXlxb2xqrU3AHqqq5L+uRoBaPU6jP6gWjTVwf+jiyg7pjtsOHG50no0X77r3MqkrebiUB+rBSHYTMQ2mSAp7UqYbs63lEIZO4JsrBxy3y99VfXnGpxagSvY9bOaGbzmKYDA3LJu3zsgAdnwWnh15TtgmzlYhwP5L4n0rkYAWvMemgV83bXaw73mqOwksmE/oOKEKQ9Jh9gL1jGCZL6RQFelp8fuIq8+bmbQjJVYH7QeUHTx7M7NXvP+aMi4xbhHOkkGCZkkJcaGfvTBwLVFQMuX/E8/xE/d/xi6M/Ud2AQAsDMU1LdNOrcGe6AgJzLByRJlvucMaurrTAn+96l6O/Q5zV0OdQ81syP5gzWs87SNTKRHZcgyGSqvVPetHoBGsBICJyGAnSkXeAEfpBufp6vs+s0ZgEWkJH7YT2VSgkX90yC+xdhwES3Own+I/zsWP3QDoFOZlt3fWzMArd6FUSBsmogwva7/mJOWQ5sDuOU5Oa/ZOVbbrt1tNOF2S2lvNU5E/FFJeg2nyptmnmTOoeeLMsl8mwUQ4IDuktL6ucoPZLf1p/1+RAlI70pHVoYtk73Bp7mYH4ClOPioEYDWOsHmhk1O6ijGuc4JNqRfqiQ9V3YSv4L1MvbaLlCHzThZoDlrWoT6Id18Uyf761W8L8qt09rrUHeErNAc/tKmPmrvx17sIh4QlMJu6tu1RUBL7nDHHpxgHubWq72+pzGFKpRM7VL6RvvWFgEtnWcvyWEg2AtXSWBU8x5qJmgnY68/pfReQD+BUPiBpYF+5KC5RnAEeyL2rSltbCnZ9/ETMslf4P1NXWtuW5/lb4HR/kuH51CbLsrB116TWC8nwoBNMAJIyXsko/p4D/+veUJLNoDlRIQclDhisa8cjENoGHDA4YdmgnLtKrsGQG+bjuV+nwMALecgTBUlffQh3WHJ+V10OYBo5om41OFvYyMZxWgmHH7sLE4WafApnVw5UFT1ftxKQRfZyWt1QDx8einlPVRltMbyNxGHH5iBzg7tW7vvwKaJ8X1HV9zsMpl9h73GQPaACCNoi2TDY2dF1AZAh/0DRHlzBP9piXqudVO0MbmCLrbpa6pDA60N/+7F0Uv1V9+9SReFDQd0uw4vAWzVWwqu3Vqvf+HBSD9IvF7XBEDLduI34a9GAyUqVPI+HU8pe4Bo1gpAE2zHHrKk7JG/9J4sMfaV0LLUvq8cOqVkX25b+GBvE+aF70j0O5jbrhjXUHmUuK9FQAcbEAYaXtLUpyGa1BRfYjFjIa81ZT4Eea/i1TmPUajoGm3B+HEy8QwvoIMzhOymcsVpk0jEC4T0VHieAs6EztmpO0qGPy785CqHsZoLAC1ZiHID/UGfbucHTPCpcaV2JuSsPcvpQGpeuNS2O5nZ0xLLRnKh8KEAp9C5yqHLpb8hpxGnhjUu5QHrmL6qHUTDEyVbs86O6Ve790DkBlE8H/KIjilra2xZyg6Hhd1ig899UBve0CsktnPb5KS5RtHFM9phxWuXHF2zTR57/S6/48ZdBPTLC49ZCMIQfEEUdGwbqfc9ycygaErtp2wbF+bl99yHSjEvt32/tt+Zo3/zOUsRwpKXxoN9K0FAsXUx7FtNALTWLWwm/KzQxCwFiOvrk/oF7eVtCtuDtQHQzHXqkH2qw1rONBGLiGkf+hSGvDsW/WnMdk55l3yfE/uBElSaNeyLpPNEBN86sY2dIreYz+DbdmYAACAASURBVDQA2qUpQQgQSb1R0sR+ijt9KRfyGAqj9gHOQ4x/2gJct30Q7zvOk/PCIEpaEdND+9wA6KGSyn/f3ABoSSicyyfpCgcReXt731CltCvi82ReUGCKYga1XnJyT+pZJymLncip+HUHcp7TD/yWunnYa7zVX9K6SKGtwdGSM0vbiEIg4rD2dbDW+VRju7S2Mrc/WgmdQQjo4TfcKiGQUFsEtNYesk7gvm7XZgnIBrGGwg9JwEVJe6m9wsc8JR4wMubBgdYGDiY5oCwNQDe9rFcCsiFX8mJkKdfrGgFoMqQv7EFQMedgTSMue/AY37uUtAdrAqDZ7yLry3umg9acGug3CKbiQCLlfM89B0Q1hU0D04K6sqSuq/8a9595LYSfR17vc8t5v+81ANqlo8UEQOTLZnasxE6nTpKpwA73GhXZawdF1L7jd4bo4b55Q4F0Ipar6FqflgOuKtJV3hscJmBIhkRPNAC6JnN0+LbMFYCmF/2ofOg4SKvCcU+1mdV7KeoGRx9AY802Rc4MnMRwE6dc/LVxWmukrfSAAlNfK8wpF85yjfkDO+qrR66UHqVeC7xby6Rzp/SInpSHTGNaqk3tk83s7gk3VbUB0JprbCTZUNa8NowZz9j3hrRsAE5Q86U8ON7Wfq3rbESJvvxhxLFTX9nv4C+ULjqGLNBTHaZvk81afkcHmK/4TCUv2ZA7mtkzE9pO+lgTAK1+QxN2iYUXb5Xca6CBWBMArfWYOj7QIaXcDw2xIeG6A0b1o4jrzpDv57hHug7oDyVbLZf8DXj/AceXBPyHMm4AdCANOWOvNrMbZDAAMjAvcQBmDkoWthGQi0WKqAk5jiJ2zzGRQyCa/8ZwQ5RPYcfQgdmvLQ2AzjFS074xZwBaPe4D0RyU8EcbimmS2fspLVwU8fnvygE9bAntxaGnEEQqmYS2iajHpac1bdIOObdE5FNc69gJD0LG6LQ2GE83sztXrq9j+tXuPQBwntXTtXMdUG+TvXTufmZGlBdc9BR7iX3VBkCr33dx2qNWgHDvEZefCx0EtBc1gAG0FgAaHs5YewWtC1DPEe2dOvAm9hxr78srAc2DHPWLagSgoVIiiGTJh3eS+/09KEDrRl5NO+xrawGgQzoI/PPjVOCfI3t04VVmBh1VrDWnhB7t9c1Y+E/sPqluFBzQlw0ioIcEVcZuS8r3NQA6kK4mGEXE/jc45UyVAiEAFWUDxP3gTCZ5H1SjaAgV1eEsEtiT86Re0RK065dmBphBdBNch9v4oWMZoMYBHd9MLQGAllSUXnUOL7wHR3SKSGg5bKSWA7bWDDJo7h3dZcImONVGX8A8m3fSzwU4LW1B3+ZoUUSWVG44YEtG9amdGm8KI17HN3aMyVrGJb7VrOeN8qcu5QdMNegb0ulHl6SykTUB0JpTACf4txQzS9XvejRwekuku9BncUiRal0a2kLpLHVYDom4T1A/OQR+TyKfZGgf2331S0DzAG50ojRTglI1AdDyq9/UHQBdcyUA9D06+qEnBCBwCe1cCwCttRiqRmr41OAraX8ae80poUf7fVN25kHdvH5YBWs9bdX+h+KP7Fe/kNjWlhqTBkBvkDzgEOlogEWpHc8wtYeNmkDpOWzAFcFIW4moo4DJXYMoCoxoLiC6T8sBjQrG5DU+vrRjEz90A6BLmZ7t310SAM3GH/27oFPFUJgrJQB9BzN79gxABi3+qQsgSdYUB2VBJ8og5eZpu3bnvUN2jjn1PjO7UCVOrta/j3QAyMX9YGCp3Ip5R7z81zS/bmlmFFRJ7UsN6bH8KnRMQGwqO1AbAE17/uQcphRcXnIU3xBdGLIpJdoRwLe07ur71KihAHcsnZWPRRDJywqDTbuOWXs+vQSkh293rtpYerip5TUC0DooT9nv9KO4/xfUN/bz+OUtAjr9iIiPmIhX6mzlxE429U4A+De8bg71hJbql8sPouYDuN9REu3Nx2qRbC10tw+OuOaPbUfK+xsA3ZOujC/pwE/N5HhK0Tj9es4MFS1cjOHLIxr6Rm6w6JuikFMqst7dB6Lh9WECf9hvUCRquBHlvzl0YFNGFOaU08cWAR1/dJcGQKNXgJ9wljcA+jB90eL/rz5HU4Dy0kw50jf0g6k1RQAqiwf5vrGzddfItLZtswqytd/19HIKRS7V0d0mi6X9Lr+Ag2CiS0qDeMhX9oVCbhSTSsmTXxMArXkGj+N5zOynbZ7tO92ku2c3s0+6f5hybdo29zV3AISITIwFgOk9D/VNbkmwaZsM2u/lJSA9JIuKYIqUa3WNAPTrnJIn1vwrP6JHbEEDoPOOivZA8Cyz1tRAVaZ1gOwfqMqWrO+MtuwYB2tQXtTgq8pn+6rvjYiGlg+bV0PTfa0B0D3ZKlIRrsxPdekQJ0zMTRoqFPQRFCtjM86EUHG/dMMf7819qgsmMVy3bPK4xCeUis6k35OwMCLfJgLrUWb2fb9RBrVFQMfTgdhvagD0eInKcZhLBHRIw4G9TUkNIaeCg0UyNdYWAaj59HwvIFsT2AAlChROcyjGO35WrvMJrbFwCHLoU4NTLxARei7ARfyBVCBKjQD0V7zfCgyYQ6ZdidmjteFETllEIc0pgQmx2q65Q10H6jvEAgTUzxyFgGPJor2nnAQ0B8ggO6+ZAYqksp8NgC4zzg2Azit3yftxZnavCvwk+Uj45P/iONjS90oaAwInX1HBGEgDhWNdtTvwg3+eccAXWMrVAOgNIyllhP+IaIMcGyd9g+i0a7mDifLNbYOgIoQiUYeLlmIGp3I555BlOKTh937mnFZwRMtx0oQmAhp+2KkVz1sEdHyT2ADo8TKdGwBND2Vvn+cFAlMBo9o8kQ3BwViqjdP4UcvzhIqt1RSRSs9lOy/jXMGxwJU8Um1f2SSBMOKeaDkO1nOv/ZvaJV0jEvi0XXTPXxMOX00AdD9ycekbyl2HVWOHLWK9IHOppP7q2+/tKJQuGRGAVj/Z3F6hMMi+65i159NLQD7Ut9ym/yqhH9UA6PTjuekLDYDOJ3etw8f06OczVGCDtdZQk+yiCed3Pilv/5LGgYDTT5vZSSsYB1qtvbA495fmtzUAeoNuKgr6dG4UjuGTMHX0riY+nIlEJMw5RZxFTAD6if1kj6hM+HXC6OTtpmH3O/q0HBgYQBgKSnAx3gDQRGA2Co7d5R3rDQ2AHi/JOQLQGufrOzVGqlRnvZf087OaWcrN0/iRS/+ENhY3NbOXVMJzRq+1qY3Nb5peou0Le0kgdOg/3vkzpSNI1U7p2ofM7CKJh69GAJri2kTTLG0jk2IoZS8p2HjFwlyo2hvgo3KYo8LbuwaoSEcJvjhnJZvuFGPZ3hlHArKfP3QKDv5OZUsaAB1nzMa+pQHQYyU2/X7hJBT6O7gS+zvHPeT0ETjwpPT+uWZ2m8IHzmqV9qxQE7Jn/UlCextDhmPf0QDoPSQmZcyZmiZg9re+OVpCoawwmu1cnaz/0/lHETuGDuclF+dRH4jG4MN9h1OPI07hQtLAp6RatgjosaZn+/0NgN4uo/4dc3QetIHh1PnrZna0ROBomFp2aTP7wMIW823aIltMVAOFCFMfqG5rj34XuELRTA4p53zwOrTPS79Pcxq+YQpMcsCb6mBpjCylay81s5slju6pEYB+pZndeGV2b4x+hPfKDr3QzG5ReEMqn5T1EQCaPUKsDB6CQr5mZqeY6PtOlW97bn4SkB5CF0l6PkXKGgA9v3Hcr8UNgM43npo7cItfu/AaQ6/loxGcAyc1FGWp5nc+KQ/7kvSe7FjqNKkw5LCn090ln/U/OkrgZy1sf9QA6D30JqyMqSIk3Jp60y5lO9TMLu4gLUZh10iHdNNj+5v7/NBXdyAaAycgmsmfWrZqqaJH+B7VXUn9h26FNER4IRsAvX1Mc9zRAOjxUp4jAK2NNH9j90h3njIHh0hL9hVA4cULW8y39V9yPpkD/UetDBR8T3cowMHA3OofbJP7Gn+X7b6OmcFbm4pWZ6xs1Q6qilOcOCXdS40AtA55UvZ77JjUer90GD15YGFwICwiSfG3H0QABqSf8Fx/3sxOUMl6UKs+tHYdAKh+7wA0QVKpAKoWAV1G4xoAnUfumjfQk5KVfZyE+56hPdL+6LVmdoOEc3toe3LeJ/zpyGYG/Qgc9yVpt9R3tYGgIei3dM0ZE1QfGgC9j4bLQFDADlqMXMqo7zzDzEhLXkpEmKhNmDhEOd6+A4Dv444vw5BLvv2Jzb9JJTu6mR17osVrEdATBbfPYw2AHi/TOQLQ9FJO75O66K67JQSsJJ9HOzf9moAYAQ44WBQjO3UFDi9jL3Dlex7dB1d/qk3t+BnVnpgiAY0fhX+pop57bd+rzZr/RAETDZzSt6oRgOagnUJHa7J7U/Q3XJPu0vmFTylsK8PINADoGJGnmqOnN7NPmNlBDYCeqiqreU56+Ccz+9euXtHnEq7VDYAuo1YNgM4jd8kZjOdpCfc8Y3ojP+1qZgZd19KK3m2ThfxBcKnHFF7z+21lnwQo/pmENnebfGL/3gDoLQA0C+4ZnaaBiDGu1JG6fBNDwOBQxI8UwJQbpdhKte194eaH0797m9ltg8KLPF+KlmNb2/f6vQHQUyW393MNgB4v07kC0Brr1FWI5WC93syIzoyVxjx+pMo9QZ/f4dHGtQCDokcirRcwpAFk5fQjxpc1r95uZpetxJHXGo0jfymnoUmpZzUC0I/tCjDft82vQSou3eCwgiJAqbJyhjQmBP6wkUQs76q7AqDJRIQTPRX11ZD+tXvmIQHpIUXcAaABQ3bVw7163gDoMjrRAOg8cheOlDrrc2hvtL5xuAnQ+bsV7o/ksxGc88WK1kTt05YWQNAA6C2zU07a083sjhkjeUS7wUJ/OXcQlwRC92k5LtQ5+KTFXt7HgwmH7FOD/Rr+kJZjqMEO72sA9BSp7f9MA6DHy3SuALSc3vM5NzO8lCk4Y+VkfcHMzu1RB2sCobWeEXFB5EUt1Ah9apRUm9rxM6o9MVUCAFpfNbOTJ5rLY9sle/Jz32Cl5jesEYB+ROfDPighaDR2TGq+XzboGmb2xkoAaNYvgL+PRRhD9Y9inO/196VYc2se49a2cRKQfuA3oIcpD4sbAD1ubGLd3QDoWJLc+z2SMbgHtpe9bi6sY69WyQd/vAcFrtUHl9/2Xx0Ifd2MmN9+WhfWgOBwAAqkJexbGwA9AIBm0YU3Ey7o4/v9OSJ0w4rDcL9QgGRpRkFE7yrAeENPjYeLmSs3ED116WkA9FTJ7f1cA6DHy3SuALQW02M4PQT2NkXEmeYpRZzIvohZzGn8aOV/QnOKKs9Ue64NgIaXG37upa1z+Ue63Bd1yEExF3i9/6kSAFr25LN++ISEUvLo1QhAw2fMQX+bX9vnh2R0pY4a6JDCOiw9Racu5oe0u46hnr+MZ8RoPpQGQraPTLujlATkP7EvA4D+eEJb0gDoMqPcAOj0cpePlJpycEpPOKAn8DG1fzSlbTme0frHXhRe7loOZeW/UkPt4IR2N4eM9Y0GQA+Qtgwy3HmPy3wiEm6aSGXFOCyRHzPs0zE92vweZnY8H58UYNSAoR98SwOgB4tq8I0NgB4sqn/cOFcAmg4IsCEigAKsKeZ8GMFzLjNLWURn/Oilf0Jr2SXM7J0VRb1prBmPc/oam14a7QspJCC7fefOgX9qhYccr+oO86H62RXA2ya7BkBvk1Ddv8snha7lXYU3oiEATTCKIpYBAqde0v8reAFuAQ4NgJ4q0eU/1wDow6IiU68dJTWpAdBppR8G23y5ogyxtL1ub99VAn36yCXggA2AHqAVinYmLfxTZnamzCC0QCWcYNIB/7BQELpPy0FxlAd0BVfg4ENRFSWdI/p8gFoc7pYGQI+V2Pb7GwC9XUb9O+YMQGtBfY5zwqfmJ75iV8n9/xa+mejrh5zfE3cc2NCQcMCXAugfq7myn3/sxgSOU9q2BAdrrByWcL/GDaCXjKbU83iozNQODraJPEoNIjQAeujI1Hmf9Jg0aTiSS0dCyU4TscxeYFf91fNX6Shp3hxkAzQAuk59rKFVDYBuAHROPdR+RjVbluATal97fTN7TSX+dzimon/NOc41fkvZ+bW0LSxEDA3HdxawR2oA9EDtkrN2VQ9/z72pkiEGMLl2x9FDFeIlGONN4u8D0RftoiMf2hUNIvKDq0ZajgZAD5xII25rAPQIYfmtcwagZWPvaWbwkKWih9BGfokFXsdozKfNjAJUNQDQsuvowM3M7KULK7w7ZlzmfK9AVwo2w/98igqAO8lTek5NDYpw7grgbRunBkBvk1Ddv8u/Po/T75UGoLXnoE4KxT131d8+x3UYZV33yLTWlZJAA6AbAJ1T95YGQIeUo9QVgE4Bu85et11NAtskIB+A7ELq0u3qA2z7XurfGwA9UMIhKPraLnX7egUie2SMiVbg+/D0LBWEZlgU6awCgaTNPsTMiIwOAYuBQ5j0tgZAxxdvA6DHy3TOALTG+5odDcMbEgLQWsTvb2aPXiHQqTXjBWZ2ywLr2F5arXERRcISimyMn8HzfkK6BYUO/M8aw9JRlVqff+MFCL+VwXdqAPQydJlDOg7rlgpAa70t3b95a8s6Wt8A6AZA59T0pQHQ8o9O0wUSfr4LtDl6BetKzvFs39pNAgqigHsfDn7+nbKOyW6t3f50A6C3y+gfd2A8GOxTukN6bP93TkoIbdIBof/N6TjmfgqybQhCkB1S+Lub2Z3M7CCXP2OScww2tTcEoFlcoElpAMq2kd3/dxmn+5nZo3YAyuTEkA5OypPeu1vrxj0tHb6Amb2/Az6PnMjxmDMALTvGwkrKcyrwSjIiDZ90fIqk/X3ccM76bsn55t1a9qKEQP9YIcmG/tjMzths6FjxVXG/bOsjnD4rVRbD2M7Kb/pox31+kYBjPKXz3gDosaNU1/1as6EE+kii9XpMj7X5pBaM+PtjcEArq7NFQI8ZjXXe2wDoBkDn1PylAdDyve/rwS+1ZB/mHNP2rekS0BrNuk+Qx4dnHgXdAOiRuiADcjsze/YOoNjIzx7udhllIowoiPDLmSvhEFn0aTng4X6QFxPieUVJl4q0kmNGkciTu17w/8RbPaSP7Z7DS+BIDgwCEkLJMJX2pgHQ89AsbfjPamaHmhnFSFNEZUkfXmJmgLBLP8Drj776S2o5DgzzjKuU7VT7QjCQwlgx0sznofnLaKX0B/3CNxHQy79LX1o7nmtm+G45DiEbAF161Hf7fhjNT9G/FGvRmBYKrIhdhJBaCG/xhpTu4xh5tHvzS6AB0A2Azql1SwKg5R/hb+N3439P3dPmHIP2rbokoDnxZA/GnDMLQgOgR+qWgFAW4kM6oISNcgkjIiX8pJndoCvU942VACnInw0t/eeCDw9aDqImuUrxQ8sx+72ZndvMvuntWRu4NXI6bby9f9iAob3rDvOsAdAxRiX9O7SQntTMPmZmJ0vETyx7DQfbtQLgNWU0ZHrpDf9CWIWb9YNo4xJr2KYW952rZj+Hj2vpOzV/z2xmn/XMgtKHGpKJwDsKGr8yk6/UAOjSGrnb92V78DGpvVISnA2jk4l8IotqV9uo54mo5rCPq2Qfdxut9nQOCTQAugHQOfRM31gSAC17y8E8B5ra5+aUZ/vW/CUgG/xDMztLl8UL5jTXbPsGQE/QR220Tmtmn3AqCF6TmwZCoMF3PRKYtHUGlP+/dDAl5Ifmv+EyfaDTowiIzh15FaaQP8bMnmNmf+txWU9Qt9U80geeAfIZ02vsOLcaAD0PFdIiejQv+gSQlSJFTXbzbX6AiHTmuoBPHVk5w1QXB4SvBYDWeHOgek4z+/MKx2bqmJZ+LhZlUop+sDaj42frqMu+loH/uW9T3lowWCH0hx7e2dQHRwAvU4xRbe/sFx5PsRYN7XPoz1/YKUFiAdCXMLN3J6S8GtrHdl/9EmgAdAOgc2rpEgFoMufJwqrF5845nu1bcSQgO1ySVjRGTxoAPVGKcv5u0VV6f2FBHk0ZsT+Z2W27An2v8P7MOSx/zJCETvgJO8DiPm7cAbFEf5HzYCCMICGK86FBeuNaDgfGjJ/uDfX1xB3/6z3N7D/M7ChTXtZ7pgHQEYSY4RUh5zORuRxApHDS9E6iyC7l31grAE015acmkvNUlZENvXRQyK5RGU2VZp7nVN0dO/6+LqLyQhXplIDDz3WRrPD55jrUqDECmloKD2gA9KBJId/y+l47ojQAjT791XX4MxHGUD7X+c3sAwnrUgwSdlDPZej97b78EggBaA5CKIa160HIXr3Qe+9tZo8tvJ5oD/E6p71M1ef8I3rEL6pvdzMz6qSUrOOwFABatvYEXUAVtpssz5LrSQ161towXQLMC+bpwV22IUWE8Q3muEdqAPR0HfgHj+DLOsqFmxRcIENDBl0BBPdE3ubgOdxBfFEfDR0CqpYT5cPE5MpNyyHuZ0Vgv6FrxH961Vvas6Zx2TbIYSQ73Fg39bGDR1tjt2skewOgt41CPb/LUaPoE2BRCgBa9pLsFdLh2NSvDYCWnM/l0eb8uxa6BM1XMkhun3CDW4/Wz78lWn85NKLQH2scVw06VUqfagSgH+eH9EsGUGLNJsnoDmb2zMKAgYC/35rZBc3sqxGi+EPKHIIlUtVciDUe7T11SQD/DFufypY0ALrMeDcAOr7cteeHAuzlifY18Vvd3lirBOQPEHh6DjP7VgR/oERfGwC9g9S1uTrISeXhYyl1qhVyxFEAiGjor6+M/qFP4XB1B34BpGOBmWPUJSyMCE8PqTcU0/uFvySV4zamjaXu7Y8V0Y6kB4vLWyd8MQCMBkCXGuXx39WcgCMNrsuUAPTnXd/+uEIAWuDYUT2dGyA6hazHa8CBNRSOM9pFkd21ZPRMkVcNz2jeAnDeqyJdQjZy1inYTARbrgPgGgHop5gZkW1r9j2GzhfJCBowfJOS9lH7ip92GXUXMLPvRbCJ0k8O+z9tZscvxAGt+UndFPqH3JdOIThUB2u7T2OFPt7azL4UQQ/36mMDoMuMfgOg48tdtrY0FVf8nrU3lpKA/JH7dZniUL7m8mtj9rcB0DtKU8aa0+B3OWWA0lF3fPXox8VzyKD+yGkMXr1CsDOMqgVggcoBSocTFQKiw40LTjZpsC92J1vO9hzTJ0YraFB4AZlwndV5nuEy4uL/xy7O0ADoKSNV5hnZU4o+UfwpxaZfm/kveJT1GgFoRleL/7MCTjpFrpYZ/QNf1biTEUGGUQPMSo/I3t/XISERlKSXnibRvJ0iAQEmv+uKD57BzH6W8bCpRgAaurhbtfk0SJVkH5/hPmSKtWhQQ4LAlu90xc+hzCCIYdesHT1PAM2XzewkhQJo5J9xcPWEoQJp9y1eAg2ALjPEDYCOK/cw0wT/6MiFDvri9qq9rbQE5I9weAzlHZm8XHM6vG0AdAQtksHGsX9+Yc4kgXiiLXhtVyXzHt1pNdFkAsbXAnaGoAVRHvf3U3txMccGOvdTpT4txwedaoJodYFBSy8eyUKMHPhzXDO7i5ndteMZO5b/P/RyV7qNTWPQAOgIRi7TK3IC0ETvkM78hwib+UziifoZyRqqImiCQv76qB+a8DI5V9jHy/jza1m3Joir6CPSIyKM/8tBrFKH8H1BSI840LpiQAmSw0mvEYD+7y5q8XoJoxaLKmLkj2tzhG3ERpbkQtWhKVk75+14vP8ecc1CTynMefpCALTm6PP8IHSufJaR1W/1r2sAdBkVaAB0XLlLntCCUhOq5EFm3J61t5WUQOjDki0MpgTGouC+km0b+u0GQA+V1Jb7ZGSe1qUM36mwsxqeguDM/djBzhesCOzUcPWpHqB4YBG4rN9Qgh8aw6FT0Vd5e77h7VlipF84BvT7Rp2RfJBHpNHt1AtyA6AjGbkMr8kJQH/F05mhx9k1miyDaKJ/Qn2mMAoAxLErAqHlXGEbLupck3NzrqIPWKUvlB69sytmBpVSans+RgxqCxlQT8ycplgjAP1uH6NGabO/FimqHztEUc2LFdZr6fGHzYzib7HGTzrK5pX3lqAQVN+wH/jla1yLx9i0tdzbAOgyI90A6Hhyly2jvtGnzOxshWxsvB61N9UkgfDwFtrdueFHDYCOpE2K+EGg8PxcqgIQug/uHeIV0D+7YLBzr+HsA9GAoJxInjEAolNE3+7VntDR/1UH/sDN+FQzI1WYK9YGI5J6T3pNX+Zs4ijGeEl/W0ye5/0a2ADoScNX5CEtoG/rePUvl2jTr7n3RafgWGsEdGhniFwlgrVklF9f4dSWl5jZzRdiE4tMqoQfZb4yn8gkABzTFYO7f9dmK6L/z94+okdzrqs1AdCyeZ9zXvUG8u2vXSE9BYXWzlQYONBG880dkHG1iBtNzQfZ/xKHR9JNatYg5xzZCbvalvZ8egk0ADq9jDd9oQHQ8eQuWZLF946KAjzi9bC9qaQEtHb+pMtiPWdQX2wua2gDoCNqj5w5IspIHa7ltAslRSExhvCdUtGbaCD4ELnmdmqyy5CFNBBE/N3Zi/Io+i8VDcSmNvdpOaAEeKxzngoc4u85pp6HOnVq53kWiJSC57kB0IdJQKDdHbzo5dwKE0hvchQhJCLhImYGQLVWQEb6AdcyQG9YOHUXOxvjWTlRHBBQSPbbPk5ztIcx5FHjO+TzvLSrxP3viQ6MpvZbYNqhXmw09xyvEYCmWjqFPdd86DZEn6TX8IZ/IqAJK3WwIl1+rtNUxPLZ1U8CIKBEKwFA66Do52Z2Di9EmHuuDtGJdk9eCTQAOq+89bUGQMeTu2RJzSd8bOxrLXVW4vWyvamkBARC43+/wvE8cIA5XA2AjjxKIeE8RQlPWjhyIuxe6FxSzITKmdBy6P8LEI0skipfFzrwREE/wDfQNDY3QNoHotEbaEI+4JJTlNkcTrVCgP/o3SEHQCjpzydMzPPcAOhlANCyn0Sd7GVXDwAAIABJREFUXSDRhlgLNsAU3Fl/WzEArY0+8xNKkuNUFqWhtenJXXbI3TNHsFa5cFXUKM1VCskC0h3F21YKpOuLpl/cLBZoN3QIagSgybYiWh3Kr5zR4ENlVst90hXof95fgQ8vO6iK97F0uQawSQA085XMUfzeppu1zIRy7WgAdBnZ12AT1HOt4a83s+vMzC5o/T+RmZF9RWBiCYqjMlrUvppLAvINyBq+wsz2sg2ATqAlMuCXN7ODzeyfKtqY9cHODzkf75qK4WnI+xQRl+hOjx7uUZHck4siQu1RZB/ON98mIvGRZsZhAVesTUcClf//EaQhR+u1neKEtBCB+jkpTsI+NgqOFCMe/51y2NAjopOJ1EsRkaV3Aiyw4dWB0xwOeOJL/cBmnwJlOPk10XAInICaiOi4781sE5JivGp5p9YjDrFvmWiuTu2r5vJfAvqN3OtnTQC05hE+Bn4OIF9ueUwdyxLPSTbwKj6nAt3WmnUDM6OweKyx0wbwqr5XSbHeDhk/fffWHhQzt8ytIX1s94yTQAOgx8kr1t0NgI4jSckR3wgfqYHPceTa3nJ4Cci3w9c9j5l9eUZ7pAZAJ9BmDA9KQXo3hTWUclFLZBBdDoFoDOPLzOxRXYE4eNi41uQAAnhxIQf6fQszI9IE6giu3E55uFBBk/IEp1NQ2ix6VEsaOm1B35XyQYV2orevHMgO+ZbU/QZAJzByCV4pwOYYHlGZindT8xmu/it5P9ac8ovNQyb/5ilcue3dNlVSe55kZveICL5s+277fW8JKELxLD5XjxrMoxrkhs7Qxo94AbkS2V01AdChH3MTn+dr8vHG6qTAg2c75UVpm6hNJkW0ydyJBUDrPedzDneCZfStsTLb5X75aE93WrwWAb2LNJfxbAOgy4xjA6DjyF24AhnNZFrmpPeM04P2lrlIQP4JNbbAX2L5B6n73wDoBBLW4D+u41y+V2URZf3uhmDnb82MVGc2+r930DCMak0gqqpeGTq9xzezuzo/9NEK0Ef0I9UpHkQ0NMViuEKqi1JCDI0caUb3NbPbmBnyCqO5S7VP320AdOkRGPZ9zb9TmBkUHCdJFDUgfXiNmd1wRqfFw6Q4/i4BZdg8CtTWRBtFbxTNSv0CDrg4JK3pEG68xOf/hGz/q3wOlQbo+hJVe+7oNS9KOOS1AdCyewQaQDnWQL6956HGTlRQJaPXBAhj/8gog8c71tjpPSfrggY+nnDN3WbxJN+PeWFg9XmtWUnb5LWG3xsAXWaUGwC9u9wlQ2qXcGB4JH9lyUCs3XvV3lCrBLR+ftH3SH+dCRVHA6ATaRQGiDRyHMaSzuuQ7vXBTkL4ATtf6Q8roruWqNshfZp6T59KgvG7f5fWcH1/YW5+6LCAJE14i59w4ahzMTa6Z2qfxz7XjxgHdL6PmZ0ykFEpuo1NfWkA9NgRLnO/nDbmHJGLOviJ7bRJH55nZqRYt0jAAyfmFKiFt71WQBHA80YRAZgymj7vr2qewo9LdA//Zo7GnqdTpSTwCr5jbMkPCznjtQHQmtOHdFHrV5kq3BU8p3E7ufvwcHeWiAqWqMPNJRHQBIfEAqD5hrLY8CnPXcj2S75/MjMyn35QaM6uQL1n08UGQJcZqgZA7y53yfARfthbE63d7r1rb6hRAlpDL+fMC3MIHm0AdGRNkmPIyReFeWoC4rZ1tQ9Ev8N5fDnBKwV2bmtzqt/7QPQVHfg9fwCy5qSW6PNDw0v46C7i+EfB2LDBTHn16TagL3igmbEp4lLacy1AhGTRAOiUWhHv3SGwBT+zop9i65P0gQwVDk5IO/57vG7M8k2SPXMZ2WPbdNBUQ4fQBa1PKlRVIqq1BlmUbkOYWgqfcG2HFardQEVwKoOX0pPaAGgBmfgMp+9s359LK1Kl39emCP8GsB65lTxg0fwi+ABqs9jZb5ofr+4K0cIxXWo+awNNVhLZSe1guNIJkqlZDYDOJOjeZxoAvZvctV+BloyMQtba2oMQd+txe7oGCWhfC53uTSMfUqfqXwOgI0tWAoWOAICwlDO3S7dCsPNvZvbCLhoRsGYOxfB26femZ8No36ME/NBExwh0zXnIEOrTT3xciOQkPTNsa0w59IHnM3cvh2tIUeGlN2jb+toA6G0SquN32U4K4VEQL1XUgObQ3Z1yqG10D0SvIgsKlF2gQs46OfGkilNfgXHMnf1Rx0wp1wptTqmTgF9Qo38jIIsi0G9vAPQ/lEVy4bCN+UPEa8xI2nJaGffL0vGHeYHuVOvQ0Fbr+88wszslAGZDoO8xBe2++gnvNlk4pQ6Oho5Luy+tBBoAnVa+e729AdC7yT0s7Po/QfZM7ECa3VrZnl6aBITDUDeMAFjwodr9uwZAR9RCRUng6L/RzK5e6QZtaJf7xfCe6HyKgJ3q6xpoOZBX6AzDkQp4dfuAJoAxzxUxyLfY+Ku45ae7Re4hHffPm31gY9JyhP0+thcBYxN0kC+sOfs9VG/79zUAeqrk8j4nXYOflNS1VBt/ATFEe722bXT/MciSP/P7aZVGbQjwvKeZsR41kCLfHFXkJXz/rDn8XZv9l8/yeTOjsBoH6KUKjNYWAR0emN/NzJ6SAMzMp43pv0Tm3wUrsIPSaeiiCDaIbfP0vsv6gU2paD1996tmdh4zg46j1NxNr13tC9sk0ADobRJK83sDoHeTq0A/MrCgi6vxkH63Hrana5WAdO1WHiAS21eI3e8GQEeUqAzPccyMonFEyZbkjovRtT4tx2ecH/p1CcDOGO1N+Y4+LQdOMsDv1fyjuSko+vzQb+hAcKJ2SPsRaD41QjCMpua/Sem4X8cLfoZCfd1lXBsAvYv08j0r+/lST51P4biFxY0uaWbvm8Epca4R0GYfzlPWrxNXAL70+65T/t916fHQIVGQsPZT/lzjl/o7cmZJ8btJpRsr2Yy7+CFKyeyGGgForYVkmFwv4O1uxd4Omz2yJfAQ4+uS9VaLD8+ByicT2Dv1+dRu949ZsM+SNRH6H/a+pqaWS2032/unSaAB0NPktutTDYCeLkHZUoLUvhQEarXo5+kybU8Ol4AwKPa17G+ld7X6dw2AHj62W++U8fkXL6JVi+O6teEDbugD0W/qnHPS9agSvivYOeDzVd0i7mc5xlAGUKiQAi5cJYBobZ6ITidV88ldhPZPg7EZ6sT3QXaMGHQbF6ugb1OVoAHQUyWX9zkBNtgUUUDEziqQTSYy8qwdkPbNFmV1uEHW5uPxZkaUcYpDgF21Sm16TwdSUHBDa1OtTtau/a3heTmKgJZkDdSoF5rbpB6evaMr+GXhuV0jAC0ZIRtA1tIyqkG3wzZIz+9sZk+tQM81XqTVMl6/SaDT0tMjmRk29UIF+y27guzvmiDauzZ9a+3ZWwINgC6jHQ2Ani53rR81ZxFO7117snYJaA/0F1/HOUSvOQq6AdARNUrCpLCVuNRiAygRmzvpVX1+6Gd5KjRVq7lqVvZJHd7nobAYDAUHoOS4t6cm81juVMYQFPieR6q/2AusMS4CajZ1qQ88s9mBx5wiTmGEYS597h947DJ2DYDeRXp5ntUm+Phm9kUzO2Gi+ROCVKdrab5HGNyaIwDDxsrWsdZSn2BN606eGXngK9KJU5oZtARQb3DlWguG9lc6weEJ63BpnagRgA79kut2QD2ZbKXlNHR8U9+n8eJvCnBfuiAQq75Kp2nPFYKCiLEP27R3eabzL6eiv9o2hvKZv9FRyp23o3z7vT8Qu7/b2jGX32MXpKyp3w2ALjMaDYCeJndFmzInOci7aAXrx7SetKfmLAGt3Y/saCwfWLl/1wDoiJomww3xPLQMpZy4iF3a81Uh2Plj52x9UQdacvKSqhhejn5N+Ua4gTuFT/qbmRkRJSFgP+XdY5/p80NTUIwI5nf7i5jwjF3o0IcAMzzPpC/zByqZcMM6ti1T7w/nDQXHft4VTKIi/dSrAdBTJZfvOc0hIu3f5dykKTJItMH9kDuIISVHvt7W/SXZg1ebGTzZtUa7MnbMbYCiD1buaNU94nu3TgeT3HFIl9lFYb9a9YE2whsLcPU1jxQtWaOiVgCaOYO9JZL9hm3e/EP5BeZx+A4F0T9VMGnluzzWAwJSHRbovXCWwl2aYu0dKk6t0dfsiimRaZmqz0PbM4f7Nvn1c2j3fm1sAHSZEWwA9DS5a/0gE1oFfhv1xjRZtqemSyA8xD2nmf05QdbU9NYd/skGQEeSpDYbx3Djc5ZEEXyRmhvlNf0o1U90iv7QrvjP//rbWcimchBHaWDGlzD+9JcNAxc0LMiCFHGuErQcjA9t4mJTAT80nKlciojmv8Wrymb0QWZ25kJtDmX0W6cS4RQPQv1diqI1ADrjRJj4KS1EtzGz5yY8vBN49nKP7m9Fjo44YLLbpGK/1w8UVXR24vAmeUyO1rfMDM5QqBdoZ0nQMUlHC75U85KioBQHrRF81vqK3rLOwU9dAy94rQB0SMNxLjP7YSXyKqjm//CJ0O9adF1BAuhRajBWugoP9FfM7MgFQWjZGA68rtJ08wjTQmMFP/npu0Mkijb+3e/SgeES9l0NgC5jERsAPU3uktuTzIwiv7X6StN6156akwS0B7qG43EhNlVTPxoAHWk0ZHwA7ygUcrSCDlykLg1+Tb8YHpE1j/IoEoGdS3CIhgikzw9NRAlpEDWAur9ybuindwskAK8ugCbA8ssUAp77+gOI8HCPYqNJUIE8eocDnQZAD9HcsvcIMAJ8BoROlT3CRo3INg5aABpKFikrK/H9v65NrrJ5anWmpSeAFVf3Lq1lrUmtP/JprmVmFK0DENP6lvrbY95Pu/jzV+e9owgv7Rxa92DMt8bcWysAHQL28OzCt7v2KFNFrx29y178lBdbzk2h1tctHRRQcBX/kUzDVAemei96QLYcmUilbH7IY3lhLwZZw3weM/dT3qsD4n82MzIE+YN9pgj5d4IPK/hkruthA6BTatHe724A9Hi5a/9yLF8/oPcrvX6oF3Od/+NHoewTYbZg2ZYc2D+/qgs6BIOqISBjk0waAB1JU2S0r9gV0HpLQectUncmvSaMYKUYHkAnfIwAn1y1ToJJnd3yUBj9TVVxKC3uYWZQXGjDnJNDM9xMEOHyYDP7vLfr1r4BLUEXwjflKJNGDxD+TpctUTgUi7uXmZGCOnVBbwB0Cg2P905tflmMSH1OmT0iHaJw6OsbAL3nIIZR0PDZ8e8ao6DpgOY3xVcp/rLEdOR4s23Ym+QYUgwU/lnWMK4aU0q1tr3SzG5ckZ8xBwAae3tBX2fllwzTkGXdJf+d6PmX7eBrxJRKSBdFhkfqS3MeyraHJDwEHtIPzenndcD7bSua00Panvoe6SpBGgS36IIvm4NYeN3fHvBnCxjZrwZM6jZPeX8DoKdIbfdnGgA9XobylwmCeGMl68f4XrQndpVASeqqsO3h4TX76R8lPLzeRWYNgN5FesGzMtr38+jfUtEDkbqz02vC6MVvezG8lwSg/NwcoV2EEUZYki5H5CWbHJzC3LQcfcoUoqAP8s7l1tfwe+gIAPMLfdMjYJ6/0SUKSjUAepgWau7doSsW9uyZAKw6mGKhBBBhzqRYyPVOeGKhyOEAZk2HYsM06MBdigokCvqqlR+qyp5wWPWEmej92PHIdb98mdM4Hzt/Tz38S91mRUuS2QBYrujnGmhYagagGRf5HxQj5DBuzVHQ2Dr6T22A81di67SWEywA2Jh6fPT+i3sRrbAoY+p53H+/5jVr9XmcOq7RKx04ACSLi0zbszv9hvRXcoSWiqho/nCfrjlFRTcAOvesO+x7DYAeL3ftI8hCgC4p9356rxbTDuphEMglf35879oT+0lAWA6sB2esSFTy2Ql+hMK0xmzfBkBHUhgZoP8yMxz6WgxQpO6Nfk0f7IRLlKiK9/ubwgjh0S+f2QOKQFBKMFQXRJmQXhhuBHNFl4nzuQQIHn77Dx4l/2QvNIgsQkBQxqkB0MMVfo4AtMaZSKfnJAS7tCB/z8woNEXB1HbtLQHNRSh6KGaq+VmjzMLoTTjjX1ypw1Wj7MI2afN5Ys/koqBOzb5Mn9O9pgOl2gFo2cND3RdZawS0dJ6sGPx3Uc2UnKsCYBkjiqy+LwMArf5SPPuLzi9c8uBJc5vABGx6agC+5HgP/bZkADc2B8Phmqw9V5gKzviRWUhBYWrz/CD4EO+qORioAdBDtSLufQ2AHidP+Rwc1H/ag7pSBNCMaZUOl6HnYf1gX6g1Zcx72r3bJSAc5Xhmhi91qoR72O2tOXCH1k/s/yUDSrqa9KAB0GNGdJ97tdnAAMHNldJxC4uTRGp+steE/L78N+mNFJb7hn9xTU5lyA/NxLtZx1tJxPxpXRY5N/q5dajP80yaIEURiULl2nQg0QDo8dNybgC0aB3QD7jjr5cw9Vfz661dodgrtejnQcol+8wG9gaJ17VBDdrnJtk05sBNfdNd46n/rv1M9bzG+rgOVvxr5eBzGCV5Pi+e1gDocdohm8jcxv6uyR9DUlp/iChl84jvntMP22u0tH8gO+wcHQ0ZlHap+J/DNmj+kEUCZVyqWgxDtZQ5TnYDwRoUOV+bfvblpPGB5hG6x710te9v857fdHQ7+D7M87cFB/C1UnQ0AHroLIl7XwOgx8mzJnmp5bILd/Ygr5r8onHSncfdku9TnNa0Bh8CyemAEZo1MmFq04MGQEfQbzmG8PuSAnrKTBv1lCB3BLEc7hXhhIQTmkqxpAXAWybKhRrSZmP3e9P7QieaU7N7mtkdu9TxY7je8ExOfuiUfe5HwnMiC88zXHV7Ac9qTwOgx4/MHAFodOT4ZvaFjjbkRInoN5CkZPMAp0la+2Z2iHbJYSFinLmLjRJwM+T53PcowwLQ4hZdMTF4gRsn9PZR0Fw4odMxwDlbGnza1mr5FI8zs/tUCE7VHgGNfOVDfsmpJ8gKWVMktPT+dk5ZVcvGUe14kZndMuPGMaThoBYH9r+kLyo5wEMP4MqlTMJt9mFpv2tsoA8jIp51bdvYbIqKRi5fdnqON3nUpmRVE0VHA6DLaHBNgKp8ECiiyFCpDUCTL8xa/zEzO28m7Gc/zQj5f8/Z+cFkfOY4vCyjrXV8VXoJDdyHB9jlXK3W+gkwfrcKfeQGQEfQBCnfWc3sIx24SiXUlCkYRENQrVvOmCJrI3Ql+StCBx8nCCoK0h651kTLof7KmSbKBVlca6bjuklxwrFmEYRqA17ivwaRR/sdOjQAevx0nBsArTlPSunBie2mwJbLe5GeFh07TL+0IYGHHTqcWkCavVofHsxC60IhK/Hf1ZR+Nkz66e/SPDipF9DBiZ7DGLOporgKHLE/dzHVNL5zAKARm+ZLLq7h9Bo97AuyCRx6fqqjf4J2hisXFdp+rdSYALr+X8aNo/pOAWgiptjTlA50kS3iQBFqpbUeHGufSRTzFSbYaGyjZKlx/rNH/r/CKZd+Eigl64IiqUvY1QZAD7Njse9qAPRwiUpWHNhDM1oDFiP6DUB76GBrBO2HS3g+dyqbCgAaH7oGKi+t3dQEwE+m7ldNhxENgI6g3zJCcO1wUq8rtiMr5+E1XZQ1kRGP7zaM5/KP1R6tFIq5HxULNxngq4plrClirc8PTRVdZEEqKBfjin7F1qUIar/nK0KeZxxceH2JUpNzO3QD0QDo8aM0RwAau/ZSL86J7igKZ3zv935CCzFAFVEK32+O2WDxyvYQpU6GD0BNDc7Vfh0IKYbu60VMQ7qXwZ1f+I2yxfgR+BVnnkHks9ZF1oc7ddkTz6gUlJoLAK2IZ9Zq+N4pBDt0jZ7z9JB/wdrz7xMAvVR911r1Hd80/jrzplFjz4EE2WqlD6PkT/60o46AFui7Lo+1ZEyiZxqTKzs90q6HAjzPH+aALvih32VmL/coPuyBrhLBQQ2ATmVh9n9vA6CHy12yIpsbX6QGHEbBj0SMr7248PCR3P1O+RMU/SPiuPS6qR5prbi2mVEksybfrgHQu+vdP6pL3sQ5jlMZIdKK4aqDQ/mBng59+44f7l5mdgLvRy1KP0SsciA5ocPZAVR/lEc1hU7XkHfN/Z6QhoRqqrf2tOKTzGhcNx0ssImBF13jqYiKIePVAOghUjr8PXMCoHUyT9r/Z8wMXd91Y7WXxGQXSV2lIAPg0Jo2sOM16fBPaKwoBvX8ipyr/foVgtDPdZojHeitNY1b8grrEcCH/hL3IebgP6iNcMJe1Cu810gbMRcAGp2Q3SV651K+kR6zVu9qX3I/r00YEWJk4NWk92oLdvY2BTaMsvVn8KCQGmiXJBOo28iWKgGI5tZRfU8Hp8d0YPgsEQ+AZTf5Ozz4xx8DrIAv+mtBx8N1I7U8GgCdWsKb398A6GFy1/pOxjsUVidLuH8Z1qIDmfdkHJNV/bvMh5dD27nE+7RuntoDdVIzIQyVodZO6JauWVngVQOgh47iPvdJiADBRHqmAqC1SQAEYMPIhXKh8BSz4/+H6Rbb+MEidD3KK0Ln/4dm9mhPmwZwXzM/9Cl8XAGjlQ6HwGsb1z7wDOBM5IyqdOPQTKm23QDo8dNrTgC0NpE3dK7elCCA3k12AbpZ0ynw+FHO/4QyNfjy2x2kSjlesXqotGNsyXvMDEqOr6+cFzrUfaI1yKTiYDvV4U+sseQ9Wkf4G6D0AxXP5TkB0MhWawf1OShAt1SKIuk/fvNH/eClpowORbBdvNPx9xfSb+0j8OGu6rYhRWbSGNug9UY1HJaqn32ZqJ+pC1zpwClc69mDsd4DREORRgp3rqsB0LkkffjvNAB6mNwlp3/z/UtK2tVhLTqwhtfK+Tu0H3O9T+smh9ocbtewRwo5waHh+GZFIHQDoCNoep8jMwUALSXibzhMofpg8LTBphvwED2oOyW/nPdpTvQNfRCTjcHDg2J1a6blIO2QiHci1bQJr4WSIzSw0BsAZpCOBM/zrtESDYAeb5zmBEDvymk4Rjqyn0RMfrDQpn5Me2u8V+NFYRMiJY9SCefdEFnJTnHAScExaJ+41nQQEdI9wXuLnb6ey2EO4DNN1Tg+0yPaax6/uQHQioZknpPNBy/s0kA++U1kmeFD41vVsEmUDVNb4KSGDuVvgc83xM7Fukfz6moeSFADuBIGMRDJ9eYF6md//DT/GIc3BpHPqf1/gdHhoQN8+6/r6AGJpPtQoJuxdK7/ngZAp5Ls/u9tAPQwuSsQjEM6qHFS0QcOa82B6GfWkIu5j16zfzS0X3O6r79u1uJXy68gsIAAg1r0ogHQEbRbG/MXdhVHKZSRwqGVA0iV8gs6T5++2+e2vLGZESUAnyNXCkA8gtg2vqIPRHOSRMQiKS5cawOiQ6qAG5nZPQN+6FRjMOS9IX0K+oXuE7kOP18sYKcB0ENG4vD3zAWAVvQzYOahne5Q9IgrxcYq5NQ8t5n9pqIT4PEjXPYJOS7YZOh1Uqx1qXqotqIPT+8+QjS8dIFvLpWShTnFuGEbuNgsESFz+plEPUsfNI9ZY+Bx/5X/UKJA1hAdnRsATZ8kSyjROPCGsmgpIHToJ8Nzi59cm/1Se8hofExB2WsdPpIXVqcmSQ1R4toHYbcv29FxQMOzFP3s2xSttWfySHhoFkuMAToZRkVjG6ABwQ6nLHDWAOghq0z8exoAvV2mIU0RGb9HT1xAfXuLDmSwUUvr/MFaPuTZdk8cCWjdhH6DcThdJT62fGcOttGNWvY6DYCOoHfaaHASxkl1Cqc2dLxwSH62gdtHVb25F74wTjvuamYHeR9TtCuC+Da+Iixk93uP1nqimVGQhauWE5xU/Q/fS3o0qXBcbATe4ny5JaJS+gcERBEB5BARyRXzgKAB0OO1ay4AtBw4TmPvlshmSnrKBCGij2JTa7Id4zVo/ycE4hD9zJyneF0tp/xD+hraTA41795FQb4tWFOWxnsb6vrxOsDgYWZG3QjGcW4H0wJfruXRgLXP4zkC0EyFsGDrFTqflk3L3EG+MPr/ye4X16b/sk34u2fzQrmhDg2xbzHv0fyChxoO/Vr2D9JPiuYBQn9lAfrZHzf5RxT+hQKDg/PS8mcPgj6yzw0zZ2LqXPiuBkCnkuz+720A9Ha5S0b395pcpecmLVYbCFIDK5n7mr19FOq8Q7rxBMfgatCNMEgDaq9aqOsaAB1Rh0lLIm0uxYZczilpUKcKopn6zQ8dbX4jChojSUqlNhf8XRuP8F7DEE5euGsowAj/dRgJUMtpTkRV+v+vUpQofaUQDEDdfzhnoYCg2N/c733hWOD0P8K5r9TWMEUyRrsaAD1einMAoLWpPm7Hk/VFMztx4ugB2c7rdxv7/+5Fg46XcHtCm2NO0omQJHq9hD2aOhL9QzQOJojo/oa/MLS7U79R+rmwD4zNTZ2e67Q+10pE0u0iE9m1F3iB3trBZ/o6VwBafiLzHMoa6A4+PuMNbRiYQZbWfX2zLoqwXfQy5rPyryjGfcvE0aVD2q1oLoJZPt9luVGTpBa7IVl9yzM6lgRCy7YROARVFNSKtYAY6AQUjwSepLbBDYAeMkvj39MA6P1lKrtIEAbZm2RxpsB8xoysvv+Hjqsdnl/qnKTMThjTtrXdK7lzaAiVLDhGiszesXKVD/0MM7tTBvs9pH0NgB4ipYH3AKacNZExkoH5sn9jW5P6QPSlnUf4Ev4gDk1tDvhefeoDBu918PNdCwIMwr73uZOv0/1IlDFRMSWuUFeoqksEEX8oSNLXs5jtawD0eGnOAYDWuBJ9ykl9ys2VwGfS9ckc+UWrCj1eqTY8oU0KYA6gTsoxjNLgDS8JaYR+6bQcz+kihH8arCuxD9VS9YX3yhaHUdyABaTzh+t+yOuZsj2x3i3fB5CJA37WHfEVx/pGivfMGYBGHpI72XYUWsLfmtvhjOwUPtVTnTe81too6DRtI0IJYIM2Y1dLXpIf2ZREdNVk56WfgND4yKTCx8zAKyF3yZvIZ+gHL1lJpoovhM7RAAAgAElEQVTGnSAr1hL+nZr6qAHQJTTwwMECAU9kKJbMFNG3X+9zvAZQVXrJPHhnEHxREmTUHp3s6Ks08LnMxPGvSg9Yi9AP6g6V5gcP/TmCWMGSoLEqmWFFmxoAHUlVGUhOnVJxvsjZwjGlcMrQS5HOmgBwVN+ri1w9g79gTkB0CBjg/LzMwY+vBoDBnFOo+1yd5/PIPBUfzD1WfeD/lV4YMpR3yg1SA6CHzvID99UOQGtxJqL/M90cJiIzZfSA5EEV9xsEJ9GpN0/jR25+T2htIRrqUpWBE2OkGYIqP+4yTChw92Izw1Hj0oFgjWuLIs9pozieafNlnF7kit6HcO0cI5vS92oNov2A6Rw+p468i9XnuQPQyEFzg2J4dzSz5we+Vsq1f9cxCH0pwDwoJKBuqQlADfuoNZANK7QSNQAttE/rNdG4ALxkX9YSBR3qJwfMZHkCwMgmzikzMtTX0zj4jP9fi76qHWSRAYznsMENgN7VCk57vkVA7y832ebneTZWDXNU6wd7HPY6OebnNO1ax1PCLshYJ+I45R53jETVDupfgOeUpmlpAPSY0dvnXib8t4M0tdinYTJybPbZiI29QoeW1HdAaDYUAEFctUyQIf0K2wonNKe0T+s23ETnCjCYk/NJm8MF46ROm0IaJmk+ivbKRZvC99A3jAMXUQ9EYLM5UltzgDENgB4yGw5/T+0AtPT8dmb27Ax2R7bihh0d0WuaYzZeofZ5QmvKGZ1TrFSRpBid6ts8qAdw5CmuqgK4WlsUmVjqEEORzvwdgs5wPFNg8LYeKUx7c68dMcYifIfs2UOcv3pOG6slANB935DDGbIeSPUNqS1ij/su7wt1hGANaFvITKwBKNirX/JXCTaAk74mPVdbSNvFz65NjmoPHMUUX3+8C7n05nqoDodjfXnX15MXjjwN2y75EjBwAW9XjrWvAdBDNSjufQ2A3lueWtPxdb9gZifMsIfZNrohJz60D2R51nKAua3tS/1denISM4O1gAPcEjW7+vINI+Wv6oe1JbGyBkBHmgEIkqIYJ0qkaHICOOFnkzkldL5Pl3AOT88FnOHKHWG7i+j70bmABFQNh89zTvzQ4SYOLtVb+5gAQmtMcqZMh5uL75vZozzqSbqhDekuYzf02QZAD5XUgftqBqAVmcShF5yiZGGkTE2SY0ZUK1z4HFBNsZvjR2E9T2izcvWuQOqbfDw1znOUQh+I/quZvdvMSAGl+BLOfXjRf/qrA7kUG/MQcO6nPnNAefYu++pGXdVtHEoysLi0Ps6FZmuTrmgtggf1Gn5DjoPPWHq7FABa+iS/Cj5g6JNyH0hvGxfmovQe3wHaiAd6kEVtoGnYF7WNwkBkkqS0JdtkuOl3BT4c1ddt1tKU6/aUNoZBKdhpiq9/x19UE5gf9i2k2qONUCU9uKtzQ9HxWvQ1PMDMGf2MnBoAPWUm7P5MA6D3lqH2pDc3M7j6a5inagNZPgT21GrvdtfMeb1BhwBk6pOdU5LKRpITCP5nLyBfmiu8AdA76rQ2GUd3h4d0vxQnHTIyOFdsxnYBUvpANKfuFGG6oMtizkA0PIUPMrOPBM5njZvW/hgA4NDu8xYagzBFG+NE2gj8vCEfau6U2wZAjzdONQPQufkkJQs5Zi0qYLw+DXlC48oawga6BkdrSLv3u0drRnj4BxcuGUgA0m/3Am19wFlgTT8DaggwvemZTVzHAEFwIZOqzx+KzuiSjZ4z8Exf5O9QGJK+/nxHn2dXfZjy/JIA6FC/NCfIDqAQcQj0cV9Of0t+VMjVfgX3pdAbtSdX9tgUPRF4ygEShy01AghqEzQmHMbVmDEZBqVAn0TWnihjaqJR6td4gfP74c4VWpu+yg5D/Ug7Wdtz8e83AHqKNdn9mQZA7y1DrelkqeB71XAQJ7zpYh312gcrqR2wuxbO/w2aR6zrB1e0Zsqmczj/yML+RgOgd9RzGaRjmRnFMEiDTQlAi4x/FwBaXQ75oVEETs/u6Txv4SZwRxFleTwEUJlgpF0+zseEBmAMcm6M9up0H3imgi7pxTj2cj5zRhD2gRaiGHHcP+vtKbkZagD0+KlTKwAtW8MBHbqlTJGUwICiWeHDfV/hhXb8SM7nCdk0bAn242oLAaEZAYEa6qNG5fde84Eo0I91Rdq+5v/+S4JhO4WZQXMCjcBFHJAlRTu8WPP6bUzQlCyvFFiPLCnCRSXxkuvQ1E4vEYDu+ygUsuGADzql77qgQlA4Nlgl30h/hxQ0bMDvbGbX9nbMIZBCm0ECJwgEkbyGHFhN1cspz0netOut3tYaov829SVs13v8kIRDQ11hpPwUWUx5ZtNBCZHkRGqT9Shap9oODnWgCTUMh6457XADoKdo2u7PNAB6swwVwIIfBh/+kRJhPWNGUAeBtAe6KTL2YmBDY9rQ7t1fAmS2Q9dy+gr0hZZqfSSTDUoldIarhM/RAOgdZ48mO1FJOODiwexHM+34mX8oDScpRMvGNDKhUwEwBMcfPJL0aW4ckqHzSbo0IPRzunRMAAM50aU4b0I5n9jBfuQMJUFuOfdTzeF3A3gmwp6rBsC+AdDjrUatALR0H35GDrlSb16Z48z3T7hjVsPh0/jRnM8TohLigIFNP1WWa4yS20Wispn0tX9wAicuEdIcQpPWxt/fNLNfOl8uvwOoMj8VRcacwMaxkTlal3FyTP8D4IyzCp3Gmbr1i7UCrsH+xXs2tWWXPpZ+NoxipGAyxSBzgh4x+79UAFoyCm04Eepw7L/caRpCOfZpavTbfhue0H8OQec+BQ0BH9BW3Mb/DoMqUh5uxtIT6TvRpdTaqDlLR237ZzMjIhaqiJzBEmNkHvrT/PchXXDQ07soY4D+MEtEfUpxUEJ7pYNh9iBrI6DzTc3s2N6p1P7QGNn15/cbPUAmt242AHrKqO3+TAOgN8tQciFbgejRGuas2kD2NNlIc/WVdtfaOt/Q15kaskPDtY7gLAp76wA0txQbAB1J4rk4oP+viwiisn1MABoR8D4miyJKcDKJzBX34hyiScKNDe1VEb0vdj8Arr7Ob8gNroabIpx2HE8WjFMWcj77G0dAeiKY/lgBSB9OxwZAjzdONQLQ2ricyzeuAG6pN67S8dv7AVRzzMbr0tgnNM5n8Y0+BTiWBkKHa4zAo20gMLq4CYDmOdYDAdAc+O53MbfDKOfYh9xjxzvF/bJfD3P/Yy6FxDbJYukANH0ODwz0b+jPoJLgDwcx+BV7XZvWgW1gIAcyFFvCN710wHvON2oABYbOC7UV4J46LLkBvqHtDO/TOoo/zf6gdnn31x+yKV7aUd292Wv2hH2THQ+j0IdEhfWj8vlmP8iFwCSyV27Wpcmz6efAUfpaW9Sz5jF9Z+6ev9PPrxbQzwZAT5mhuz/TAOgjyjAMNCSohSjo0r6tMu2JYCWTmiy8Oawhu2vofN6gucTeF7+Imi1cpX13rdswBSgDp0RgZgOgI+kyEx8uPKKXUhgmvZNUMpzuVFefnwxqCBxNDFzNDtMmefSjfImCAPglXYUrNRDdp9vocxPmBvX7NCXPM7NHmxnFBiWP3DzP++lxA6DHz/LaAOiQngH+XGxX6k2rop+JSGXh52/aUWKBHT+C835Cc5aoRDb5crjmEI24i+Q3pc5rg8A6M+TSetWP/pTDWtppHdKHXe6R7aJoC0CNnPchINAu30317BoAaMmuD0Tr/3+uo+T5lPtc/DebZGg72DRv8zVIXeVQBroZokYpmk1gxPmcwknfCCNa5zJHZC/IzKPuB0D9HNYoga3Y9Q/7+ppivxNzTm6iUfq1c/kTEQ2NEtmrf9vno5v0aj+7xMEihcQv6oAzfk9Im5Tb9x8rz35kZQlgqwHQY0ctzv0NgD6iHCWTy3UZlfA/y7eLI/Fpb9EchRIJipzYQYnTWtWe6ktA40KkMZlOqfe/Q0ZA+svemCLmpWqsNAB6yGgNuIcFGueatNkUDpneyekbJ9Kpr5AnjQKLd/Cq4lB0cNUwiYbKIAReSYN+lhfYo1AJV+zoyD7wDNcbIP4NAtmFkWxD+zH1vv7mECCQYmGkUar/NVIUNAB6/IjXBkBrbt3Sedlz2A1940lus2LP7/Gjsq4nNG+p/AyYWPtmO/XoCKjYC7AQuDEX8CyFvGS3AIQo2gJAuS0SNkU7Yr5zTQC05CZfQ35FX574X2x6fuD0NL/zsQb8A7TjD5Rkx3XaGUA7/M/+IY78lZx+VEzd0BoF3d1jE/igMdvaf5fASCJ6AW+x9zVG8W6SAXLv6wy69xWnjoGrE+okAGn2B9D47XfRd6Kb+XNqp046g3NrcmjCIYou6WztspJucnDEGJeyxQ2ATjmL9353A6CPKBvJBIqpG1VSfFCYEIf1ZHXMOVusjKbn+ap0B0o5Cjfn2ANv61lIUcXe/EWF9KcB0NtGauDvODWQeqfivpSxIVJCZOYDm7bTbSF4cyrnPsLgoTibnLmdPpb44XDiswEi+heDgIMV0mTs0owwUoBN1N29MA78nlw5jU8feP5y53w/1Mxe620Rb2utEWYNgB6viTUB0JoLp/FCbcyH1NQb0mWADqKf4eMtEb0zfuSW9YTm7l06nsunNBB6WYMbuTdaEynmCL3YrxYyZ9cIQPdVQ3QE22hqtqlUmB1QO4C3rS/Sd4rxqnDU3A5bZN8JZMCnzOnXbpPvkN+lT3vp5Z+cfgIKit92frwOSniOQxIi86HRgMOZv/Xv/rf1HfGgD2lbyXukh4wn0dtQlpTynxoAXUYTGgB9eLlL/0/mmTyp6nyNGe1aIljHtHmt90p/oA6j1hb1XBi/0lmhWrM5RL5soQj6BkBHnBXv90U7RQR0aHAAggFYcqVc9PmhL+ROJ1xmAlXnsino03J83Gk5SKvhmkrLIWBNY88pKc45hwVcucnnQx0kiuNpXoSF9FeuUk7lmOnWAOgx0jq8npGxAK93yVNxObJwgV450yZVi+orzezGM4ssGz/adT+h8SfKj8O+tUdC1z1aZVqn+QotFuDzT2eyNg2RVgOgjyilMBtgU2ZAPxtgadkBYYT4JTp6hg/OdI0KeY/f7gUg5wZCSzsFuipTcipYrL2F/OvUh+1DbNDYe/oc/CWzxxoAPXb04tzfAOjDy1HygCsX2soa7JzaQADdrRbkM8XR4PreIh0iUv3fK9EhYYp/95oa1ErLjQs1ADqCrmqjQbVgCqOkMFBSFk7i4WyBtzcXAC0R9fmhAVnhVD6T35Ci3xGGZ+MrlA6n1E4Aq0eZ2Zf87qGOV59ug5Q1CihdMgCepzq0U/oe0o3w36QMUbWXtEKuqQD7lLbs+kwDoMdLsJYI6E0RsEO5cMf3+rAnBGhghy7sUddD5/HUb7bn9pZAaBuhIKJwFfqZ0x628alXArJVrLmXd1qGJc3XBkDXq3ulWiYfGV/zATMFn8P9AD7maR1IX0rR2TAjcEh24CbO/lL6tct3pZvv6ej5qFfD2PL/hshgl+/u9WwDoFNIdfs7GwB9eBkpU5gAQ/YVzIvUe5n9Rimcj3BSQ1tGG5mr7apTAtIhauMQcSw8r3RrZfMf4Vhebv+7AdARNEAbjef7aVQKIDY8rQDkJF0192mFRBWCmMdxiom7mdlBG6qiRxBv0leoYBlj+AePFH6ipwH3weV+Q8LJCs3A/c0Mnh8tBjn5Cft0GxDeA4TjTHLNCXiWnBsAPV71awCgNS8oFoUeUrAoR4aE7O7rzOy6Be3j+FFb7hOhDX2k28jQ5i63561n+0lAcxXuVQrofHvmYNymvjYAus2BUALS+U96piTcwzXW3hgzalrrOUCi6KwoLdbMZz9GfrXcqzWZDBQyXLHHpfaX4T6TOXNv50lPsa8eKn/51fItcwM1Q9sZ474GQB+QomRBodgPdUFqR/KfSto3zQMiVi9gZn/2NpU6KIqhc0t/h3xB9sJk3RNEmoIpYawc1QaCQNivo0s5A1sbAD12xDbcr4X6Md0A3icR3UJ4YnJ1Mzu4gg1buAifxSknShXa23UYQ+eGYpJEDb8iAG/D1MmQLxpu5zt6sbPj+f05HaU+8AznLUAPkc+hgVNk9K5yyvl8A6DHS7s0AC1byMEUDht2IcdCG3IXEqXAIr/kTcJ4zSj3RAhCc0iHfWogdLnxKP1l2Sj48K5pZt+pAOxIIZMGQKeQ6jzfKXAATmEAPurFlAb4YklS6yz1TgjeaFkusSSb5z3aQ6CPV+uACCjTavCdWgR0nvHvf6UB0AckIhtNxsr9EmE7Y0dZ+AIBZmQW1jBXx/ZhjfdrnJQNmhMn2k/ewhY5RH5H5mj6BkBHmAlSrHt0FbyfkNBISWHvZGbPKMzvKrH1o4RJ3YL7mOIqXHNyRvtgLqkSANGk3nAxWUKeN6Is6SunWVy5DUoI4lAoBZ7nJ5vZr709c1+YGgA93jiVBKBlC9DL1zu4lGtO6Dv/3dHoXG9Bm/vxGlDnE+E6wfqFrdKhQeliHHVKbJmtkn2C+/baZvazBW+gGgC9TB0e26uw7ogqzs/dN+vLQL4aHKlwpeaueTJ2TNr9BySgseJwmFoNtehmA6DLaGkDoA8vd6JWiRAlyzlHMM22UWc9EW8v7VrKQea2fs/9d40TQVkEXxBNXwMVh/bOrzIzaHVz2v8GQEfQagmR6N9XJwQiMTpUYH5KV5kZyouSBcb6YgujgmnjzZ1T5uSFwNldhjXkUcZAvMij9khL4yIdB+CZaAGu3CB7H7h5jdNtfDkAnuee2klXGgA9XotLAtAar4f6/Mi1CdV8IH1I0WWAP3OM+h8/4vN5IgShb9NVg35W4OyU5NSbjwTn29LwcPetZnbDzofh0DSns5tbeg2Azi3xOr+ndfA5XZHN2y9U51Vwj/nMITBZmrnW/zpHfR6t0hipmFlN9rgB0GV0qAHQh8ldciBL6w0VgYVgLfA+E+wXZmaX0Zb21TESkE+ID8z45QrQ2q+Nys76uRcj/FHGQ40GQI/Rnj3ulaGiqrUI4VOcbEhZ/8eLHYqHqCbun9CBoSjJvboopzt0J+tHDvju5gI2IG9x1xKp9QIzg2YDcJ3TqxCojqBGW1/Rj9D+cPcEhb1ImxBgW7JoyNYOjLyhAdAjBRZs+phzz854SKWxYm5wYBPOnfG9GPeE7OIznQ6nRQSMk1/uu7VGXNHMXtIB0SesxBHLLYe1fC9cJwE6oKz6S0Ynt5ScGwBdSvL1fFdrE/uCq3Yc+Evgfd5LutJ3aOn+zw+DGwhdjy72W6KxAQwhG+WvQVZSDa1uAHSZUWgA9GE8uApiIaiQ4MIabJkisG9nZs/NuL8ro4nL+6r2yTf1vU8tVITyU25rZmQx5TqIbAB0BB0X4HGm7lTj0C5C+diJTstkfCjcc54ChOFDRdWn5aCtRAwTFcGFsucs0De03Zvu64O+uif3yVX4ve96qhyAuIA+2rW0iM8GQI/X3BIR0BonKjJzOMbhjBy48T0Y94R0/jddlMI5zYzT2xb9PE6GJe6WzjBmZHCQlpY7k6REv9f2zXDdwgeA0oprDYdEtQLQKYIj1qbXQ/or3aemyMW66GcKvC1d79W/EzmXMIWNagBuhozXmu7RmHzUi8D+qkLdbAB0GY1sAPSBQmxkcENzwaFa6XVT34di88xOX5azYFwZbVzWVzVeBDJ+wcxOXIFeCZNj3lO3CV9FWcWppd8A6AgSllIdq+M9/Wx3snHqxFxBOA9n9ErFNRugPhBNKgsE7Odymc8JcOgXIcxVBTeMHoNigLT1x5oZ6RJcuU6qIkyT0a9oAPRokf1js5crAlr6d34zI5KGhTUnT5o2+RR/fdzC58N4baj7CekOThhFUy/jzc2pP3VLaN6tE8gB1QbUA0QSMeZLoIcaMjK1AtC0vfRmeoj85nyP1iVA50ub2RcrBPhSyTcEod9sZvgGDYROJe3x7w2LwF7JzH5cqW42AHr82MZ4ogHQB/bVd/W6SrkDzjaNo+btS7vCzTerdM7G0L+lv0PrIxHsUBHWsDaKRYEMrQt32VqfzLSXbgB0JG3XZuMTzhGcymBp43ANjzacAwDJhNOJytF8M3pvT70OT18iDcUiXtOPvH6jR4992nvHxF0S3camQZNxAlx8zA7Apgw8vKNEW5bgTteicwEvagklTQoQIGcEtOTIgRLgM5Q7OcFDfYtDP4qe1pZCughDlLgTWr+YD0THQtnU1oTEQk/8+nDt+ryZ3cLM8Ivm4KvEFE2tALTWiBTrT0z5zfVdWpfIyoFmiKzItel+eLh4sIPQqfZEc9WTEu3W3MdnunJXMPKHFetmA6BLaMgBW0WdqScVBsikrxQ1v04m0FXBZexv3utUQqVtlwBC2naVzp4eUvG8LaO18/mqgjAu7pS9tDxXxvB+UtJcA2u5Xyb9agB0JL3VYkkk140TclrKED6qq4T6gEJg2lSRhU74qToKEYBFKmajhP3CelO/sYTnwsUOwJmiblAbcK0pgoxilmzmcIQevwO42QDo+LNCc/lsDj6fIqHN29R62QsW7ss7D/raNvnxR7XMG8O09OuZGVzex8/MI16m58v7arh2vdLM7mJmv5yZnxJrVGoDoEPfkQI4UKOV3ljHknUt7xH4/McuG5KMP+pzlDjwrkEesutkRZH9cNmmb0WHRXP9406HWGvks4TUAOgy6rL2CGj1n2AhKAn4d66M571GXOvKN8zs7B5sU0Y72ld3lYB0CapKKJAI4KrBD1NAwre7QsLs68m4T82w0ADoXbUpAAZRort3fEFPTKhQAtPe7lU0pSA1FSLcT6R9Wg7C/R/ofeG5nMXLIg19tNeERugnZvYEB2NUsIkPLY3neS/hqVAlMnl0V7TqvjvMqQZAR1PR//+iMPKZ6KZT7jA2U1umufIKM7tJpsiIqW1tz22XAOsCc565Ch/08z0VTGvCXArXbu/pMu8Io57/4Gv6U3u+0TJ7vnevagOg/25mHOpyyPOpLgISIOo4Oxzsrm08t/VXaxKRzxStetuKwWfJSiD0Ub3oErq3Zh9/mw6l+B3bzLrK3H+36yYUfrUf2DcAOoU2bH9nA6APs1H4L3cusLfZNELawyrwsPa5u13L1n2Hxo9IY8a0BgBa+BJrNkVp35BhjWgAdKR5IIXilB9wOFUqut77My+6NdfCJih5CKhCjwAQfVb//2tyUsWJKQAG8AXQ9fsr3MCjF2zcZZDhSCI1/7guiykn0Q2AjmTkgg31v/gCBe1G7sVTlYN/0RU6osgR86QVHow3xiXfpHUUx4RDp/t3nPeAF3OqF1BSfiW+Hfo6H/aoZyg3+mt8ibaV/GatAPTtOrok+AdJAYXaq4HQu2uJ1kDWpOt66vZaI5/70gwzXNhss+kON7u7S7+9YS8JhKn7ZKSQcUpk2xwArAZAl9HrNQPQWrOP3WUJkH2cup7XkBFWZCoUgzn5eYe0rd0zTQJaE0/vdePY43BNwTemtWDzU8JKoCoFk0tdNLkB0JFGTwNFcUAIvI+RiOM1dNwo2vSumTgTe4k5VHCKOHLiSNouKdhLd1L7PM+ka1Kk8SPe9zXRbYQRkHQf3f7PIApyF77KBkDvbuTCzAU4yNjMMF9zg8/oAd9k4YJb9sUzt3+7j8zy3hCuCRfxSBToArhy69vypBuvR+H6RZYOh6bwx1HIZA4ARzxJbH5TrQD0rdxucnAACA2910Ftbk1WB/kX3/Xo8o81/T+CLLWxxmbcsitW/PTgYJG1vF3xJRCulQ/zvQVfSQ0qxOpJA6BjSXLce9YMQGvPTQTof1eyJioYj8P9iwV0peNGtd1dkwTE+cx6SBYxfPz4Y6UzPYWz/N6DQX+QmIajAdCRtFKbjaM7rwscKqmioOVYPNkpP+a+2evTcpzWo6H/PeA8luMUabiKvyZ0Dr/qUb6v8sVlTcAzAxHq7xm6efNgM7tREAmtqOipg9YA6KmSO+y5MJIR8ILN41ES2rf9Wqt58zrf7GszNRcKot1GYj1PhwdSHOaSHcPhJJECrV5AeT0I16/3ez0Hiq3NCeBILcWaAegXug3n4OBCHa8k9rRENkvqMUj5/vAABtAZeglA6Bb5vLfU5esRyfc83+Qqo6l09FdKXcn9btlngAQyHthbhIcAudsz5XsNgJ4itd2fWTMArTWbQ9mrVQRAMyZ3MLNnt8PN3RW8kjdonhFpLOynhjVQuCV0wmCMKf2ZBkBHVEYpFCdnVGxNFa0lBSFFhFR4uP245g7C9KNgL+pgJNGwXEug5Qj78Duf4E8xM3gDdSq2Jp5n0Y8QgXUnLzgI3UZMkKkB0NONXHg4UDp9VvaN4jkUCPlRo96YPrAzeTKM1jq3F2S96oLWg5kMwz+aGa5f1Cl4pJk9xylScCb5fe5+SKwxqR2AVuQp6yPUZ/it/J3Kb40l1xreE4Km/2Vmt+8OyH7VwIFBQ6NNJ1mObHAp2i7/vnQE2KAOVHyT9g6sm2RSAlp9xkGEudnmBkCXUbS1AtDyNU/ncyZlFvvQkVVEKmsL/u/3ZpTBMLSPa71P/iHYx5e6A9mTFgrq6stf/h8BJWTIpcQXGwAdUftluO/qjlUqR14bPKJXiCQAiJ57FHQ4DH3uyJt1k+ABZgZfzlyB6JDnmT683DfvRD9zLWn8tk2pkOeZe4l2JsLxzIk2Ig2A3jYiR/w9PAw6mUcrXangIVBIvXH9Dihh07+mOTN+BJfzRD9DhkjDR3Q0MGRLzHU9mNvohMAza9mLPGuHDdHa1q+hYzcHAFrc6ozviZ2a4wpBsWP5YkP7vIb75Ncjuwc57UybA+NGPly7odKizgcbcGQrez/ujeu+u0/nB7DPnmkufM+bRq8B0GV0eq0AtPp9LzN7XCUHsfK7OBxm39P2PGXmRKqv6tCDrOI7BoEcqb439L0KACQ77qMJDz0aAD10RAbcJ2WiMBYVxnfhrd32OYFqFGmCe3GJhinsE0UB7uZp2Px3zAjZbbLe5WvESUQAACAASURBVPcQOOM9RCVAMfHOYOMucHqX78zh2X6E+wW7RsPzzIY3JZDUAOhx2hFGnV7KC1Zx+JOKUmhI67TpJ9qSaLMl2rshcljzPf16ARQo5bCXAxKuVqgwrnZojeWtAiL/1/0N+Ai52jzcW+ZzAaDDcWQ8n+h1OLQmt6jUw8Y4jC79lkeXvq0V25xsdMKMv1N1dXOe4JmjzZaPE2mfzu8eZnbIAuxzA6DH6UGsu9cIQGutpu9gN0Qbl9zvaCyFIUEH8ubmb8VS8Wreo7lGrZv3BTRJpak4tKY8zX3BVH5+A6AjqmIYUv/ZLpoEpyqVEdN7P9U5G+dfODF9yEFDlCygJaeB2iDtyhEcUQUO96rQMfyOb9wpmkZKQz/KO1UbanlvaMBO2RWq4uDk5mZ2pAzRVg2AHq4FGqd/cl5XItOPXPhkVvOIk9hLmBnVoLlaqv/wcV3SnaEtIWoOEPrWZsbBZO1rwlzGoU939UHP2Pk/7wDrVwhQz6VfOds5JwAauYQHPPhXbD5O6OuzwMKc8qvlW/3o0heY2X07yrBfNkAgyhCF/j11XyjETR0YrnaouLeIQxoYsmGf6tH40PktwT43ADrK9Br9kjUC0Fr7KPIHEKi9RUkgUBgPh53/bGbwuYc+xeiBbQ9UKwHG9RNdQUKKrafCDMd0Xm0gwxHdY01JseduAPSYURlwrwzZ683sWgmBG52M4aBxegI4k+qUYkC3k9/Sj54lavahzgVbG+gQbt5JgWMj96QuYuZnweZ9jTzPFK6D55kIjRO5LFLR1IQK2QDo7dMztB2c/rOZgYOdq+SCqHnCZp/2QFkzlyru26Xe7pgqgT4tx1nMDKomDrVOEOgt62SL4Bwm5T7QxlPv9fXrjcHaJZsw7K3rvWtuADQjFUalAgJSn2LNnOuhf/IVpwrDt+dasr+de9aGgOnx3Eek6CxF3Wvz73PLpv+9MBKf34jCh27jkwvTywZAl9G0NQLQ6vOzPMNSe8YyI3DYV9UGsAP2zG29KTka6b6tcaXoH9lnOTCRIb1RO6A8hAImhf41AHrISIy4RwIVD3RK8EYKsiYDFUYOE6VJ5BucTacOHNVSgEOf55lKutBtfC5wDNdCt9Hneb56JwMi1zlNy72haAD03gYsHCei0bFbRD0fs4LooxAQS7kIjjDv7dbKJNC3M0REA0KzLpCBxCU9atyiRxw8yYZftG7y/w724oKKeNbv+BztGiaBOQLQ6lm42WA+wbnO3Mq9dg+TdNy7+gcxf/KaLmwOf+3zJJw3cb++7reFend2D1i4qWdhSffWasdle2WnoQp4jJm9YaH7iwZAl7EFawOgtU5z8PX5jnLwJInpU4eOqjLM/tXMPtYCb4aKbXb3hcUvYTQ4ViX6p0BKaPeggEkRfd8A6MjqKmWCKgJjhoBTcUEL3P6BVy9fU4pG6KhSPOc+Zna7ziEjyrYfIRB5iI/wuv6GBcfwYWbGxNXGfS3Acz8yET50QPiSUVQNgD7iDMBO8QfZcF3aU+zh5dZGr9RBjlqrcWMukZab4gQ2tW1o788jgT4QfRwvbnpdMyOtMtQp2aiS6ZV5pLL5K9rY9KPDf+5gBgUG2fBw9e15yXbP7dtzBqCRdRiVenKnnbhVDwyslf5siq70/Tj+/RoH+cIggnYIM0W6w5/p2xyCFogO4xAaOjAufAPp3pLtuHQynGekaj/DzF7ldH5LtdENgB4+Z2LeuTYAWiDYTTrqn5cVzvjUOIa0gxSCW0vGdEw9ntO7hBuSaXiNSqKghVv+walBvp7gEKQB0JG1VJsOFApaDAC4lFHQejdRAhjPtYE0IX/ceR2oygl2hukSP/bNyvO6zRqcbGE6a2Q1q/J1oe5BsQFP4m3N7KiFi0Y2APqAuvSpbM7ofNw4X9isPvdrKUXTvHq5mcELuTa7Vkruc/9ufzOOTnOoAj0Hp/gcVoZOvoC2JYMY9FGgM/4Ca2Z4URj3lV12ypu6yPEf+g9LBTVy6vfcAWjJKrS9+LOs69cM6ljMnaeXORHOC9YeCj493szCYptrCSLIOUf2+1b/UPGsZkbh2WubGQciuuauf30Z7GWr0UWAZ+w01H5cS/aLGgBdZiauDYBWVjWFOy/va0Hp4Bvtf+7mNFhLnudltLyur2p88avIaEmJGY7pufQQn++xCdabBkCPGY2B90qZSFuEmysln5AU5ENmdvHgpGxNBbr6m2UcVKJuz+njlUL+/QIgz3X+nu+vwDHsT4MwUgoaB0BnOKuUAl+a06gB0AeihRS9RZrZXTxr4CAf0FoWPY0Xhc8u54c5AtEGmuB228ol0D9oQRwUPyUamqho6iYcN5AR66UOX7QhmbsIN9FrqE/w2QKy4eweGnQU36XRC8QZ+aUA0Eij72ORFszm+EoBT++maM04koz/lj7ozBcotMN8eI6ZkcXGtbZi0fElvfsb+2MAFQxFMjk0p15FeCkyeo42vE+xQb+offHWzpemePm7e3Z66Qci2kdDsQjVSMl9hHxS+N+JxF8yIKi+QccH7VCK/fNQq6BvY5fx22LXf9H7zuQc6gqWKhmQwDpKu4g8PZeZfTsR/cH/a+9Mw62pyjP9/IiCIIIGNQiigqgENK0EjYi2AxouiSZKTDAaidiKAwaNiC2RRkCc4oAoqEBUbDAOGOd5xKgYlQZbEGODIiqgCIpMAfpH19N537Ao9zlnn31q3HXXde1vf+fsqjXca1WdXc9663nnHQP2a59AzjcnUreXv7WTIdyPZxvOkbR7C5H4CNAtzK28gD9S0meLL7FtXdQyVP4RkTRomf84rjZc5RfVzSQdFP7QW8dBTXyBqT+m6Zv4o4sbFrNf9i+GOQb1m9J9YsHFN6fehhJNmxdRJwX1Iy5l1HwLp//MIvOLzgMru4t/kWShvg1rnvzC9ty4kXY9NxV/OO4aUUR+lDqjQYcyTjlnfA5dEAtql7TwpbOrMaee/gnkUyh+Lx+dv0clvDqR7Z9USZx8vbJlR7mV1/Ax2AyUUXOzLEZ8XXACz09W4vvnQ8xI+53cH+G52fm6TAJ0kqmLgbZH2K+6Xj9V0rYFvjx/huLXW87t+vl8flht2G7jB9EHhOdmz4UmSqtHRLtMW4c54MRPt5TzrxzvoczBkkFpg1Rv341xP+HET84jc9HEhOfsbt7HvrT6vvzKJiZQA2V4PPyI/DLfY2ffDomnQBrAtuEinJPCeYSaFqCzr76Hd+6bIW1t9XlIfaQtNxPIufgmSU7AO7RtL0lfaPjal1rMAVWOETsHWKtwbrc+t9J65CHVwtd5TV132hKAV4JlP2KvHHh1rc3VjBRWLa5ZZGv6It3nZFik7vLLgYUG+0NbcMvfL/KFtC4829/7SEmZEX1KNyx14dmPRjrBoFeovXXtwb3aHMknAfzuC+iXGr6Azjs/85y02HVGXGTbFKC9+HJ80bhdIjGbo4Yy8nNIwrObmtcxW9l4rL7X01jNO6bsNy4CKWDUhVYnn3lozDk/ReTkV/Wt7vuawrb36/J7RQoXrrd8ymnWI6OOnvNil63AvBBuH9sUnX188pjKgmnXs3UZBehkWI+Ud+SORUCLBH6MefMCdjm/ujhvSnGvbG85/o4q80KMI+t8U+Ubn/KcwOe567Nl/vpmCdFOmuyAHwdB+H3HWnH1a1y5MDl/zYvtOc98tOjsp1j9/dQiZ3qOT/k6nfdrTihsEdqM+ops9/XA9/MOOLI4NAUB2sln/SSx7ST7sqRI7s6n9PwWtA1fByyC+T7e97H5BMViZ3ozR/laZRHO88wBA2mN2EzplDJUAqkR+KkeL4Z3eV+xGpM8B/0UjvMxNXntSwHa+dveOsCBsYuCtb5GNNUuBzQbfEx4rDYRfbvS+OSNqC+efrTYCYSanCQDnBdrNqkukpqLBWN/OfU276N6deH555JeFyfLtRP0eS5PxDuG1cbzKia37dnnebVzw3PBYow9wn/c1MVkzRl4yx3yfHx43PCmbUnT16SMgLbnrT3hHa3xVxHt6THyNjTh2W3KBTqPkyNTnWhn6tewdU4xdl8HAZ9/fpWCrA+3cGZ/UXvd+m+GIzx3lpQ2NfUq0rrDv89zuTynFzm/y0Uzl5s/Z5tX6qajN/06u/o795UQMX5R2zlvJBHY1jFZFtx1mQXoRDJLDLTVjb9n2Z7D55GDAOpbWmDkeTPr3FkL+6zzxOXMEkuuq3yrvxOPtzpQw9nmbbmRG9Yza9Ee5uezxs3Xaue28EKIFxZ9/faTX7M2XwfLQIBF5mGWW87Hta7ZrtcL7Baaba3h6/WFtUVF35yX58kwR6D9VjnxpK0R+k7E5mvdDYX/dvs977cGPz3pJ4mHwN2LD76Gt7F5XL2A5a1c1G+jrnnL9HXoNwNqz7ztZr9mCNyumWIaKyXvlWwL0+RWPhnuPHYuv6/FrvLvuNvlhbfjJFnzK7/LL9z/RW4GF60sxRP7pnhlOxP/tNWGFLhPb8kraVEOfR9XCtH+vxOa2Zd7p+IPjtmVkTkZsVDezPgP4LuqlUkvKFwcx05JICsjvD2XvTpujkPxeV5pnqXYap9TC0re+vhClXPl0RGNmF92mr4epJDrKGt/abflR25DTdaTbfYXLlsiOGpzSudW39fIqddfPhFTF2Y9Dy2gWZS+T3jy3Td+tm1H118UfQNs4ezy+DtkAcNPWdlew3+XrqwNZv4NywjAodxgTWHOTUGAznHMc6geaepFaouBTgTqxdd7hvVT3fKmyfng72p+isb5OHxu+O+JzxMvzpR/+/NGhycAmqTfT1mrXcNtNXZ3SQ+ovnvtEYL0nST5ZZGt7c031Xm99iKIv4v6sd4fxg13WT+ic9ujQfkQgAAEIACBjgk0Lfas1fx8vMMCtIXotqOgMxrLjxE7s30jYeNrdXIkn2fEqRn55seWHE6WV39Ur94di2JOAvLGeJTZn0/Z59mee44ktzeOt6GKmjmOec79XYxhX8Jm1utHRP04WQpBbV+T8uZ6qD62KT77aQJ7OX6mJ4/ukVzGaGbLBMpHs/3/eoR0Vu+/IU6GZRHjzhFhZ6HaP/sz23rY6saLQBYV8vzzdaC0vsgIPL/7XLB4dlU8sWEx2U8E/DSe3LCo5tX4y0Jcm4XC5bvdpaiG6NzypFmh+CkJ0ImgPH/8u/qCjs8Ff+faIZKCWhj0yxGqPnccieaIxzxnMuo/I0H97jJ9nljY+2WcE/bJdQSpRWefL84hUF+McXtS4CutbPqZHdTaFoGcg3n/MyvgwHPNwROed76O+/+O3Pf/fd22pYzFab9S3M5raz4V6XL998EvLwz6Wm2h2ddpLwb6lfPRT975ul7fPB9Liw6u1b/NqO3vyOudh1MZoylxH1pfPSenMs/We/5NYf8hzsc25+RKT671PdZ5f9ZIO7oe1BSdnMX3tS0L0Pll33Xa286RlqXo2gjAkRdSRkO7KxYHzMm+vI5u85dSfyG06GyPQEcrfDpubLz/1B7TLMVaRzE5SYM9hHOulVEnQ5waeePhm1RnE7Zw09eiTHodPbmKCHtPB9eCFKD6fpxltXmRiwO/iqz2n0N8HuJpNOk21QW1/BI2z1MUvtY4QtqPsdrTzy8LGn73eWkRza8UMOxD6+hm/26erX5uE8k5D7Xu9pmiAF2nW1/4XMv6xeKzF3BsheO/mSkC+tzweeF3PxppMW+tx0HLumf58HY3E6ipTwL1OTjPddLXVlt5+PrteZjXb7/7eu156HcvnPvlubjSYmX2fZF29MmNuiEAAQhAAAIQaIBA1wJ0il1eZfcjgOkj2VY78ku2631C5V/5YR5lnzlr6kJ07pTRaZmQJn+/0v4NTMlBFlEuXHjOHlzd8L0wokLqntiD7EA0Kv2Q+45+dnNSgH5OtdBxQtyspC3PkBm21bYUnx0x5MSpX0V8bgs15bZAoB4pXRe4moheqdfhbmQ98wjgLXSbItdBAAH6t2HNOm/mEQRXw95GmesYZnYdIYH8Tp/naFMLFHlvl2Iz0c0jnBw0GQIQgAAEINAkgbaE39XamFGkziDpxGBt2nC4HflI+/fD/zWjRJq4IW5yLIZQVvkltB69UH/0cwjtbbsNdaHdyeucBfneUXHbc7fJ/qX4/NlIhtTUDcaibUwB2tm8XxkRNI6mmeKWY+NHVf+0ylz/LRbKpjgNJtHn8jvHat8/yr/P/K1ejqmBAL3+ccxzZJ5zhfNk/Xw5Yn4CzMX5WbEnBCAAAQhAAAIrEOhDgM4oaHvmOsqvzLjc1kClCP2KSvA+HHFnbszl/JjSzU1deLYlycslPaYQnofqIVwf3DJC2xYqtlhxlG1f1hvZvqz/DRFNniLs3JNzSXbMRQwvkD1J0rlEPi/JyNINCECgJIAAzXyAAAQgAAEIQAACEIDAhAn0IUAbdwp8Z0QWZgvEbXqzpgh3ffgbW+TpW4Cb8LQbdNdLn2dbxThC1wkaHZ1rsXDoPs8l3DJC+8tVIqKnSvrZwOb+6ZFsb0zR5E1M4EyQ6kjwL1UZ4J8WyaL6SgrZRJ8oAwIQgMBKBBCgmRsQgAAEIAABCEAAAhCYMIG+BOh8/N6iyymFTUabQ5EC1xcl7R11btRrr832Una3BLwg4c1zwskY7U18qKQ7x+/HJJCmH6r75EUXJ/y0zYWTFg1h4SWFCIutZ0ravaNrQLczauXayvHx9e/ZkUgK8XkoI0Q7IACBpgkgQDdNlPIgAAEIQAACEIAABCAwIgJ9CdB5I7Jp5Xl6tqT7dCRApYj4khDlEHxGNFlbamrdbuNxlS3MEZJ2G6HwXE+I+NFKcD5K0lnRlyGIz25Knv+bVZG/PwyRvwsrnpam0LqKLRcyjg5PcRcwlLFZV2fYGQIQgMCcBBCg5wTFbhCAAAQgAAEIQAACEFhGAn0J0GaZ4u+Bkt7WQTJC15mJ1xwVuqekcxB+lnFaz92njMT3AfcLMXDfQngei8+zm1x6KNti5khJtrfIc21I0f4ptt4rPI9tbzIFATrH6MqIsH9/XH/yujT3xGVHCEAAAiMjgAA9sgGjuRCAAAQgAAEIQAACEGiSQJ8CdNa9eQjBO4QIlVYITfazLCsTEn5b0sPDogABqC3awyy3jHzfWtKLJR1URcU7Ire0Rxhm62/ZqjKi9gpJ/yDpzZV9yHUhbnrv7NNQ+pP8n1AJ//88AfE5xX/3+2uSDpD0g1iEG9LCwFDmB+2AAASWjwAC9PKNKT2CAAQgAAEIQAACEIDA3AT6FKDdyBSiDpZ0bEdR0K43RbuTJD1LUhkJOzc8dhwdgYxozvF/RrUAYTsWL36U82IMHStFTf//5Mq7+jVhaVGeW0PsiyOeb6o8qQ+rkjse0+F53weLcoHghPAVv7a49vXRJuqEAAQg0DUBBOiuiVMfBCAAAQhAAAIQgAAEBkSgbwHa9fu1paRvStqxoyjoUmx0NOI7EaEHNCubb4rnmBc7bIHg7dHVPy+XtEf8bJFwLHYbjtZ3e71o4u3z0RdH1npzP4ceVZsLT++W9Nc1+5DmR7+fEssFgh9LOqSwRMHvuZ8xoVYIQKA/AgjQ/bGnZghAAAIQgAAEIAABCPROoG8BOgUzC2p/E0JwWmS0DcdCnjf7Qf+xpK8Sldg28l7KL6Pb71mJt4dXUcJPi5Z4ruUiSC+NW2elpc/zBZFg8NRi0WYMVjIpQtxG0jfCe7urc36duBfavb5A8E+SXiTpUvyeF+LJQRCAwHIQQIBejnGkFxCAAAQgAAEIQAACEFiIwBAE6BQAHRXoKM4HdvhIfgpfF0t6RNgXEJ240FQa3EGlz/MWIQL+raTbF8ko2/YbbwpKaeNwtaTXh8+zk9l5G9OczbbuJOl7RSR3U6z6LKcU0n9e2Yz8vaR/jAZh89PnyFA3BCDQNwEE6L5HgPohAAEIQAACEIAABCDQI4EhCNDufoqFe0v6VFgIdCUOprhnCxBbM/xmZIJej9NnkFXnvMnEe/uHz/PO0dox2W3UEyL+T0mvDuE2z5uh223UJ0me6/tJcnTwMkQ/O+rZ/XDfvNnS56jqqY6LBpwIcpAnL42CAASWlgAC9NIOLR2DAAQgAAEIQAACEIDA2gSGIkC7pRkZ+XFJ+3QYBe26U4T+hKR9q+RoN4Y1QwqAa5Nkj74JeC57DnksvT2sinQ+QtIj4+cxCc91QfNfqvl4pKQvRF/G4PO80nzISOC3VbYUB47c/7k+Tl7EepmkzxXjlPOx7/OD+iEAAQj0SQABuk/61A0BCEAAAhCAAAQgAIGeCQxRgN4lEhJu2rE/b4rQ75P0lIho9PCkV3TPQ0X1qxAo7TbuESKgI59TqPWhXUXUb3SgSrsNR9C+MiJq7f9cj+7eaF1dH5/Xm/R/vm/HC01N9bcuPF8i6R8knRCLVx6nMfhxN8WDciAAAQisRQABei1CfA4BCEAAAhCAAAQgAIElJjAkAdqYU0g8phJyDutBnMokb++Q9MxCfEaEHuZJUHof2+f5IEkvlHTHaO6Y7B3KhIjXSjpO0rGSfhF9GZPP80qzJc/vB0j618KyYmjXoZXaX08w+CtJjuQ+vrpe/CwOKhdDhnnW0CoIQAAC3RNAgO6eOTVCAAIQgAAEIAABCEBgMASGJvxkhOfmks6RtEPHInQZ2fguSU9fIvFvMJOugYZk4sq0SPnLSPjmiFpvY7Pb8LzLuf/+iHr+TiFojs3neS0B2osEb+j43N7ItKtHPF8nyX7cXiD4/hKO00ZYcSwEIACBWQQQoJkXEIAABCAAAQhAAAIQmDCBoQnQHoqMIPxTSR/uSUzMSOjTQoS+icSEgzhL6j7Pu0eyNyevHKPwXCaus3+wfZ4/WQiaKXwOAn4DjUgBwp7We44gAWH6N2dywWsknRoRz+cu8Tg1MNQUAQEIQOAWBBCgmRAQgAAEIAABCEAAAhCYMIEhCtClyOgoZHv5lr64XQ1X1vkxSU+T9OtCHO+qDdRzM4HS2mB7SYdKepakWxV+u2P0ef6ppNeGlUMudLjXy5YAMy1Edg37jc1i3IZ2DUrR3+3Ntl0aEc9vr64FP4wpOXY/bq4tEIAABLokgADdJW3qggAEIAABCEAAAhCAwMAIDE38STzZrjtJOkvSXUKs6lpgTBH6TEm2efiJpN+pktw5QpqtGwJlQjcnr3u2pJdIunNU38fixKI9L32er5d0kqRXVX26LApcZv/g7NshkbBvSOOWCQP9ntHOHhJfe/wUxHslWYT2hvC86OznOAhAYMoEEKCnPPr0HQIQgAAEIAABCEBg8gSGKkB7YFKw+nNJH4iI0PT+7XLg0o7jQklPlfSNEKFStOqyLVOqq2638fiq8y+XdP+A4HHxHBnyHM7xqnsIO6r+CElnxw5e1LAgu8zJLvPctdXIbgOw3yjtTUrR+UpJn5Lkpy++WESie4y8gLBskelTuqbQVwhAoD8CCND9sadmCEAAAhCAAAQgAAEI9E5g6OJditBvjcjXFIO7BpfRmldVVhwvCHGqFMm7bs8y11cXnp1Y0MLzEwvh2VGoXUfDL8K8LjyfF8LzB6Mwz+9l83mexcn9tHD7sBB1+1hIcrsymWPOsWzrjZL8lIPHxYsDFxWdmMoYLTK/OQYCEIDAvAQQoOclxX4QgAAEIAABCEAAAhBYQgJDF6BTqNpCkhOXWYy0iNSH+FjW++bwIP73sORY9ujVrqZ+aUFh+xXbNTyv8ki2X3CKh2W0alftWqSe0mLi8rCdOEHStTF/Pbczyd0i5Y/pmPR/PlHSM8PCxhHFbW6lrYbrqYvON0j6uqQvRLJTLw7klv7POefabCdlQwACEJgCAQToKYwyfYQABCAAAQhAAAIQgMAKBIYuQLvZKUruLumMyjN3kxCT+mh7iloWqL4i6bmSLFylUM7j+YudaqWvroXJZ0h6qaS7RXFD8gteq4elUO6I/XdWiRKPkfTjOHCZfZ5nsUnRYRtJ50q6QwfJB1dapHICwW9L+oykL1cJTn9Usz0h2nmt2c3nEIAABBYjgAC9GDeOggAEIAABCEAAAhCAwFIQ6EPEXQRcinYHSnpbRxGUq7WztOSwUPr2iNBNq4Fl9vJdZPxWOqZut/GoKjr4KEl7xAFj9nm2f7B9nr9aCM9TjKjNc/ewEOK7WkzwOWiB+Xvx9MS/xmLRL2uTEW/nJs9oyoIABCAwmwACNDMDAhCAAAQgAAEIQAACEyYwFgHaQ2ShyIKkBWgL0X35Qed0KYW0T1fWCi+OCE9/PrUo10VOoZLRPavxfFklGO4fBZlt3TJhkTq6OqacC46yfUX4hFsEnXJUrSPbzeB2ks6StEP83JaFTo6Dk5baJue7lWf7r2uTIC1c6hYdXc0V6oEABCAwRQII0FMcdfoMAQhAAAIQgAAEIACBIDAmATptLmzB8fmIku0qmnKlCVMmmftNJTYeHcKX/WXTR3YqPr/znlRllPiWkg6OxI63LxLyjcnnOcfZ43+spDdJurIQ0Kc8/rnIYEuVk8Pzuq2xTUHZvB8qyRHP9UWMKSR8nPc8ZD8IQAACXRJAgO6SNnVBAAIQgAAEIAABCEBgYATGJEAbXSYzu0d4uG7fY1LCcihLIfx/hfXCx2OHKUfAJqNcPPDP6c+7X0Q97xw79b2YsJ5Ts54Q8b2x+GC7B29EwN/si34bSd+SdJ+Wo59zXtmTfbcQu0kOup5Zzb4QgAAE2iOAAN0eW0qGAAQgAAEIQAACEIDA4AmMTYAuxb0HV5GOX5BkgWulpGNdDkAZDe16Pyjp1ZH0LMXzFGC7bFffddV9sR8bCQb3LITnjCLuu61r1e8xtqhpOxhvZ1ZRtkdGUrucm1P0eZ7Fre7b3vYCQ5bvhI+2c2ERYK3ZzOcQgAAEuiOAAN0da2qCAAQgAAEIQAACEIDA4AiMUYA2xPSD/gtJ7wsBuoyy7RO0Bchsy01V5KejY18v6TvRqLQFWGahsp5c0F1/uKRDqmjYfQrheaw+zz+NcK1c3gAAGn9JREFUhHr/KMljnJ7GHlO2m+f/ZpLOkbRjy4tEmfTTY/GgqDOflmA8IAABCECgfwII0P2PAS2AAAQgAAEIQAACEIBAbwTGKkAbWEY4Pk/SWyIydSiRtPVo6BslnS7pRElnFKO9TPYcpZicvscej70lPT/e3fX06m0rEV3TJ1OZENHe3k6C+SpJP4+KiLT9beLJ5LAQ6ruIfvZ88rm1V+El3vRcoDwIQAACEFiMAAL0Ytw4CgIQgAAEIAABCEAAAktBYMwCdClCH15FoR41MBE6xVZHxWbiNYuvn5J0iiR7RF8XsyiF8xRnM6Jz6JMsI739XkZ0O7ngvpIOkPSQ6ERdlB9639wfv9Juw+N1hCR7fOfcW+Yo9kXHx3PZY21/dkc/ey54a/NakxY8nm/vxH5j0aHjOAhAAAKtEUCAbg0tBUMAAhCAAAQgAAEIQGD4BNoUhbrqfUZbvlHSCwYoQpvDLPH1AkmnSfpwCHUlL4ueKW4OSYzO+ZLRzv+3Nsh7VFYjT5DkBIPbxWdjE57rPs+2TrHP84eiPymwDmlcujrX5qkn7XHeJWn/OB9zAWae49e7T4rPl1ZPGewq6coiWel6y2J/CEAAAhBohwACdDtcKRUCEIAABCAAAQhAAAKjILAMAnTpN3xc2D34kf+h2HHUJ0Jp6eDP/l3SNyNp4acl/aB2gPtXWnV0LXwmX7+77WX9Zrxz+Dr/uaTdi7anH/JYrDbc9NIq4heSXhuWG9cWvt74PK98acvFoMdI+mQwa3v8c8yOlfRCop9H8XeHRkIAAtMjgAA9vTGnxxCAAAQgAAEIQAACEPhPAssgQLszaQVhcfDNkg6S5OhcC2JD7WPd4sH9uF7SmZK+Vom5n5B0vqTfzJivKa7nDd1GrTtKK40scyV7ia0i0tTJBB8q6Y8Ki5EUcceUXNBtrieOPFnSqysLkYuDPT7Pa180cw7dVtLXJe3ScuJBtygXQ+yxfv84X0g+uPZYsQcEIACBrgkgQHdNnPogAAEIQAACEIAABCAwIAJDFWcXQVSK0I6GPHigdhz1vqVFhX9ftyq4qEre9w1JZ8XrXEmXrwInGZS71Me4HkG9VkTv71XR2feV9ICIcLbNxja1NpRJB8c0p+r2II5At5e4FwFyPPB5nu9sTOuN11Te5ofGAlD6Z89Xwvr3yuhnJ/h8EtYb6wfIERCAAAQ6IoAA3RFoqoEABCAAAQhAAAIQgMAQCYxJLJyHXylCW0h0csIyunWeMvrcZzUx2p9dVfnq/kjS2ZL+TdKPJf1Mkv1vr6g8sH+9YONvL+kOld2Exea7Srq7pHtHVKn/n4nkyuLHKjq7D3Xh+bwq2eArJL03Opi2EWuJ8wviXrrDMkL8UZFk0/y6sMDJxQFbfnwR+42lm1d0CAIQWB4CCNDLM5b0BAIQgAAEIAABCEAAAusmsGwCtAGUntAvkvS6oJLJytYNqccDMiGem7BSNKmFYAvT18TrV5GIzb7FV1fRqNcV0aibRDm2SbhdCMsWnv3z5vHzSgnjbGlS+kH3iGVDVZfz4JeSHC1v25a0OsHCYX14MymjFzHsZb5jB9YbbmFGP1t43iua3LU/+vpIsTcEIACB6RJAgJ7u2NNzCEAAAhCAAAQgAAEIDNYfeaNDU0ZC7y/pREm3riWZ22gdXR+f4lrp95wJCptsSyYaLH2hU9hvsp6uyyqTIvr/76rmxCslXRgNsfCO3cb6RqU8z06rEmj+VUfnWJ4Drv+xlQ+5rVPw6V7f2LE3BCAAgS4JIEB3SZu6IAABCEAAAhCAAAQgMDACyxgBXSJOUeqRkk4N7+KMnBzYUCzcnFKYdiHrjQLNOVB/X7hBAzuwbrdxRhXJfaSkL0U7HVmeovvAmj745qTvs/3WHUlujl1Yb+Q5/FVJPrf9M3Ypg58uNBACEJgwAQToCQ8+XYcABCAAAQhAAAIQgMCyC9Ae4RTJdpX07vA1tp2Exekp9H+qs7wuPF8QPs+nBBB8njc2M0rf50/G+dSF+OxWp42Ko58/RfTzxgaSoyEAAQh0QAABugPIVAEBCEAAAhCAAAQgAIGhEpiKAJtimX2P31Yl8HtyDMgYfaGHOpeG1K4y8aS9sd8k6fWS7I/tDbuGjY1W+mQ7QeVXInFlV+dSRj9/RtLeEXGdlhwb6xVHQwACEIBAWwQQoNsiS7kQgAAEIAABCEAAAhAYAYGpCNAeijK53EsrEfLoECIdDb1Sgr8RDCFNLAjUo57fF+N8XuyT0fBAW5xAnkdbSvq8pD/syPc5W5xWG3tKOpPFhMUHkiMhAAEIdEgAAbpD2FQFAQhAAAIQgAAEIACBoRGYkgCdInRGS/6xpOMl7dihd+3Qxn9Z2lMXnr9Rdezlkhwl6w2f52ZG2uKzWTuC/MOS9ulYfM7oZyc8fGptUamZHlIKBCAAAQi0QQABug2qlAkBCEAAAhCAAAQgAIGREJiaAO1hcZ8toDnyeTtJx0l6QozXsiUoHMk03FAzyzG7RNKrwmbF44vP84bQ3uJgnzd+OQL5HZKeHudQV08PpK3K1eHj/qOiPc31kpIgAAEIQKANAgjQbVClTAhAAAIQgAAEIAABCIyEwBQF6Bya0gf4OWHV8LtEQ49k5v6HEOrNIvONkt4q6TWSLo3f4/Pc3FCW4vNbJD2vY/HZPcmFhpdJOobo5+YGl5IgAAEIdEAAAboDyFQBAQhAAAIQgAAEIACBoRKYsgCd4mVacuws6VhJj4nBwht6mLO2brfxsSoS9khJZ0Vz8XludtxK8fl1kl7Use2Ge5MJDs+XtLuk68MKxHOBDQIQgAAEhk+gFKA/UXn42watz6fObqoWM28l6VnxVA/fHYY/h2ghBCAAAQhAAAIQgMCICUxdgPbQlZYcjpp1dOfhkrYuRK60chjxUC9F08ub1e9WUbBHSTo9euaxs1CJKNncUKfns5m+WdJBPTwhUC447B2+3kS3NzfGlAQBCECgCwKlAH2GpId1UekcdTw3nqBCgJ4DFrtAAAIQgAAEIAABCEBgUQII0DeTs9iWtg47VInrXiHpyfFxafewKGuOW5xAKTxfLsmRuCdIugaf58WhrnFkirw+L94u6b/1ID67iTn2J0t6JtYbrY03BUMAAhDoisAhVSLb/xJWTn0t8PtvyyaRM+IrkRvEv2ODAAQgAAEIQAACEIAABFoggAB9S6jm4ZuhvAl5fERD/2Hs5t/nPi0MB0WuQsCLABYhnWTwotiPSNh2pkxy3UrSOyX9WQ+ez+5ZWm/8NBIPXkHiwXYGnFIhAAEIQAACEIAABCAAAQhAAAIQgEBbBBCgZ5NNLn78f1NJT698Z19SiXF3i93tD22RDn5tzcyby7Xob7/I10tylJI37Dba456PIW8r6X2SHtKjT2dGPz9R0oeIUGtv0CkZAhCAQIcEhvbdCeuuDgefqiAAAQhAAAIQgAAEpklgaDcBQxuFMsL298If+hmVJcE2CNGdDFUmiHxBeBCn6O8FALZmCZTJBh8q6ZTqdY+eIp/dsxSfbf/xbMTnZgeb0iAAAQhAAAIQgAAEIAABCEAAAhCAQFcEEKDXJl235dhO0sHhR7tlHI41x9ocF93DIrTH4CRJz5d0A2LkoihXPK5caHmWpDdI2rzHyOe03jhf0h9JujpaTpRa40NPgRCAAAQgAAEIQAACEIAABCAAAQhAoF0CCNDz860L0XeX5Gho23PYrsBbekfbRxq287Nda88UJL8u6SBJZ4cIbUEyE0SuVQaf/zYBz1GLz44o30LSayPa2Hsm86655Zh6oeHRkjzmZYLQrttDfRCAAAQgAAEIQAACEIAABCAAAQhAAAIbIIBIun54pVWBj946ROinSrpfUVxGRef+66+JI0oCaclwlaS/k/SO+BA/6MXmSSnqOsr4eEkPiEWUPhdQLIbbh/pvC9uVXNhZrKccBQEIQAACEIAABCAAAQhAAAIQgAAEINAbAQToxdHXI6JvW0VrPiasOR4haZMo2hGdKZ7Ce3HePjI5+v/vkXRoxftnEW1utkRDr823nLdOsPmiiuvhMV9LvmuX1PweWf+pkv4aq5XmAVMiBCAAAQhAAAIQgAAEIAABCEAAAhDomgCC6MaJlzYGWdr9Jf2ZpP0qofRetSoc4ekIU7/Y1k8gExOa3yWSDouEeS6JaOjVeZZez3uG5caD45C+LDeyxVm/7VX+q6Rr4gN8n9d/jnAEBCAAAQhAAAIQgAAEIAABCEAAAhAYDAEE6OaGIiNLS1/iW0dU9N6SHlfZRmxfVFful8c215rlL6mM1v10Ff38PyR9K7qNEH3z+Ncj9W0Z48hxJ9L0/PSCiHn1eS1I8fnnkh4m6Qf4Pi//CUwPIQABCEAAAhCAAAQgAAEIQAACEJgGgT5Fp2UmbEHPW+lda4uOR0myGO3o011rACzCZbRn+kYPcXwyAnkI3tbJzLydtO4tko6TdDFC9P8XlNPn2WPm/x8QEeP3KOZnztW+zsecTzfFIs3nsN7oayioFwIQgAAEIAABCEAAAhCAAAQgAAEINE9giAJn873sr8RZUdFuzeaSfr+K2N0nxGj/f5sZzXR0qrdZgnTbY5dieAqEbof/7wRxufnnttsxz+iV0dCOon2DpJOqKN9fxcFus/eZgp1DPeLZCJ4o6cWSnGzQW99ez+X88SKCRfADJZ0Y8yvn/Txjzz4QgAAEIAABCEAAAhCAAAQgAAEIQAACAyYwBPFwwHgabVoKg36vC2zbSbq3pIdI2kPSPSsx7i6SbrNKCywiWrwrI5FzPOcZ11JgdjVlZPNalgw/kbSFpK2iDUPws85kjymQXyjpeEnvlnRFcMx2LmOywvQVz7llDo+tvJQPkfTQ6H99vjQ6wRcozG11O4+oIrSPwsN7AYIcAgEIQAACEIAABCAAAQhAAAIQgAAEBk5gHqFy4F0YZfPKiObSCzo7s5mknSXtFMK0I6T9sijtzzbtoNcWuJ0IzuLtBVVCxe9XkbT/W5KF3XMlWTT/eBVpvO2AROgU0jOq1j+7vadIepckC+e5WWSfxb4DtI1VUbfZcMGOrn+SpGfGYoZ/l4L7EBYKsvMpPp8g6XmIz43NCQqCAAQgAAEIQAACEIAABCAAAQhAAAKDIoAAPYzhsDCYY7GaKPq7ku4a4q/fbdvh3/nl5HK3k2SvaYvUfneSudxcvoVIeyXn6zeSfi3pqrCruEySLSwulXSJpIvifaWI4QdK+lTlu3yHgYnQKbqaZXocu4/vr0T90ySdUXBJ9hkBPnSbjnKulB7jjqD/S0lPlnSf6F/pkT2Mmf4frUjx2WPxtGhYafUypLbSFghAAAIQgAAEIAABCEAAAhCAAAQgAIENEECA3gC8Fg/NCGmLjSlIzyOM3iosDWxr4FcZ8eoy06bCwqRfTvx24xzeyLPa47ItgD5C0kdD8HaZQ4qynSVEu43fDiH6M5Vg+2+1cTS3FNz7FkVLS5Ucv3Ix4I6SHhnC82Mi+nlWn1ucqusuOsXn06uo+v1qrNddGAdAAAIQgAAEIAABCEAAAhCAAAQgAAEIDJsAAvSwx6feutK6ox4xPY9AvVJvS4HZ+5TRwKuVa7HWguLjIrrY1iBDFKGzTxbMyySKjv62GP0BSV+rrCvOmwHI+9ejozfCerUx8GflGM9KnHg3SfeX9Bfh7WwrlNw8FukFPcSZneLzR8ImxAsgbu8yenIPkT9tggAEIAABCEAAAhCAAAQgAAEIQAACnRNAgO4ceWsVbmQsNyKoliL0e8P+Y6gidCmuu42lGH29pLNDiP5sJfB+L+xHZg1YmVCyLDP/P6/InPunVcas42yvcndJj4po8wdIulOxY9pwlNYcrU2yDRTsdtoO5UOSniLJvDOqewPFcigEIAABCEAAAhCAAAQgAAEIQAACEIDAkAlsRLQccr9oW7cEUoR+dERCbxX2HOm/3G1r5q+t9Nuut9XR0WdJ+m4kXbQ47WSM10bf5q9l/j3t3e0I510k7VqJtX8gabfw/S5LSdE5hfD5a+h+z7R98Rx5j6Snh+0Lkc/djwU1QgACEIAABCAAAQhAAAIQgAAEIACBzgkgQHeOfGkrTBF6T0n/LMn+xBn1OoZOl2L0rGhi98WJDH8UQrQTNGbSxsslOaHj1ZKuCYHVdhO2mDAXJ4O0P7ctSpwo0gK9X04cuW1EOG9f+VLvFNy8b7mVFiBjEJ2z7dlu8zypSm55YNiZID6P4YygjRCAAAQgAAEIQAACEIAABCAAAQhAoAECCNANQKSI/ySQIvQDIxLa0bzp+zs2TGXyx3l8lZ3M8YYQnS1W21bD7z7W0dV+N59NQohejUdGDdetPsbE0P1PP+tjqnnwsmDQd2LHMTGkrRCAAAQgAAEIQAACEIAABCAAAQhAYPQEEKBHP4SD60CK0HcNywVHRI8pEnoloOmTXU/QmOLyegfCAm0m3ysTD7qcsZ+XOd5+P7iK6j4e8Xm904P9IQABCEAAAhCAAAQgAAEIQAACEIDAchAYu9C1HKOwfL2wKGvx0TYTJ1c+yvsW0cDLOOdmJXEsfzerz8vIwTM5xecrJR0g6SOIz8t3gtMjCEAAAhCAAAQgAAEIQAACEIAABCAwL4FlFcHm7T/7tUcgfX49x15f+Se/MKpahmjo9qiNt+Qy2eB3JP2NpHPCdsRjPkukH29vaTkEIAABCEAAAhCAAAQgAAEIQAACEIDAXAQQoOfCxE4LErAInZYVFiTfGFHRY/WFXhDD0h9mKxGPtbcPRrLBK8L72uIzGwQgAAEIQAACEIAABCAAAQhAAAIQgMBECSBAT3TgO+x2+htbpNw9LDnuF/7H+VmHzaGqhgnkYoLfD5f0mlh0SBuWhqujOAhAAAIQgAAEIAABCEAAAhCAAAQgAIExEUCAHtNojbutmZzQvtBvkfSU6A6WHOMc14xsd+TzDyU9R9Jnoyu+rmC5Mc5xpdUQgAAEIAABCEAAAhCAAAQgAAEIQKBRAgjQjeKksDUIlFGxz5D06kqM3nrJExQu46QoFw3eH/7el+D3vIxDTZ8gAAEIQAACEIAABCAAAQhAAAIQgMDGCCBAb4wfR6+fQHoF25JjZ0nHSdoriiEaev08uzzCY+bNY3iZpP8u6ZT4HZYbXY4EdUEAAhCAAAQgAAEIQAACEIAABCAAgZEQQIAeyUAtYTNTsLSYeXBl2XBElaRwy/CGTpFzCbs9yi7ZTsOLA7ZR8faBEJ9tvVF6fI+yczQaAhCAAAQgAAEIQAACEIAABCAAAQhAoD0CCNDtsaXktQlYfM6o2t+XdLSkJ8ZhTmpnkZo5ujbHNvcoo9IvlvT3kk6NCtPXu836KRsCEIAABCAAAQhAAAIQgAAEIAABCEBgxAQQ90Y8eEvSdM9BC80WnL09ubJ4OKoSOe8ZP2PL0c9Ae2Ego5tvlHSipGPCeqO0UemnddQKAQhAAAIQgAAEIAABCEAAAhCAAAQgMAoCCNCjGKZJNLIUNe8o6dBK7Hy2pNsiRHc6/haebbnhRQFvn6z+ebmkb8XPeD13OhxUBgEIQAACEIAABCAAAQhAAAIQgAAExk0AAXrc47eMrS8Fzp3Ca3j/EEQtjFogtVjN3G129OvC8zclvVbSB6MaMzd/v9ggAAEIQAACEIAABCAAAQhAAAIQgAAEIDAXAUS8uTCxU8cEPC8teNp+w9uDJB0m6fFFO/wZQvTGB6YuPJ9fRZ2/TtJpkm4gyeDGAVMCBCAAAQhAAAIQgAAEIAABCEAAAhCYMgEE6CmP/vD7Xvcafrikg0KIvlU0n2SF6x/HjCRPmw2XcJ6k40J4vjaKxG5j/Ww5AgIQgAAEIAABCEAAAhCAAAQgAAEIQKAggADNdBgDgbr9wx6SDpS0n6RbRwfqkbxj6FfXbZzF6MxIMPhPEfHsNll4zn27biP1QQACEIAABCAAAQhAAAIQgAAEIAABCCwRAQToJRrMCXTFwmhG77q7fyDJ/tBPkrRd9D8/99zO1wTQrNjFUkjOiOcbJX2kYnaypM+H2IzwPOVZQt8hAAEIQAACEIAABCAAAQhAAAIQgEBLBBCgWwJLsa0SqFtzbC3pcZKeIekhRc1l0kL/eirzPfvt998peJwr6WOS3l1Fj3+/+D0Rz61OVwqHAAQgAAEIQAACEIAABCAAAQhAAALTJTAVQW66I7zcPc8khJms0L19sKR9Jf2JpHvXum+/aB+TAvYy0XGks1/1/l0q6cuS3iPpS5LS33kWu2XiQV8gAAEIQAACEIAABCAAAQhAAAIQgAAEBkAAAXoAg0ATNkzA89iCailE2xvaSQufKGkfSdvWIqBLwXaMVh0rCc6GeYWkMyR9tIoI/5ykSwrCjojOYzcMngIgAAEIQAACEIAABCAAAQhAAAIQgAAEILAaAQRo5scyEUgh2n0qxejNJD1Q0qMl7VXZUOwWifbKvpdeyUPyj7aNRr6yvRm9XLb//0j6YtW/r1ZR4J+RdHnxYXo/k1hwmWY7fYEABCAAAQhAAAIQgAAEIAABCEAAAiMggAA9gkGiiQsRSDG6TFrogm4laccqQvgRkh4k6b7x8u/rm0VsH5/nSf3d+2/kHHLZudX/nz+XHs5l+yw4f1fSmZFI0D+nvUa2y8Jz9mEhiBwEAQhAAAIQgAAEIAABCEAAAhCAAAQgAIGNENiIeLaRejkWAl0SSDHa7/aBLrfbSNpe0v3DP3oXSdtJuoukLeZoZJnwr9y9PLdKcTnF4VlRzLOq87G20PiJJCcRdITz2fHzr2oHWHB2vYjOcwwcu0AAAhCAAAQgAAEIQAACEIAABCAAAQi0TwABun3G1DAsAqW9xixB2q3dPETpu1fJ++4lye/5ukN8vqkkv9LeYtFeXi/punhdI+liSRfG6yJJP43fXTajghSc01qjLnQv2iaOgwAEIAABCEAAAhCAAAQgAAEIQAACEIBAIwQQoBvBSCEjJjDL77n0j653bUtJ20jaqvZytLQFaVt5lC+LwjdE4j+/2ybDQvPV8XLCwF+EZ3M9ormsu4yYnuULPeIhoOkQgAAEIAABCEAAAhCAAAQgAAEIQAACy0rg/wFbY5HdEBgzlAAAAABJRU5ErkJggg==" preserveAspectRatio="none" width="100%" height="100%"></image></symbol><symbol id="image-586b60642e948451d54ea19202de939285026ebd9adc5cf4d370715693e9b4d8dd63b367a9d09937ba0c53d300441eb4"><image href="data:image/png;base64,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" preserveAspectRatio="none" width="100%" height="100%"></image></symbol><symbol id="image-abb8a09bad8a00e9e45b10d3c3a2b973ade8007325351468d2bfe860b99e3e2170f2c187061f2331c06c89529f998279"><image href="data:image/png;base64,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" preserveAspectRatio="none" width="100%" height="100%"></image></symbol><symbol id="image-fd5a0e89e39657b09e80610a7478867ebf1143f0fdc2649a58e7e2b2e4007d0acfce91b931249ad9862e52bdcb921319"><image href="data:image/png;base64,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" preserveAspectRatio="none" width="100%" height="100%"></image></symbol><symbol id="image-3380d919c79e57fb90b77f82462627ddf0081e4646147056cf39e7688f0f939de154b5770fd90d543a9230c11af30bbe"><image href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAyAAAAMgCAYAAADbcAZoAAAAAXNSR0IArs4c6QAAIABJREFUeF7s3XucXHV9//HPZ3Y3hItctNVyay1Qk+xsCNlZBEPBG6jdsDuTUFfpRa318vNeFarSi63Weikq1ku9t1arQCvZSSBYBVoRjCRzdnOZMwmwYqwBsQImkNte5nx+3eAVksxlz8x8v+e8+Mf6mPP9ft+f5+c8yuPj7uxXpUX/9BYHXq9mV6jqiS06gm0RQAABBBBAAAEEEGiDgP3YTL6ZyWQ+tmV4wzfbcGCij9C4q+u7vn+RVXW1ip4R997shwACCCCAAAIIIIBAZwXsg+V8cFlnM/h9evwDSHHgHhH5bb9ZSI8AAggggAACCCCAwMEFTKJXhfmxz+DTnECsA0h2NPcHqvpvzUVhFQIIIIAAAggggAAC7guYyV1hobTA/aRuJox3ACkOfEpFXuVmqaRCAAEEEEAAAQQQQCAegf09XcdNDN7xcDy7pWuXWAeQvmLuGhEdSRch1SKAAAIIIIAAAgikTYABpPmOxzuAjA5cLSovaj4OKxFAAAEEEEAAAQQQcF7gnnK+dLrzKR0NGO8Awk9AHG0zsRBAAAEEEEAAAQTiEjCRt4X50gfi2i9t+zCApK3j1IsAAggggAACCCDQtICJ3b1rct6SHSPr9jW9ScoXMoCk/AWgfAQQQAABBBBAAIH6BExkv1g1FxbGK/Wt4KmDCTCA8F4ggAACCCCAAAIIIFCXgL22nA/+qa5HeeiQAgwgvBwIIIAAAggggAACCNQSMFtVLgQraz3G57UFGEBqG/EEAggggAACCCCAQJoFTHZEU3sXVUYqu9PMEFftDCBxSbIPAggggAACCCCAQBIFZkxnloXDGzcksbhO1MQA0gl1zkQAAQQQQAABBBDwQsDM3h4Wgvd7EdaTkAwgnjSKmAgggAACCCCAAALtFTCTm8NC6cL2npr80xhAkt9jKkQAAQQQQAABBBBoUMDEHqhWuxZuW7n+wQaX8ngNAQYQXhEEEEAAAQQQQAABBH5JwMRM1C4Mh8duASZ+AQaQ+E3ZEQEEEEAAAQQQQMBnAZO/LxdKf+FzCS5nZwBxuTtkQwABBBBAAAEEEGirgJmsD/Olc0XF2npwig5jAElRsykVAQQQQAABBBBA4DACZjunumb67hradC9OrRNgAGmdLTsjgAACCCCAAAIIeCQQqQxWhks3ehTZy6gMIF62jdAIIIAAAggggAACcQqYyMfCfOkNce7JXgcXYADhzUAAAQQQQAABBBBItYCJhPNPtqXBQDCdaog2Fc8A0iZojkEAAQQQQAABBBBwUcD2mtiSMD824WK6JGZiAEliV6kJAQQQQAABBBBAoD4Bi15cLoxdU9/DPBWHAANIHIrsgQACCCCAAAIIIOCdgIn9a5gPXupdcM8DM4B43kDiI4AAAggggAACCDQuYGJ375qct2THyLp9ja9mxVwEGEDmosdaBBBAAAEEEEAAAe8EzGxKJFoaFsYr3oVPQGAGkAQ0kRIQQAABBBBAAAEE6hcwi14fFsY+Xv8KnoxTgAEkTk32QgABBBBAAAEEEHBbwGxtuRAsdztkstMxgCS7v1SHAAIIIIAAAggg8DMBkx17j7a+ey4KdoHSOQEGkM7ZczICCCCAAAIIIIBAmwTMLJJM9dxweOOGNh3JMYcQYADh1UAAAQQQQAABBBBIvEAkdkUlH7w38YV6UCADiAdNIiICCCCAAAIIIIBA8wJmcnNYKF3Y/A6sjFOAASROTfZCAAEEEEAAAQQQcErAxB6oVrsWblu5/kGngqU4DANIiptP6QgggAACCCCAQJIFTMxE7cJweOyWJNfpW20MIL51jLwIIIAAAggggAACdQmY2vvC4eAddT3MQ20TYABpGzUHIYAAAggggAACCLRLwEzWh1OlZTIi1XadyTn1CTCA1OfEUwgggAACCCCAAAKeCJjII9OZ6UV3DW2615PIqYrJAJKqdlMsAggggAACCCCQfIFqxlZsHQpGk1+pnxUygPjZN1IjgAACCCCAAAIIHETAzD4RFoLXgeOuAAOIu70hGQIIIIAAAggggEADAiYSzj/ZlgYDwXQDy3i0zQIMIG0G5zgEEEAAAQQQQACBVgjYXhNbEubHJlqxO3vGJ8AAEp8lOyGAAAIIIIAAAgh0SCDS6E8qw2P/0qHjObYBAQaQBrB4FAEEEEAAAQQQQMA9ARO5OsyXLnUvGYkOJsAAwnuBAAIIIIAAAggg4K2AmW3fNTWvd8fIun3eFpGy4AwgKWs45SKAAAIIIIAAAkkRMLMp6YqeHg6Nb0pKTWmogwEkDV2mRgQQQAABBBBAIIkCZm8qF4J/TGJpSa6JASTJ3aU2BBBAAAEEEEAgqQJma8uFYHlSy0tyXQwgSe4utSGAAAIIIIAAAkkUMNmx92jru+eiYFcSy0t6TQwgSe8w9SGAAAIIIIAAAgkSMLNIMtVzw+GNGxJUVqpKYQBJVbspFgEEEEAAAQQQ8FvAxP4qzAd/53cV6U7PAJLu/lM9AggggAACCCDgjYCJ3Rbmg/O9CUzQgwowgPBiIIAAAggggAACCDgvYGIPqEz2lfPlHzkfloCHFWAA4QVBAAEEEEAAAQQQcF7ANHpuODx2i/NBCVhTgAGkJhEPIIAAAggggAACCHRSwEQ+EOZLb+tkBs6OT4ABJD5LdkIAAQQQQAABBBCIWcBM1odTpWUyItWYt2a7DgkwgHQInmMRQAABBBBAAAEEDi9gIo9MZ6YX3TW06V6skiPAAJKcXlIJAggggAACCCCQKIFqxlZsHQpGE1UUxQgDCC8BAggggAACCCCAgIMC9slyPniNg8GINEcBBpA5ArIcAQQQQAABBBBAIF4BEwkne3bmJgYnJuPdmd1cEGAAcaELZEAAAQQQQAABBBA4IGAi+0WixWF+bAKSZAowgCSzr1SFAAIIIIAAAgj4KvCn5Xzp876GJ3dtAQaQ2kY8gQACCCCAAAIIINAGARO5OsyXLm3DURzRQQEGkA7iczQCCCCAAAIIIIDAowJmtn3X1LzeHSPr9mGSbAEGkGT3l+oQQAABBBBAAAHnBcxsSrqip4dD45ucD0vAOQswgMyZkA0QQAABBBBAAAEE5iJgGr05HB67ai57sNYfAQYQf3pFUgQQQAABBBBAIHkCZmvLhWB58gqjokMJMIDwbiCAAAIIIIAAAgh0RMBE7t93lC2856JgV0cCcGhHBBhAOsLOoQgggAACCCCAQLoFzCwS1QvCfOn2dEukr3oGkPT1nIoRQAABBBBAAIGOC5jZO8NC8K6OByFA2wUYQNpOzoEIIIAAAggggEC6BUzstnA4uEB09uJz/kmbAANI2jpOvQgggAACCCCAQAcFTOwBlcm+cr78ow7G4OgOCjCAdBCfoxFAAAEEEEAAgbQJmEbPDYfHbklb3dT7CwEGEN4GBBBAAAEEEEAAgTYJ2AfL+eCyNh3GMY4KMIA42hhiIYAAAggggAACSRIwk43hVGlARqSapLqopXEBBpDGzViBAAIIIIAAAggg0ICAiTwSdVcXb10+/v0GlvFoQgUYQBLaWMpCAAEEEEAAAQRcEahmbMXWoWDUlTzk6KwAA0hn/TkdAQQQQAABBBBItICJfSbMB69KdJEU15AAA0hDXDyMAAIIIIAAAgggUK+AiYSTPTtzE4MTk/Wu4bnkCzCAJL/HVIgAAggggAACCLRdwET2i0SLw/zYRNsP50CnBRhAnG4P4RBAAAEEEEAAAT8FzOyVYSH4rJ/pSd1KAQaQVuqyNwIIIIAAAgggkEYBs1XlQrAyjaVTc20BBpDaRjyBAAIIIIAAAgggUKeAmW23qX2LKyOV3XUu4bGUCTCApKzhlIsAAggggAACCLRQYMYy1YFwaHxTC89ga88FGEA8byDxEUAAAQQQQAABVwQisbdW8sGHXMlDDjcFGEDc7AupEEAAAQQQQAABvwTM1pYLwXK/QpO2EwIMIJ1Q50wEEEAAAQQQQCBBAiZy/76jbOE9FwW7ElQWpbRIgAGkRbBsiwACCCCAAAIIpEHAzCJRvSDMl25PQ73UOHcBBpC5G7IDAggggAACCCCQZoG/LedLf5NmAGpvTIABpDEvnkYAAQQQQAABBBD4qYCJ3RYOBxeIioGCQL0CDCD1SvEcAggggAACCCCAwC8EzHaKTi4s58s/ggWBRgQYQBrR4lkEEEAAAQQQQACBAwKRymBluHQjHAg0KsAA0qgYzyOAAAIIIIAAAikXMJMPh4XSW1LOQPlNCjCANAnHMgQQQAABBBBAII0CZrJx/in29GAgmE5j/dQ8dwEGkLkbsgMCCCCAAAIIIJAKARN5JOquLt66fPz7qSiYIlsiwADSElY2RQABBBBAAAEEkidQzdiKrUPBaPIqo6J2CjCAtFObsxBAAAEEEEAAAU8FTOxzYT54hafxie2QAAOIQ80gCgIIIIAAAggg4KKAid092bNr8cTgxKSL+cjklwADiF/9Ii0CCCCAAAIIINBWARPZL1bNhYXxSlsP5rDECjCAJLa1FIYAAggggAACCMxdINLo1ZXhsU/PfSd2QOBRAQYQ3gQEEEAAAQQQQACBgwuYrSoXgpXwIBCnAANInJrshQACCCCAAAIIJETAzLbb1L7FlZHK7oSURBmOCDCAONIIYiCAAAIIIIAAAg4JzFimOhAOjW9yKBNREiLAAJKQRlIGAggggAACCCAQm4DZ5eVCcGVs+7ERAr8kwADC64AAAggggAACCCDwcwEzuTkslC6EBIFWCTCAtEqWfRFAAAEEEEAAAc8ETOT+ajXTt23l+gc9i05cjwQYQDxqFlERQAABBBBAAIFWCZiYiej5Yb50e6vOYF8EZgUYQHgPEEAAAQQQQAABBMTE3h3mg7+GAoFWCzCAtFqY/RFAAAEEEEAAAccFTOy2cDi4QFTM8ajES4AAA0gCmkgJCCCAAAIIIIBA0wJmO0UnF5bz5R81vQcLEWhAgAGkASweRQABBBBAAAEEkiYQqQxWhks3Jq0u6nFXIN4BZHTgalF5kbvlkgwBBBBAAAEEEEDgZwImclWYL70ZEQT6Rs8+VcReIio9kdgj1h39x9bl499vhQwDSCtU2RMBBBBAAAEEEHBcwETGw3yp3/GYxGuxwBlrzzl2/tTMu0X1jY89ytTeFw4H74g7AgNI3KLshwACCCCAAAIIuC5gsk/MFpdXBN91PSr5Wiew+PrFJ0Qz825X1UWHOsXE/inMB6+NM0W8A0gxd42IjsQZkL0QQAABBBBAAAEEYhaw6MXlwtg1Me/Kdh4J5Eq5nsl75VYRPfdwsc0sqlr19G0rNm6PqzwGkLgk2QcBBBBAAAEEEPBBwOSfy4XSy32ISsYWCZhoXzH3VVFdUc8JkdhllXzwwXqereeZeAcQvoRejznPIIAAAggggAACnRK486GM9d83FOztVADO7bxAdjT3cVWt+9eqTOwLYT54WVzJ4x1A+BWsuPrCPggggAACCCCAQKwCJrJfrJoLC+OVWDdmM68E+or9l4tkPtBQaJNryoXSixtac5iHGUDikmQfBBBAAAEEEEDAaQF7TTkffNLpiIRrqUDv6v4RNb1aRRubARhAWtoXNkcAAQQQQAABBJInYLaqXAhWJq8wKqpXoHe0//yM6M2i2lPvmp8/xwDSMBkLEEAAAQQQQACB9AqY7Iim9i6qjFR2pxch3ZUvun6gL1OV21Xk2KYkGECaYmMRAggggAACCCCQRoEZ05ll4fDGDWksnppFFhSXntQjXWMi8pSmPRhAmqZjIQIIIIAAAgggkCoBE3lbmC819oXjVAklu9inrjrr+GMyXetEdOGcKmUAmRMfixFAAAEEEEAAgVQImMnNYaF0YSqKpcjHCdR70WBddAwgdTHxEAIIIIAAAgggkFoBE7m/Ws30bVu5/sHUIqS58AYvGqxJxQBSk4gHEEAAAQQQQACB1AqYmIno+WG+dHtqEVJeeLY48CkVeVVsDAwgsVGyEQIIIIAAAgggkDgBM3lPWCj9ZeIKo6C6BJq6aLDWzgwgtYT4HAEEEEAAAQQQSKeAmawP86VzRcXSKZDuqpu+aLAWGwNILSE+RwABBBBAAAEEUihgtnOqa6bvrqFN96aw+tSXPKeLBmvpMYDUEuJzBBBAAAEEEEAgfQKRymBluHRj+iqn4jlfNFiLkAGklhCfI4AAAggggAACKRMw+2i5ELwxZVVTrsR00WAtSQaQWkJ8jgACCCCAAAIIpEfARML5J9vSYCCYTk/VVDorENtFg7U4GUBqCfE5AggggAACCCCQFgHba2JLwvzYRFoqps5HBWK9aLAWKgNILSE+RwABBBBAAAEEUiJg0YvLhbFrUlItZf6SQN9o7jpRXdEWFAaQtjBzCAIIIIAAAggg4LSAiX0hzAcvczok4Voi0Dea+4iotu87PwwgLekjmyKAAAIIIIAAAt4ImNjduybnLdkxsm6fN6EJGotASy4arJWMAaSWEJ8jgAACCCCAAALJFTCzKZFoaVgYryS3Sio7mEDLLhqsxc0AUkuIzxFAAAEEEEAAgeQKmEWvDwtjH09uhVR20OFjtP/8jOjNotrTdiEGkLaTcyACCCCAAAIIIOCGgNnaciFY7kYYUrRLoOUXDdYqhAGklhCfI4AAAggggAACCRQw2bH3aOu756JgVwKro6RDCCwoLj2pR7rGROQpHUNiAOkYPQcjgAACCCCAAAKdEpgxnVkWDm/c0KkAnNt+gbZdNFirNAaQWkJ8jgACCCCAAAIIJEsgEruikg/em6yqqOZwAm29aLBWKxhAagnxOQIIIIAAAgggkBwBM7k5LJQuTE5FVFKPQFsvGqwViAGklhCfI4AAAggggAACyRAwsQeq1a6F21aufzAZFVFFPQJtv2iwVigGkFpCfI4AAggggAACCPgvYGImaheGw2O3+F8NFdQr0Deau0xU/6He59vyHANIW5g5BAEEEEAAAQQQ6KiAqb0vHA7e0dEQHN5WgY5dNFirSgaQWkJ8jgACCCCAAAII+C1gJuvDqdIyGZGq35WQvl6B3k5eNFgrJANILSE+RwABBBBAAAEEPBYw2znVNdN319Cmez2ugugNCHT8osFaWRlAagnxOQIIIIAAAggg4K9ApDJYGS7d6G8FJG9EwImLBmsFZgCpJcTnCCCAAAIIIICAnwJm9omwELzOz/SkblTAmYsGawVnAKklxOcIIIAAAggggIB/AiYSzj/ZlgYDwbR/6UncqIBTFw3WCs8AUkuIzxFAAAEEEEAAAd8EbK+JLQnzYxO+JSdvcwJOXTRYqwQGkFpCfI4AAggggAACCPglYGIvC/PBF/xKTdpmBZy7aLBWIQwgtYT4HAEEEEAAAQQQ8EfARK4O86VL/UlM0rkIOHnRYK2CGEBqCfE5AggggAACCCDgh4CZbd81Na93x8i6fX4kJuVcBJy9aLBWUQwgtYT4HAEEEEAAAQQQcF/AzKakK3p6ODS+yf20JJyrgNMXDdYqjgGklhCfI4AAAggggAAC7gtEam+sDAcfdT8pCecq4PxFg7UKZACpJcTnCCCAAAIIIICA4wJma8uFYLnjKYkXg4AXFw3WqpMBpJYQnyOAAAIIIIAAAg4LmOzYe7T13XNRsMvhlESLQcCbiwZr1coAUkuIzxFAAAEEEEAAATcFzCySTPXccHjjBjcTkiouAa8uGqxVNANILSE+RwABBBBAAAEEHBUw+ctyofQeR9MRK0YBry4arFU3A0gtIT5HAAEEEEAAAQTcEzCx28J8cL57yUgUt4B3Fw3WAmAAqSXE5wgggAACCCCAgFsCJvaAymRfOV/+kVvJSBO3gJcXDdZCYACpJcTnCCCAAAIIIICAOwImZqJ2YTg8dos7qUjSCgFvLxqshcEAUkuIzxFAAAEEEEAAAXcETOQDYb70NncSkaQVAl5fNFgLhAGklhCfI4AAAggggAACbgiYyfpwqrRMRqTqRiJStELA+4sGa6EwgNQS4nMEEEAAAQQQQKDzAibyyHRmetFdQ5vu7XwaErRKIBEXDdbCYQCpJcTnCCCAAAIIIIBA5wWqGVuxdSgY7XwSErRKYEFxwRN65Jj1IrqwVWc4sS8DiBNtIAQCCCCAAAIIIHAYAftkOR+8BqLkCjx60aDeJCIXJLfKn1bGAJL4FlMgAggggAACCHgsYCLhZM/O3MTgxKTHZRC9hkCiLhqs1W0GkFpCfI4AAggggAACCHRKwPaa2JIwPzbRqQSc23qBxF00WIuMAaSWEJ8jgAACCCCAAAKdEYgsenmlMPbPnTmdU9shkMiLBmvBMYDUEuJzBBBAAAEEEECg/QImcnWYL13a/pM5sV0Cib1osBYgA0gtIT5HAAEEEEAAAQTaK2Bm23dNzevdMbJuX3tP5rR2CST6osFaiAwgtYT4HAEEEEAAAQQQaJ+AmU1JV/T0cGh8U/tO5aR2CiT+osFamAwgtYT4HAEEEEAAAQQQaKeA/Vk5H3yknSdyVvsEUnHRYC1OBpBaQnyOAAIIIIAAAgi0ScBsbbkQLG/TaRzTZoHUXDRYy5UBpJYQnyOAAAIIIIAAAq0XMJH79x1lC++5KNjV+tM4od0CqbposBYuA0gtIT5HAAEEEEAAAQRaK2BmkaheEOZLt7f2JHbvlECqLhqshcwAUkuIzxFAAAEEEEAAgdYKmNhfh/ng3a09hd07JZC6iwZrQTOA1BLicwQQQAABBBBAoHUCJnZbmA/Ob90J7NxJgd5i7q0Z0Ss7mcG5sxlAnGsJgRBAAAEEEEAgJQIm9oDKZF85X/5RSkpOVZmpvWiwVpcZQGoJ8TkCCCCAAAIIINAaAdPoueHw2C2t2Z1dOymQ6osGa8EzgNQS4nMEEEAAAQQQQKAFAmZXlgvB5S3YmS07LJD6iwZr+TOA1BLicwQQQAABBBBAIF4BM9kYTpUGZESq8e7Mbp0W4KLBOjrAAFIHEo8ggAACCCCAAAIxCZjII1F3dfHW5ePfj2lLtnFEgIsG62wEA0idUDyGAAIIIIAAAgjEIFDN2IqtQ8FoDFuxhUMCXDTYQDMYQBrA4lEEEEAAAQQQQGAOAiby6TBfevUctmCpowJcNNhAYxhAGsDiUQQQQAABBBBAoEkBEwkne3bmJgYnJpvcgmWOCnDRYIONYQBpEIzHEUAAAQQQQACBBgVMZL9ItDjMj000uJTHHRfgosEmGsQA0gQaSxBAAAEEEEAAgUYEVF5RHi59rpElPOu+ABcNNtkjBpAm4ViGAAIIIIAAAgjUI2C2qlwIVtbzKM/4I8BFg3PoFQPIHPBYigACCCCAAAIIHEbAzLbb1L7FlZHKbqCSI7CgOLCgW2S9ihybnKraWInTA8jowNWi8qI2cnAUAggggAACYma7VXSLqfSpyBMgQaBZgUikv5IvjTe7nnXuCTxtzZKTe6rdG1T1RPfSeZKIAcSTRhETAQQQQKDVAt8TsQ9Il32zfPHY1p8d1lfsP9Mk84cq9noRParVIdg/OQJm8pawUPpwciqikjPWnnPsEdPVb6tIFo05CDCAzAGPpQgggAACiRAwsc+F+eAVhyvmjLVLf/2I6a5/VZEXJKJoimitgNnaciFY3tpD2L3dAtnR3K2qen67z03ceQwgiWspBSGAAAIINCJgdmW5EFxe75K+4sDsXzJ6eb3P81waBexe7ZpavOXiLT9JY/VJrbmvmLtWRF+Y1PraWhcDSFu5OQwBBBBAwCkB+7dyPvijRiNli7k1Knpxo+t4Ph0CkUUXVApj30pHtemoMlvMXaWib0pHtW2o0ukBpJi7RkRH2sDAEQgggAACaRMw2xJN7RuojFSmGi39jLVnHHHE1PG3qsrTG13L84kX+JtyvvS3ia8yRQVy0WALms0A0gJUtkQAAQQQcFvAbJdIZnG5sOEHzQY97Ru5447aq3eIyIJm92BdsgRM7LZwOLhAVCxZlaW3Gi4abFHvGUBaBMu2CCCAAAJOCphZZF3R8ypD4zfPNeCir+ZO7OrW2T+x+pS57sV6zwXMdopOLiznyz/yvBLi/1SAiwZb+CowgLQQl60RQAABBJwTiMSuqOSD98YVrHf1kqxazzruC4lL1M99IpXBynDpRj/Tk/qxAlw02OJ3ggGkxcBsjwACCCDgkIDdUM4HsX95PFscOE/MblHVeQ4VS5Q2CZjYh8J88NY2HccxLRZYUFx6Uo9k1ovoyS0+Kr3bM4Ckt/dUjgACCKRJwMy+23Xk9JLNz9+8pxV1Z0f7h0S1qKLaiv3Z000BM9kYTpUGZESqbiYkVSMCC4oLntAjx8wOHwsbWcezDQowgDQIxuMIIIAAAt4JmNnuGdWBO/OlO1sZPjuae62qfryVZ7C3OwIm8kjUXV28dfn4991JRZJmBXKlXM/kvXqTiFzQ7B6sq1OAAaROKB5DAAEEEPBWoGqyfGuhtLYdBWRHc+9T1be14yzO6KxANWMrtg4Fo51NwelxCfSN5q4T1RVx7cc+hxFgAOH1QAABBBBIsoCZvT8sBG9vZ43cmNxO7c6cZWafDQvBKztzOqfGLdA3mvuIqL4x7n3Z7xACDCC8GggggAACCRa4tTxcelbb72W4VrqyR+S+rqLPSbBtakszsbsne3YtnhicmEwtQoIK7y3m3pIR/WCCSnK/FAYQ93tEQgQQQACBxgVM7L5M11Tflou3/KTx1XNfcdKa3FEnRHqbiiyd+27s4IqAiewXq+bCwnjFlUzkaF6Aiwabt5vTSgaQOfGxGAEEEEDAQQETmzTRZ1TypdlLAjv2T/Zr2SfK/vnrVfX0joXg4FgFIo1eXRke+3Ssm7JZRwS4aLAj7I8eygDSQXyORgABBBBoiYCp/EE4XPpKSzZvcNO+0bNPNbFxVXlSg0t53DUBs1XlQrDStVjkaVyAiwYbN4t1BQNIrJxshgACCCDQcQH7ZDkfvKbjMX4pQO+qs87KZLpuE9GjXcpFlvoFzGy7Te1bXBmp7K7PwUHdAAAgAElEQVR/FU+6KMBFgw50hQHEgSYQAQEEEEAgJgEbKx/7hHPk2f89E9OGsW2TLeaeraJfF5Hu2DZlo3YJzFimOhAOjW9q14Gc0xoBLhpsjWvDuzKANEzGAgQQQAABFwXM/rdalbO2XhL80MV4s5myowO/ryr/7mo+ch1CwOzyciG4Eh+/Bbho0KH+MYA41AyiIIAAAgg0J2BSjcTOqxSCO5rboH2rssWBP1eR97fvRE6ai4CZ3BwWShfOZQ/WuiHARYNu9OFACgYQh5pBFAQQQACBpgRMozeHw2NXNbW4A4uyxYGPqcjrOnA0RzYgYCL3V6uZvm0r1z/YwDIedVCAiwYdawoDiGMNIQ4CCCCAQEMCJnJdmC9d0tAiBx7OFgeKKjLsQBQiHETAxExEzw/zpdsB8luAiwYd7B8DiINNIRICCCCAQJ0Ctm3n5Lz+HSPr9tW5wJnHZn8fff+9couK/q4zoQjycwEze1dYCN4Jid8Ci9bkCplIrlNR9buShKVnAElYQykHAQQQSIuA2S7tzvRvuXjDPb6W3Htt7zGZeUetE5U+X2tIYm4Tuy0cDi4QFUtifWmpafaiwf8b8G9S1XlpqdmbOhlAvGkVQRFAAAEEfiow++sxlokuqgyN3+w7yunXnfnk+V09G1T0N32vJRH5zXaKTi4s58s/SkQ9KS2CiwYdbzwDiOMNIh4CCCCAwMEE/qacL/1tUmgWX3/2aTYTBaJ6fFJq8rWOSGWwMly60df85BbhokEP3gIGEA+aREQEEEAAgV8ImNxULpQuShpJdvVZZ4t136oi85NWmy/1mMhVYb70Zl/ykvPxAlw06MlbwQDiSaOIiQACCCAw+4tX352c190/MXjHw0nkyI72P18lc4OodCWxPpdrMpON80+xpwcDwbTLOcl2aAEuGvTo7WAA8ahZREUAAQRSLWB7p0X778yX7kwyQ2+x/w8zkvlSkmt0rzbbW+2OercuH/++e9lIVK8AFw3WK+XAcwwgDjSBCAgggAACtQUsWlkujK2q/aD/T2RHc3+tqon5jovzHbHoxeXC2DXO5yTgIQW4aNCzl4MBxLOGERcBBBBIoYCZfDgslN6SptKzxdxnVfRP01Rzh2r9fDlfwrlD+HEcy0WDcSi2eQ8GkDaDcxwCCCCAQIMC9p3ycHCeqEQNLvT7cRPNrh5YqyIv8LsQd9Ob2N2TPbsWTwxOTLqbkmSHE+CiQU/fDwYQTxtHbAQQQCAFAiZ232RPdNbE4PiPU1Du40o8Y+0ZRxwxdfytqvL0NNbfyppNZL9YNRcWxiutPIe9WyfARYOts235zgwgLSfmAAQQQACBZgTMpiPVcyr50ngzy5Oy5rRv5I47aq/eISILklKTG3XYa8r54JNuZCFFowJcNNiomGPPM4A41hDiIIAAAggcEIhM/l+lUPoUHCKLvpo7MdMtJRU9CY8YBMxWlQvByhh2YosOCHDRYAfQ4z6SASRuUfZDAAEEEJirgJl9OSwEfzjXfZK0fuF1S57W1dVTUpEnJKmuttdisiOa2ruoMlLZ3fazOXDOAlw0OGdCNzZgAHGjD6RAAAEEEPiZgI1Fk/ueURmpTGHyqwLZ4sB5YnaLqs7DpimBGdOZZeHwxg1NrWZRRwW4aLCj/PEezgASrye7IYAAAgg0L2AmD0VV69t6SfDD5ndJ9srsaP+QiI6qaibZlcZfnYm8LcyXPhD/zuzYDgEuGmyHcpvOYABpEzTHIIAAAggcVsDMIhN7VqUw9i2oDi/QVxx4uYh8Dqf6Bczk5rBQurD+FTzpkgAXDbrUjRiyMIDEgMgWCCCAAAJzFuB/nW6MsG904D2ickVjq9L5tIncX61m+ratXP9gOgX8rpqLBv3u30HTM4AksKmUhAACCHgmYCLXhfnSJZ7F7njcvuLAF0XkjzoexOEAJmYien6YL93ucEyiHUKAiwYT+mowgCS0sZSFAAIIeCNg23ZOzuvfMbJunzeRXQlqksmuHriB29IP3RAzeU9YKP2lKy0jR/0CXDRYv5V3TzKAeNcyAiOAAAKJETCz3ZnuzJItF2+4JzFFtbmQA7elTx+/TkWWtvlo548zk/VhvnSuqJjzYQn4KwJcNJjwF4IBJOENpjwEEEDAYYGqyfKthdJahyN6ES37tewTZf/89ap6uheB2xHSbOdU10zfXUOb7m3HcZwRnwAXDcZn6exODCDOtoZgCCCAQLIFTP6+XCj9RbKLbF91faNnnypqs/dbPKV9p7p7UqQyWBku3ehuQpIdTICLBlPyXjCApKTRlIkAAgi4JGByUzlfeh6/GhNvU3pXL8lmrPsOET063p09283so+VC8EbPUqc+LhcNpugVYABJUbMpFQEEEHBAwMT+Z7Kne/HE4B0POxAncRGyxdyzVfTrItKduOLqKMhMNs4/xZ4eDATTdTzOIw4JcNGgQ81odRQGkFYLsz8CCCCAwM8ETGwy6tKBrReXyqi0TiA7OvD7onatimrrTnFxZ9tb7Y56ty4f/76L6ch0aAEuGkzZ28EAkrKGUy4CCCDQQQFT+YNwuPSVDkZIzdG9xdxbM6JXpqbg2UItenG5MHZNqmpOQLHZ0YE3q8qHElAKJdQrwABSrxTPIYAAAgjMRcBEPh7mS6+fyx6sbUwgWxz4mIq8rrFVfj5tYl8I88HL/Eyf3tRcNJjS3jOApLTxlI0AAgi0VcC+Ux4OzhOVqK3Hcpj0FXPXiugLk0xhYnfvmpy3hMss/eoyFw361a9Y0zKAxMrJZggggAACjxUw+9/986K+icHxH4PTAYFrpSt7RO7rKvqcDpze8iPNbEokWhoWxistP4wDYhPgosHYKP3ciAHEz76RGgEEEPBCwKQaiZ1XKQR3eJE3oSFPWpM76olVvUNU+pJWopm9LiwEn0haXUmuh4sGk9zdOmtjAKkTiscQQAABBBoWiNTeWBkOPtrwQhbELnD6dWc+eX5XzwYV/c3YN+/UhmaryoVgZaeO59zGBbhosHGzRK5gAElkWykKAQQQ6LiAmX05LAR/2PEgBPi5wOLrzz4tmrH1qvIk71lMdkRTexdVRiq7va8lJQVw0WBKGl1PmQwg9SjxDAIIIIBAQwJmW6KpfQOVkcpUQ+t4uOUCvavOOksz3etUZH7LD2vdATOmM8vC4Y0bWncEO8ctwEWDcYt6vB8DiMfNIzoCCCDgrIBdXM4HNzgbL+XBsqP9z1fJ3CAqXT5SRGbvqBSC9/mYPa2Zs6MDH1KVN6e1fup+jIDTA8jowNWi8iKahgACCCDgk4DtKeeDY3xKnMas2WLupSr6L/7Vbt8o54Pn+Zc7vYn7irk3iehV6RWg8scJOD2AFHPXiOgIbUMAAQQQ8EfAxDaF+eAsfxKnN2nf6v4rxDLv8UXAxB6oVrsWblu5/kFfMqc9JxcNpv0NOET9Tg8g/ASEtxYBBBDwTsDMvh4Wgud7FzylgbOjuY+r6mt9KD/KVC+sDI3f7ENWMoosKi69oEu6vokFAvwEhHcAAQQQQKDVAt8s50vPavUh7B+TgIlmVw+MqshwTDu2aBt7bzkfXNGizdk2ZgEuGowZNGnb8ROQpHWUehBAAIGOC3yvnC+d1vEUBKhb4Kn/9dT5Rz/8azepyHl1L2rngybfLhdKbmZrp4MnZz1tzZKT51V71onKqZ5EJma7BRhA2i3OeQgggEDyBaYy06fcNbTp3uRXmpwKT/tG7rgj98g6VV3kVFVmO0UyZ5YLG37gVC7CHFTgp+/Rt1W1FyIEDing9ADCl9B5cxFAAAFPBfh1GR8bt+iruRMz3VJS0ZNcyR+pDFaGSze6kocchxbgokHejroFGEDqpuJBBBBAAIF6BUz2RRlbWBkO/qfeJTznhsDC65Y8rTvTfYeoHt/pRCby8TBfen2nc3B+fQJcNFifE0+JiNMDCH8Fi3cUAQQQ8FmgFE3ufXZlpLLb5yLSmL1v9Kxlot23d7J2/pxzJ/UbPztbzH1QRd/S+EpWpFLA6QGEX8FK5TtJ0QggkCQB+87OyXnP2TGybl+SqkpDLdnR/iERHVXVTPvrtb0mtiTMj020/2xObFSgd3XuDRnTf2x0Hc+nWIABJMXNp3QEEECgPQK37u/Z+byJwYnJ9hzHKXEJ9BUHXi4in4trv3r3MZOXhoXSv9b7PM91ToCLBjtn7/XJDCBet4/wCCCAgB8CJjcdcYoNBgPBtB+BSfkzgWwx9y4V/at2iZjI1WG+dGm7zuOc5gV6R/vPV9GbVHVe87uwMpUCDCCpbDtFI4AAAu0XMFtbngqGZUSq7T+cE+ci0Fcc+KKI/NFc9qhnrYndvWty3hJ+Za8erc4+w0WDnfX3/nQGEO9bSAEIIICAPwJmo+V8cImoRP6EJqmYZLKrB25QkRe0SsPMpkSipWFhvNKqM9g3HoEFxaUn9UhmvYieHM+O7JI6AQaQ1LWcghFAAIHOCsT8L57OFpOe089Ye8YRR0wdf6uqPL0VVUcib6jkSx9rxd7sGZ/AguKCJ/TIMbPDx8L4dmWn1AnE/O8BjROwj7+CFScneyGAAALOCJjYZ8J88CpnAhGkLoGf3nIdqOrpdS2o96HZX88rBMvrfZznOiPARYOdcU/kqQwgiWwrRSGAAALOC5jIx8J86Q3OByXgrwj0jZ59qqhtEJGnxEJjsmPv0dZ3z0XBrlj2Y5OWCXDRYMto07cxA0j6ek7FCCCAgDMCZleWC8HlzuQhSF0CvauXZNV61qnIE+pacIiHzCySTPXccHjj7EDDPw4LcNGgw83xMRoDiI9dIzMCCCCQHAEze1dYCN6ZnIrSUUm2OHCeivy3iHQ3XbFGf1EeHvv7ptezsC0CXDTYFuZ0HcIAkq5+Uy0CCCDgokAkdlklH3zQxWxkOrRAdnTg90XtWhVt+DugZnJzWChdiK/bAlw06HZ/vE3HAOJt6wiOAAIIJErALHp9WBj7eKKKSkEx2dHca1W1ob6Z2APVatfCbSvXP5gCIm9L5KJBb1vnfnCnB5DRgatF5UXuK5IQAQQQQCAOgUijV1eGxz4dx17s0T6B7Orce9X07fWeWDW9aGthw031Ps9z7RfIji7tVcl8W1SPa//pnJh4AQaQxLeYAhFAAAGvBEzsZWE++IJXoQkrfcXcm0T0qsNRmMlDkVZXbM2P3wqZuwJcNOhubxKTjAEkMa2kEAQQQCA5Aha9uFwYuyY5BaWjkkWr+8/tMv2UiJ752IpNZPWMVF9zZ378vnRo+FnlGWvPOfaIqZl1qtrrZwWk9kKAAcSLNhESAQQQSJ1ANWMrtg4Fo6krPAEFLygOLOg2OUfETlSxu6a69Ft3DQUPJKC0xJfQVxyY/ctmz0x8oRTYWQGnBxBuQu/sy8HpCCCAQGcFZiKV4cpw6cbOxuB0BNIh0Md3b9PRaBeqZABxoQtkQAABBBA4mICZTZnYhZXC2LcQQgCB1glw0WDrbNn5IAIMILwWCCCAAAJuC9jeyOQ5lUJwh9s5SYeAnwJcNOhn37xOzQDidfsIjwACCKRCwMx2Rxl55tbhYCwVBVMkAm0S4KLBNkFzzK8KMIDwRiCAAAIIeCFgtmtG5PxthWCLF3kJiYDjAlw06HiDkhyPASTJ3aU2BBBAIFkCs/dIZLrsvC1DwbZkVUY1CLRX4MBfKhNZryLHtvdkTkNARBhAeA0QQAABBPwSsB+b2LIwPzbhV27SIuCGABcNutGHVKdgAEl1+ykeAQQQ8FLAzH5YteqybSs2bveyAEIj0CGBBcUFT+iRY9aL6MIOReBYBPgJCO8AAggggICnAiY/2D9vatnE4OYdnlZAbATaK/Bfz+rue3j3zSJyQXsP5jQEHiPAT0B4JRBAAAEEPBb4XtStyyrLN9zvcQ1ER6AtAlw02BZmDqlHgAGkHiWeQQABBBBwVcDE7p7OyLK7hoIHXM1ILgQ6LdBXzF0pom/tdA7OR+CAAAMILwICCCCAgO8CZrY10z113paLt/zE91rIj0DcAlw0GLco+81ZgAFkzoRsgAACCCDghIBt3t/Tff7E4B0POxGHEAg4IMBFgw40gQiPF2AA4a1AAAEEEEiMgFmwc2re+TtG1u1LTE0UgkCTAlw02CQcy1ovwADSemNOQAABBBBoq8Ct+3t2Pm9icGKyradyGAIOCXDRoEPNIAo/AeEdQAABBBBIgYDJTUecYoPBQDCdgmopEYFfEeCiQV4I5wX4CYjzLSIgAggggEAzAmZry1PBsIxItZnlrEHARwEuGvSxaynMzACSwqZTMgIIIJAWAbPRcj64RFSitJRMnSkW4KLBFDffs9IZQDxrGHERQAABBBoTmP0XXb50qahYYwt5GgG/BLho0K9+pTotA0iq20/xCCCAQDoETL5YLpReko5iqTKNAlw0mMaue1wzA4jHzSM6AggggEDdAib2mTAfvKruBTyIgCcCXDToSaOI+QsBBhDeBgQQQACBtAiYyMfCfOkNaamXOpMvwEWDye9xIitkAElkWykKAQQQQOBQAmZXlgvB5QAh4LsAFw363sEU52cASXHzKR0BBBBIqYCJ/XWYD96d0vIpOwECXDSYgCamuQQGkDR3n9oRQACB9ApEYpdV8sEH0ytA5b4KnH7dmU8+sqtnTERP9rUGcqdcgAEk5S8A5SOAAAIpFjCzV4aF4LMpJqB0zwQOXDRox9wuqos9i05cBH4hwADC24AAAgggkFYBEzMTe0klP/altBpQt0cCXDToUbOIelgBBhBeEAQQQACBNAuYWWQZu7QyPHZtmh2o3X0BLhp0v0ckrFOAAaROKB5DAAEEEEiugEk1ysglleFSMblFUpnPAlw06HP3yP44AQYQXgoEEEAAAQQOCMxEKsOV4dKNeCDgkgAXDbrUDbLEIsAAEgsjmyCAAAIIJEDAzKasKxqsDI3fnIByKCEBAlw0mIAmUsLjBRhAeCsQQAABBBD4hYCJ7DeLnlcpjH0LFwQ6KcBFg53U5+yWCjCAtJSXzRFAAAEEvBSwvZHJcyqF4A4v4xPaewEuGvS+hRRwOAEGEN4PBBBAAAEEHi9gZrujjDxz63Awhg8C7RTgosF2anNWRwQYQDrCzqEIIIAAAj4ImO2aETl/WyHY4kNcMvovwEWD/veQCuoQYACpA4lHEEAAAQRSK2AmD2W67LwtQ8G21CJQeHsEuGiwPc6c0nkBBpDO94AECCCAAAKuC9iPTWxZmB+bcD0p+fwV4KJBf3tH8gYFGEAaBONxBBBAAIFUCpjZDyfnTT99YnDzjlQCUHRLBbhosKW8bO6aAAOIax0hDwIIIICAwwLfi7p1WWX5hvsdzkg0zwS4aNCzhhF37gIMIHM3ZAcEEEAAgfQImNjd0xlZdtdQ8EB6qqbSVglw0WCrZNnXaQEGEKfbQzgEEEAAAQcFzGxrpnvqvC0Xb/mJg/GI5IkAFw160ihixi/AABK/KTsigAACCKRBwDbv7+k+f2LwjofTUC01xivARYPxerKbZwIMIJ41jLgIIIAAAu4ImAWZI6efufn5m/e4E4okrgtw0aDrHSJfywUYQFpOzAEIIIAAAokWsO/snJz3nB0j6/YlukyKi0WAiwZjYWQT3wUYQHzvIPkRQAABBBwQuHV/z87nTQxOTDqQhQiuCnDRoKudIVe7BRhA2i3OeQgggAACiRQwuemIU2wwGAimE1kfRc1ZgIsG50zIBkkRYABJSiepAwEEEECg4wJma8tTwbCMSLXjWQjglEDfaO4fRPUyp0IRBoFOCTCAdEqecxFAAAEEEilgNlrOB5eISpTI+iiqYQEuGmyYjAVJF2AASXqHqQ8BBBBAoO0Cs/9yzZcuFRVr+9kc6JQAFw061Q7CuCLAAOJKJ8iBAAIIIJAoAZMvlgullySqJoppSICLBhvi4uE0CTCApKnb1IoAAggg0E4BE/lYmC+9oZ1ncpYbAlw06EYfSOGoAAOIo40hFgIIIIBAMgTMriwXgsuTUQxV1CPARYP1KPFMqgUYQFLdfopHAAEEEGiDgJm9KywE72zDURzRYQEuGuxwAzjeDwEGED/6REoEEEAAAb8FIrHLKvngg35XQfrDCnDRIC8IAvUJMIDU58RTCCCAAAIIzFXALHp9WBj7+Fz3Yb2bAlw06GZfSOWgAAOIg00hEgIIIIBAYgXM7JVhIfhsYgtMaWFcNJjSxlN2cwIMIM25sQoBBBBAAIFmBEzMTOwllfzYl5pZzxr3BLho0L2ekMhxAQYQxxtEPAQQQACBxAmYWWQZu7QyPHZt4opLWUFcNJiyhlNuPAIMIPE4sgsCCCCAAAINCZhUo4xcUhkuFRtax8POCPSO5s5RkVtVdZ4zoQiCgA8CDCA+dImMCCCAAAIJFZiJVIYrw6UbE1pfYsuavWiwR2ydiJ6Q2CIpDIFWCTCAtEqWfRFAAAEEEKgtYGZT1hUNVobGb679NE+4IMBFgy50gQxeCzCAeN0+wiOAAAIIJEDARPab2bMqheCOBJST6BK4aDDR7aW4dgkwgLRLmnMQQAABBBA4tICZ7Y4y8sytw8EYTo4KcNGgo40hlncCDCDetYzACCCAAAJJFTDbNSNy/rZCsCWpJfpcFxcN+tw9sjslwADiVDsIgwACCCCQcgEzeSjTZedtGQq2pZzCqfK5aNCpdhDGdwEGEN87SH4EEEAAgeQJ2I9NbFmYH5tIXm3+VcRFg/71jMSOCzCAON4g4iGAAAIIpFLAzH5YteqybSs2bk8lgCNFc9GgI40gRrIEGECS1U+qQQABBBBIkIDJD/bPm1o2Mbh5R4Kq8qYULhr0plUE9U2AAcS3jpEXAQQQQCBlAt+LunVZZfmG+1NWd0fL5aLBjvJzeNIFGECS3mHqQwABBBDwXcDE7p7OyLK7hoIHfK/Fh/xcNOhDl8jotQADiNftIzwCCCCAQEoEzGxrpnvqvC0Xb/lJSkruSJlcNNgRdg5NmwADSNo6Tr0IIIAAAv4K2Ob9Pd3nTwze8bC/NTicnIsGHW4O0RIlwACSqHZSDAIIIIBA0gXMgsyR08/c/PzNe5Jearvr46LBdotzXmoFGEBS23oKRwABBBDwVsC+s79n17MmBicmvS3BseC9xYEPZEQudywWcRBIpgADSDL7SlUIIIAAAgkXMLnpiFNsMBgIphNeacvL46LBlhNzAAK/KsAAwhuBAAIIIICApwJma8tTwbCMSNXTCjoem4sGO94CAqRRgAEkjV2nZgQQQACBxAiYjZbzwSWiEiWmpjYVwkWDbYLmGAQeK8AAwjuBAAIIIICA5wKz/zLPly4VFfO8krbF56LBtlFzEAKPF2AA4a1AAAEEEEAgAQImXywXSi9JQCUtL4GLBltOzAEIHF6AAYQ3BAEEEEAAgWQImNhnwnzwqmRU05oquGiwNa7sikBDAgwgDXHxMAIIIIAAAk4LmMjHwnzpDU6H7FQ4LhrslDznIvCrAgwgvBEIIIAAAggkTMDsynIh4E6Lx7SViwYT9p5Tjr8CDCD+9o7kCCCAAAIIHErAzN4ZFoJ3IfSoABcN8iYg4JAAA4hDzSAKAggggAACMQpEYpdV8sEHY9zSy62yxf5XqmQ+7WV4QiOQRAEGkCR2lZoQQAABBBB4VMAsen1YGPt4Wj0OXDRYla+qaiatBtSNgHMCDCDOtYRACCCAAAIIxCoQSfTHlfzYl2Ld1IPNuGjQgyYRMZ0CDCDp7DtVI4AAAgikR8DMIsvYpZXhsWvTUjUXDaal09TppQADiJdtIzQCCCCAAAKNCZhUo4xcUhkuFRtb6N/TXDToX89InDIBBpCUNZxyEUAAAQTSLDATqQxXhks3JhWBiwaT2lnqSpQAA0ii2kkxCCCAAAIIHFbAzKasKxqsDI3fnDgqLhpMXEspKKECDCAJbSxlIYAAAgggcAgBE9lvFj2vUhj7VpKQuGgwSd2klkQLOD2AjA5cLSovSnQDKA6BBgRM5GEV2Wdm+0Rkn+rs/y17VHTSDvx323fgPw88owf+M1LbnRH5iZj9RDTzkEQy/ctHmkZHWCYzX02ONI3mZ0znm9p8i3R+RnW+mJ1gKseL6PEqcvzsf5/9v03sBFU9poH4PIoAAk4J2B6x6vPKhY3fdipWk2Gyo7n3qerbmlzOMgQQaKcAA0g7tTkLgYMLmMmDIvIDUduhIjvEdIc9+t9/UK3O3Ltt5aa7XLXrGz371KjLThSTEyWS38ionGgij/53kVNV5SxXs5MLgbQLmMgj1Sh69rYVY4HPFtnR/tepZj7mcw1kRyBVAgwgqWo3xXZW4B4zGRe1TaZ2YLiIpqMfuDxcxMWVLfafIZLpFbNFotIrootm/29+ghKXMPsg0LzA7E9WJVO9IBwa39T8Lp1bmV09cIma/EfnEnAyAgg0LMAA0jAZCxCoLWBSnh00IpGxLs0E+7oz4xODdzxce2G6nuhblTvduvQsiexsVekXkQERPSFdClSLQOcFZn8Km+my390yFGzrfJr6Eyxcs/QZXVHXLSoyv/5VPIkAAh0XYADpeAsI4LmAmVVUNBCxUpSRsZ0qY/cNBXs9L6tj8RfdsPS3uqa131T71fR3ReQcUTmyY4E4GIGUCJjYA1Gmumzr0Ma7fSi57/r+RTKj3xbV433IS0YEEPglAacHkGLuGhEdoWEIuCRgIveryY2R2o1TPd3/yU82Wtyda6Wr74ilS0Uy55nJ7EBynqrOfr+EfxBAIGYBM/th1arLtq3YuD3mrWPdjosGY+VkMwTaL+D0AMJfwWr/C8GJBxcw+bap3WiiN1TypXGYOiuw+PqzT6vOVJ+ZUb1ERJd3Ng2nI5AsATPbPjlv+vyJwc07XKzsjLXnHDt/euZbInqmi/nIhAACdQg4PYDwE5A6OsgjrRB49M/d2n+a6fUyf9/14QvCh1pxDnvOXeCUa59x5PHzJ59rpsNicjE/HZm7KTsgYGJ3T2dk2V1DwQNOaXDRoFPtIAwCTRAsrbQAACAASURBVAs4PYDwE5Cm+8rCZgTsx2LylagrWp3IG4KbIfFwTXb1WWdL1HWxqORVdImHJRAZAScEzGyrzN//uy79DzDZ0dy/qeofOAFECAQQaF7A6QGEn4A031hW1iUw+zfwRWyVmH05zI99Q1SiuhbykBcCT1uz5OSealdBRIdF5FmqOs+L4IREwBkB27y/p/t8F77r1lsc+EBG5HJnaAiCAALNCzg9gPATkOYby8rDCpjZf6rYP+8+7qHi9mdv3w9X8gV6r+09JjNv/nLRzMUitkJEj05+1VSIQCwCpWl55Dl35u98JJbdmtikr5h7jYh+oomlLEEAARcFnB5A+AmIi6+Mt5lm/8Skif6zdVc/vnX5+Pe9LYTgcxY4aU3uqBMieaGK/omJXaCiOudN2QCBRAvYd3ZOznvOjpF1+9pd5qI1uUKmKl9V1Uy7z+Y8BBBokYDTAwg/AWlR19O1rZmsN43+sZIf+7d0VU619QjM/kWtqBr9iZq+VFROrWcNzyCQUoFbd072vKCdQwgXDab0TaPs5AswgCS/x2mtcPbXrP7vArv3h/ngv9JqQN2NCfQVBy4SsVeK6AsbW8nTCKRDYPb/r4aF4AXtqJaLBtuhzBkIdEjA6QGEX8Hq0Fvh77EmZiK6ykT+jvs6/O1jp5Mf+KnITPTW2V/R4hb2TneD850TMFtbngqGZUSqrcrGRYOtkmVfBBwRcHoA4VewHHlLPIlh8sVplffcmS/d6UliYjou8LQ1uV/rqcprRfRNqvJEx+MSD4G2CZjZf4SFoCU/KZy9aPCI6Zlb+TPabWsnByHQfgEGkPabc2K8Amb2ZVF7Z5gfm4h3Z3ZD4BcCfasH/tTM3q6iZ+CCAAIHBL5Uzpf+OG6L7OjATary3Lj3ZT8EEHBIgAHEoWYQpTGB2Z94ZKbeeefw5u81tpCnEWheILt64BI1ebuIDDS/CysRSIaAiX0uzAeviKsaLhqMS5J9EHBcwOkBhO+AOP72dCqebY5EX8Z3PDrlz7mzAn2rBp5lGXmbirTlC7moI+CqgIl9JswHr5prvmxx4P0q8udz3Yf1CCDggQADiAdNIuIBATPbLaJ/HeZLH+HGcl4KVwSyo0t7VTNXiOiLRKTblVzkQKCtAmZXlgtB07eUZ4v9r1TJfLqtmTkMAQQ6J+D0AMKX0Dv3Yjh2sokVpzMzr7traNO9jkUjDgIHBPpW5U4XlX8Q1RWQIJBGATN7V1gI3tlo7X2j/StEM9c1uo7nEUDAYwGnBxB+BcvjNyu26PdUpfonW/Pjt8a2Ixsh0EKBhav6c12ZzEdU5LwWHsPWCDgpEIldVskHH6w3XO9o7hwVuVVV59W7hucQQCABAgwgCWhiIkuwPWby7vmnyIeCgWA6kSVSVKIFsqP9QyL6flVdlOhCKQ6BxwiY2IfC4eDyWr8q27tm6XO1mhlV1WNARACBlAk4PYDwK1gpexsfLddM1kRVe/XWS4IfphKAohMl8NPfbX+3iDwlUYVRDAKHETCx/5qR6I/uzI/fd7DH+oq5vxfRd4CIAAIpFWAASWnjnS3b/qycDz7ibDyCIdCEQO+1vcfoEUf+rYq+pYnlLEHASwET2a9mX4tUvqVmoWYyp1hk/aryQhH9dS+LIjQCCMQj4PQAwndA4mmyB7uY2XdVbWU5P7bZg7hERKApgb7r+xdJNfNJEbmgqQ1YhAACCCCAQBIEnB5A+BWsJLxiddRg/x5N7nt5ZaSyu46HeQQB7wV6i7kXqshVKnqS98VQAAIIIIAAAo0KMIA0KsbzcQpEZu+oFIL3xbkneyHgg8BJa3JHnWDyV2o6e6s6/yCAAAIIIJAeAacHEH4FK8Evou2NVH+/Mly6McFFUhoCNQUWr8ktjKr6FVU5q+bDPIAAAggggEASBBhAktBFz2ow+UGUmf69yvCm0LPkxEWgNQImmd7VuTdnTN8tKke25hB2RQABBBBAwBEBpwcQvgPiyFsSZwwb21ed/r3vrtz8v3Huyl4IJEFg8fVnn2ZV+7yIPDMJ9VADAggggAACBxVwegDhV7CS9daa3LRzqmd4x8i6fckqjGoQiFcgO5p7hYpcKarHxbszuyGAAAIIIOCAAAOIA01IR4TPl4dLr6x1M246KKgSgdoCC4pLT+qRrq/wJ3trW/EEAggggIBnAk4PIPwKlmdv08Hjmtk7w0LwrkQUQxEItFmgr9h/uUjmA20+luMQQAABBBBonYDTAwi/gtW6xrdhZxMzFXltOR/MXrzGPwgg0KTAousH+jIzdq2qLmpyC5YhgAACCCDgjgADiDu9SFISM4tE5I/DQvDlJNVFLQh0SqD32t55esSRsz8JeaOKaqdycC4CCCCAAAJzFnB6AOFXsObc305tUM3Yiq1DwWinzudcBJIq0Lcm9zx79N6QJya1RupCAAEEEEi4AANIwhvcgfJMot8L82Nf68DRHIlAKgT6Rs8+VTQaFdH+VBRMkQgggAACyRJwegDhOyBevWyzv3alai8s58eu8yo4YRHwUGD2V7Iy8476V1F5kYfxiYwAAgggkGYBBpA0dz/e2k3sZWE++EK8u7IbAggcTiA7mnutilwlqj1IIYAAAggg4IUAA4gXbXI+ZCR2RSUfvNf5oAREIIECvaO5czIqa0T01xNYHiUhgAACCCRNwOkBhC+h+/G6mfxzuVB6uR9hSYlAMgUWfTV3YqZbb1CRpcmskKoQQAABBBIjwACSmFZ2phCTdeVCaVlnDudUBBD4ZYEz1p5z7Pyp6u2i0ocMAggggAACzgowgDjbGg+C2b37e6KlE4PjP/YgLBERSIXAwlX9ue5MppSKYikSAQQQQMBPAacHEP4KlrMvlYlNWlQ9t7Ji40ZnQxIMgZQKZIu5URXNp7R8ykYAAQQQcF2AAcT1Djmb70/L+dLnnU1HMARSLNA32v8i0czVKSagdAQQQAABlwWcHkD4Erqbr47JF8uF0kvcDEcqBBBYfP3Zp1nVvosEAggggAACTgowgDjZFodD2baHMpK7byjY63BIoiGQaoFFNyz9ra6Zru2pRqB4BBBAAAF3BRhA3O2Nc8lM9mmX9W8ZCrY5l41ACCDwc4GFa5Y+ozvq+jYkCCCAAAIIOCnAAOJkW5wMZWavCwvBJ5wMRygEEPi5QLY48Ocq8n5IEEAAAQQQcFKAAcTJtjgXysRuC/PB+c4FIxACCDxOoG904H9E5VRoEEAAAQQQcFKAAcTJtjgXaqY6vWDbyk13OReMQAgg8CsC2eLAh1Xkz2BBAAEEEEDAWQGnBxDuAXHivTGzt4eFgF/ncKIbhEDg0ALZ0f7nq2a+hhECCCCAAAJOCzg9gPBneB14d2xzOR8scSAIERBA4DACZ6w985T50z2bRfQEoBBAAAEEEHBawOkBhJ+AdP7dsZnzyoWN/DWdzneCBAgcWsBEs6sH7lCRs2FCAAEEEEDAeQEGEOdb1LGAJvaVMB/8QccCcDACCNQl0FfM/b2IvqOuh3kIAQQQQACBTgswgHS6A66eb3uj7szpleUb7nc1IbkQQECkb9XAsyxjt6io4oEAAggggIAXAk4PIHwHpGPvUCR2RSUfvLdjATgYAQRqCiwoLj2p27q2qMoTaz7MAwgggAACCLgi4PQAwndAOvKamMmDk/N2njwxODHZkQAcigACtQUe/d7Ht1TkvNoP8wQCCCCAAAIOCTCAONQMZ6JEf17Oj/2DM3EIggACjxPIFnPvUtG/ggYBBBBAAAHvBBhAvGtZSwPz04+W8rI5ArEI8L2PWBjZBAEEEECgUwIMIJ2Sd/PcSOyySj74oJvpSIUAAtmvZZ8o+4+8S1WehAYCCCCAAAJeCjg9gPAl9La+U2by0E+67NT7hoK9bT2Yww4qcMq1zzjy2COnF2ei6BQzOVFUf0NFTzKRE1XsBDE9xsSOEZVjRPQYFZn/s43MbLeK7BXVPWKyxw7837ZHRPao6ex/7jWVPWK2R1QfMo22q0Tfm+zW7ROD4z+mJe4K9I0OfENULnQ3IckQQAABBBCoIcAAwivyCwF7bzkfXIFI+wV6Vy/JatT9DFE9S00WiNoiET25/UlmT7S9Jvo9Fds++58m9r2M2PZIMt/bf5Tdc89Fwa7O5OLUbDH3lyr6biQQQAABBBDwWoABxOv2xRq+OmMnbb0k+GGsm7LZQQX6iksHzDKDMvsXjFTPVZFj/aGyH5tIWUQ3mUZbM1FUjqamNldGKrv9qcG/pIuKSy/okq5v+pecxAgggAACCDxGgAGEV+LA/+Yt9oUwH7wMjdYJ9BVzy83k91VkUFSf3LqTOrWzbTbRWyKTb+jU3lsZSOLrw9PW5H5tXqRlEXlKfLuyEwIIIIAAAh0SYADpELxjx86YnbmtEGxxLJb3cbLF/jNMMq9Sk5en70vD9h0TuUkjvbm8ovTf3jezgwXwvY8O4nM0AggggED8Agwg8Zv6tqOJjIf5Ur9vuV3Om12zdIlWu67ky8KPdslE9ovZrap2U1X15q3DwZjL/XMpW+9o7u0Z1fe6lIksCCCAAAIIzEnA6QGEm9Dn1Nt6F5tGbw6Hx66q93meO7TA6ded+eT5mZ73i8pLVVSxOriAid2nIl+JouqXKis2bsTp4AI//a7QHaqawQgBBBBAAIHECDg9gPBneNvynu3vqT6ZP706d+q+Yv/lIvo3InrU3HdL0w62zUT+LeqOvrh1+fj301T54Wp96qqzjj9GuzeLyqmYIIAAAgggkCgBpwcQfgLS8nfNTNaEhdJwyw9K8AGP/rpV5ouiujjBZba8NBMzEbndTL+0/2i7Ou1/7jdbHLhRRV7QcngOQAABBBBAoN0CTg8g/ASk5a9DpNGLKsNj17b8oIQekB0d+DtV+YuEltfRsszkq6rRl8v5ses6GqQDh/eN5i4T1X/owNEciQACCCCAQOsFnB5A+AlIS18AM5vac9yDx21/9vb9LT0ogZsvKC54Qrcd8++q+vwEludUSSb2gIh+PuqufiINv6I1+70Pka51ItLtVCMIgwACCCCAQFwCTg8g/AQkrjYfYh+7oZwPLm7xIYnbvm9V7nTJ6NdF5LTEFed4QSbytShjn9o6FIw6HrWpeLPf+zg607VJRX+zqQ1YhAACCCCAgA8CDCA+dKlFGVVeUR4ufa5Fuydy28XXn32azdg3ReWURBboSVFm9n3J2FW79h/xqR0j6/Z5ErtmzGwxt0ZF+R8FakrxAAIIIICA1wJODyD8ClbL3q3ZL/xmuqaetOXiLT9p2SEJ23jRDUt/q2u66zaGD3caayYP/t8Fjx+1I/Z9NHxB+JA7yRpPkl3d/2dqmQ83vpIVCCCAAAIIeCbg9ADCr2C17G0yszvCQnBuyw5I2MYnrckddUIkG1X0dxJWWiLKOXDRochnpzPT77traNO9vhXVu+qsszKZ7nHfcpMXAQQQQACBpgScHkD4CUhTPa1nkam9LxwO3lHPszwjki0OfFVFVmLhtsCjN67LP8n8fX/ny09Eeq/tPUbnHblFVZ/qti7pEEAAAQQQiEnA6QGEn4DE1OXHbxNlqhdWhsZvbtkBCdq4r5j7fyL6TwkqKQWl2B4T+dBkT/eVE4N3POxywQy3LneHbAgggAACLRFgAGkJq/Ob7pzsOSpJX95tFXjvDWf/Rmba7hGVI1t1Bvu2UMBs1//9Odu/KxeCK1t4StNbZ0f7X6ea+VjTG7AQAQQQQAABHwUYQHzs2hwzm/x3uVB69hx3ScXybDH3Lyr60lQUm+AiTexuEXtjmB/7mitlZtcsXaJR10ZX8pADAQQQQACBtgkwgLSN2pmDzOz9YSF4uzOBHA2SXX3W2Wrd6x2NR6xmBMzWiskbyyuC7zazPK41sxdZ9sgTNonIb8e1J/sggAACCCDgjQADiDetii+oRS8uF8auiW/DZO7EnQzJ7OtsVSbygTBfelunKsyODvyHqlzSqfM5FwEEEEAAgY4KOD2A8FewWvJuzFSnF2xbuemulmyekE0XrTnrdzJR150qqgkpiTIeL3BPpPbSynBwWztxekcHXp1R+WQ7z+QsBBBAAAEEnBJwegDhr2DF/66Y7CsXSkfFv3GydswWc59V0T9NVlVUczABE/vcZE/3W9rx17J6Vy/JqvWUVGQ+3UAgqQI//XPYe1Rkr6jsFbE9ZrJHVaMDNZvMMznwhz2OUpEj/+8nkkep2pEiyr+bkvpSUBcCjxVgAEnXO2Fm3woLwQXpqrrxarPFgV0qcmzjK1nho4CJ3ReZvnJrobS2VfnP/M8zj67umzemKk9r1Rnsi0DrBGz2gs+KmZYtE21T07tFq7tNbG9U1T3TFu09+mjZs/n5m/fMJcNTV511/DHS9aSoW5+k1egEtcyTrSt6kkSZX1OV3xKRU0XkN/n+1FyUWYuAAwIMIA40oY0RzOyzYSF4ZRuP9O6o7Or+56hluCPFu87FENjkU7uPe+DPtj97++zN6rH+ky0OfEVFXhzrpmyGQMwCJvY/IloxkS0ZkW1VjSqR7QnvzN/5SMxHzXm7RV/Nnahd8pui9jtqmYWiskjMFqpq75w3ZwMEEGitAANIa31d293M3h4Wgve7lsulPNli7ioVfZNLmcjSVoE7o2jmxZUVG2P7E7m9o/1/ktHM59taBYchUEPAREI1WW8SBdaV2dA9byqc608wXEFfeN2Sp3V19yzWyJ4pos8WlT5XspEDAQQO/CrmNeVCKbb/US7WL+z28R2QFryj0SXl/Nh1Ldg4MVv2jeZKoppLTEEU0pSAmbwlLJQ+3NTiX1qUHV3aq9oVznUf1iMwdwH7hph8XTOZDQ9qtOG+oWDv3Pf0Y4fTvpE7bv4+fVYmst8V1WeJyIAfyUmJQEIFGEAS2thDlGWZ6lnh0Pjs/QP8cwiBvtGB2S9OcvM5b8js/0TzDZHJPy7nyz9qhuOkNbmjnhhJIKILm1nPGgTmImAmD6pKsZqxNT3zpr+RlJ9uzMXkZ2tn7+LJ/H/2zgRMjqpq/++pnskCgYRFlEUIIZLMdCdkppt9DYJgwkx1WIKCICL4qbh9gqiIigqCiugn7oIICEL+QLonIYCALIII6ZoJSXcngQBxQ5A9kHWm6/ztICJIkp7pWm5Vvf08PMCTe89539+5meR01b1XtzhQBIdYQP1iXjYkXoBlDBJolAAbkEZJxWOcNWLdKP4htOFapoud4wXWo/GoNl14QUChz0L11Eq+d85g46UL2StE5JTBzuN4EhgqAYU+LCo3D6Rqc5d09T0w1DhJm1dvSFqwxVSBngjgKJ7IlbQVQL+BE2ADEjjy0BIq8HLFLvFkp41UoK2Qm5YS3BxakZjYWAIK/Hzlls9+utEN6tz3YWwpYyhMb3cFcwZk4KZHuh6un1bFT5ME2oudJ4paMyCYzmOzm4TJ6STwVgTYgCRnXSh0WcV23pUcx4N3mu7JHSOKGwY/kzMSQmCpWrXjN/UaY7qn8zOiVtP7RxLClDaHQKC+gVyBn67ZTK9+/HDnpSGE4JQGCKw/PntN67GAnC7A/g1M4RASIIFGCLABaYRSTMYoHijnS/vFxI0vNtKF7Akico0vwRk0PgQU564Zlrr0zZcXTpzdmW0R6wcQ8PdZfKptjhPFahW91hW9bHF37x/NEZYMJZPmZCe6Lk4XxYchMjoZrumSBHwiwAbEJ7AGhlWgp2KXbAOlGSOpvafzFEutK4wRRCGmEygBqF+8JlCMg2An0wVTX/QI1O/mUMh3sHbVr6ozq69Ez0H8FKeLufeJ6lk8MTF+taWjgAiwAQkItAFpFHp5xXZOM0CKsRL4BMTY0lAYCSSPgOIPauGSSnfpxuSZj4bjdDFXfy3rbAG6o6GYKknAEAJsQAwpRBAyFD8r50sfDSJVVHOkC51dIlZPVPVTNwmQQAwIqM52U3JRtav0UAzcJMJC25wp77LclrME+EgiDNMkCTRLgA1IswQjNf+XZbv04UgpDlhse6HzQEusewNOy3QkQAIkUL93Zpaq+7VKvq9KHNEksNtNk7cbabWeC5FPRtMBVZNAQASMbkCK2esBmRkQitinUehVFdv5YOyNNmFw0txJW2lt+PNNhOBUEiABEmiYgEIVkNnQ2pfZeDSMzfiBu8/ZY8dWt/UrApwKoMV4wRRIAkETMLoBKeSug+D4oJnEN59eU7adD8TXnzfO0oXskyKyvTfRGIUESIAE3pqAQufWFOcsyTuLyCieBCb0TN61VYd9HQD/7I1nielqqATYgAyVXBTn6ayy7bCh20TpMsXc5Xj1Wyt+SIAESMB7Aoqym6p9ptrVd6f3wRnRRALtPdkDLJXLAEwwUR81kUDgBNiABI48vISqhXLemRGegGhkThc7jxRYt0RDLVWSAAlEiMDTEHyp3F2qf8nBTwIJZIq5r/7T9nkJtE7LJPBGAmxAkrMiFLilYpemJcfx0J1mirnHAIwbegTOJAESIIHXCSjw7dSIdV9feMTC+r0x/CSYQP3ErJTbUn8aclCCMdB60gmwAUnQClDcUc6XDk+Q4yFbzRSzHwXkJ0MOwIkkQAIksJ6A/tGVgdOq3Q9XCIQE/pNAe0/nR0St7wiwJcmQQOIIGN2A8BQsr9fjvWW7dLDXQWMZ765DWtIrXl4skPGx9EdTJEAC/hJQfQmCL5a7nZ9CoP4mY/SoEmi7Mbu91SKXC/DeqHqgbhIYEgGjGxCegjWkmm5wkuKBcr60n7dB4xstXeg8QsS6Nb4O6YwESMAPAgrcpC1yRnX6/Kf8iM+Y8SPQXuz8gAX5ASBbxc8dHZHAWxBgA5KkZaG9ZdvJJslxs17ThewVInJKs3E4nwRIIBkEVPX0St6pv9/PDwkMikD9EsMRVutVInLEoCZyMAlEkQAbkChWbcianyjbJW6sHgS+CcUJW7ToqIUiMnYQ0ziUBEggYQQU+qjKwAzu9UhY4X2wmy7mzhbgWz6EZkgSMIeA0Q0I94B4ulAUWFGxS6M9DZqAYK++o4t7BPKuBNilRRIggUET0Fkvrh12yl9nPrB60FM5gQTegkBbT7bTcnEjv/zi8ogtAaMbEO4B8Xzdle2SeB40AQEn3rTXNqmUe7sAHQmwS4skQAINElC4H6nYvb9ocDiHkUDDBMbP23vL4f21KwQ4uuFJHEgCUSFgdAPCJyCeL6M1rbXtlk3re8bzwAkIuP51LGxxpwB7JsAuLZIACWyEgEL/7KZk+uKjSmWCIgE/CWQKuQsgOMfPHIxNAoETYAMSOPJQE/YDE5fapaWhiohw8rF3jR2x+YptfiCQ0yNsg9JJgASaIFC/1HVta+p9y6Y9uKKJMJxKAg0TaC90fsiC9QsIUg1P4kASMJmA0Q0IX8Hyfum4mFqeUbrb+8DJitje0znTcuXnEOGemmSVnm4TTkBVv1DJO9wgnPB1EIb99UfDw5oNwcgw8jMnCXhKgA2IpziND+aK+6Fqd++vjBcaAYHtN+/5DqvfvRwi0yIglxJJgASaIVC/WFAlzy9wmoHIuc0SaJ89ZYpYLbcI8I5mY3E+CYRKwOgGhHtA/FgbXyvbpfP8CJzUmJlC5/Eq1vf5B0JSVwB9x53A+v0eVu2wxV0LHo27V/ozn0DbzR27WP3W3Twhy/xaUeFGCBjdgPAVLM/XrkKvrNgOL9bzmOy/Tiv5GoCPCjDC4/AMRwIkEBIBVX2wP4WjHulyng1JAtOSwH8RePXSwmG3iWAK8ZBAJAmwAYlk2ZoRfU/ZLh3STADO3TCB8fM63jZ8nXUmgDNEZBRZkQAJRJmAzirbzvFRdkDt8SXw6smMo+YJ5ID4uqSz2BJgAxLb0m7AmP6tbDs7Jc110H7/1YicJyIfDzo385EACTRPQKH/V7GdzzQfiRFIwF8CmUJ2NkTy/mZhdBLwmAAbEI+BRiCcDl+9TeXIyvMRkBp5iRNnTxmbkpZPAXo6n4hEvpw0kBgCemHZdnjvQmLqHX2j6WK2IBA7+k7oIDEE2IAkptSvG+VRvIEXffJtkzevrW45BSLv4+PywPEzIQk0TEChX67YzvkNT+BAEjCEQLqYmyfAew2RQxkksHECbECSuEL0M2Xb+b8kOjfBc33z4MhU6zFQOQmCfU3QRA0kQAKAivu/le7e75MFCUSVQKaQux2Cw6Kqn7oTRIANSIKK/S+rCr28YjunJc+5eY4nFHMTUsCHLcX7IHineQqpiASSQcAV/VS127k0GW7pMq4Ext41dsTmK7a5WSCHxtUjfcWEABuQmBRyEDZUsaCSL3UMYgqHBkCgfsGUlbKmQaULkH0CSMkUJEACdQKKc8v50gWEQQJxIPDqK7+t80WkLQ5+6CGmBIxuQHgRoS+rTlVdXbd6dHVm9RVfEjBo0wTWXzQ1YJ0kwImATGw6IAOQAAm8JQGedsWFEUcC4+dN3mlEf+tCQLaKoz96igEBNiAxKOIQLKi63ZV875whTOWUgAmsf01L9D2ieA8Uh/A0rYALwHSxJaCqv6rknQ/F1iCNJZpApjBlPyB1N0RaEw2C5s0kwAbEzLr4rkr14nLe+ZzveZjAUwLZUrZ11d/cfS1Yh4lKfaPhXhCkPE3CYCSQAAKquLFil46DQBNglxYTSqC92HmiBevXCbVP2yYTMLoBKeSug4C30PqwgFT1wUre4T4DH9gGGXL9Tbi6+SEQebcAUwGZHGR+5iKBKBJQxZ2VfIknBUWxeNQ8aALpQu4SEfzvoCdyAgn4ScDoBoR7QHwrvUK1Vku9bcnRDz3nWxIGDpzAxJv22iZluVMBnQpgKjchBl4CJjSdgKLsrlu1L/fAmV4o6vOMgMLK9OTuAnCQZzEZiASaJcAGpFmC0Z2v0FMqtnNldB1Q+aYI1BsSK1U7VBT1pyQHA9ouENnUPP46CcSRgEKfXFPr73js6IX/iKM/eiKBDRGYNHfSVm5tWFkgO5ASCRhBgA2IEWUIR4Tq7HLeOTqc5MwaBoH0remtZe3wQxRyEOr/np5FtgAAIABJREFUqO4hIlYYWpiTBIIkoMDLtVp/bsnRDz8SZF7mIgFTCLQXcx2W6oPclG5KRRKuw+gGhHtAfF6duqpsO5v7nIThDSZQ30PSilEHQWU/oP6UBPV/80MC8SPgYmp5Runu+BmjIxJonEC6kP24iPyo8RkcSQI+EWAD4hPYiITlcbwRKVSAMtuKHQcJrP1l/VMS7CfAlgGmZyoS8JyACz2najsXeh6YAUkgggQy/HI3glWLoWSjGxBuQvd/xXm8APwXzAyBElBIpqdzEiD7q+IAAPuLyC6BamAyEmiCgELvqtjOoU2E4FQSiBWB9acnYlR9P8jOsTJGM9Ei4PHfPz3d3JphA+L/YlKsdtet2o4nwviPOi4ZJhQ7dmhVORBY/9rW/oBM4V0kcalu7Hw8rcNXt1eOrDwfO2c0RAJNEJg4p2PflGvdz0NJmoDIqc0RMLoB4WPC5orb4GxVfLCSL13V4HAOI4E3ENhhTnazrVT3gUq9GVnflAiwBTGRQNgEaqgdvNjuuzdsHcz/3wTq38KLtVmmZSA1vGbVXHVlpVrWK7XWdSsH1lqvLJ+x4EVy85dAuid7oah8wd8sjE4CGyDABoRLQ1V/W8k7R5AECXhFYP23azXrcBG8FxBeeOkVWMZpmIBCv1KxnW80PIEDmyIwft7eWw4fWDtBXGucKzLOgoxXxS4CHQPB5lAZBdHNAdlqEImeVuijAB4DsAwij4m6lbLdu3AQMTh0IwTShVyfCKYQEgkEToANSODIjUzYL+vGLe1e+ISR4igq0gTqR/9i3cgj4Op7IDhKINtG2hDFm09A8UA5X+KJbj5Wqr1njzTc1gNE9GAo9gt0b5jqiwr5PYC7YA3cV+leMN9Hq7EOnS50tIukKrE2SXNmEmADYmZdglal0EsqtnNm0HmZL3kEMsWOnAvrcIEcKKr7QmRM8ijQsX8EdJWkrEmLjpr/uH85khd57F1jR2y2YutjBNbRonqoUb9v6w2JyCxx8RsetTz4tdlezH7Rgnxz8DM5gwSaIMAGpAl4cZqq+tLzKezwZJezKk626MV8AvVv4ACr/m31VECOEME25qumQlMJqOrplbxzman6oqYrXcx1A3q0qMyEYKTp+lX17yK4tpaSXy0+qlQ2Xa8p+tLF7AKB7GGKHupIAAE2IAkocsMW9eNl2/lJw8M5kAR8INA+J7eX1PRIgRwJwb4+pGDImBJQ6NyK7XTF1F5gttrmTHmX5bZ8SlRPgsjowBJ7nEiBW13ULuRBBJsG2z57yhTLaunb9EiOIAGPCLAB8QhkDMLUN/tVbGf3GFihhZgQaO/J7iwu3i/AcRDJxsQWbfhCQF9Y0+pOWDat7xlfwicgaLon936oni6QqfGyq390RS6qdpeK8fLlrZt0IXe+CL7kbVRGI4ENEGADwqXxBgIuTi7PKF1NKiRgGoFJc/cc5w6oDeiRIvIe0/RRT7gEXLgfqNq914SrIprZM8XOowHrYgC7RtNBY6pVsQCWe2alu/d3jc1I3qh0MfuIQN6VPOd0HDgBNiCBIzc94RNluzTOdJHUl2wCO83ad+QWw/qnWqJHQWUm940kez2o6m2VvHNksikM3v36V61qqR8mr6HXm5HSz5WP6l08eGrxntHek7MtRSHeLunOCAJsQIwog2kiPly2S780TRT1kMCGCKQLnUeIWDMVOFaALUkqSQR0FdSaWM7P/0uSXDfjtX1W+yhr2MivQuSsZuJEfa5Cf7G2teWsZdMeXBF1L17qTxdz9wmwv5cxGYsE/osAGxAuirdYFH8p50s7kwwJRJFA/dQegc4EMAOQzaLogZobJ+ACn6zapR82PiPZI9sLnQdaYl0Z99etGq2yQv/swj2JG9VfJzZxdme2xbJKjTLkOBIYEgE2IEPCFvtJCv1GxXa+EnujNBhbAvXXtEYPWzcDIscL0B1bo0k2puqU804uyQga9V6/x2PzFdtcIJDPNjonSeNU9VuVvPOFJHnemNd0MXutQN5PHiTgGwE2IL6hjXxg3o4e+RLSwL8IjLs9O3rkShwHyPtE8G6CiQcBV3Wfat55MB5u/HNRv/xT1bpORHbzL0v0I6/fpC7ucRW7d1n03TTnYOLsKWNbrJYnmovC2SSwEQJGNyDF7PWA1F+l4CcEAqq4s5IvHRZCaqYkAd8ITCh27NAC66OAnC7AO3xLxMC+ElDguopd4je0m6CcKWY/porvi8gwXwsSk+AKrFCrdnS1q+/OmFgaso10MfdDAc4YcgBOJIGNETC6ASnkroPgeFYwRALqvq+c770+RAVMTQK+EUgXcsdC9OPxu/fAN2TmBFbZmRvPN16OdCF7hYicYk7RoqPEhZ5VtZ3vRkex90rrX9a0IvU37yMzIgkAYAPCZbBRAqov1WpoW3yM83eSIoG4EkgXOtohqU8L9APcuG5+lVVxQSVfOtd8peEorL8+k7JSBYHsEY6C2GT9ddkunRQbN0Mwki5mfy6Q04cwlVNIYOME2IBwhWySgOKOcr50+CbHcQAJRJzAhOKELVLY4oOiepaI7BJxO3GV//Tzlo57sstZFVeDzfha30wjdS/vxmmG4utzFeip2CXbm2jRi8K9INGrWWQUswGJTKnCFar66XLe+UG4IpidBIIjkC52ng6Vc0RkbHBZmWlTBFzomVXbuWRT45L465li52RV63dsPrytvkKLFdvJexs1OtHSxeyVAjk5OoqpNBIE2IBEokxGiHTdgY7qjAULjBBDESQQEIF0IXeyCM4BMCGglEyzQQL6zItrh+3y15kPrCakNxJoL+Y6LNXfQWQM2XhPQFVvqOSd47yPbH7ECcXchFZgiflKqTBSBNiARKpcYYt9vB8vT1lqL305bCHMTwJBE0gXsicAOFdE2oLOzXyvEXDPLtu93yGPNxJo68l2Wip3C7AF2fhHQFWvreSdE/3LYG7kTCE7GyKJfQpkbmUirIwNSISLF4J0VdxYyZeODSE1U5KAEQTYiIRTBlU8p+tWja3OrL4SjgIzs2ZmZ3dTkQf52lVg9fla2S6dF1g2QxK1FTsOSiF1jyFyKCMOBIxuQHgPiJFLTIHPV+zSt40UR1EkEAQBhbTP6TxOXDmPT0SCAL7+yMZzy/nSBQFli0SasbOnjNncSs0XyPhICI6JSFUcV8mXboiJnYZtpAu5PhFMaXgCB5LAxggY3YDwHhCDF697TNnuvclggZRGAoEQqD8REcG3AdkxkIQJTKKqr6wd1rLjsmkPrkig/Q1azhRy90OwH5kES0CBNYLagWW7rxRs5nCzpXty7xfFteGqYPbYEGADEptSBmqk/gO45roHLJnR6wSamMlIwEACY+8aO2LUim2/8M/v6b9qoLzIS1LF9yr50mcjb8RDA+lC7gYRHONhSIYaBAEFnhKsmVK2y08PYlrkh2aK2b/yy5bIl9EMA2xAzKhDNFXoM/3Sv/fS7oVPRFM/VZOAtwQyhT3fCXEvBmSmt5GTHa3WUhu7eHrfn5JN4XX37cXsZy1Iom/pNmItqM4r553pRmgJSES6kP28iFwUUDqmiTMBoxsQ7gExfump6mMYsWavypGV540XS4EkEBCB9kLngZZYv+DRvc0D58EXb2RYv+sDsOpPnluap8sIzRPQj5Vt56fNx4lGhN3nZLdtreFpEbGioZgqjSXABsTY0kRGmAJ9L1h6AG8mjkzJKDQIAncd0pJZseJ/VeUrIjIqiJSxzKED+5fzC/4QS2+DNNU+q32UDBu5iJdjDhKcj8PrryNbKUkvOmr+4z6mMSp0upgtCCSxt8MbVYwoizG6AeEm9MgsLYXetXLL56Ytn7p8TWREUygJBECg7eaOXVL9qV9BcEgA6WKWQnvLtpONmakh2+G+jyGj83WiKh6q5Et7+5rEoODpQmeXiNVjkCRKiSIBoxsQvoIVrSWluPuV0c++l01ItMpGtQEQUEi6mPsMBN8UYEQAGWORwlX31Gq+94pYmGnSRLqYe58Av2kyDKf7RUBwWrm7dLlf4Y2Kq5BMT/ZpQN5mlC6KiRYBoxsQPgGJ1mJaf1Q/7te1q47kZWGRKx0FB0AgM7ezTWvWNQJ0BJAu0ikUWFGxS6MjbcIj8f969eoREdneo5AM4zEBhT65csvndkvKF3DpQvYiEfm8xxgZLkkE2IAkqdrBeFVgfr+l0x7pcp4NJiOzkEC0CPAP703XS6E/qdjOxzc9Mv4jMoXs/0HkU/F3Gm2HruoXq3knESdEtc2Z8q6U2/JItCtG9aESMLoB4StYoa6NZpIr9M+uVTtscdeCR5uJw7kkEFcC9ZOyRKxZArwjrh6b8aVaS1fyfdVmYsRhbnvPHmnLbX0YglQc/MTag+pL0rJu10VHLXoh1j7/ZS5TyC6EyKQkeKVHHwgY3YDwFSwfKh5cyPorFGrVjq529d0ZXFZmIoHoEJh4017btKTcGwEcHB3VAShVdcp5JxdAJuNTpAvZP4pIYjY4G1+QTQlUvbicdz63qWFx+PV0MftlgXw9Dl7oIQQCbEBCgJ6wlC7wyapd+mHCbNMuCTRMIF3M/VCAMxqeEPOBqu4nKvneH8Xc5ibtpYvZqQL53SYHcoAxBFT1lZVae+fyGQteNEaUT0Lqe9pQsxL/lNInvPEPywYk/jU2waFCL6/YzmkmaKEGEjCRQKaYOxVAMk7R2UQB3BbZvjp9/lMm1ilITelC9jYReU+QOZnLCwLu2WW79zteRDI9RqaYXQzIRNN1Up+BBIxuQLgHxMAVM3RJ9c3pa1tr05dN63tm6FE4kwTiSyBdzO0v0DmAbBVflxt3ptD7KrZzYFL9v+Z7/d4PbS0nnUMk/av+o7zO2QEzUYuk/kGIThez3xDIuYOYwqEk8CoBoxsQ7gGJ4zJ9GsBJZbt0exzN0RMJNEsgMzu7m1q4RSDvajZWFOe7op+qdjuXRlG7l5oz/ALOS5yBx1LFByv50lWBJw44YabYORmwHg44LdPFgQAbkDhUMYIeVC8t5x0eKxnB0lGy/wTG3Z4dPXIV5grkAP+zmZWhH7Udl9p9T5qlKlg1E3om79qqwx4PNiuzeUmg/sS/Ypf28jKmqbEyxexfAdnRVH3UZSgBNiCGFiYRsnQJ4J5UtvtKibBLkyQwCAI7zdp35Ojh6+pNyKGDmBbxofrHsu3sG3ETTcvnay1NIzQiwJrWde9cNm3hX40Q46OITCH3Swg+5GMKho4jAaMbED6CjuOSe4MnVXUF+JG7bvU5vD099uWmwUESaJ/VPswaPnIuIIcPcmo0h4v7pXJ37zejKd471elC9kneeu4dz7AiqeKzlXzpe2HlDypvptB5PMS6Lqh8zBMTAkY3INwDEpNV1pCNp11xP1Xt7p3V0GgOIoEEEcgUs/UmZHrcLasM7FXpXjA/7j435i9TzNWbzd8mmUFcvKvq7yt556C4+NmQj/St6a1l7cjn4u6T/jwmYHQDwicgHlfb/HAK9PRb+uFHupxnzVdLhSQQDIHx88YPH75uzL0iiO875aovlfPOmGCImpslwy/ezC3OIJUpVLXF2iEJR0qni7mHBNhzkIg4PMkEjG5A+IM4oUtTX1DFJyp559qEAqBtEvgvAmNnTxmzuaTuF5H2OOJR1Rsqeee4OHpr1NOE4oQtWrHFikbHc5z5BFzFR6v50s/MV9qcwnQx+3WBfLm5KJydKAJsQBJV7kiZVeDWmurZS/LOokgJp1gS8InA7nP22HGY2/JgHE+cccX9n2p37899QheJsJmezqOg1pxIiKXIhggo9DcV2zmhocERHtRW7DgohdQ9EbZA6UETMLoB4StYQS8H4/LVH2GLyiwV99yK3bvMOIEURAIBE5g0JztRXZQA2Tzg1P6mc3V8eYbzmL9JzI6eKWT/DyI8ntzsMg1KnUKfrNhO7I+orb8mOqJ/zCsAWgYFiIOTS8DoBoSvYCV3Yb6Fc4VeOSD9X1vavfAJgiGBJBNIFzqPELFujQ8D/VvZdnaKj5+hOckUcosgyAxtNmeZSsAV3aXa7fzZVH1e6coUcvdDsJ9X8Rgn5gSMbkD4BCTmq29I9gbqjYgKvp6EH+hDIsRJiSCQKWY/CshPYmHW4z+Ioshk/LyOt43oT/0jitqpeeMEXLgfqNq918SdU3sx920L+FzcfdKfRwQ8/rkvHslaH4angXhJM4axFFfUWmtfWzy9708xdEdLJLBJApli7nIAp25yoOEDVN1PVPK9PzJcpq/y2oudJ1qwfu1rEgYPhYCq/riSd84IJXmASdOFzi4RqyfAlEwVZQJGNyB8AhLlpRWMdtV+FVzFJyLB4GYWswisP563f/QigbzLLGWDU1MTzS7udnoHNyteozOF7A8g8sl4uaKbOgGF3lexnQPjTqN9Vvsoa/hmL8fdJ/15RMDoBoR7QDyqcjLCqOq1sGrfT/pFZsmoNl2+RiBd6GgXpEoQjIwkFcXqcr60WSS1eyg6XcjeJiLv8TAkQ5lCQPUf5bzzdlPk+KkjXchW4npUuJ/cEhmbDUgiyx5r0wrMV7g/qNq9fJ0h1pWmudebkOxpIvKLSBJR3FHOl+q3fyf6kynk/gzBOxMNIcbmV22mYx4/3HkpxhbXW8sUcldBcFLcfdKfBwSMbkD4CpYHFU5wCNV/KOQXA1L78VK778kEk6D1BBDIFHP1M/gPipxV1YvLeSfRG1ezpWzr2r/JusjVjoIbJuCq7lPNOw82PCGiA9uL2c9akO9GVD5lB0nA6AaEr2AFuRTinUu1AJEfl+3S7fE2SndJJTChZ/Kure6wSuRexXJxcnlG6eqk1q3uu60n25lScZLMIO7eXbgnJeGpfLqn81BR686415P+PCDABsQDiAwRGQKqeERFf7bKrf1y+YwFL0ZGOIWSQAME0oXc/4rgkgaGGjPEdQc6qjMWLDBGUAhC0sXc/gLcF0JqpgyIgKqeXsk7lwWULrQ0k+ZO2kprw58PTQATR4cAG5Do1IpKPSaguEIt99eV7t7feRyZ4UggNAKZQrYEkWxoAgaZuGyXPD2+fZDpjRmeKeTuguAQYwRRiGcEFLpM167uqM6s1m8Kj/2H+5liX2JvDLIB8YYjo0SZgP4NwHWAe13Z7itF2Qm1k0C6Z8qeoi0PRYOELinbTls0tPqvMl3InSyCcf5nYoagCKi6z6wd1nr1smkPrggqZ9h50oVcjwi6wtbB/IYTYANieIEoL1ACqvoYBNdKSn9TPqp3caDJmYwEPCKQKeR+CcGHPArnWxhVvaGSd47zLQEDkwAJBE4gXcx+QyDnBp6YCaNFgA1ItOpFtQESUF0ES6/rx8BvlnYvfCLAzExFAk0R2O2myduNsFofE5FRTQXyebKqfquSd77gcxqGJwESCJBAZnbuJFi4KsCUTBVFAkY3IDyGN4pLKpaaVVF/peW6AaldzyN9Y1ni2JlqL2a/aEG+abYx/VjZdn5qtkaqIwESGAyBTGHKfpCW+wczh2MTSIANSAKLTstDJqBQFaBPVW6B4JbK2tIfMRO1IQfkRBLwicDk2yZvXlvTulwg2/qUoumwCve9Fbv31qYDMQAJkIAxBOpPYEemhj1tjCAKMZOA0Q0I7wExc9FQ1b8JKLACitvFwi21fp23+Bjn78RDAqYQyBSyZ0HkO6boebMOsbRtUZezxFR91EUCJDA0Auli7iUBthzabM5KBAE2IIkoM00GRUB1kYrcAuitFdu5K6i0zEMCb0Vgp1n7jhwzbN3yf17CuZ2JhF5c27rZX2c+sNpEbdREAiQwdAKZYtYBpHPoETgz9gTYgMS+xDQYGgFdqcAdAtxaa3FvWTy970+hSWHixBLI9HSeA7UuMBDA02W79A4DdVESCZBAkwQy3MPbJMEETGcDkoAi06IhBHTJ+r0jcG+r5HtvM0QUZcScwO5zstsOc+UZ42yqLirnncnG6aIgEiCBpglkitlvAvLFpgMxQHwJGN2AsIOO78JLuDMF1gBwFPiDWvqH/pR7/7Jpfeb9JTHhdYqL/XQhe4WInGKYn3vKdok3fxtWFMohAS8ItBdzn7CAS72IxRgxJcAGJKaFpa3oEVCU63tH1NJbRuwgv3dyTn/0TFCxiQQyczvbULOqJmlT4KaKXTrGJE3UQgIk4A2BdE/uGFHc4E00RoklAaMbEJ6CFcs1R1ONENBVUNztCu6zXHnglTHP/nH51OX1pyb8kMCQCGQKufsh2G9Ik32YpNBfVGznIz6EZkgSIIGQCbT1dO6TUuuBkGUwvckE2ICYXB1qI4HXCSgwH4r7VPSBtbX+ex47euE/yIcEGiWQLmRPE5FfNDre73EqelGl2+E74n6DZnwSCIFAe092Z0uFB6+EwD4yKdmARKZUFEoCbyCgqssheECAewcU9y/JO4uIiAQ2RGD8vL23HNFfe8kcQu7ZZbvX2DtKzOFEJSQQTQKZYk6jqZyqAyHABiQQzExCAr4TWH8pInC/qt4L6P3VfO/vfU/KBJEikC5mrxTIySaIVnU/Ucn3/sgELdRAAiTgPYFMMfsPQN7mfWRGjAUBNiCxKCNNkMBbElDgflHcUwPud+Xl3y+1l75MVMkl0D6n492Wm7rDDAL68bLt/MQMLVRBAiTgNYFMIbcIgozXcRkvJgTYgMSkkLRBAg0QUKCvvrkdwB8wYvXvKkdWnm9gGofEiECmkH0BImPCt6QfK9vOT8PXQQUkQAJ+EEgXsveKyIF+xGbMGBBgAxKDItICCQyVgKKssr4huX9ta+1O3kUyVJDRmZcp5q4G8IGwFbuKj1bzpZ+FrYP5SYAE/CGQLmbnCOQof6IzauQJsAGJfAlpgAQ8I6CqVQhudeEWF9t993oWmIGMIWDK+fwK9yMVu9eYU7mMKRCFkEBMCGSK2V8DcmJM7NCG1wTYgHhNlPFIIB4EVPEcRAsK3CbD19zJ17XiUdf2We2jrOGbhb4XSFVPr+Sdy+JBlS5IgATeTCBdzP5YIB8jGRJ4SwJsQLgwSIAEGiGg0IcB3Omq3PlSSu9+sstZ1cg8jjGPQKaQuwuCQ8JUxgYkTPrMTQL+E0j3ZC8UlS/4n4kZIkmADUgky0bRJBA6AVX9PQS3q+K31bzzYOiCKKBhAulC7nwRfKnhCT4MZAPiA1SGJAGDCKQL2c+LyEUGSaIUkwiwATGpGtRCAlEloC8AuMOFFltGDBQWHrFwZVSdJEF3e0/uvZZiXpheuQk9TPrMTQL+E8gUsx8D5Mf+Z2KGSBJgAxLJslE0CRhLQIE1Ar3RFbmm2l26xVihCRY27vbs6M1WyYthInBFP1Xtdi4NUwNzkwAJ+EcgXcieICLX+JeBkSNNwOgGpJi9HpCZkQZM8SSQbAJPK/QagV5ZtnsXJhuFWe7DvyTMPbts937HLCpUQwIk4BWBdKGzS8Tq8Soe48SMABuQmBWUdkjAXAJLXaBHgGKlu/QABK65UuOvLF3IXiEip4TmVHFuOV+6ILT8TEwCJOArgbZix0EppO7xNQmDR5cAG5Do1o7KSSDCBB5XuBeN2FF+5eSc/gj7iKz0dE/nZ0St74Vo4Gtlu3ReiPmZmgRIwEcC7bOnTLGslj4fUzB0lAkY3YAUctdBcHyU+VI7CZDAhgko8JRCL67hlZ8vtZeGfjdFkmqVLmanCuR3oXlWfLOcL4V6Eldo3pmYBBJAYELP5F1bddjjCbBKi0MhwAZkKNQ4hwRIwFsCukohvx4ALllql5Z6G5vR3opA+tb01rJ25HNh0XGB71Tt0tlh5WdeEiABfwmE/TPGX3eM3jQBoxsQbkJvur4MQAJRIqBQBXCzuPLd8ozS3VHSHkWt6WL2bwLZIRTtqj8o551Ph5KbSUmABPwnoJBMT457/fwnHc0MRjcgfAUrmouKqknAGwL3DKh+ckneWeRNOEZ5M4F0IXeHCN4dBhmF/qRiOx8PIzdzkgAJBEMgU8zVv1TihwT+mwAbEK4KEiABswnoT5+3cOaTXc4qs3VGT126kP2FiJwWjnK9pmw7HwgnN7OSAAkEQYANSBCUI5rD6AaEr2BFdFVRNgl4S0BVH3MtzFzc7fR6GznZ0TI9nedArXCOwlWdV84705NdAbongXgTSBezawQyPN4u6W5IBIxuQPgK1pBqykkkEFsCvDvC09Kmi7n3CfAbT4M2GkzxQDlf2q/R4RxHAiQQPQJ8AhK9mgWmmA1IYKiZiARIwAsCqs6AO3DCkqMffsSLcEmOke6Zsqdoy0PhMNAlZdtpCyc3s5IACQRBgA1IEJQjmsPoBoSvYEV0VVE2CfhMQPUlqOR5UlZznDOFPd8J0T83F2WIs1X/Uc47bx/ibE4jARKIAAG+ghWBIoUl0egGhK9ghbUsmJcEIkHAhfuBqt17TSTEGihyhznZzbZ2ZWVY0sp2ScLKzbwkQAL+E+ATEP8ZRzaD0Q0In4BEdl1ROAkEQWD9vSGKj1TyzmVB5ItjjnQxt1qAEWF4s0asG7XwiIWhNUBheGZOEkgKgZ1m7TtyzPB+nl6YlIIP1qfRDQifgAy2nBxPAokk4Kp7ajXfe0UizTdpOl3IPiki2zcZZkjT+2XduKXdC58Y0mROIgESMJpAutB5hIh1q9EiKS48AmxAwmPPzCRAAt4RcFX3qeadB72LmIxI6WKuLEA6FLcupnIfTyjkmZQEfCeQ4ZfIvjOOdAI2IJEuH8WTAAn8m4D+7RW3llk+Y8GLhNI4gUwxdzeAgxuf4eFIFyeXZ5Su9jAiQ5EACRhAYGIhO6lFZKEBUijBVAJsQEytDHWRAAkMloCq3lDJO8cNdl6Sx4f5LaVCv1yxnfOTzJ/eSSBuBMbP63jb8HXWAyKyW9y80Y+HBNiAeAiToUiABEIn4Ary1e5SMXQhERGQLua+J8BnwpCrqpdV8s7pYeRmThIgAe8JtM/peLfUrKvD2lfmvSNG9I0AGxDf0DIwCZBAGAQU5XK+NCmM1FHMmS7mzhbgW2FoV9XbKnnnyDDZr4nzAAAgAElEQVRyMycJkIA3BNpu7tjFGrBOFpWDIDjMm6iMEnsCbEBiX2IaJIHEEVDBsZXu0o2JMz4Ew+3Fzg9YsMLah7G0bJcmDkF2LKdMnNOxb8q1fiKQPWJpkKZIgARI4DUCbEC4FkiABOJGQKF3VWzn0Lj58sNPW2HPw1Kit/sRu5GYvIzwdUqZQvZpiGzXCDeOIQESIIFIE2ADEunyUTwJkMAGCNSsgd0Xdy14lIA2TiDdM2VP0ZaHwuIklrYt6nKWhJXflLzj503eaUT/sL+Yooc6SIAESMBXAkY3ILwJ3dfaMzgJxJmAq/rFat65KM4evfCWKeYOB/BbL2INJQZfl3vDE5AXIDJmKBw5hwRIgAQiRYANSKTKRbEkQAINElDofRXbObDB4Ykd1l7MHmdBZoUFQKFfqdjON8LKb1LeTCF3OzfxmlQRaiEBEvCNgNENCG/R9K3ufgZW1VdEZIkCa0U1zW/0/KTN2BsjwP0Fm14fmZ7ch6G4bNMj/RmhqtdW8s6J/kSPVtR0T/ZCUflCtFRTLQmQAAkMgQAbkCFA45QNEXjchX6hajv/7z8HTCh27JASeY+odaEA7yA+EgiMgKvjyzOcxwLLF8FE7cXsmRbk4rCkK/Thiu1MCSu/SXnThdyxInjDz0+T9FELCZAACXhGgA2IZyiTHUi10C+vnLzUXvryhkCkb01vLWtH3AzIPsmGRfdBEVB1uyv53jlB5YtinnQhd74IvhSmdj6pepX+hJ7Ju7bqsMfDrAVzkwAJkEAgBIxuQLgJPZA14EGSe8rdpUMhcDcVq31W+zAZPnKWQOxNjeWvk4AHBL5WtkvneRAntiEyxdzlAE4N06ALdFbtUl+YGkzJnSnm6g3IrqbooQ4SIAES8IUAGxBfsCYmqAJPrXQH2pbPWPDiYEyni9kfC+Rjg5nDsSQwaAKq88p5Z/qg5yVoQrqQvVVEjgjTsqv4aDVf+lmYGkzJnS5mvy+QT5uihzpIgARIwBcCRjcg3ITuS829DFpD7eDFdt+9Q4mZKWTPgsh3hjKXc0igMQK6pGw7bY2NTeaoTDH7MCCTw3Sv0MsrtnNamBpMyd0+p+Pdlpu6wxQ91EECJEACvhAwugHhK1i+1Ny7oHph2XbOaSbe+k2X0Gsh0tpMHM4lgbcioMD8il3ai3Q2TCBdyD0ngq1DZaQol/OlSaFqMCW5wsr0ZF8GZDNTJFEHCZAACXhOwOgGhE9APK+3VwFV8VAlX9rbi3jpns5DxZWbIDLai3iMQQKvE9Dby7bzHhJ5awJj7xo7YtSKbVebwMcasW7UwiMWrjRBS9ga0oXs/xORY8PWwfwkQAIk4BsBNiC+oY1tYAVeHpB1eyztXviEVyYzs7O7wcJcQCZ6FZNxSAAe/4CLG9GJN+2xe0uqdakJvlx1D6rme39vgpawNfA43rArwPwkQAK+E/D4z2fxUnCGT0C8xOlZLAXeX7FL13kW8F+BJhQnbNGCLX4tQLfXsRkvmQRU9auVvPP1ZLrftOt0MdctQHHTI/0f4ULPqdrOhf5nikYGI16NiwYqqiQBEogiAaMbEO4BMW9JKa4u50sn+yksU8ydp9CvCMTThtZPzYxtKgE9qmw7N5uqLmxd6UL28yJyUdg61udX3F3Ol6YaocUAETwNy4AiUAIJkIB/BIxuQPgExL/CDy3y49aIdZODeE87XejsgljXCLDF0KRyFgkAa1pr2y2b1vcMWbw1gXQhe4WInGIKnxfXtm7215kPGLEnJWwmbXNzmVQNi8LWwfwkQAIk4AsBoxsQPgHxpeZDDDrgugN7VmcsWDDE+YOe1nZzxy7WgFUUyB6DnswJiSegqtVK3kknHsRGAKQL2T+KiCeHSXjCWdyucnfvXE9ixSBIppibDyAXAyu0QAIkQAJvJGB0A8InIMYsVwU+X7FL3w5DULqY/a5APhtGbuaMLgGFnl+xnS9H14H/ytPF3AqjnjKqXlrOO5/y33k0MrT3dJ5iqXVFNNRSJQmQAAkMgoDRDQifgAyikr4Ovbdslw72NcMmgmeKucMBvR6QrcLUwdzRIaAysFele0H9G2R+3oJAutg5XmA9ahIcVTxSyZcmmKQpVC2zkEoPyz4mIruEqoPJSYAESMBrAkY3IHwC4nW5Bx1Poc+6A5i8+Bjn74Oe7PGEthuz26da5DcAQm2GPLbFcD4QUNU/VfLOWB9CxyZkptB5PMTy/DS7pgGp7FzOz/9L03FiEiBTzJ0K4PKY2KENEiABEniVgNENCJ+AhL5Ma4rpi/OleaELeU2AQjLF7CchuJA3BRtTFeOEuKKfqnY7lxonzCBBmWL2YkDONEjSeiku9Myq7Vximq7Q9PApSGjomZgESMBHAmxAfIQb9dAGv4+9foN6v3W9URtoo17vuOhXffGV0c9tv3zq8jVxseSHj0wxd7eJTxMVuL9ilw7ww3NUY6aLnacLrJ9HVT91kwAJkMB/ETC6AeErWKGtWAUqFbuUCU1Ag4nbi9nPWpDvNjicw5JAQNwvlbt7v5kEq814TBeyL4vIqGZi+DXXbZHtq9PnP+VX/CjGzRRzSwBwf0wUi0fNJEAC/02ADQhXxVsSSLnt5aN6F0eBzr82015m4re5UeAXL426pGw7bfHy5L2b9tlTplhWS5/3kb2KqB8v285PvIoWhzjpYnaqQH4XBy/0QAIkQALcA8I18F8EXMVHq/nSz6KGpr3YeaLAuliAd0RNO/U2T0ChCqntzZOvNs0yXcj9rwiM3Wehijsr+dJhm3aSrBGZYu5qAB9Ilmu6JQESiCUBPgGJZVmHbkq1UM47M4YeINyZ427Pjh65Si4Q4IxwlTB70AQUeknFdozbVB00h0bypYvZgkDsRsaGNUaHr96mcmTl+bDym5h3/LyOt41YZz0CkTEm6qMmEiABEmiYgNENCE/BariOXgxU4KmV7kDb8hkLXvQiXpgxJhayk1KQy0SwV5g6mDsYAqp4qDJ61P6YevdAMBkjnEUh6WJ2han7P14jy5PM3nqNZYrZjwLC19Mi/FuQ0kmABHgML9fAvwioqqvQQ6r53t/HBsqrf9F6P4Bv8iKv2FT1v4yo6t/7U5j8SJfzbHxdeuesvZjrsIBe7yL6E0mhD1dsZ4o/0aMdNV3I3SGCd0fbBdWTAAkkmoDRT0B4ClZga1Oh36jYzlcCSxhwokwhexaAL/HVhYDB+5xOgTWC2oFlu6/kc6rYhE8Xsp8XkYuiYMh1BzqqMxYsiILWIDXuPie7bWsNC0Vk+yDzMhcJkAAJeEbA6AaEr2B5VueNBVLVByu2sy8EGkjCkJJMmjtpK3dg+JcBPUNEhoUkg2m9IzDgCrqr3aVbvAsZ/0jpQu7BqLyaqMAPK3bpk/GvyuAdpou5/aF6r4hYg5/NGSRAAiQQMgGjGxA+AfF9dajqK26rm1k8ve9PviczJMHE2VPGpqzU2YB8SIARhsiijEESUMGxle7SjYOclujhbTdmt0+1yJPRgaAvlG1n6+joDVZpupg9VyDfCDYrs5EACZCABwTYgHgAMcoh1H1fOd97fZQtDFX7q09Ehn1SBJ8A5G1DjcN5wRNQxQcr+dJVwWeOdsb2Qu5/LMFPo+TCFff4anfvrChpDlJrupC9VUSOCDInc5EACZBA0wSMbkD4ClbT9d1oAMUV5XzpVH+TmB99/Lzxw4etG3OKiJ4pkHeZrzi5CusntdWs2tFLuvoeSC6FoTtPF7K3ich7hh4hhJmKP5Tzpf1DyByJlDvMyW62lSv3CdARCcEUSQIkQAJ1AmxAErsOnnje0syTXc6qxBJ4s/H6qVk9uS4B6ndJHEQuhhFQ3LEupe/naVdDq8vEm/baJmXV/hHFPQOuhb2rXaWHhuY8/rPSt6a3xtoRfQLZOf5u6ZAESCAWBIxuQLgHxLc1xtNlNo72X0eVfpa3Dvu2BAcVWIHPV+zStwc1iYPfQMD02883Wi6P/6CK49JIFzvHQ636AQPcMxPHAtMTCcSNgMc/18VLPhk2IF7i/HcsF3pm1XYu8SV4zILuPmePHVvc1k9b0NMA2Spm9sy3o3hAUnrqoi5niflizVaYKWQXQmSS2So3ok5l53J+/l8iqz8A4ZliRw6w7gZk8wDSMYWfBBQ/U3EdseRPrupYUasN0KkC2cPPtIxNAoERYAMSGGpDEuntZduJ1jvghpDL9HQepWqdKMD7DJEUYxm66p8viJ5Xtnu/E2OTgVmbOLsz22JZEb8rRb9btp36fT78bIRA+5zcXlZNb+OdR9FcJqp6rVr4YrXb+fNbOUgXsqeJyC+i6Y6qSeA/CLABSdJy0GeAtZPKdvnpJLn22mv7rPZRGDbiOIF1Im8j9ppufV8afri2tfb1ZdP6nvE+ejIjpou5HwpwRpTdK7BiAC/vtNRe+nKUfQShPT2nYw+41h0C2TaIfMzhCYEnAPxP2S7dvqlomdm5k2CBpwBuChR/3WwCRjcgPAXL08XjWrXDql19d3oaNOHB6jcSD1OxVTUPyGG8V2RoC0KhCsVvalr70pIZC5YPLQpnvRWBnWbtO3L08P6nBNgy6oQU+pWK7fDeiwYKuX5PCOQegezQwHAOCYmAqq4TyMVrhr349WXTlq1tVEamkLsKgpMaHc9xJGAcAaMbEO4B8Wy9qOJ7lXypvqmaH58ITL5t8ubumpYjADlaIfXTtCL/Fz6fUP07bP0iTAiudq3a9xZ3LXjU73xJjJ/pyX0Yisti4V31RXfd6ndWZ1ZfiYUfn0203dyxi9Vv3Skiu/mciuGHQECh91kWTh/KHrexs6eMGWW11PfGvX0IqTmFBMInwAYk/Br4rUChD1dsZ4rfeRj/jQTSxdz+AhyuQP3JCO8x+A88Cn0Uiu+nRvZfufCIhSu5dvwjkClmHUA6/csQbGRX9YvVvHNRsFmjm238vL23HLFu4FcQmRFdF3FTrs/AlTPLM0pXN+MsU8xOB2RuMzE4lwRCI8AGJDT0ASXWVTWrNoXfLgeEewNp6vtGZPhmh0L1CIEcBEEmXEUhZFf8QUVvVcjcql3qC0FB4lK+eipSan6cjKviuRdSujPvMBpcVTPF7KcB+f7gZnG0twR0pQLfesHCd71av+li9kqBnOytTkYjgQAIsAEJAHKYKQSnlbtLl4cpgbn/m8C427OjN1uFAxTYR1QOUME+8ds/os8ocAeA2zB8zZzKkZXnuRaCJZAp5H4JwYeCzRpANtXPlfPOxQFkilWKV0/Iwg0QvDNWxiJhRr+rw9d80+ufg/UnXMP7BxZzr08kFgFF/icBNiDxXQ+quLGSLx0bX4fxclb/ttoVyYhrjYegTRS7R+tJia5SyD0KvdNC/bjn3oXxqlC03NTf/08NpGK6oV+f6ccru/FErMGvyUlzJ23lDgy7REROGfxszhgsAQV+PoDa15bafU8Odm6j49t7cu+1FPMaHc9xJGAEATYgRpTBcxEK/fPqzTD58cOdlzwPzoCBEpg4e8pYq0V2s9zULgrdEYqdAbwTIjvV/x30ZncF1kCxBNCqQKquhXJNsWSpXVoaKBgm2yiBTDFXf/J5alwxKfD9il3637j689tXutB5hIhcDsiOfudKYnyFXgno+RW7d1kQ/tPF7K8E8sEgcjEHCXhCgA2IJxiNC/LPV18OqNil+40TRkG+EBg/b/JOw2upbaCyjapsYwGv/relo6AYCWAzgYxUxUiBjlSp/1ssKPpVsEoUqxW6GoLVAqzSV/95UYDnBHi2JvqcpXjWSvU/t+ioRS/4YoJBPSOQmZ3dDZYE8hcfz0QPIZBY2jaUE4SGkCqWU+on99XWDLvon7/HPxFLgwGbUuizovJzt1UurU6f/1SQ6fkqVpC0mcsTAmxAPMFoVBBV/Wol73zdKFEUQwIkEBiBxNwRoLi7nC9NDQxsTBNlClP2A1I/gEg2phZ9taWKRxS4pJov/czXRJsIzlexwqTP3IMmwAZk0MiMnlA/V7xiOwcaLZLiSIAEfCPQ3rNH2tLWsm8JDAusiuMq+dINhsmKpJy2Qm5aSvQbcTq22c9CqOpvIfq9it17q595BhObr2INhhbHhkqADUio+D1NXr/UTWC1l/Pz/+JpYAYjARKIDIF0MXunQA6NjOBmhSr++uK61t3/OvOB1c2G4vxXCbT35GzLxfnROgQjqOrpElX8SlutK4N+zaoRh+tfxVo3sEREtm9kPMeQQGgE2ICEht7zxC70nKrtXOh5YAYkARKIBIFXv8HGzZEQ66FIhV5SsZ0zPQzJUADqF90p5FQBjk42EH0GwFU1wbWLu51e01nwVSzTK0R96wmwAYnHQlh/MtHw1Tt6fcZ4POjQBQkkg0CmmFsCYEIy3L7ZZW3Pst1XSqZ3f13vdtPk7Uakhp0C1Y+IyG7+ZjMkuuo/FOhRS26qdpduMURVwzJ4QWHDqDgwLAJsQMIi721eVdxZyZcO8zYqo5EACUSFQHsx94l/nn52aVT0eq1ToQ9XbGeK13EZ740E2nuyB4jKSVAcI4Jt4sVH/6jAPIF7S9SbWZ6KFa+VGUs3bEDiUlb9adl2PhYXN/RBAiTQOIH2m/d8hwzoIwJs0fis+I1U4PMVu/Tt+Dkz01FbseOglFrHADIjkrerK/4C0QdcaM+AJbc90uU8aybpoaniq1hD48ZZARFgAxIQaL/TqF5azjuf8jsN45MACZhHIF3IXiMiJ5inLHhFkpLdFh01//HgMyc7Y/uc3F7i6lGA5AB0CPAOk4ioahXAAgH6arAWtLSscZJwp1G6kL2Ct96btBKp5d8E2IDEYzGoYk4lX+qOhxu6IAESaJRA+5yOd1tu6o5Gx8d9nKo+WMk7+8Tdp+n+1u8bsVo6FNJhCToV0g5gNwFG+KldoY9CZQkEiwVY6qpWVqwbtjCpp6SNuz07euQqVAWyg5/cGZsEBk2ADcigkRk5ob4JfW1r6u3Lpj24wkiBFEUCJOA5gbF3jR0xasW2lX+e0DPO8+ARDqiKCyr50rkRthBb6e092Z0h7rtQS42H1BsSbROVbVQwQqAjVTFCREYqMFKALV8FoS8A8qICL9b/WxQvvfb/Cv2HJfqIqi6p5PvqTzn4eROBpJ6Ox4VgOAE2IIYXaBDyVPVblbzzhUFM4VASIIEIE2gv5r5tAZ+LsAXfpNdQO3ix3XevbwkYmAQiRIAXFEaoWEmRanQDUsxeD8jMpNSiaZ+KmgoOrtil+5uOxQAkQAJGE2gvdB4oIvcIRIwWGpI4BZ5a6Q60LZ+x4MWQJDAtCRhDYEJxwhatOmoZRLYzRhSFJJuA0Q1IIXfdP9/jPD7ZFRqce1U8r4LDqnapb3AzOZoESCAqBCbNnbSVWxteNW2jr3H8VGeX807CL9EzrioUFBIBnooVEnimfWsCRjcgfAIyxGWrq1zL7a529d05xACcRgIkYDCBTDE7F5DpBks0RhqP5jWmFBRiAAG+imVAESjhVQJGNyB8AtLUMnXF/VC1u/dXTQXhZBIgAaMIpAudZ4hYPzRKlOliLD2i3OX81nSZ1EcCfhPgBYV+E2b8hgkY3YDwCUjDddzIwPPKdulrXgRiDBIggXAJZApT9gNa7oUgFa6SiGVXfUlarE7eDxKxulGuLwTSxc4jBdYtvgRnUBJolAAbkEZJRXrcL8vdpdMg0Ei7oHgSSDCBibOnjG2xUr2AbJVgDE1Y1yXWiP7cwiMWrmwiCKeSQCwI8FWsWJQx2iaMbkD4CpZ3i0t1njWyfyb/8PUOKSORQFAE2me1j5JhIx8UWX+ZGz9DJKBAT8Uu2UOczmkkEBsCfBUrNqWMrhE2INGt3WCVq+piUXSVZziPDXYux5MACYRHIFPI3gyRaeEpiFNm/WnZdj4WJ0f0QgJDIcBXsYZCjXM8I2B0A8I9IJ7V+bVACqwQS4/jhkzP0TIgCfhCIF3MXiaQD/sSPKFBFfqViu18I6H2aZsE/k0gXcheISKnEAkJBE6ADUjgyENPqKquAl+q5p2LQhdDASRAAhskkOnpPAdqXUBEvhD4cNku/dKXyAxKAhEhUL+gsAWjlghkh4hIpsy4EGADEpdKDt6HAjet3PLZE5dPXb5m8LM5gwRIwE8C6ULuWBH8Pz9zJDl2/YsYQKdV8r23JZkDvZNAupidKpDfkQQJBErA6AaEm9ADWAu6EC6O5r6QAFAzBQk0SIDvZjcIyoNhCj20Yjt3eRCKIUggsgTShew1InJCZA1QePQIGN2AcA9IIAtKVV8RlY+XZ5SuDiQhk5AACWyQQFthz8NScOdBpJWYgiCgq1zFodW882AQ2ZiDBEwkMGlOdqK6sthEbdQUUwJGNyB8AhLoqlPVa3Xd6v+pzqy+EmhiJiMBElhPIFPMTgdkLnEETUBXupADq3apL+jMzEcCphDIFLMPALKPKXqoI+YEjG5A+AQk8NWnqstdC8cs7nZ6A0/OhCSQYAJthdy0lKAIoCXBGEKzrornrZTuv6jLWRKaCCYmgRAJpIu5SwX4RIgSmDpJBIxuQPgEJLSl6ELPqtrOd0MTwMQkkCAC7T2dMy21rk+QZVOtPo2UO7V8VC9fRTG1QtTlG4FMIfclCM73LQEDk8B/EmADwvWwQQKKO1xLP1ztdv5MSiRAAv4QaC/k/scS/NSf6Iw6aAKqLwK16eX8gj8Mei4nkECECaQL2R+JyMcjbIHSo0TA6AaEr2CFvpQUeFmgZ5dth39BCr0aFBA3Auli9lyB8EI8wwqr0LWAzKzYpR7DpFEOCfhGIF3M/o33gfiGl4HfTIANCNdEQwQUd9daa6csnt73p4bGcxAJkMBGCfB9a7MXiEJVgI/zyxez60R13hBIF7IniMg13kRjFBJogIDRDQj3gDRQweCGKLAG4n6x0t37/eCyMhMJxIvAuNuzo0eukqsE6I6Xs3i6UeglFds5M57u6IoEgN1umrzdiNSwhwV4B3mQQGAE2IAEhjo2iRS4v1brP3XJ0Q8/EhtTNEICARCYOLsz2yLWbAjeGUA6pvCKgOIOaVk7c9FRi17wKiTjkIAJBHafk912WE16INjXBD3UkCACRjcg3ANi7EpU1XWwcMkLgm882eWsMlYohZGAIQTae7KfFBcXi8gwQyRRxiAIqOqfRLS7bPcuHMQ0DiUBYwmki51HCuQqQN5mrEgKiy8BoxsQvoJl/MJT6JMQOavSXfqN8WIpkARCIDB29pQxm1stlwtwdAjpmdJjAi7cD1TtXr4r7zFXhguOwOTbJm/urhn2AwCnBpeVmUjgTQTYgHBJeEJAcbeidkYl31f1JB6DkEAMCKSL2akCXA3IjjGwQwuvEVC9tJx3PkUgJBA1ApN69jzYVfcqgewcNe3UGzMCRjcgfAUraqttQIEfrm1NfXXZtAdXRE089ZKAVwSypWzrmr/J+VA9S0Qsr+IyjjkEVPHQgNRmLLX7njRHFZWQwFsTGD9v7y2H99e+A+jpAhFyIoHQCRjdgPAVrNDXx1AEqOJ5Fb2gajuXDGU+55BAlAlMKOYmtEKvBaQzyj6ovREC+oJCT6jYvbc2MppjSCAMApnZuZPU0ksEsm0Y+ZmTBN6SgNENCJ+ARHrVrt+0qfLlcr50DQRupM1QPAlsioDCyvR0nqmQbwhk+KaG89fjQWD9fSEqF5bt0pf5cy4eNY2Li7abO3axBqxfCuTQuHiijxgRMLoB4ROQWKw0Va0K9Nxyvnd2LAzRBAm8iUC62Dle1LoSgv0IJ5kE6q9k1aCnLck7i5JJgK5NIpAp5L4EwfkmaaIWEngDATYgXBBBEVh/f4hV+9ySrr4HgsrJPCTgN4F0T+dnRK3v+Z2H8aNCQC8s2845UVFLnfEikJmdO0QFPxPB7vFyRjexI2B0A8JXsGK33uqGFHqXAN8tdzvzINBYmqSp2BNo78nZ4uqFItIWe7M0OFgCj7uiH6x2O/cNdiLHk8BQCIyf1/G24eus74vICUOZzzkkEDgBoxsQvoIV+HoIMqEqHgH0/yp558dB5mUuEmiGQHshu7cILhbIAc3E4dz4E1DVX9Xc1FlLjn7oufi7pcOwCGSK2U9D8TWIjA5LA/OSwKAJsAEZNDJO8JhA/dQsiP5obat76bJpfc94HJ7hSMATAvXTrVpUzxeRYz0JyCDJIKD6kgv5fDVf+lkyDNNlUATShc4zINa5ArwjqJzMQwKeEWAD4hlKBvKAgAI/r7nuz5fM6HU8CMcQJNA0gQk9k3dt0dbzBHJy08EYIMEE9I+q7od5WWuCl4BH1l9tPOQcgezgUUiGIYHgCbABCZ45M26agCoWAO5lum7NldWZ1Vc2PYMjSMBbArvP2WPH1lrLeSJymreRGS3JBBT4fr+lFzzS5TybZA70PngCmWL2o6r4gojsMvjZnEEChhFgA2JYQSjnjQQUq1X015DaLyrdC+YTDwn4TaB+pC5gfU6Aj/idi/ETSkCxGtAfrUvhW2xEEroGBmF7feMBfFEgOw9iGoeSgNkE2ICYXR+qe52AQh+G4oerN8f/e/xw5yWyIQEvCaR7Og8Vlc8CMt3LuIxFAhskUG9ERH+8ptX9Fve/cZ28mUB7T+dHLNeqX3C5E+mQQOwIsAGJXUkTYUgVcwBctXL0s3OXT12+JhGmadIXAume3Pvh4mwRTPElAYOSwKYIrH/Si8tr7sB3l8xYsHxTw/nr8SWQvjW9tawZ+TGFniEi28fXKZ0lnoDRDQjvAUn8+twUAAVWADpbINeUu0t3QuBuag5/nQQmFrKTWoDTFXKiCLYmERIwgYCquhApALikYpfuN0ETNQRDYNLcPce5A+6ZIjgFkM2CycosJBAiAaMbEN4DEuLKiGJqfQaK3wC168v5BX+IogNq9o/AuNuzozdbhRMUcroAHf5lYmQSaJ7Aqwdx6Hcqeefa5qMxgqkEMj2dR6laHxLgaFM1UhcJ+ELA6AaET0B8qXkSgirwFIAeFRRG7qB3ODmnPwm+6fGNBEdOsWgAAAtGSURBVOpNx8iVYgM4FqLvEchwMiKBKBFQ1b9D8JN+Cz/hhvUoVW4DWhWSKeQOVgvvh+JYPoGNQU1pYWgEjG5A+ARkaEXlrDcR0JWquEWh89YNa71x2bQHVxBRfAlMmjtpK3dg2DEQOUaAI+PrlM4SR0BxhasDP6jOWLAgcd4jbjhT7MgB1vtUcQL3dkS8mJTvDQE2IN5wZJToEFDFnQBurql7Ly88jE7dNqZ0/LzJO41Y13q0CvICmRoPV3RBAhsiUL/UUGZpq/ymOn1+/WkvPwYSyMztbNOavB/A+wUy3kCJlEQC4RFgAxIee2YOn4ACLwO4D6r31FLuvUu6+h4IXxUVNEKgbW4ukxqADdGjAelsZA7HkEDsCCj+oMANbEbMqGym2DkZanUBejxEJpmhiipIwEACbEAMLAolhUxAb1fFfaJy7/Mt+tCTXc6qkAUxPYCJczr2tVxrX1HsKyIHAng7wZAACbxOQKH3QeUmgdxQzs//C9kEQyBd6DwCkG4A03lLeTDMmSUGBNiAxKCItOAzAV2oil4RPAS488t2X8nnhIkPP35ex9tG9MuBCmtvqL7WcCSeCwGQQKMEVPGQiHuDK3J9tdv5c6PzOG7TBDLFzNsVw7rrl5aKynsgGLnpWRxBAiTwBgJsQLggSGAoBPSPCnGgeMi1tLy42+kdShTOeZVAupjbX6H7WMDeUNkHgneSDQmQgDcEFOiD4m4I7rZSa3+/6KhFL3gTOTlR2ufk9pKa1p9wTAOQS45zOiUBnwiwAfEJLMMmj4Ci/srDUoU+IsBSpLCkX/sfXdq98Inkwfhvx+09e6TFTY1Tkd0toL4hcze8ujFzV/IhARIIkICirIL6XUl3udaAs7hrwaMBZjc+1W43Td5uRGrYPgLdp95sKGQfAbYwXjgFkkCUCLABiVK1qDWqBBSoCHT5v+4neRKKpwT694GUPoUB/fuSGQuWR9Xba7rrr021DshulivjIBgHxW4iMk6h4wWyQ9T9UT8JxJWAqr4iIr0KLYkrC9xUf2+1++FKXP2+5munWfuOHDN8TVo11Q5L26DI/PP+qE7+vIp75enPCAJsQIwoA0WQAAB9QRVPQfAUVJ6H6PMCPKuQF6H6vIg+D9d6XltqL0it5Xlr5NrnFx6xcKWX6Hafk9221dUxAh1T05YxFnQMxN1KgDGq1miIbg1gDCBbiWI0BFtDdSuIbOelDsYiARIIn8D629gFj0OxGKKPqmIJ1q2uVGdWXwlfXWMKJhQ7dhALu6Q0NRau7iyQXVWwC1QnisjYxqJwFAmQgOcE2IB4jpQBSYAESIAESCC+BFRfBNa/cvoXFfkroOv/G6L1f55bm6o9t2zawr/6AWDybZM3X7kSm7eKtZmV0s0FspnUWjYH8E61dBcAYwXYWYFdefeGHxVgTBLwiAAbEI9AMgwJkAAJkAAJkMDrBBSrATynov+/nbtHrTIKozB6vkow4ijstItoYaOtgkkVwRnYWjkFC0fgANTOKFhqYakRm+ssrBQEfziSwn7D/mJuYKVJ87LvyUr1EMjX5fgvufnXMubcGcvYmWOcH3PZWY6/+29TuaBLAtsusNUBcrj7YozlYNsNvY8AAQIECBAgQIAAgVBAgIRQzggQIECAAAECBAgQ6AUESG9ogQABAgQIECBAgACBUECAhFDOCBAgQIAAAQIECBDoBQRIb2iBAAECBAgQIECAAIFQQICEUM4IECBAgAABAgQIEOgFBEhvaIEAAQIECBAgQIAAgVBAgIRQzggQIECAAAECBAgQ6AUESG9ogQABAgQIECBAgACBUECAhFDOCBAgQIAAAQIECBDoBQRIb2iBAAECBAgQIECAAIFQQICEUM4IECBAgAABAgQIEOgFBEhvaIEAAQIECBAgQIAAgVBAgIRQzggQIECAAAECBAgQ6AUESG9ogQABAgQIECBAgACBUECAhFDOCBAgQIAAAQIECBDoBQRIb2iBAAECBAgQIECAAIFQQICEUM4IECBAgAABAgQIEOgFBEhvaIEAAQIECBAgQIAAgVBAgIRQzggQIECAAAECBAgQ6AUESG9ogQABAgQIECBAgACBUECAhFDOCBAgQIAAAQIECBDoBQRIb2iBAAECBAgQIECAAIFQQICEUM4IECBAgAABAgQIEOgFBEhvaIEAAQIECBAgQIAAgVBAgIRQzggQIECAAAECBAgQ6AUESG9ogQABAgQIECBAgACBUECAhFDOCBAgQIAAAQIECBDoBQRIb2iBAAECBAgQIECAAIFQQICEUM4IECBAgAABAgQIEOgFBEhvaIEAAQIECBAgQIAAgVBAgIRQzggQIECAAAECBAgQ6AUESG9ogQABAgQIECBAgACBUECAhFDOCBAgQIAAAQIECBDoBQRIb2iBAAECBAgQIECAAIFQQICEUM4IECBAgAABAgQIEOgFBEhvaIEAAQIECBAgQIAAgVBAgIRQzggQIECAAAECBAgQ6AUESG9ogQABAgQIECBAgACBUECAhFDOCBAgQIAAAQIECBDoBQRIb2iBAAECBAgQIECAAIFQQICEUM4IECBAgAABAgQIEOgFBEhvaIEAAQIECBAgQIAAgVBAgIRQzggQIECAAAECBAgQ6AUESG9ogQABAgQIECBAgACBUECAhFDOCBAgQIAAAQIECBDoBQRIb2iBAAECBAgQIECAAIFQQICEUM4IECBAgAABAgQIEOgFBEhvaIEAAQIECBAgQIAAgVBAgIRQzggQIECAAAECBAgQ6AUESG9ogQABAgQIECBAgACBUECAhFDOCBAgQIAAAQIECBDoBQRIb2iBAAECBAgQIECAAIFQQICEUM4IECBAgAABAgQIEOgFBEhvaIEAAQIECBAgQIAAgVBAgIRQzggQIECAAAECBAgQ6AUESG9ogQABAgQIECBAgACBUECAhFDOCBAgQIAAAQIECBDoBQRIb2iBAAECBAgQIECAAIFQQICEUM4IECBAgAABAgQIEOgFBEhvaIEAAQIECBAgQIAAgVBAgIRQzggQIECAAAECBAgQ6AUESG9ogQABAgQIECBAgACBUECAhFDOCBAgQIAAAQIECBDoBQRIb2iBAAECBAgQIECAAIFQQICEUM4IECBAgAABAgQIEOgFBEhvaIEAAQIECBAgQIAAgVBAgIRQzggQIECAAAECBAgQ6AUESG9ogQABAgQIECBAgACBUECAhFDOCBAgQIAAAQIECBDoBQRIb2iBAAECBAgQIECAAIFQQICEUM4IECBAgAABAgQIEOgFBEhvaIEAAQIECBAgQIAAgVBAgIRQzggQIECAAAECBAgQ6AUESG9ogQABAgQIECBAgACBUECAhFDOCBAgQIAAAQIECBDoBQRIb2iBAAECBAgQIECAAIFQQICEUM4IECBAgAABAgQIEOgFBEhvaIEAAQIECBAgQIAAgVBAgIRQzggQIECAAAECBAgQ6AW2OkBeXn0+lnGv/yktECBAgAABAgQIECCwDQJzzGebvaP7a71lWWvoeOfy4e6TZSwP19y0RYAAAQIECBAgQIDA6QnMOR9v9o8erfWCtQPk1jKWt2s9zg4BAgQIECBAgAABAqcrMJff1zZ3P39Y6xWrBsjxo668vPpuLOPmWg+0Q4AAAQIECBAgQIDA6QjMOV5v9j/eXfPTVw+QS2+uXzz368+bZYwbaz7UFgECBAgQIECAAAEC/09gzvl+/vxx+8vBl+9rfurqAfLvcVcOdx+MMe6MsVxY88G2CBAgQIAAAQIECBA4OYE55rcx5qvN3qenJ/EpJxYgJ/FYmwQIECBAgAABAgQInG0BAXK2f39eT4AAAQIECBAgQOBMCfwFEIqFltycMnEAAAAASUVORK5CYII=" preserveAspectRatio="none" width="100%" height="100%"></image></symbol><symbol id="image-2ae5acf4f56a6b5cc88c7dbbc9d4014410b02ca6f713249bed10e29271c47ca25e6b025260c33ad6f4c9db2c86f944b8"><image href="data:image/png;base64,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" preserveAspectRatio="none" width="100%" height="100%"></image></symbol><style class="style-fonts">
+      @font-face { font-family: Excalifont; src: url(data:font/woff2;base64,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); }</style></defs><rect x="0" y="0" width="1044.52734375" height="467.8006869612069" fill="#ffffff"></rect><g stroke-linecap="round"><g transform="translate(66.68359375 348.6385775862069) rotate(0 447.056640625 0.3046875)"><path d="M0 0 C189.69 0.13, 379.37 0.26, 894.11 0.61 M0 0 C339.52 0.23, 679.05 0.46, 894.11 0.61" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(66.68359375 348.6385775862069) rotate(0 447.056640625 0.3046875)"><path d="M23.5 -8.53 C18.51 -6.72, 13.53 -4.91, 0 0 M23.5 -8.53 C14.58 -5.29, 5.65 -2.05, 0 0" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(66.68359375 348.6385775862069) rotate(0 447.056640625 0.3046875)"><path d="M23.49 8.57 C18.5 6.75, 13.52 4.93, 0 0 M23.49 8.57 C14.57 5.31, 5.65 2.06, 0 0" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(66.68359375 348.6385775862069) rotate(0 447.056640625 0.3046875)"><path d="M870.62 9.14 C875.6 7.33, 880.59 5.52, 894.11 0.61 M870.62 9.14 C879.54 5.9, 888.46 2.66, 894.11 0.61" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g><g transform="translate(66.68359375 348.6385775862069) rotate(0 447.056640625 0.3046875)"><path d="M870.63 -7.96 C875.61 -6.14, 880.59 -4.32, 894.11 0.61 M870.63 -7.96 C879.55 -4.7, 888.46 -1.45, 894.11 0.61" stroke="#1e1e1e" stroke-width="2" fill="none"></path></g></g><mask></mask><g transform="translate(65.515625 376.1581088362069) rotate(0 95.85773814976221 37.798828125)"><text x="0" y="26.6406140625" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="30.239062500000003px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">Completely</text><text x="0" y="64.43944218749999" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="30.239062500000003px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">Deterministic</text></g><g transform="translate(56.9765625 197.0917025862069) rotate(0 83.734375 83.734375)"><use href="#image-2ae5acf4f56a6b5cc88c7dbbc9d4014410b02ca6f713249bed10e29271c47ca25e6b025260c33ad6f4c9db2c86f944b8" width="167" height="167" opacity="1"></use></g><g transform="translate(10 109.8182650862069) rotate(0 57.779296875 57.779296875)"><use href="#image-3380d919c79e57fb90b77f82462627ddf0081e4646147056cf39e7688f0f939de154b5770fd90d543a9230c11af30bbe" width="116" height="116" opacity="1"></use></g><g transform="translate(144.59765625 10) rotate(0 75.115234375 109.30561691810345)"><use href="#image-fd5a0e89e39657b09e80610a7478867ebf1143f0fdc2649a58e7e2b2e4007d0acfce91b931249ad9862e52bdcb921319" width="150" height="219" opacity="1"></use></g><g transform="translate(801.6131248348952 382.2030307112069) rotate(0 76.52721804380417 37.798828125)"><text x="153.05443608760834" y="26.6406140625" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="30.239062500000003px" fill="#1e1e1e" text-anchor="end" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">Completely</text><text x="153.05443608760834" y="64.43944218749999" font-family="Excalifont, Xiaolai, Segoe UI Emoji" font-size="30.239062500000003px" fill="#1e1e1e" text-anchor="end" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">Agentic</text></g><g transform="translate(707.5625 123.9276400862069) rotate(0 84.111328125 84.111328125)"><use href="#image-abb8a09bad8a00e9e45b10d3c3a2b973ade8007325351468d2bfe860b99e3e2170f2c187061f2331c06c89529f998279" width="168" height="168" opacity="1"></use></g><g transform="translate(870.0078125 138.3377963362069) rotate(0 82.259765625 82.259765625)"><use href="#image-586b60642e948451d54ea19202de939285026ebd9adc5cf4d370715693e9b4d8dd63b367a9d09937ba0c53d300441eb4" width="165" height="165" opacity="1"></use></g><g transform="translate(754.8282948369565 270.1752963362069) rotate(0 118.62563938618916 32.21015625000001)"><use href="#image-aa1b51a5a56b73096388e3f04e434974ae7b55a8f9571012d44d6a17bdfed96ab885ddcfbf9de8e98411a6343ea5f623" width="237" height="64" opacity="1"></use></g></svg>
\ No newline at end of file
diff --git a/packages/docs/images/evals.png b/packages/docs/images/evals.png
new file mode 100644
index 000000000..1ed5c2e5a
Binary files /dev/null and b/packages/docs/images/evals.png differ
diff --git a/packages/docs/images/favicon.svg b/packages/docs/images/favicon.svg
new file mode 100644
index 000000000..2d18ca7f1
--- /dev/null
+++ b/packages/docs/images/favicon.svg
@@ -0,0 +1,13 @@
+<svg width="40" height="40" viewBox="0 0 40 40" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_1005_777)">
+<rect width="40" height="40" fill="#FFC83C"/>
+<path d="M40 0H0V39.1042H40V0Z" fill="#FFC83C"/>
+<path d="M28.2317 10.1157C28.2317 8.86018 27.0391 7.83838 25.7836 7.83838C24.528 7.83838 23.4096 8.86018 23.4096 10.1157L23.4068 14.2225C23.0177 13.9776 22.56 13.8334 22.0673 13.8334C21.2554 13.8334 20.536 14.2183 20.0755 14.8132C19.6192 14.1707 18.8703 13.7508 18.0221 13.7508C17.5266 13.7508 17.0647 13.8964 16.6755 14.1441V12.61C16.6755 11.3545 15.4844 10.2305 14.2288 10.2305C12.9733 10.2305 11.6953 11.3545 11.6953 12.61V22.3927C11.6953 22.4977 11.7037 22.5999 11.7107 22.6545L11.7079 22.7735C11.7079 27.4542 15.1736 31.2628 19.8543 31.2628C27.0503 31.2628 28.2989 24.6995 28.2989 19.8256L28.2345 10.1143L28.2317 10.1157Z" fill="white"/>
+<path d="M28.2317 10.1157C28.2317 8.86018 27.0391 7.83838 25.7836 7.83838C24.528 7.83838 23.4096 8.86018 23.4096 10.1157L23.4068 14.2225C23.0177 13.9776 22.56 13.8334 22.0673 13.8334C21.2554 13.8334 20.536 14.2183 20.0755 14.8132C19.6192 14.1707 18.8703 13.7508 18.0221 13.7508C17.5266 13.7508 17.0647 13.8964 16.6755 14.1441V12.61C16.6755 11.3545 15.4844 10.2305 14.2288 10.2305C12.9733 10.2305 11.6953 11.3545 11.6953 12.61V22.3927C11.6953 22.4977 11.7037 22.5999 11.7107 22.6545L11.7079 22.7735C11.7079 27.4542 15.1736 31.2628 19.8543 31.2628C27.0503 31.2628 28.2989 24.6995 28.2989 19.8256L28.2345 10.1143L28.2317 10.1157ZM20.7306 16.3543C20.7306 15.6167 21.3296 15.0176 22.0673 15.0176C22.8049 15.0176 23.404 15.6167 23.404 16.3543V17.8408H21.6292C21.3128 17.8408 21.0105 17.9052 20.7306 18.0172V16.3543ZM16.6839 16.2717C16.6839 15.5341 17.283 14.935 18.0207 14.935C18.7583 14.935 19.3574 15.5341 19.3574 16.2717V18.1936C19.3574 18.9312 18.7569 19.5303 18.0207 19.5303C17.2844 19.5303 16.6839 18.9312 16.6839 18.1936V16.2717ZM26.9047 23.0198C26.9047 23.0198 26.9047 23.0268 26.9047 23.0296C26.6836 24.5175 26.2973 25.7871 25.7416 26.8173C24.5546 29.0218 22.6286 30.0926 19.8515 30.0926C15.9449 30.0926 12.8823 26.8845 12.8753 22.7875L12.8781 22.6825V22.5845L12.8683 22.5019C12.8669 22.4865 12.8627 22.4389 12.8627 22.3927V12.61C12.8627 12.0334 13.5765 11.4007 14.226 11.4007C14.8755 11.4007 15.5026 12.0222 15.5026 12.61V16.2143C15.5026 16.2339 15.4998 16.2521 15.4998 16.2717V18.1936C15.4998 19.5863 16.628 20.7145 18.0207 20.7145C18.477 20.7145 18.9011 20.5899 19.2706 20.3771C19.2706 20.3715 19.2706 20.3659 19.2706 20.3603C19.3196 20.8502 19.5212 21.3164 19.8557 21.6845C20.1889 22.0498 20.6298 22.2962 21.1071 22.3927C20.1315 23.1612 19.6038 24.26 19.6038 25.6037C19.6038 25.9271 19.8655 26.1888 20.1889 26.1888C20.5122 26.1888 20.7739 25.9271 20.7739 25.6037C20.7739 23.3418 22.7728 22.6559 23.9639 22.4487C24.5434 22.3479 24.5336 21.8944 24.5252 21.8049C24.521 21.7503 24.4622 21.2674 23.8729 21.2674H21.5536C21.2373 21.2674 20.9321 21.133 20.7194 20.8978C20.5024 20.6599 20.4016 20.3505 20.4324 20.0272C20.487 19.4575 21.0119 19.0124 21.6278 19.0124H24.4174C24.4552 19.0194 24.4944 19.0236 24.535 19.0236C25.3706 19.0236 25.9977 19.2616 26.398 19.7305C26.9621 20.3897 27.1371 21.5277 26.9033 23.0198H26.9047ZM24.7044 17.859C24.6666 17.8492 24.6274 17.845 24.5868 17.8436V16.3543C24.5868 16.3081 24.5826 16.2633 24.5798 16.2185V10.1157C24.5798 9.53625 25.1537 9.00995 25.7836 9.00995C26.4134 9.00995 27.0601 9.54745 27.0601 10.1241L27.1175 18.7926C26.5254 18.2048 25.715 17.8926 24.703 17.8604L24.7044 17.859Z" fill="black"/>
+</g>
+<defs>
+<clipPath id="clip0_1005_777">
+<rect width="40" height="40" fill="white"/>
+</clipPath>
+</defs>
+</svg>
diff --git a/packages/docs/images/light_license.svg b/packages/docs/images/light_license.svg
new file mode 100644
index 000000000..a6270ab54
--- /dev/null
+++ b/packages/docs/images/light_license.svg
@@ -0,0 +1,11 @@
+<svg width="117" height="29" viewBox="0 0 117 29" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M3 0.5H74.5V28.5H3C1.61929 28.5 0.5 27.3807 0.5 26V3C0.5 1.61929 1.61929 0.5 3 0.5Z" fill="#100D0D"/>
+<path d="M3 0.5H74.5V28.5H3C1.61929 28.5 0.5 27.3807 0.5 26V3C0.5 1.61929 1.61929 0.5 3 0.5Z" stroke="#635943"/>
+<path d="M9.51914 9.06H10.7231V17.852H15.6791V19H9.51914V9.06ZM17.6337 17.964H20.6157V12.616H17.7737V11.58H21.7917V17.964H24.3537V19H17.6337V17.964ZM20.5037 9.046H21.7357V10.418H20.5037V9.046ZM29.3042 19.168C28.6229 19.168 28.0209 19.0093 27.4982 18.692C26.9849 18.3747 26.5882 17.922 26.3082 17.334C26.0282 16.746 25.8882 16.0647 25.8882 15.29C25.8882 14.5153 26.0282 13.834 26.3082 13.246C26.5882 12.658 26.9849 12.2053 27.4982 11.888C28.0209 11.5707 28.6229 11.412 29.3042 11.412C30.1349 11.412 30.8209 11.636 31.3622 12.084C31.9129 12.532 32.2629 13.1667 32.4122 13.988L31.1802 14.072C31.0682 13.5867 30.8442 13.2087 30.5082 12.938C30.1815 12.6673 29.7802 12.532 29.3042 12.532C28.6229 12.532 28.0862 12.7793 27.6942 13.274C27.3115 13.7593 27.1202 14.4313 27.1202 15.29C27.1202 16.1487 27.3115 16.8253 27.6942 17.32C28.0862 17.8053 28.6229 18.048 29.3042 18.048C29.7989 18.048 30.2142 17.9033 30.5502 17.614C30.8955 17.3247 31.1242 16.9093 31.2362 16.368L32.4682 16.452C32.3095 17.2827 31.9455 17.9453 31.3762 18.44C30.8162 18.9253 30.1255 19.168 29.3042 19.168ZM37.6287 19.168C36.9381 19.168 36.3361 19.0093 35.8227 18.692C35.3094 18.3747 34.9127 17.9267 34.6327 17.348C34.3621 16.76 34.2267 16.074 34.2267 15.29C34.2267 14.5153 34.3621 13.834 34.6327 13.246C34.9127 12.658 35.3047 12.2053 35.8087 11.888C36.3127 11.5707 36.9007 11.412 37.5727 11.412C38.2167 11.412 38.7861 11.566 39.2807 11.874C39.7847 12.1727 40.1721 12.616 40.4427 13.204C40.7227 13.792 40.8627 14.492 40.8627 15.304V15.654H35.4587C35.4961 16.438 35.7014 17.0353 36.0747 17.446C36.4574 17.8473 36.9754 18.048 37.6287 18.048C38.1047 18.048 38.4967 17.9407 38.8047 17.726C39.1221 17.502 39.3461 17.194 39.4767 16.802L40.7367 16.9C40.5407 17.5813 40.1627 18.132 39.6027 18.552C39.0521 18.9627 38.3941 19.168 37.6287 19.168ZM39.5747 14.618C39.5187 13.9273 39.3134 13.4093 38.9587 13.064C38.6041 12.7093 38.1421 12.532 37.5727 12.532C36.9941 12.532 36.5181 12.7093 36.1447 13.064C35.7807 13.4187 35.5521 13.9367 35.4587 14.618H39.5747ZM43.0413 11.58H44.1193L44.1473 12.91C44.3339 12.4153 44.6279 12.042 45.0293 11.79C45.4306 11.538 45.8973 11.412 46.4293 11.412C47.2413 11.412 47.8573 11.6733 48.2773 12.196C48.7066 12.7187 48.9213 13.3953 48.9213 14.226V19H47.7453V14.562C47.7453 13.862 47.6193 13.3347 47.3673 12.98C47.1246 12.6253 46.7279 12.448 46.1773 12.448C45.5893 12.448 45.1133 12.6347 44.7493 13.008C44.3946 13.372 44.2173 13.89 44.2173 14.562V19H43.0413V11.58ZM54.4318 19.168C53.8065 19.168 53.2558 19.0607 52.7798 18.846C52.3131 18.622 51.9445 18.3233 51.6738 17.95C51.4031 17.5673 51.2491 17.138 51.2118 16.662L52.4438 16.578C52.5185 17.0447 52.7238 17.4087 53.0598 17.67C53.3958 17.922 53.8531 18.048 54.4318 18.048C54.9918 18.048 55.4211 17.9687 55.7198 17.81C56.0185 17.642 56.1678 17.3947 56.1678 17.068C56.1678 16.844 56.1165 16.6667 56.0138 16.536C55.9111 16.396 55.7198 16.2793 55.4398 16.186C55.1691 16.0833 54.7585 15.9853 54.2078 15.892C53.4985 15.7707 52.9385 15.612 52.5278 15.416C52.1265 15.22 51.8371 14.982 51.6598 14.702C51.4918 14.422 51.4078 14.072 51.4078 13.652C51.4078 12.9893 51.6551 12.4527 52.1498 12.042C52.6445 11.622 53.3351 11.412 54.2218 11.412C55.0898 11.412 55.7758 11.636 56.2798 12.084C56.7931 12.532 57.1105 13.1013 57.2318 13.792L55.9998 13.876C55.9158 13.4653 55.7151 13.1387 55.3978 12.896C55.0898 12.6533 54.6931 12.532 54.2078 12.532C53.6851 12.532 53.2885 12.6347 53.0178 12.84C52.7471 13.0453 52.6118 13.316 52.6118 13.652C52.6118 13.904 52.6725 14.1047 52.7938 14.254C52.9151 14.394 53.1018 14.5107 53.3538 14.604C53.6151 14.688 53.9838 14.772 54.4598 14.856C55.2251 14.9773 55.8178 15.1313 56.2378 15.318C56.6578 15.5047 56.9518 15.738 57.1198 16.018C57.2878 16.2887 57.3718 16.6387 57.3718 17.068C57.3718 17.712 57.0965 18.2253 56.5458 18.608C55.9951 18.9813 55.2905 19.168 54.4318 19.168ZM62.8123 19.168C62.1217 19.168 61.5197 19.0093 61.0063 18.692C60.493 18.3747 60.0963 17.9267 59.8163 17.348C59.5457 16.76 59.4103 16.074 59.4103 15.29C59.4103 14.5153 59.5457 13.834 59.8163 13.246C60.0963 12.658 60.4883 12.2053 60.9923 11.888C61.4963 11.5707 62.0843 11.412 62.7563 11.412C63.4003 11.412 63.9697 11.566 64.4643 11.874C64.9683 12.1727 65.3557 12.616 65.6263 13.204C65.9063 13.792 66.0463 14.492 66.0463 15.304V15.654H60.6423C60.6797 16.438 60.885 17.0353 61.2583 17.446C61.641 17.8473 62.159 18.048 62.8123 18.048C63.2883 18.048 63.6803 17.9407 63.9883 17.726C64.3057 17.502 64.5297 17.194 64.6603 16.802L65.9203 16.9C65.7243 17.5813 65.3463 18.132 64.7863 18.552C64.2357 18.9627 63.5777 19.168 62.8123 19.168ZM64.7583 14.618C64.7023 13.9273 64.497 13.4093 64.1423 13.064C63.7877 12.7093 63.3257 12.532 62.7563 12.532C62.1777 12.532 61.7017 12.7093 61.3283 13.064C60.9643 13.4187 60.7357 13.9367 60.6423 14.618H64.7583Z" fill="#FFDC83"/>
+<mask id="path-3-inside-1_2074_1480" fill="white">
+<path d="M75 0H114C115.657 0 117 1.34315 117 3V26C117 27.6569 115.657 29 114 29H75V0Z"/>
+</mask>
+<path d="M75 0H114C115.657 0 117 1.34315 117 3V26C117 27.6569 115.657 29 114 29H75V0Z" fill="#FFDC83"/>
+<path d="M75 -1H114C116.209 -1 118 0.790861 118 3H116C116 1.89543 115.105 1 114 1H75V-1ZM118 26C118 28.2091 116.209 30 114 30H75V28H114C115.105 28 116 27.1046 116 26H118ZM75 29V0V29ZM114 -1C116.209 -1 118 0.790861 118 3V26C118 28.2091 116.209 30 114 30V28C115.105 28 116 27.1046 116 26V3C116 1.89543 115.105 1 114 1V-1Z" fill="#635943" mask="url(#path-3-inside-1_2074_1480)"/>
+<path d="M85.044 10.67V19H83.84V9.06H85.66L87.2 15.976L88.74 9.06H90.56V19H89.356V10.67L87.732 17.88H86.668L85.044 10.67ZM92.5145 17.852H94.9925V10.208H92.5145V9.06H98.6745V10.208H96.1965V17.852H98.6745V19H92.5145V17.852ZM103.387 10.208H100.349V9.06H107.629V10.208H104.591V19H103.387V10.208Z" fill="#100D0D"/>
+</svg>
diff --git a/packages/docs/images/light_npm.svg b/packages/docs/images/light_npm.svg
new file mode 100644
index 000000000..4f6c67464
--- /dev/null
+++ b/packages/docs/images/light_npm.svg
@@ -0,0 +1,11 @@
+<svg width="109" height="29" viewBox="0 0 109 29" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M3 0.5H41.5V28.5H3C1.61929 28.5 0.5 27.3807 0.5 26V3C0.5 1.61929 1.61929 0.5 3 0.5Z" fill="#100D0D"/>
+<path d="M3 0.5H41.5V28.5H3C1.61929 28.5 0.5 27.3807 0.5 26V3C0.5 1.61929 1.61929 0.5 3 0.5Z" stroke="#635943"/>
+<path d="M9.7522 11.58H10.8302L10.8582 12.91C11.0449 12.4153 11.3389 12.042 11.7402 11.79C12.1415 11.538 12.6082 11.412 13.1402 11.412C13.9522 11.412 14.5682 11.6733 14.9882 12.196C15.4175 12.7187 15.6322 13.3953 15.6322 14.226V19H14.4562V14.562C14.4562 13.862 14.3302 13.3347 14.0782 12.98C13.8355 12.6253 13.4389 12.448 12.8882 12.448C12.3002 12.448 11.8242 12.6347 11.4602 13.008C11.1055 13.372 10.9282 13.89 10.9282 14.562V19H9.7522V11.58ZM17.9227 11.58H19.0147L19.0287 12.77C19.2527 12.3313 19.5607 11.9953 19.9527 11.762C20.3541 11.5287 20.8067 11.412 21.3107 11.412C22.0201 11.412 22.6127 11.5893 23.0887 11.944C23.5647 12.2893 23.9194 12.756 24.1527 13.344C24.3861 13.932 24.5027 14.5807 24.5027 15.29C24.5027 15.9993 24.3861 16.648 24.1527 17.236C23.9194 17.824 23.5647 18.2953 23.0887 18.65C22.6127 18.9953 22.0201 19.168 21.3107 19.168C20.8254 19.168 20.3821 19.0653 19.9807 18.86C19.5887 18.6547 19.2947 18.3747 19.0987 18.02V21.1H17.9227V11.58ZM21.1987 18.048C21.8427 18.048 22.3467 17.8053 22.7107 17.32C23.0841 16.8347 23.2707 16.158 23.2707 15.29C23.2707 14.422 23.0841 13.7453 22.7107 13.26C22.3467 12.7747 21.8427 12.532 21.1987 12.532C20.5454 12.532 20.0321 12.77 19.6587 13.246C19.2854 13.7127 19.0987 14.394 19.0987 15.29C19.0987 16.186 19.2807 16.872 19.6447 17.348C20.0181 17.8147 20.5361 18.048 21.1987 18.048ZM25.7573 11.58H26.8353L26.8633 12.672C26.9939 12.2707 27.1853 11.9627 27.4373 11.748C27.6893 11.524 27.9879 11.412 28.3333 11.412C29.0986 11.412 29.5653 11.8973 29.7333 12.868C29.8546 12.4107 30.0553 12.056 30.3353 11.804C30.6153 11.5427 30.9466 11.412 31.3293 11.412C31.9266 11.412 32.3606 11.622 32.6313 12.042C32.9019 12.462 33.0373 13.148 33.0373 14.1V19H31.8613V14.24C31.8613 13.596 31.7913 13.1387 31.6513 12.868C31.5113 12.588 31.2919 12.448 30.9933 12.448C30.6853 12.448 30.4379 12.602 30.2513 12.91C30.0739 13.2087 29.9853 13.6613 29.9853 14.268V19H28.8093V14.24C28.8093 13.6053 28.7393 13.148 28.5993 12.868C28.4686 12.588 28.2493 12.448 27.9413 12.448C27.6333 12.448 27.3859 12.602 27.1993 12.91C27.0219 13.2087 26.9333 13.6613 26.9333 14.268V19H25.7573V11.58Z" fill="#FFDC83"/>
+<mask id="path-3-inside-1_2074_1475" fill="white">
+<path d="M42 0H106C107.657 0 109 1.34315 109 3V26C109 27.6569 107.657 29 106 29H42V0Z"/>
+</mask>
+<path d="M42 0H106C107.657 0 109 1.34315 109 3V26C109 27.6569 107.657 29 106 29H42V0Z" fill="#FFDC83"/>
+<path d="M42 -1H106C108.209 -1 110 0.790861 110 3H108C108 1.89543 107.105 1 106 1H42V-1ZM110 26C110 28.2091 108.209 30 106 30H42V28H106C107.105 28 108 27.1046 108 26H110ZM42 29V0V29ZM106 -1C108.209 -1 110 0.790861 110 3V26C110 28.2091 108.209 30 106 30V28C107.105 28 108 27.1046 108 26V3C108 1.89543 107.105 1 106 1V-1Z" fill="#635943" mask="url(#path-3-inside-1_2074_1475)"/>
+<path d="M50.756 11.58H52.044L54.2 17.796L56.356 11.58H57.644L54.942 19H53.458L50.756 11.58ZM59.2345 17.852H62.3705V11.636H59.7665V10.6H61.1105C61.6425 10.6 62.0205 10.4833 62.2445 10.25C62.4779 10.0167 62.5945 9.62 62.5945 9.06H63.5745V17.852H65.9545V19H59.2345V17.852ZM70.1491 17.32H71.8291V19H70.1491V17.32ZM79.3556 19.224C78.4036 19.224 77.6289 18.972 77.0316 18.468C76.4343 17.9547 76.0983 17.278 76.0236 16.438L77.2836 16.354C77.3489 16.9047 77.5636 17.3247 77.9276 17.614C78.2916 17.9033 78.7676 18.048 79.3556 18.048C80.0089 18.048 80.5269 17.8473 80.9096 17.446C81.2923 17.0447 81.4836 16.4987 81.4836 15.808C81.4836 15.108 81.2969 14.5573 80.9236 14.156C80.5503 13.7453 80.0369 13.54 79.3836 13.54C78.9823 13.54 78.6043 13.638 78.2496 13.834C77.8949 14.03 77.6383 14.3007 77.4796 14.646H76.1916L76.8496 9.06H82.1416V10.236H77.9556L77.5916 13.232C77.8249 12.9613 78.1189 12.756 78.4736 12.616C78.8283 12.4667 79.1876 12.392 79.5516 12.392C80.1769 12.392 80.7323 12.5413 81.2176 12.84C81.7029 13.1293 82.0763 13.5353 82.3376 14.058C82.6083 14.5713 82.7436 15.1547 82.7436 15.808C82.7436 16.4707 82.5989 17.0633 82.3096 17.586C82.0203 18.0993 81.6189 18.5007 81.1056 18.79C80.5923 19.0793 80.0089 19.224 79.3556 19.224ZM86.9381 17.32H88.6181V19H86.9381V17.32ZM96.1727 19.224C95.454 19.224 94.8333 19.0187 94.3107 18.608C93.788 18.188 93.382 17.5907 93.0927 16.816C92.8127 16.032 92.6727 15.108 92.6727 14.044C92.6727 12.98 92.8127 12.056 93.0927 11.272C93.382 10.488 93.788 9.886 94.3107 9.466C94.8427 9.046 95.4633 8.836 96.1727 8.836C96.882 8.836 97.498 9.046 98.0207 9.466C98.5527 9.886 98.9587 10.488 99.2387 11.272C99.528 12.056 99.6727 12.98 99.6727 14.044C99.6727 15.108 99.528 16.032 99.2387 16.816C98.9587 17.5907 98.5573 18.188 98.0347 18.608C97.512 19.0187 96.8913 19.224 96.1727 19.224ZM96.1727 18.048C96.8727 18.048 97.4187 17.6887 97.8107 16.97C98.212 16.2513 98.4127 15.276 98.4127 14.044C98.4127 13.1013 98.296 12.3033 98.0627 11.65L94.8707 17.46C95.2347 17.852 95.6687 18.048 96.1727 18.048ZM93.9327 14.044C93.9327 14.9773 94.0493 15.7707 94.2827 16.424L97.4747 10.614C97.12 10.2127 96.686 10.012 96.1727 10.012C95.4727 10.012 94.922 10.376 94.5207 11.104C94.1287 11.8227 93.9327 12.8027 93.9327 14.044Z" fill="#100D0D"/>
+</svg>
diff --git a/packages/docs/images/light_slack.svg b/packages/docs/images/light_slack.svg
new file mode 100644
index 000000000..87bfc3df2
--- /dev/null
+++ b/packages/docs/images/light_slack.svg
@@ -0,0 +1,27 @@
+<svg width="254" height="29" viewBox="0 0 254 29" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M3 0.5H85.5V28.5H3C1.61929 28.5 0.5 27.3807 0.5 26V3C0.5 1.61929 1.61929 0.5 3 0.5Z" fill="#100D0D"/>
+<path d="M3 0.5H85.5V28.5H3C1.61929 28.5 0.5 27.3807 0.5 26V3C0.5 1.61929 1.61929 0.5 3 0.5Z" stroke="#635943"/>
+<g clip-path="url(#clip0_2074_1485)">
+<mask id="mask0_2074_1485" style="mask-type:luminance" maskUnits="userSpaceOnUse" x="12" y="6" width="16" height="17">
+<path d="M28 6.5H12V22.5H28V6.5Z" fill="white"/>
+</mask>
+<g mask="url(#mask0_2074_1485)">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M17.8406 6.53941C17.6312 6.5396 17.4239 6.58104 17.2305 6.66137C17.0371 6.74169 16.8614 6.85932 16.7135 7.00754C16.5656 7.15576 16.4483 7.33167 16.3684 7.52521C16.2885 7.71876 16.2475 7.92615 16.2477 8.13555C16.2475 8.34493 16.2886 8.55229 16.3685 8.74581C16.4484 8.93932 16.5657 9.11519 16.7136 9.26338C16.8616 9.41157 17.0372 9.52917 17.2306 9.60947C17.4239 9.68978 17.6312 9.73121 17.8406 9.73141H19.4335V8.13555C19.4337 7.92615 19.3927 7.71876 19.3128 7.52521C19.2329 7.33167 19.1156 7.15576 18.9677 7.00754C18.8197 6.85932 18.6441 6.74169 18.4507 6.66137C18.2573 6.58104 18.05 6.5396 17.8406 6.53941ZM17.8406 10.7957H13.5929C13.3835 10.7959 13.1762 10.8373 12.9829 10.9176C12.7895 10.9979 12.6138 11.1155 12.4659 11.2637C12.318 11.4119 12.2007 11.5878 12.1208 11.7813C12.0409 11.9748 11.9998 12.1822 12 12.3916C11.9998 12.601 12.0408 12.8084 12.1207 13.0019C12.2006 13.1955 12.3179 13.3713 12.4658 13.5196C12.6137 13.6678 12.7894 13.7854 12.9828 13.8657C13.1762 13.9461 13.3835 13.9875 13.5929 13.9877H17.8406C18.05 13.9875 18.2573 13.9461 18.4507 13.8657C18.6441 13.7854 18.8197 13.6678 18.9677 13.5196C19.1156 13.3713 19.2329 13.1955 19.3128 13.0019C19.3927 12.8084 19.4337 12.601 19.4335 12.3916C19.4337 12.1822 19.3926 11.9748 19.3127 11.7813C19.2327 11.5878 19.1155 11.4119 18.9675 11.2637C18.8197 11.1155 18.644 10.9979 18.4506 10.9176C18.2573 10.8373 18.05 10.7959 17.8406 10.7957Z" fill="#FFDC83"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M27.9286 12.3916C27.9288 12.1822 27.8877 11.9748 27.8078 11.7813C27.7279 11.5878 27.6106 11.4119 27.4627 11.2637C27.3147 11.1155 27.1391 10.9979 26.9457 10.9176C26.7523 10.8373 26.5451 10.7959 26.3357 10.7957C26.1263 10.7959 25.9191 10.8373 25.7257 10.9176C25.5323 10.9979 25.3567 11.1155 25.2087 11.2637C25.0608 11.4119 24.9435 11.5878 24.8636 11.7813C24.7837 11.9748 24.7426 12.1822 24.7428 12.3916V13.9877H26.3357C26.5451 13.9875 26.7524 13.9461 26.9458 13.8657C27.1392 13.7854 27.3149 13.6678 27.4627 13.5196C27.6107 13.3713 27.7279 13.1955 27.8079 13.0019C27.8878 12.8084 27.9288 12.601 27.9286 12.3916ZM23.6809 12.3916V8.13555C23.6811 7.92615 23.6401 7.71876 23.5602 7.52521C23.4803 7.33167 23.363 7.15576 23.2151 7.00754C23.0671 6.85932 22.8915 6.74169 22.6981 6.66137C22.5047 6.58104 22.2974 6.5396 22.088 6.53941C21.8786 6.5396 21.6713 6.58104 21.4779 6.66137C21.2845 6.74169 21.1089 6.85932 20.9609 7.00754C20.813 7.15576 20.6957 7.33167 20.6158 7.52521C20.5359 7.71876 20.4949 7.92615 20.4951 8.13555V12.3916C20.4949 12.601 20.5359 12.8084 20.6158 13.0019C20.6957 13.1955 20.813 13.3713 20.9609 13.5196C21.1089 13.6678 21.2845 13.7854 21.4779 13.8657C21.6713 13.9461 21.8786 13.9875 22.088 13.9877C22.2974 13.9875 22.5047 13.9461 22.6981 13.8657C22.8915 13.7854 23.0671 13.6678 23.2151 13.5196C23.363 13.3713 23.4803 13.1955 23.5602 13.0019C23.6401 12.8084 23.6811 12.601 23.6809 12.3916Z" fill="#FFDC83"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M22.088 22.5C22.2974 22.4998 22.5047 22.4583 22.6981 22.3781C22.8915 22.2977 23.0671 22.1801 23.2151 22.0319C23.363 21.8837 23.4803 21.7077 23.5602 21.5142C23.6401 21.3207 23.6811 21.1133 23.6809 20.9039C23.6811 20.6945 23.6401 20.4871 23.5601 20.2936C23.4801 20.1001 23.3629 19.9242 23.2149 19.776C23.0671 19.6279 22.8914 19.5103 22.698 19.4299C22.5047 19.3496 22.2974 19.3082 22.088 19.308H20.4951V20.9039C20.4949 21.1133 20.5359 21.3207 20.6158 21.5142C20.6957 21.7077 20.813 21.8837 20.9609 22.0319C21.1089 22.1801 21.2845 22.2977 21.4779 22.3781C21.6713 22.4583 21.8786 22.4998 22.088 22.5ZM22.088 18.2437H26.3357C26.5451 18.2435 26.7523 18.2021 26.9457 18.1218C27.1391 18.0415 27.3147 17.9239 27.4627 17.7757C27.6106 17.6275 27.7279 17.4516 27.8078 17.2581C27.8877 17.0646 27.9288 16.8572 27.9286 16.6479C27.9288 16.4385 27.8878 16.2311 27.8079 16.0375C27.7279 15.8439 27.6107 15.6681 27.4627 15.5199C27.3149 15.3716 27.1392 15.254 26.9458 15.1737C26.7524 15.0933 26.5451 15.0519 26.3357 15.0517H22.088C21.8786 15.0519 21.6713 15.0933 21.4779 15.1737C21.2845 15.254 21.1089 15.3716 20.9609 15.5199C20.813 15.6681 20.6957 15.8439 20.6158 16.0375C20.5359 16.2311 20.4949 16.4385 20.4951 16.6479C20.4949 16.8572 20.5359 17.0646 20.6159 17.2581C20.6959 17.4516 20.8131 17.6275 20.9611 17.7757C21.1089 17.9239 21.2846 18.0415 21.478 18.1218C21.6713 18.2021 21.8786 18.2435 22.088 18.2437Z" fill="#FFDC83"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M12 16.6479C11.9998 16.8572 12.0409 17.0646 12.1208 17.2581C12.2007 17.4516 12.318 17.6275 12.4659 17.7757C12.6138 17.9239 12.7895 18.0415 12.9829 18.1218C13.1762 18.2021 13.3835 18.2435 13.5929 18.2437C13.8023 18.2435 14.0096 18.2021 14.2029 18.1218C14.3963 18.0415 14.5719 17.9239 14.7198 17.7757C14.8678 17.6275 14.985 17.4516 15.065 17.2581C15.1449 17.0646 15.186 16.8572 15.1858 16.6479V15.0517H13.5929C13.3835 15.0519 13.1761 15.0933 12.9827 15.1737C12.7893 15.254 12.6136 15.3717 12.4657 15.5199C12.3178 15.6682 12.2005 15.8441 12.1206 16.0377C12.0407 16.2313 11.9997 16.4384 12 16.6479ZM16.2477 16.6479V20.9039C16.2475 21.1133 16.2885 21.3207 16.3684 21.5142C16.4483 21.7077 16.5656 21.8837 16.7135 22.0319C16.8615 22.1801 17.0371 22.2977 17.2305 22.3781C17.4239 22.4583 17.6312 22.4998 17.8406 22.5C18.05 22.4998 18.2573 22.4583 18.4507 22.3781C18.6441 22.2977 18.8197 22.1801 18.9677 22.0319C19.1156 21.8837 19.2329 21.7077 19.3128 21.5142C19.3927 21.3207 19.4337 21.1133 19.4335 20.9039V16.6481C19.4337 16.4387 19.3927 16.2313 19.3128 16.0378C19.2329 15.8443 19.1156 15.6683 18.9677 15.5201C18.8197 15.3719 18.6441 15.2543 18.4507 15.1739C18.2573 15.0937 18.05 15.0522 17.8406 15.052C17.6312 15.0522 17.4239 15.0937 17.2305 15.1739C17.0371 15.2543 16.8615 15.3719 16.7135 15.5201C16.5656 15.6683 16.4483 15.8443 16.3684 16.0378C16.2885 16.2313 16.2475 16.4385 16.2477 16.6479Z" fill="#FFDC83"/>
+</g>
+</g>
+<path d="M36.3117 19.224C35.2103 19.224 34.333 18.9067 33.6797 18.272C33.0357 17.628 32.6763 16.7787 32.6017 15.724L34.3237 15.626C34.417 16.27 34.6363 16.7693 34.9817 17.124C35.327 17.4787 35.7797 17.656 36.3397 17.656C36.8997 17.656 37.3243 17.544 37.6137 17.32C37.9123 17.0867 38.0617 16.774 38.0617 16.382C38.0617 16.0927 37.9917 15.85 37.8517 15.654C37.721 15.4487 37.4923 15.2667 37.1657 15.108C36.839 14.9493 36.377 14.7953 35.7797 14.646C34.7343 14.394 33.9737 14.0487 33.4977 13.61C33.031 13.1713 32.7977 12.5553 32.7977 11.762C32.7977 11.1833 32.9377 10.6747 33.2177 10.236C33.4977 9.79733 33.8943 9.45667 34.4077 9.214C34.921 8.962 35.523 8.836 36.2137 8.836C37.1937 8.836 37.9917 9.13467 38.6077 9.732C39.233 10.32 39.6017 11.104 39.7137 12.084L37.9637 12.182C37.8983 11.6313 37.7117 11.1973 37.4037 10.88C37.105 10.5627 36.699 10.404 36.1857 10.404C35.6723 10.404 35.271 10.5207 34.9817 10.754C34.7017 10.978 34.5617 11.2907 34.5617 11.692C34.5617 12.0933 34.7017 12.4013 34.9817 12.616C35.271 12.8307 35.7937 13.0313 36.5497 13.218C37.7257 13.498 38.5657 13.89 39.0697 14.394C39.5737 14.8887 39.8257 15.5653 39.8257 16.424C39.8257 16.9653 39.6763 17.4507 39.3777 17.88C39.0883 18.3 38.6777 18.6313 38.1457 18.874C37.6137 19.1073 37.0023 19.224 36.3117 19.224ZM44.2162 11.356C44.2162 11.076 44.1415 10.8613 43.9922 10.712C43.8429 10.5627 43.6282 10.488 43.3482 10.488H41.6402V9.06H43.4602C45.0749 9.06 45.8822 9.86733 45.8822 11.482V17.572H48.4162V19H41.3602V17.572H44.2162V11.356ZM52.0367 19.168C51.5701 19.168 51.1407 19.084 50.7487 18.916C50.3567 18.7387 50.0441 18.4867 49.8107 18.16C49.5867 17.8333 49.4747 17.4507 49.4747 17.012C49.4747 16.4147 49.6707 15.9387 50.0627 15.584C50.4547 15.22 51.0101 14.9633 51.7287 14.814L54.0527 14.324C54.0527 13.316 53.6141 12.812 52.7367 12.812C51.9434 12.812 51.4674 13.1667 51.3087 13.876L49.6007 13.764C49.7407 13.0173 50.0861 12.4247 50.6367 11.986C51.1874 11.5473 51.8874 11.328 52.7367 11.328C53.6887 11.328 54.4214 11.5987 54.9347 12.14C55.4574 12.6813 55.7187 13.4467 55.7187 14.436V17.082C55.7187 17.2687 55.7561 17.3993 55.8307 17.474C55.9054 17.5393 56.0267 17.572 56.1947 17.572H56.5867V19C56.4374 19.0373 56.2087 19.056 55.9007 19.056C54.9954 19.056 54.4494 18.6687 54.2627 17.894C54.0947 18.2767 53.8101 18.5847 53.4087 18.818C53.0074 19.0513 52.5501 19.168 52.0367 19.168ZM52.2467 17.768C52.7974 17.768 53.2361 17.6187 53.5627 17.32C53.8894 17.0213 54.0527 16.62 54.0527 16.116V15.598L52.1907 15.976C51.8547 16.0413 51.6074 16.1533 51.4487 16.312C51.2901 16.4613 51.2107 16.6573 51.2107 16.9C51.2107 17.1707 51.2994 17.3853 51.4767 17.544C51.6541 17.6933 51.9107 17.768 52.2467 17.768ZM61.5233 19.168C60.8233 19.168 60.2073 19.0093 59.6753 18.692C59.1433 18.3653 58.7326 17.908 58.4433 17.32C58.1539 16.7227 58.0093 16.032 58.0093 15.248C58.0093 14.464 58.1539 13.778 58.4433 13.19C58.7326 12.5927 59.1433 12.1353 59.6753 11.818C60.2073 11.4913 60.8233 11.328 61.5233 11.328C62.4099 11.328 63.1519 11.5893 63.7493 12.112C64.3559 12.6253 64.7293 13.3253 64.8693 14.212L63.1333 14.31C63.0306 13.8433 62.8393 13.484 62.5593 13.232C62.2886 12.9707 61.9433 12.84 61.5233 12.84C60.9726 12.84 60.5386 13.0547 60.2213 13.484C59.9133 13.9133 59.7593 14.5013 59.7593 15.248C59.7593 16.004 59.9133 16.5967 60.2213 17.026C60.5293 17.446 60.9633 17.656 61.5233 17.656C61.9433 17.656 62.2933 17.5253 62.5733 17.264C62.8626 16.9933 63.0586 16.6107 63.1613 16.116L64.8973 16.214C64.7479 17.11 64.3699 17.8287 63.7633 18.37C63.1566 18.902 62.4099 19.168 61.5233 19.168ZM66.6278 9.06H68.2938V14.912L71.3318 11.496H73.3758L70.4638 14.688L73.5018 19H71.4858L69.3718 15.836L68.2938 16.984V19H66.6278V9.06Z" fill="#FFDC83"/>
+<mask id="path-8-inside-1_2074_1485" fill="white">
+<path d="M86 0H251C252.657 0 254 1.34315 254 3V26C254 27.6569 252.657 29 251 29H86V0Z"/>
+</mask>
+<path d="M86 0H251C252.657 0 254 1.34315 254 3V26C254 27.6569 252.657 29 251 29H86V0Z" fill="#FFDC83"/>
+<path d="M86 -1H251C253.209 -1 255 0.790861 255 3H253C253 1.89543 252.105 1 251 1H86V-1ZM255 26C255 28.2091 253.209 30 251 30H86V28H251C252.105 28 253 27.1046 253 26H255ZM86 29V0V29ZM251 -1C253.209 -1 255 0.790861 255 3V26C255 28.2091 253.209 30 251 30V28C252.105 28 253 27.1046 253 26V3C253 1.89543 252.105 1 251 1V-1Z" fill="#635943" mask="url(#path-8-inside-1_2074_1485)"/>
+<path d="M97.85 19.224C96.8607 19.224 96.072 18.9113 95.484 18.286C94.896 17.6607 94.588 16.8253 94.56 15.78L95.736 15.668C95.764 16.48 95.9507 17.082 96.296 17.474C96.6413 17.8567 97.1593 18.048 97.85 18.048C99.2407 18.048 99.936 17.2547 99.936 15.668V9.06H101.14V15.668C101.14 16.7693 100.841 17.6373 100.244 18.272C99.656 18.9067 98.858 19.224 97.85 19.224ZM106.595 19.168C105.913 19.168 105.316 19.0093 104.803 18.692C104.299 18.3747 103.907 17.9267 103.627 17.348C103.347 16.76 103.207 16.074 103.207 15.29C103.207 14.506 103.347 13.8247 103.627 13.246C103.907 12.658 104.299 12.2053 104.803 11.888C105.316 11.5707 105.913 11.412 106.595 11.412C107.267 11.412 107.859 11.5707 108.373 11.888C108.886 12.2053 109.283 12.658 109.563 13.246C109.843 13.8247 109.983 14.506 109.983 15.29C109.983 16.074 109.843 16.76 109.563 17.348C109.283 17.9267 108.886 18.3747 108.373 18.692C107.859 19.0093 107.267 19.168 106.595 19.168ZM106.595 18.048C107.276 18.048 107.803 17.8053 108.177 17.32C108.559 16.8253 108.751 16.1487 108.751 15.29C108.751 14.4313 108.559 13.7593 108.177 13.274C107.803 12.7793 107.276 12.532 106.595 12.532C105.913 12.532 105.381 12.7747 104.999 13.26C104.625 13.7453 104.439 14.422 104.439 15.29C104.439 16.158 104.625 16.8347 104.999 17.32C105.381 17.8053 105.913 18.048 106.595 18.048ZM111.909 17.964H114.891V12.616H112.049V11.58H116.067V17.964H118.629V19H111.909V17.964ZM114.779 9.046H116.011V10.418H114.779V9.046ZM120.528 11.58H121.606L121.634 12.91C121.82 12.4153 122.114 12.042 122.516 11.79C122.917 11.538 123.384 11.412 123.916 11.412C124.728 11.412 125.344 11.6733 125.764 12.196C126.193 12.7187 126.408 13.3953 126.408 14.226V19H125.232V14.562C125.232 13.862 125.106 13.3347 124.854 12.98C124.611 12.6253 124.214 12.448 123.664 12.448C123.076 12.448 122.6 12.6347 122.236 13.008C121.881 13.372 121.704 13.89 121.704 14.562V19H120.528V11.58ZM140.173 19.168C139.491 19.168 138.894 19.0093 138.381 18.692C137.877 18.3747 137.485 17.9267 137.205 17.348C136.925 16.76 136.785 16.074 136.785 15.29C136.785 14.506 136.925 13.8247 137.205 13.246C137.485 12.658 137.877 12.2053 138.381 11.888C138.894 11.5707 139.491 11.412 140.173 11.412C140.845 11.412 141.437 11.5707 141.951 11.888C142.464 12.2053 142.861 12.658 143.141 13.246C143.421 13.8247 143.561 14.506 143.561 15.29C143.561 16.074 143.421 16.76 143.141 17.348C142.861 17.9267 142.464 18.3747 141.951 18.692C141.437 19.0093 140.845 19.168 140.173 19.168ZM140.173 18.048C140.854 18.048 141.381 17.8053 141.755 17.32C142.137 16.8253 142.329 16.1487 142.329 15.29C142.329 14.4313 142.137 13.7593 141.755 13.274C141.381 12.7793 140.854 12.532 140.173 12.532C139.491 12.532 138.959 12.7747 138.577 13.26C138.203 13.7453 138.017 14.422 138.017 15.29C138.017 16.158 138.203 16.8347 138.577 17.32C138.959 17.8053 139.491 18.048 140.173 18.048ZM148.049 19.168C147.312 19.168 146.724 18.9207 146.285 18.426C145.847 17.922 145.627 17.2313 145.627 16.354V11.58H146.803V16.032C146.803 16.7507 146.929 17.2827 147.181 17.628C147.443 17.964 147.839 18.132 148.371 18.132C148.95 18.132 149.407 17.9453 149.743 17.572C150.079 17.1893 150.247 16.6667 150.247 16.004V11.58H151.423V19H150.303V17.796C150.098 18.2347 149.804 18.5753 149.421 18.818C149.039 19.0513 148.581 19.168 148.049 19.168ZM154.022 17.964H155.954V12.616H154.022V11.58H156.934L157.018 13.008C157.27 12.056 157.862 11.58 158.796 11.58H160.322V12.644H158.81C158.268 12.644 157.853 12.8073 157.564 13.134C157.274 13.4513 157.13 13.9133 157.13 14.52V17.964H159.482V19H154.022V17.964ZM173.947 19.168C173.265 19.168 172.663 19.0093 172.141 18.692C171.627 18.3747 171.231 17.922 170.951 17.334C170.671 16.746 170.531 16.0647 170.531 15.29C170.531 14.5153 170.671 13.834 170.951 13.246C171.231 12.658 171.627 12.2053 172.141 11.888C172.663 11.5707 173.265 11.412 173.947 11.412C174.777 11.412 175.463 11.636 176.005 12.084C176.555 12.532 176.905 13.1667 177.055 13.988L175.823 14.072C175.711 13.5867 175.487 13.2087 175.151 12.938C174.824 12.6673 174.423 12.532 173.947 12.532C173.265 12.532 172.729 12.7793 172.337 13.274C171.954 13.7593 171.763 14.4313 171.763 15.29C171.763 16.1487 171.954 16.8253 172.337 17.32C172.729 17.8053 173.265 18.048 173.947 18.048C174.441 18.048 174.857 17.9033 175.193 17.614C175.538 17.3247 175.767 16.9093 175.879 16.368L177.111 16.452C176.952 17.2827 176.588 17.9453 176.019 18.44C175.459 18.9253 174.768 19.168 173.947 19.168ZM182.145 19.168C181.464 19.168 180.867 19.0093 180.353 18.692C179.849 18.3747 179.457 17.9267 179.177 17.348C178.897 16.76 178.757 16.074 178.757 15.29C178.757 14.506 178.897 13.8247 179.177 13.246C179.457 12.658 179.849 12.2053 180.353 11.888C180.867 11.5707 181.464 11.412 182.145 11.412C182.817 11.412 183.41 11.5707 183.923 11.888C184.437 12.2053 184.833 12.658 185.113 13.246C185.393 13.8247 185.533 14.506 185.533 15.29C185.533 16.074 185.393 16.76 185.113 17.348C184.833 17.9267 184.437 18.3747 183.923 18.692C183.41 19.0093 182.817 19.168 182.145 19.168ZM182.145 18.048C182.827 18.048 183.354 17.8053 183.727 17.32C184.11 16.8253 184.301 16.1487 184.301 15.29C184.301 14.4313 184.11 13.7593 183.727 13.274C183.354 12.7793 182.827 12.532 182.145 12.532C181.464 12.532 180.932 12.7747 180.549 13.26C180.176 13.7453 179.989 14.422 179.989 15.29C179.989 16.158 180.176 16.8347 180.549 17.32C180.932 17.8053 181.464 18.048 182.145 18.048ZM186.9 11.58H187.978L188.006 12.672C188.137 12.2707 188.328 11.9627 188.58 11.748C188.832 11.524 189.131 11.412 189.476 11.412C190.241 11.412 190.708 11.8973 190.876 12.868C190.997 12.4107 191.198 12.056 191.478 11.804C191.758 11.5427 192.089 11.412 192.472 11.412C193.069 11.412 193.503 11.622 193.774 12.042C194.045 12.462 194.18 13.148 194.18 14.1V19H193.004V14.24C193.004 13.596 192.934 13.1387 192.794 12.868C192.654 12.588 192.435 12.448 192.136 12.448C191.828 12.448 191.581 12.602 191.394 12.91C191.217 13.2087 191.128 13.6613 191.128 14.268V19H189.952V14.24C189.952 13.6053 189.882 13.148 189.742 12.868C189.611 12.588 189.392 12.448 189.084 12.448C188.776 12.448 188.529 12.602 188.342 12.91C188.165 13.2087 188.076 13.6613 188.076 14.268V19H186.9V11.58ZM195.294 11.58H196.372L196.4 12.672C196.531 12.2707 196.722 11.9627 196.974 11.748C197.226 11.524 197.525 11.412 197.87 11.412C198.636 11.412 199.102 11.8973 199.27 12.868C199.392 12.4107 199.592 12.056 199.872 11.804C200.152 11.5427 200.484 11.412 200.866 11.412C201.464 11.412 201.898 11.622 202.168 12.042C202.439 12.462 202.574 13.148 202.574 14.1V19H201.398V14.24C201.398 13.596 201.328 13.1387 201.188 12.868C201.048 12.588 200.829 12.448 200.53 12.448C200.222 12.448 199.975 12.602 199.788 12.91C199.611 13.2087 199.522 13.6613 199.522 14.268V19H198.346V14.24C198.346 13.6053 198.276 13.148 198.136 12.868C198.006 12.588 197.786 12.448 197.478 12.448C197.17 12.448 196.923 12.602 196.736 12.91C196.559 13.2087 196.47 13.6613 196.47 14.268V19H195.294V11.58ZM206.811 19.168C206.074 19.168 205.486 18.9207 205.047 18.426C204.608 17.922 204.389 17.2313 204.389 16.354V11.58H205.565V16.032C205.565 16.7507 205.691 17.2827 205.943 17.628C206.204 17.964 206.601 18.132 207.133 18.132C207.712 18.132 208.169 17.9453 208.505 17.572C208.841 17.1893 209.009 16.6667 209.009 16.004V11.58H210.185V19H209.065V17.796C208.86 18.2347 208.566 18.5753 208.183 18.818C207.8 19.0513 207.343 19.168 206.811 19.168ZM212.867 11.58H213.945L213.973 12.91C214.16 12.4153 214.454 12.042 214.855 11.79C215.257 11.538 215.723 11.412 216.255 11.412C217.067 11.412 217.683 11.6733 218.103 12.196C218.533 12.7187 218.747 13.3953 218.747 14.226V19H217.571V14.562C217.571 13.862 217.445 13.3347 217.193 12.98C216.951 12.6253 216.554 12.448 216.003 12.448C215.415 12.448 214.939 12.6347 214.575 13.008C214.221 13.372 214.043 13.89 214.043 14.562V19H212.867V11.58ZM221.038 17.964H224.02V12.616H221.178V11.58H225.196V17.964H227.758V19H221.038V17.964ZM223.908 9.046H225.14V10.418H223.908V9.046ZM233.605 19C232.886 19 232.349 18.832 231.995 18.496C231.64 18.16 231.463 17.6467 231.463 16.956V12.616H229.013V11.58H231.463V9.62H232.639V11.58H235.593V12.616H232.639V16.956C232.639 17.3013 232.718 17.558 232.877 17.726C233.035 17.8847 233.278 17.964 233.605 17.964H235.593V19H233.605ZM238.639 20.064H239.493C239.745 20.064 239.932 20.022 240.053 19.938C240.184 19.8633 240.286 19.7373 240.361 19.56L240.627 18.86H240.221L237.463 11.58H238.751L241.005 17.768L243.119 11.58H244.407L241.397 19.938C241.257 20.3393 241.047 20.6333 240.767 20.82C240.487 21.0067 240.1 21.1 239.605 21.1H238.639V20.064Z" fill="#100D0D"/>
+<defs>
+<clipPath id="clip0_2074_1485">
+<rect width="16" height="16" fill="white" transform="translate(12 6.5)"/>
+</clipPath>
+</defs>
+</svg>
diff --git a/packages/docs/images/logo_dark.svg b/packages/docs/images/logo_dark.svg
new file mode 100644
index 000000000..1941e4539
--- /dev/null
+++ b/packages/docs/images/logo_dark.svg
@@ -0,0 +1,16 @@
+<svg width="194" height="57" viewBox="0 0 194 57" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M72 30.2216H74.525V31.2316C74.525 32.4184 75.5098 33.4031 76.6965 33.4031H78.3882C79.676 33.4031 80.585 32.5951 80.585 31.4841C80.585 27.9996 72.2525 27.2421 72.2525 22.4446C72.2525 19.9701 74.1967 18.2531 76.949 18.2531H78.1357C80.7365 18.2531 82.8575 20.3489 82.8575 22.9496V23.7071H80.3325V22.9496C80.3325 21.7376 79.3478 20.7781 78.1357 20.7781H76.949C75.5855 20.7781 74.7775 21.4094 74.7775 22.4446C74.7775 25.1211 83.11 26.1564 83.11 31.4841C83.11 34.0091 81.0647 35.9281 78.3882 35.9281H76.6965C74.0958 35.9281 72 33.8324 72 31.2316V30.2216Z" fill="white"/>
+<path d="M95.4726 25.5756H90.8014V31.3831C90.8014 32.5194 91.6851 33.4031 92.8214 33.4031H95.4726V35.9281H92.8214C90.2964 35.9281 88.2764 33.9081 88.2764 31.3831V25.5756H84.3626V23.0506H88.2764V19.7681H90.8014V23.0506H95.4726V25.5756Z" fill="white"/>
+<path d="M105.942 23.0506H108.467V35.9281H105.942V34.5141L103.846 35.9281H101.902C99.4018 35.9281 97.3565 33.8829 97.3565 31.3831V27.5956C97.3565 25.0706 99.4018 23.0506 101.902 23.0506H103.846L105.942 24.4646V23.0506ZM103.063 33.4031L105.942 31.4589V27.5199L103.063 25.5756H101.902C100.791 25.5756 99.8815 26.4846 99.8815 27.5956V31.3831C99.8815 32.4941 100.791 33.4031 101.902 33.4031H103.063Z" fill="white"/>
+<path d="M120.198 23.0506H122.723V36.6604C122.723 39.1601 120.703 41.2306 118.178 41.2306H116.158C113.658 41.2306 111.613 39.1601 111.613 36.6604H114.138C114.138 37.7714 115.047 38.6804 116.158 38.6804H118.178C119.289 38.6804 120.198 37.7714 120.198 36.6604V34.5141L118.102 35.9281H116.158C113.658 35.9281 111.613 33.8829 111.613 31.3831V27.5956C111.613 25.0706 113.658 23.0506 116.158 23.0506H118.102L120.198 24.4646V23.0506ZM117.319 33.4031L120.198 31.4589V27.5199L117.319 25.5756H116.158C115.047 25.5756 114.138 26.4846 114.138 27.5956V31.3831C114.138 32.4941 115.047 33.4031 116.158 33.4031H117.319Z" fill="white"/>
+<path d="M136.979 27.3431V30.0701H128.394V31.3579C128.394 32.4689 129.303 33.3779 130.414 33.3779H132.434C133.545 33.3779 134.454 32.4689 134.454 31.3579V31.1054H136.979V31.3579C136.979 33.8576 134.959 35.9281 132.434 35.9281H130.414C127.915 35.9281 125.869 33.8576 125.869 31.3579V27.5956C125.869 25.0706 127.915 23.0506 130.414 23.0506H132.434C134.884 23.0506 136.853 24.9444 136.979 27.3431ZM134.454 28.0501V27.5956C134.454 26.4594 133.571 25.5756 132.434 25.5756H130.414C129.278 25.5756 128.394 26.4846 128.394 27.5956V28.0501H134.454Z" fill="white"/>
+<path d="M146.691 23.0506C149.19 23.0506 151.236 25.0706 151.236 27.5956V35.9281H148.711V27.5956C148.711 26.4846 147.802 25.5756 146.691 25.5756H145.529L142.651 27.5199V35.9281H140.126V18.0006H142.651V24.4646L144.746 23.0506H146.691Z" fill="white"/>
+<path d="M162.967 23.0506H165.492V35.9281H162.967V34.5141L160.871 35.9281H158.927C156.427 35.9281 154.382 33.8829 154.382 31.3831V27.5956C154.382 25.0706 156.427 23.0506 158.927 23.0506H160.871L162.967 24.4646V23.0506ZM160.089 33.4031L162.967 31.4589V27.5199L160.089 25.5756H158.927C157.816 25.5756 156.907 26.4846 156.907 27.5956V31.3831C156.907 32.4941 157.816 33.4031 158.927 33.4031H160.089Z" fill="white"/>
+<path d="M175.203 23.0506C177.703 23.0506 179.748 25.0706 179.748 27.5956V35.9281H177.223V27.5956C177.223 26.4846 176.314 25.5756 175.203 25.5756H174.042L171.163 27.5199V35.9281H168.638V23.0506H171.163V24.4646L173.259 23.0506H175.203Z" fill="white"/>
+<path d="M191.48 18.0006H194.005V35.9281H191.48V34.5141L189.384 35.9281H187.44C184.94 35.9281 182.895 33.8829 182.895 31.3831V27.5956C182.895 25.0706 184.94 23.0506 187.44 23.0506H189.384L191.48 24.4646V18.0006ZM188.601 33.4031L191.48 31.4589V27.5199L188.601 25.5756H187.44C186.329 25.5756 185.42 26.4846 185.42 27.5956V31.3831C185.42 32.4941 186.329 33.4031 187.44 33.4031H188.601Z" fill="white"/>
+<rect width="57" height="57" fill="#FFC83C"/>
+<path d="M40.7828 34.5435C40.7957 34.8326 40.7931 35.1346 40.7802 35.4418C40.7957 35.1423 40.7957 34.8404 40.7828 34.5435ZM21.1019 24.4643C21.1019 24.4643 21.1045 24.4643 21.1045 24.4695C21.1174 24.3921 21.1303 24.3146 21.1458 24.2346C21.1277 24.3121 21.1148 24.3869 21.1019 24.4643ZM21.1458 24.2346C21.1768 24.0798 21.2129 23.9223 21.2568 23.77C21.2129 23.9197 21.1742 24.0746 21.1458 24.2346Z" fill="white"/>
+<path d="M40.7803 35.4411C40.7726 35.6063 40.7623 35.7741 40.7494 35.9418C40.7184 36.3058 40.6771 36.6723 40.6229 37.0336C40.61 37.124 40.5945 37.2117 40.5816 37.2969C40.5584 37.4389 40.5326 37.5808 40.5067 37.7176C40.5067 37.7383 40.499 37.7564 40.4964 37.7744C40.468 37.9215 40.4371 38.0738 40.4061 38.2261C40.388 38.301 40.3725 38.3784 40.3545 38.4558C40.3003 38.6856 40.2435 38.9127 40.1841 39.1321C40.1351 39.3153 40.0834 39.4909 40.0292 39.656C39.9544 39.8909 39.8744 40.1026 39.7969 40.2729C39.7763 40.3168 39.7556 40.3607 39.735 40.3994C39.704 40.4614 39.6731 40.5156 39.6447 40.562C38.3515 45.9023 34.7406 48.5041 28.6156 48.5041C28.4143 48.5041 28.2104 48.5015 28.0039 48.4963C20.3767 48.2873 17.997 43.9768 17.4498 42.6579C16.4844 40.3426 15.9527 34.2874 15.9527 30.9861C15.9527 27.9379 15.2842 24.9386 15.2765 24.9076L15.2274 24.6547C14.9229 23.1473 14.466 20.8708 13.9137 18.4833C13.6246 17.2263 13.8491 16.0596 14.5331 15.2853C15.1061 14.6349 15.9605 14.3303 16.9387 14.4258C19.1327 14.6452 19.6798 17.3837 20.0051 19.0201C20.1238 19.6086 20.2167 20.2281 20.3096 20.8295C20.5006 22.0684 20.6968 23.3461 21.102 24.4637C21.102 24.4637 21.1029 24.4654 21.1046 24.4689C21.1175 24.3914 21.1304 24.314 21.1459 24.234C21.1769 24.0791 21.213 23.9217 21.2569 23.7694C21.2801 23.6919 21.3034 23.6171 21.3292 23.5422C21.3524 23.4777 21.3782 23.4132 21.404 23.3512C21.4195 23.3151 21.435 23.279 21.4531 23.2428C21.4634 23.2144 21.4789 23.186 21.4918 23.1577C21.5124 23.1189 21.5331 23.0802 21.5537 23.0441C21.5589 23.0312 21.5666 23.0183 21.577 23.0079C21.5976 22.9667 21.6208 22.9279 21.6466 22.8918C21.6802 22.8376 21.7163 22.7886 21.7551 22.7421C22.612 21.6709 23.505 21.6709 24.0987 21.6709C24.411 21.6709 25.9209 21.7355 26.703 22.9047C26.7546 22.9847 26.8037 23.0673 26.8476 23.1551C26.8837 22.9589 26.9224 22.7834 26.9689 22.6337C27.0489 22.3653 27.1625 22.1304 27.2967 21.9239C27.3199 21.8903 27.3431 21.8568 27.3664 21.8232C27.4154 21.7587 27.467 21.6967 27.5186 21.6374C28.1226 20.9586 29.0183 20.6979 29.7461 20.6979C29.8881 20.6979 30.0688 20.7056 30.2753 20.734C30.3166 20.7392 30.3579 20.7443 30.3992 20.7546C30.4379 20.7598 30.4766 20.765 30.5153 20.7753C30.5773 20.7856 30.6392 20.8011 30.7011 20.8166C30.7657 20.8321 30.8302 20.8502 30.8947 20.8708C30.9928 20.9018 31.0935 20.9353 31.1941 20.9792C31.2251 20.9921 31.2587 21.0076 31.2922 21.0231C31.3258 21.0386 31.3593 21.0541 31.3929 21.0721C31.7929 21.2709 32.1904 21.578 32.5105 22.04C32.5389 22.0788 32.5647 22.1175 32.5905 22.1588C32.5724 21.5651 32.5415 20.8811 32.5105 20.1403C32.4202 17.9464 32.3143 15.4608 32.4098 13.5405C32.5828 10.0947 33.6462 8.48926 35.7549 8.48926C38.2999 8.48926 38.5942 11.2872 38.5942 13.3933C38.5942 16.5475 38.5942 20.8682 38.8523 24.474C38.8781 24.8431 38.9065 25.3 38.9374 25.8059C39.0355 27.3829 39.1697 29.5407 39.3659 30.9087C39.3969 31.11 39.4356 31.3681 39.482 31.6675C39.4924 31.6753 39.5027 31.6856 39.5104 31.6959C39.7298 31.8973 39.9286 32.1089 40.0964 32.3283C40.1273 32.367 40.1531 32.4032 40.1789 32.4419C40.2848 32.589 40.3751 32.7387 40.45 32.8936C40.468 32.9323 40.4861 32.971 40.5016 33.0071C40.5351 33.082 40.5635 33.1594 40.5893 33.2369C40.6022 33.2756 40.6152 33.3143 40.6255 33.353C40.6358 33.3917 40.6461 33.4304 40.6539 33.4692C40.6926 33.6395 40.721 33.8202 40.7416 34.0034C40.7545 34.117 40.7649 34.2332 40.7726 34.3519C40.7778 34.4138 40.7829 34.4784 40.7829 34.5429C40.7958 34.832 40.7932 35.134 40.7803 35.4411Z" fill="white"/>
+<path d="M21.1458 24.2346C21.1768 24.0798 21.2129 23.9223 21.2568 23.77C21.2129 23.9197 21.1742 24.0746 21.1458 24.2346ZM21.1019 24.4643C21.1019 24.4643 21.1045 24.4643 21.1045 24.4695C21.1174 24.3921 21.1303 24.3146 21.1458 24.2346C21.1277 24.3121 21.1148 24.3869 21.1019 24.4643ZM39.5155 39.5767C39.7323 38.934 39.9698 37.9635 40.1195 36.9336C39.9646 37.9687 39.722 38.9417 39.5155 39.5767ZM40.7828 34.5435C40.7957 34.8326 40.7931 35.1346 40.7802 35.4418C40.7957 35.1423 40.7957 34.8404 40.7828 34.5435Z" fill="black"/>
+<path d="M40.7829 34.5429C40.7829 34.4784 40.7778 34.4138 40.7726 34.3519C40.7649 34.2332 40.7545 34.117 40.7416 34.0034C40.721 33.8202 40.6926 33.6395 40.6539 33.4692C40.6461 33.4304 40.6358 33.3917 40.6255 33.353C40.6152 33.3143 40.6022 33.2756 40.5893 33.2369C40.5635 33.1594 40.5351 33.082 40.5016 33.0071C40.4861 32.971 40.468 32.9323 40.45 32.8936C40.3751 32.7387 40.2848 32.589 40.1789 32.4419C40.1531 32.4032 40.1273 32.367 40.0964 32.3283C39.9286 32.1089 39.7298 31.8973 39.5104 31.6959C39.5027 31.6856 39.4924 31.6753 39.482 31.6675C39.4356 31.3681 39.3969 31.11 39.3659 30.9087C39.1697 29.5407 39.0355 27.3829 38.9374 25.8059C38.9065 25.3 38.8781 24.8431 38.8523 24.474C38.5942 20.8682 38.5942 16.5475 38.5942 13.3933C38.5942 11.2872 38.2999 8.48926 35.7549 8.48926C33.6462 8.48926 32.5828 10.0947 32.4098 13.5405C32.3143 15.4608 32.4202 17.9464 32.5105 20.1403C32.5415 20.8811 32.5724 21.5651 32.5905 22.1588C32.5647 22.1175 32.5389 22.0788 32.5105 22.04C32.1904 21.578 31.7929 21.2709 31.3929 21.0721C31.3593 21.0541 31.3258 21.0386 31.2922 21.0231C31.2587 21.0076 31.2251 20.9921 31.1941 20.9792C31.0935 20.9353 30.9928 20.9018 30.8947 20.8708C30.8302 20.8502 30.7657 20.8321 30.7011 20.8166C30.6392 20.8011 30.5773 20.7856 30.5153 20.7753C30.4766 20.765 30.4379 20.7598 30.3992 20.7546C30.3579 20.7443 30.3166 20.7392 30.2753 20.734C30.0688 20.7056 29.8881 20.6979 29.7461 20.6979C29.0183 20.6979 28.1226 20.9586 27.5186 21.6374C27.467 21.6967 27.4154 21.7587 27.3664 21.8232C27.3431 21.8568 27.3199 21.8903 27.2967 21.9239C27.1625 22.1304 27.0489 22.3653 26.9689 22.6337C26.9224 22.7834 26.8837 22.9589 26.8476 23.1551C26.8037 23.0673 26.7546 22.9847 26.703 22.9047C25.9209 21.7355 24.411 21.6709 24.0987 21.6709C23.505 21.6709 22.612 21.6709 21.7551 22.7421C21.7163 22.7886 21.6802 22.8376 21.6466 22.8918C21.6208 22.9279 21.5976 22.9667 21.577 23.0079C21.5666 23.0183 21.5589 23.0312 21.5537 23.0441C21.5331 23.0802 21.5124 23.1189 21.4918 23.1577C21.4789 23.186 21.4634 23.2144 21.4531 23.2428C21.435 23.279 21.4195 23.3151 21.404 23.3512C21.3782 23.4132 21.3524 23.4777 21.3292 23.5422C21.3034 23.6171 21.2801 23.6919 21.2569 23.7694C21.213 23.9217 21.1769 24.0791 21.1459 24.234C21.1304 24.314 21.1175 24.3914 21.1046 24.4689C21.1046 24.4689 21.1038 24.4671 21.102 24.4637C20.6968 23.3461 20.5006 22.0684 20.3096 20.8295C20.2167 20.2281 20.1238 19.6086 20.0051 19.0201C19.6798 17.3837 19.1327 14.6452 16.9387 14.4258C15.9605 14.3303 15.1061 14.6349 14.5331 15.2853C13.8491 16.0596 13.6246 17.2263 13.9137 18.4833C14.466 20.8708 14.9229 23.1473 15.2274 24.6547L15.2765 24.9076C15.2842 24.9386 15.9527 27.9379 15.9527 30.9861C15.9527 34.2874 16.4844 40.3426 17.4498 42.6579C17.997 43.9768 20.3767 48.2873 28.0039 48.4963C28.2104 48.5015 28.4143 48.5041 28.6156 48.5041C34.7406 48.5041 38.3515 45.9023 39.6447 40.562C39.6731 40.5156 39.704 40.4614 39.735 40.3994C39.7556 40.3607 39.7763 40.3168 39.7969 40.2729C39.8744 40.1026 39.9544 39.8909 40.0292 39.656C40.0834 39.4909 40.1351 39.3153 40.1841 39.1321C40.2435 38.9127 40.3003 38.6856 40.3545 38.4558C40.3725 38.3784 40.388 38.301 40.4061 38.2261C40.4371 38.0738 40.468 37.9215 40.4964 37.7744C40.499 37.7564 40.5042 37.7383 40.5067 37.7176C40.5326 37.5808 40.5584 37.4389 40.5816 37.2969C40.5945 37.2117 40.61 37.124 40.6229 37.0336C40.6771 36.6723 40.7184 36.3058 40.7494 35.9418C40.7623 35.7741 40.7726 35.6063 40.7803 35.4411C40.7932 35.134 40.7958 34.832 40.7829 34.5429ZM32.9261 13.5663C33.13 9.52428 34.5444 9.00548 35.7549 9.00548C37.3604 9.00548 38.0779 10.358 38.0779 13.3933C38.0779 16.4287 38.0779 20.8889 38.336 24.5102C38.3619 24.8792 38.3902 25.3335 38.4238 25.8394C38.5219 27.4242 38.6561 29.5949 38.8548 30.9836C38.8652 31.0481 38.8755 31.1178 38.8858 31.1926C37.2907 30.0389 35.0787 29.3162 34.1211 29.1432C33.9353 29.1097 33.6255 29.0864 33.228 29.0684C33.4139 27.5894 33.4836 25.1812 33.1196 23.5371C33.1222 23.5216 33.1222 23.5061 33.1222 23.4932C33.1351 22.7137 33.0861 21.5109 33.0267 20.1197C32.9364 17.9361 32.8331 15.4634 32.9261 13.5663ZM27.2063 24.4482V24.443C27.2218 24.203 27.2425 23.9733 27.2709 23.7565C27.276 23.6997 27.2838 23.6455 27.2915 23.5939C27.3018 23.5138 27.3147 23.4364 27.3302 23.3616C27.3431 23.2867 27.356 23.2119 27.3741 23.1422C27.387 23.0751 27.4025 23.0105 27.418 22.946C27.4309 22.8892 27.4464 22.835 27.4619 22.7834C27.8103 21.6245 28.9099 21.2141 29.7461 21.2141C30.2572 21.2141 31.3851 21.338 32.0872 22.3394C32.1672 22.4504 32.2395 22.5743 32.304 22.7085C32.3272 22.7524 32.3479 22.7989 32.3685 22.8453C32.3892 22.8918 32.4098 22.9434 32.4279 22.9925C32.464 23.088 32.4976 23.186 32.526 23.2919C32.5905 23.5113 32.6447 23.7513 32.6912 24.0068C32.8176 24.7424 32.8693 25.6045 32.8693 26.4486C32.8693 27.4087 32.8047 28.3457 32.7118 29.0529C31.2561 29.0168 29.0957 29.0503 27.5057 29.0839C27.356 28.2553 27.2502 27.321 27.2038 26.4021C27.1702 25.7233 27.1676 25.0573 27.2063 24.4482ZM21.5305 25.4652C21.5331 25.3851 21.5382 25.3051 21.5434 25.2251C21.5563 25.0264 21.5744 24.8328 21.6002 24.6444C21.6028 24.6315 21.6053 24.6211 21.6053 24.6108C21.6234 24.4869 21.6441 24.3656 21.6699 24.252C21.6828 24.1901 21.6983 24.1281 21.7112 24.0688C21.7396 23.9526 21.7705 23.8416 21.8093 23.7384C21.8273 23.6842 21.8454 23.6326 21.866 23.5835C21.8867 23.5319 21.9073 23.4829 21.9306 23.4364C21.9538 23.39 21.977 23.3461 22.0003 23.3022C22.0493 23.2144 22.1009 23.137 22.1577 23.0647C22.2016 23.0105 22.2455 22.9589 22.2893 22.9099C22.3332 22.8608 22.3771 22.8144 22.421 22.7757C22.5087 22.6879 22.5939 22.6182 22.6791 22.5563C22.9036 22.3911 23.123 22.3007 23.3347 22.2517H23.3373C23.407 22.2336 23.4766 22.2207 23.5463 22.213C23.7373 22.1872 23.9206 22.1872 24.0987 22.1872C24.3542 22.1872 25.5596 22.2362 26.2152 23.1086C26.2849 23.199 26.3468 23.2996 26.401 23.408C26.4217 23.4493 26.4397 23.4906 26.4578 23.5293C26.5069 23.6377 26.5456 23.741 26.574 23.8442C26.5869 23.8752 26.5946 23.9088 26.6024 23.9397C26.6153 23.981 26.623 24.0197 26.6307 24.0585C26.6411 24.0998 26.6488 24.1411 26.6566 24.1824C26.6617 24.2211 26.6695 24.2572 26.6746 24.2959C26.6798 24.3398 26.685 24.3863 26.6875 24.4301C26.6953 24.4972 26.7004 24.5644 26.703 24.6315C26.703 24.6469 26.7056 24.6624 26.7056 24.6779C26.703 24.6805 26.703 24.6857 26.7056 24.6882C26.7004 24.7941 26.6979 24.9025 26.6953 25.0135V25.0548C26.6927 25.1554 26.6901 25.2561 26.6901 25.3593V25.5348C26.6901 25.6484 26.6927 25.762 26.6953 25.8781C26.6953 25.9943 26.7004 26.1104 26.7056 26.2292C26.7185 26.6783 26.7469 27.1377 26.7882 27.5997C26.8218 27.9637 26.8785 28.5083 26.974 29.0968C26.1145 29.1174 25.5131 29.1355 25.4305 29.1381C24.5323 29.1381 23.6238 29.7575 23.6238 30.9448C23.6238 31.2701 23.6909 31.6495 23.8277 32.0418C23.3218 31.8327 22.7875 31.3991 22.39 30.4028C22.2119 29.9589 22.0648 29.5072 21.9435 29.009C21.8196 28.5134 21.7189 27.9714 21.6286 27.3468C21.546 26.7635 21.5073 26.1027 21.5305 25.4652ZM40.277 35.2166C40.2744 35.343 40.2693 35.4721 40.2615 35.6011C40.2615 35.6089 40.259 35.6192 40.259 35.6295C40.2512 35.7612 40.2409 35.8928 40.2306 36.0244C40.228 36.0399 40.228 36.0554 40.2254 36.0709C40.1996 36.3548 40.1635 36.6413 40.1222 36.9227C40.1222 36.9278 40.1222 36.9304 40.1196 36.933C39.9699 37.9628 39.7324 38.9333 39.5156 39.576C39.4769 39.6922 39.4382 39.8006 39.402 39.8935C39.384 39.9426 39.3633 39.989 39.3453 40.0303C39.3194 40.0923 39.2962 40.1439 39.2704 40.1878C39.2472 40.2368 39.2239 40.2729 39.2007 40.2962C39.2007 40.2987 39.1955 40.3039 39.193 40.3065L39.1465 40.3684V40.4252C38.6742 42.3946 37.2417 48.2305 28.0194 47.9801C20.702 47.7814 18.4435 43.7058 17.9247 42.4617C16.9878 40.2058 16.469 34.2461 16.469 30.9861C16.469 27.7262 15.7875 24.825 15.7824 24.7992L15.7333 24.5514C15.4288 23.0441 14.9693 20.7624 14.4144 18.3671C14.1692 17.2908 14.3576 16.2661 14.9203 15.626C15.3281 15.164 15.896 14.9239 16.5774 14.9239C16.678 14.9239 16.7813 14.9291 16.8871 14.942C18.5596 15.1072 19.112 17.1876 19.4992 19.1234C19.6153 19.699 19.7082 20.3133 19.7986 20.9069C20.0206 22.3472 20.2477 23.8339 20.8052 25.1115C20.8542 25.2251 20.9239 25.3309 21.0117 25.4316C20.9833 26.1182 21.0298 26.8177 21.1175 27.4191C21.3008 28.7148 21.5382 29.6646 21.9125 30.5964C22.3771 31.7579 23.0766 32.4238 24.1064 32.669C24.5452 33.4795 25.2963 34.2357 26.3933 34.548C27.3302 34.8165 28.4453 34.8165 29.4312 34.8165C30.3191 34.8165 31.1606 34.8165 31.4832 35.0307C32.1724 35.4902 32.1595 35.9728 32.144 36.4374C32.144 36.4994 32.1414 36.5639 32.1414 36.6233H32.6576C32.6576 36.5691 32.6602 36.5097 32.6602 36.4503C32.6757 35.9315 32.6963 35.2191 31.7671 34.6023C31.3154 34.3003 30.4843 34.3003 29.4312 34.3003C28.4814 34.3003 27.4025 34.3003 26.5327 34.0525C25.7454 33.8279 25.1595 33.322 24.7672 32.7516C24.6459 32.5761 24.5426 32.3928 24.4575 32.2122C24.2432 31.7605 24.14 31.3062 24.14 30.9448C24.14 30.0569 24.8085 29.6543 25.4383 29.6543C25.4589 29.6543 26.1171 29.6336 27.0618 29.613C27.2347 29.6078 27.4154 29.6027 27.6038 29.6001C29.1654 29.5665 31.2329 29.5356 32.6318 29.5639C32.8176 29.5691 32.9906 29.5743 33.1506 29.5794C33.5455 29.5949 33.8527 29.6181 34.0282 29.6491C35.1768 29.8582 37.5591 30.7048 39.002 31.9282C39.0329 31.9566 39.0639 31.985 39.0949 32.0134C39.1439 32.0547 39.1904 32.096 39.2368 32.145H39.2394C39.2781 32.1812 39.3169 32.2173 39.3504 32.256C39.3582 32.2612 39.3633 32.2664 39.3659 32.2715C39.3995 32.3051 39.4304 32.336 39.4588 32.3696C39.495 32.4083 39.5285 32.447 39.5621 32.4858C39.593 32.5193 39.6188 32.5529 39.6447 32.5864C39.6731 32.62 39.6963 32.6509 39.7195 32.6845C39.7453 32.7181 39.7686 32.7516 39.7892 32.7852C39.815 32.8187 39.8357 32.8523 39.8537 32.8858C39.8976 32.9503 39.9337 33.0175 39.9673 33.0846C39.9983 33.1465 40.0267 33.2085 40.0525 33.2704C40.0525 33.2782 40.0576 33.2859 40.0602 33.2911C40.0731 33.3246 40.0834 33.3556 40.0938 33.3891C40.1144 33.4537 40.1325 33.5182 40.148 33.5827C40.2564 34.068 40.2925 34.6281 40.277 35.2166Z" fill="black"/>
+</svg>
diff --git a/packages/docs/images/logo_light.svg b/packages/docs/images/logo_light.svg
new file mode 100644
index 000000000..6575702c3
--- /dev/null
+++ b/packages/docs/images/logo_light.svg
@@ -0,0 +1,16 @@
+<svg width="194" height="57" viewBox="0 0 194 57" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M72 30.2216H74.525V31.2316C74.525 32.4184 75.5098 33.4031 76.6965 33.4031H78.3882C79.676 33.4031 80.585 32.5951 80.585 31.4841C80.585 27.9996 72.2525 27.2421 72.2525 22.4446C72.2525 19.9701 74.1967 18.2531 76.949 18.2531H78.1357C80.7365 18.2531 82.8575 20.3489 82.8575 22.9496V23.7071H80.3325V22.9496C80.3325 21.7376 79.3478 20.7781 78.1357 20.7781H76.949C75.5855 20.7781 74.7775 21.4094 74.7775 22.4446C74.7775 25.1211 83.11 26.1564 83.11 31.4841C83.11 34.0091 81.0647 35.9281 78.3882 35.9281H76.6965C74.0958 35.9281 72 33.8324 72 31.2316V30.2216Z" fill="black"/>
+<path d="M95.4726 25.5756H90.8014V31.3831C90.8014 32.5194 91.6851 33.4031 92.8214 33.4031H95.4726V35.9281H92.8214C90.2964 35.9281 88.2764 33.9081 88.2764 31.3831V25.5756H84.3626V23.0506H88.2764V19.7681H90.8014V23.0506H95.4726V25.5756Z" fill="black"/>
+<path d="M105.942 23.0506H108.467V35.9281H105.942V34.5141L103.846 35.9281H101.902C99.4018 35.9281 97.3565 33.8829 97.3565 31.3831V27.5956C97.3565 25.0706 99.4018 23.0506 101.902 23.0506H103.846L105.942 24.4646V23.0506ZM103.063 33.4031L105.942 31.4589V27.5199L103.063 25.5756H101.902C100.791 25.5756 99.8815 26.4846 99.8815 27.5956V31.3831C99.8815 32.4941 100.791 33.4031 101.902 33.4031H103.063Z" fill="black"/>
+<path d="M120.198 23.0506H122.723V36.6604C122.723 39.1601 120.703 41.2306 118.178 41.2306H116.158C113.658 41.2306 111.613 39.1601 111.613 36.6604H114.138C114.138 37.7714 115.047 38.6804 116.158 38.6804H118.178C119.289 38.6804 120.198 37.7714 120.198 36.6604V34.5141L118.102 35.9281H116.158C113.658 35.9281 111.613 33.8829 111.613 31.3831V27.5956C111.613 25.0706 113.658 23.0506 116.158 23.0506H118.102L120.198 24.4646V23.0506ZM117.319 33.4031L120.198 31.4589V27.5199L117.319 25.5756H116.158C115.047 25.5756 114.138 26.4846 114.138 27.5956V31.3831C114.138 32.4941 115.047 33.4031 116.158 33.4031H117.319Z" fill="black"/>
+<path d="M136.979 27.3431V30.0701H128.394V31.3579C128.394 32.4689 129.303 33.3779 130.414 33.3779H132.434C133.545 33.3779 134.454 32.4689 134.454 31.3579V31.1054H136.979V31.3579C136.979 33.8576 134.959 35.9281 132.434 35.9281H130.414C127.915 35.9281 125.869 33.8576 125.869 31.3579V27.5956C125.869 25.0706 127.915 23.0506 130.414 23.0506H132.434C134.884 23.0506 136.853 24.9444 136.979 27.3431ZM134.454 28.0501V27.5956C134.454 26.4594 133.571 25.5756 132.434 25.5756H130.414C129.278 25.5756 128.394 26.4846 128.394 27.5956V28.0501H134.454Z" fill="black"/>
+<path d="M146.691 23.0506C149.19 23.0506 151.236 25.0706 151.236 27.5956V35.9281H148.711V27.5956C148.711 26.4846 147.802 25.5756 146.691 25.5756H145.529L142.651 27.5199V35.9281H140.126V18.0006H142.651V24.4646L144.746 23.0506H146.691Z" fill="black"/>
+<path d="M162.967 23.0506H165.492V35.9281H162.967V34.5141L160.871 35.9281H158.927C156.427 35.9281 154.382 33.8829 154.382 31.3831V27.5956C154.382 25.0706 156.427 23.0506 158.927 23.0506H160.871L162.967 24.4646V23.0506ZM160.089 33.4031L162.967 31.4589V27.5199L160.089 25.5756H158.927C157.816 25.5756 156.907 26.4846 156.907 27.5956V31.3831C156.907 32.4941 157.816 33.4031 158.927 33.4031H160.089Z" fill="black"/>
+<path d="M175.203 23.0506C177.703 23.0506 179.748 25.0706 179.748 27.5956V35.9281H177.223V27.5956C177.223 26.4846 176.314 25.5756 175.203 25.5756H174.042L171.163 27.5199V35.9281H168.638V23.0506H171.163V24.4646L173.259 23.0506H175.203Z" fill="black"/>
+<path d="M191.48 18.0006H194.005V35.9281H191.48V34.5141L189.384 35.9281H187.44C184.94 35.9281 182.895 33.8829 182.895 31.3831V27.5956C182.895 25.0706 184.94 23.0506 187.44 23.0506H189.384L191.48 24.4646V18.0006ZM188.601 33.4031L191.48 31.4589V27.5199L188.601 25.5756H187.44C186.329 25.5756 185.42 26.4846 185.42 27.5956V31.3831C185.42 32.4941 186.329 33.4031 187.44 33.4031H188.601Z" fill="black"/>
+<rect width="57" height="57" fill="#FFC83C"/>
+<path d="M40.7828 34.5435C40.7957 34.8326 40.7931 35.1346 40.7802 35.4418C40.7957 35.1423 40.7957 34.8404 40.7828 34.5435ZM21.1019 24.4643C21.1019 24.4643 21.1045 24.4643 21.1045 24.4695C21.1174 24.3921 21.1303 24.3146 21.1458 24.2346C21.1277 24.3121 21.1148 24.3869 21.1019 24.4643ZM21.1458 24.2346C21.1768 24.0798 21.2129 23.9223 21.2568 23.77C21.2129 23.9197 21.1742 24.0746 21.1458 24.2346Z" fill="white"/>
+<path d="M40.7803 35.4411C40.7726 35.6063 40.7623 35.7741 40.7494 35.9418C40.7184 36.3058 40.6771 36.6723 40.6229 37.0336C40.61 37.124 40.5945 37.2117 40.5816 37.2969C40.5584 37.4389 40.5326 37.5808 40.5067 37.7176C40.5067 37.7383 40.499 37.7564 40.4964 37.7744C40.468 37.9215 40.4371 38.0738 40.4061 38.2261C40.388 38.301 40.3725 38.3784 40.3545 38.4558C40.3003 38.6856 40.2435 38.9127 40.1841 39.1321C40.1351 39.3153 40.0834 39.4909 40.0292 39.656C39.9544 39.8909 39.8744 40.1026 39.7969 40.2729C39.7763 40.3168 39.7556 40.3607 39.735 40.3994C39.704 40.4614 39.6731 40.5156 39.6447 40.562C38.3515 45.9023 34.7406 48.5041 28.6156 48.5041C28.4143 48.5041 28.2104 48.5015 28.0039 48.4963C20.3767 48.2873 17.997 43.9768 17.4498 42.6579C16.4844 40.3426 15.9527 34.2874 15.9527 30.9861C15.9527 27.9379 15.2842 24.9386 15.2765 24.9076L15.2274 24.6547C14.9229 23.1473 14.466 20.8708 13.9137 18.4833C13.6246 17.2263 13.8491 16.0596 14.5331 15.2853C15.1061 14.6349 15.9605 14.3303 16.9387 14.4258C19.1327 14.6452 19.6798 17.3837 20.0051 19.0201C20.1238 19.6086 20.2167 20.2281 20.3096 20.8295C20.5006 22.0684 20.6968 23.3461 21.102 24.4637C21.102 24.4637 21.1029 24.4654 21.1046 24.4689C21.1175 24.3914 21.1304 24.314 21.1459 24.234C21.1769 24.0791 21.213 23.9217 21.2569 23.7694C21.2801 23.6919 21.3034 23.6171 21.3292 23.5422C21.3524 23.4777 21.3782 23.4132 21.404 23.3512C21.4195 23.3151 21.435 23.279 21.4531 23.2428C21.4634 23.2144 21.4789 23.186 21.4918 23.1577C21.5124 23.1189 21.5331 23.0802 21.5537 23.0441C21.5589 23.0312 21.5666 23.0183 21.577 23.0079C21.5976 22.9667 21.6208 22.9279 21.6466 22.8918C21.6802 22.8376 21.7163 22.7886 21.7551 22.7421C22.612 21.6709 23.505 21.6709 24.0987 21.6709C24.411 21.6709 25.9209 21.7355 26.703 22.9047C26.7546 22.9847 26.8037 23.0673 26.8476 23.1551C26.8837 22.9589 26.9224 22.7834 26.9689 22.6337C27.0489 22.3653 27.1625 22.1304 27.2967 21.9239C27.3199 21.8903 27.3431 21.8568 27.3664 21.8232C27.4154 21.7587 27.467 21.6967 27.5186 21.6374C28.1226 20.9586 29.0183 20.6979 29.7461 20.6979C29.8881 20.6979 30.0688 20.7056 30.2753 20.734C30.3166 20.7392 30.3579 20.7443 30.3992 20.7546C30.4379 20.7598 30.4766 20.765 30.5153 20.7753C30.5773 20.7856 30.6392 20.8011 30.7011 20.8166C30.7657 20.8321 30.8302 20.8502 30.8947 20.8708C30.9928 20.9018 31.0935 20.9353 31.1941 20.9792C31.2251 20.9921 31.2587 21.0076 31.2922 21.0231C31.3258 21.0386 31.3593 21.0541 31.3929 21.0721C31.7929 21.2709 32.1904 21.578 32.5105 22.04C32.5389 22.0788 32.5647 22.1175 32.5905 22.1588C32.5724 21.5651 32.5415 20.8811 32.5105 20.1403C32.4202 17.9464 32.3143 15.4608 32.4098 13.5405C32.5828 10.0947 33.6462 8.48926 35.7549 8.48926C38.2999 8.48926 38.5942 11.2872 38.5942 13.3933C38.5942 16.5475 38.5942 20.8682 38.8523 24.474C38.8781 24.8431 38.9065 25.3 38.9374 25.8059C39.0355 27.3829 39.1697 29.5407 39.3659 30.9087C39.3969 31.11 39.4356 31.3681 39.482 31.6675C39.4924 31.6753 39.5027 31.6856 39.5104 31.6959C39.7298 31.8973 39.9286 32.1089 40.0964 32.3283C40.1273 32.367 40.1531 32.4032 40.1789 32.4419C40.2848 32.589 40.3751 32.7387 40.45 32.8936C40.468 32.9323 40.4861 32.971 40.5016 33.0071C40.5351 33.082 40.5635 33.1594 40.5893 33.2369C40.6022 33.2756 40.6152 33.3143 40.6255 33.353C40.6358 33.3917 40.6461 33.4304 40.6539 33.4692C40.6926 33.6395 40.721 33.8202 40.7416 34.0034C40.7545 34.117 40.7649 34.2332 40.7726 34.3519C40.7778 34.4138 40.7829 34.4784 40.7829 34.5429C40.7958 34.832 40.7932 35.134 40.7803 35.4411Z" fill="white"/>
+<path d="M21.1458 24.2346C21.1768 24.0798 21.2129 23.9223 21.2568 23.77C21.2129 23.9197 21.1742 24.0746 21.1458 24.2346ZM21.1019 24.4643C21.1019 24.4643 21.1045 24.4643 21.1045 24.4695C21.1174 24.3921 21.1303 24.3146 21.1458 24.2346C21.1277 24.3121 21.1148 24.3869 21.1019 24.4643ZM39.5155 39.5767C39.7323 38.934 39.9698 37.9635 40.1195 36.9336C39.9646 37.9687 39.722 38.9417 39.5155 39.5767ZM40.7828 34.5435C40.7957 34.8326 40.7931 35.1346 40.7802 35.4418C40.7957 35.1423 40.7957 34.8404 40.7828 34.5435Z" fill="black"/>
+<path d="M40.7829 34.5429C40.7829 34.4784 40.7778 34.4138 40.7726 34.3519C40.7649 34.2332 40.7545 34.117 40.7416 34.0034C40.721 33.8202 40.6926 33.6395 40.6539 33.4692C40.6461 33.4304 40.6358 33.3917 40.6255 33.353C40.6152 33.3143 40.6022 33.2756 40.5893 33.2369C40.5635 33.1594 40.5351 33.082 40.5016 33.0071C40.4861 32.971 40.468 32.9323 40.45 32.8936C40.3751 32.7387 40.2848 32.589 40.1789 32.4419C40.1531 32.4032 40.1273 32.367 40.0964 32.3283C39.9286 32.1089 39.7298 31.8973 39.5104 31.6959C39.5027 31.6856 39.4924 31.6753 39.482 31.6675C39.4356 31.3681 39.3969 31.11 39.3659 30.9087C39.1697 29.5407 39.0355 27.3829 38.9374 25.8059C38.9065 25.3 38.8781 24.8431 38.8523 24.474C38.5942 20.8682 38.5942 16.5475 38.5942 13.3933C38.5942 11.2872 38.2999 8.48926 35.7549 8.48926C33.6462 8.48926 32.5828 10.0947 32.4098 13.5405C32.3143 15.4608 32.4202 17.9464 32.5105 20.1403C32.5415 20.8811 32.5724 21.5651 32.5905 22.1588C32.5647 22.1175 32.5389 22.0788 32.5105 22.04C32.1904 21.578 31.7929 21.2709 31.3929 21.0721C31.3593 21.0541 31.3258 21.0386 31.2922 21.0231C31.2587 21.0076 31.2251 20.9921 31.1941 20.9792C31.0935 20.9353 30.9928 20.9018 30.8947 20.8708C30.8302 20.8502 30.7657 20.8321 30.7011 20.8166C30.6392 20.8011 30.5773 20.7856 30.5153 20.7753C30.4766 20.765 30.4379 20.7598 30.3992 20.7546C30.3579 20.7443 30.3166 20.7392 30.2753 20.734C30.0688 20.7056 29.8881 20.6979 29.7461 20.6979C29.0183 20.6979 28.1226 20.9586 27.5186 21.6374C27.467 21.6967 27.4154 21.7587 27.3664 21.8232C27.3431 21.8568 27.3199 21.8903 27.2967 21.9239C27.1625 22.1304 27.0489 22.3653 26.9689 22.6337C26.9224 22.7834 26.8837 22.9589 26.8476 23.1551C26.8037 23.0673 26.7546 22.9847 26.703 22.9047C25.9209 21.7355 24.411 21.6709 24.0987 21.6709C23.505 21.6709 22.612 21.6709 21.7551 22.7421C21.7163 22.7886 21.6802 22.8376 21.6466 22.8918C21.6208 22.9279 21.5976 22.9667 21.577 23.0079C21.5666 23.0183 21.5589 23.0312 21.5537 23.0441C21.5331 23.0802 21.5124 23.1189 21.4918 23.1577C21.4789 23.186 21.4634 23.2144 21.4531 23.2428C21.435 23.279 21.4195 23.3151 21.404 23.3512C21.3782 23.4132 21.3524 23.4777 21.3292 23.5422C21.3034 23.6171 21.2801 23.6919 21.2569 23.7694C21.213 23.9217 21.1769 24.0791 21.1459 24.234C21.1304 24.314 21.1175 24.3914 21.1046 24.4689C21.1046 24.4689 21.1038 24.4671 21.102 24.4637C20.6968 23.3461 20.5006 22.0684 20.3096 20.8295C20.2167 20.2281 20.1238 19.6086 20.0051 19.0201C19.6798 17.3837 19.1327 14.6452 16.9387 14.4258C15.9605 14.3303 15.1061 14.6349 14.5331 15.2853C13.8491 16.0596 13.6246 17.2263 13.9137 18.4833C14.466 20.8708 14.9229 23.1473 15.2274 24.6547L15.2765 24.9076C15.2842 24.9386 15.9527 27.9379 15.9527 30.9861C15.9527 34.2874 16.4844 40.3426 17.4498 42.6579C17.997 43.9768 20.3767 48.2873 28.0039 48.4963C28.2104 48.5015 28.4143 48.5041 28.6156 48.5041C34.7406 48.5041 38.3515 45.9023 39.6447 40.562C39.6731 40.5156 39.704 40.4614 39.735 40.3994C39.7556 40.3607 39.7763 40.3168 39.7969 40.2729C39.8744 40.1026 39.9544 39.8909 40.0292 39.656C40.0834 39.4909 40.1351 39.3153 40.1841 39.1321C40.2435 38.9127 40.3003 38.6856 40.3545 38.4558C40.3725 38.3784 40.388 38.301 40.4061 38.2261C40.4371 38.0738 40.468 37.9215 40.4964 37.7744C40.499 37.7564 40.5042 37.7383 40.5067 37.7176C40.5326 37.5808 40.5584 37.4389 40.5816 37.2969C40.5945 37.2117 40.61 37.124 40.6229 37.0336C40.6771 36.6723 40.7184 36.3058 40.7494 35.9418C40.7623 35.7741 40.7726 35.6063 40.7803 35.4411C40.7932 35.134 40.7958 34.832 40.7829 34.5429ZM32.9261 13.5663C33.13 9.52428 34.5444 9.00548 35.7549 9.00548C37.3604 9.00548 38.0779 10.358 38.0779 13.3933C38.0779 16.4287 38.0779 20.8889 38.336 24.5102C38.3619 24.8792 38.3902 25.3335 38.4238 25.8394C38.5219 27.4242 38.6561 29.5949 38.8548 30.9836C38.8652 31.0481 38.8755 31.1178 38.8858 31.1926C37.2907 30.0389 35.0787 29.3162 34.1211 29.1432C33.9353 29.1097 33.6255 29.0864 33.228 29.0684C33.4139 27.5894 33.4836 25.1812 33.1196 23.5371C33.1222 23.5216 33.1222 23.5061 33.1222 23.4932C33.1351 22.7137 33.0861 21.5109 33.0267 20.1197C32.9364 17.9361 32.8331 15.4634 32.9261 13.5663ZM27.2063 24.4482V24.443C27.2218 24.203 27.2425 23.9733 27.2709 23.7565C27.276 23.6997 27.2838 23.6455 27.2915 23.5939C27.3018 23.5138 27.3147 23.4364 27.3302 23.3616C27.3431 23.2867 27.356 23.2119 27.3741 23.1422C27.387 23.0751 27.4025 23.0105 27.418 22.946C27.4309 22.8892 27.4464 22.835 27.4619 22.7834C27.8103 21.6245 28.9099 21.2141 29.7461 21.2141C30.2572 21.2141 31.3851 21.338 32.0872 22.3394C32.1672 22.4504 32.2395 22.5743 32.304 22.7085C32.3272 22.7524 32.3479 22.7989 32.3685 22.8453C32.3892 22.8918 32.4098 22.9434 32.4279 22.9925C32.464 23.088 32.4976 23.186 32.526 23.2919C32.5905 23.5113 32.6447 23.7513 32.6912 24.0068C32.8176 24.7424 32.8693 25.6045 32.8693 26.4486C32.8693 27.4087 32.8047 28.3457 32.7118 29.0529C31.2561 29.0168 29.0957 29.0503 27.5057 29.0839C27.356 28.2553 27.2502 27.321 27.2038 26.4021C27.1702 25.7233 27.1676 25.0573 27.2063 24.4482ZM21.5305 25.4652C21.5331 25.3851 21.5382 25.3051 21.5434 25.2251C21.5563 25.0264 21.5744 24.8328 21.6002 24.6444C21.6028 24.6315 21.6053 24.6211 21.6053 24.6108C21.6234 24.4869 21.6441 24.3656 21.6699 24.252C21.6828 24.1901 21.6983 24.1281 21.7112 24.0688C21.7396 23.9526 21.7705 23.8416 21.8093 23.7384C21.8273 23.6842 21.8454 23.6326 21.866 23.5835C21.8867 23.5319 21.9073 23.4829 21.9306 23.4364C21.9538 23.39 21.977 23.3461 22.0003 23.3022C22.0493 23.2144 22.1009 23.137 22.1577 23.0647C22.2016 23.0105 22.2455 22.9589 22.2893 22.9099C22.3332 22.8608 22.3771 22.8144 22.421 22.7757C22.5087 22.6879 22.5939 22.6182 22.6791 22.5563C22.9036 22.3911 23.123 22.3007 23.3347 22.2517H23.3373C23.407 22.2336 23.4766 22.2207 23.5463 22.213C23.7373 22.1872 23.9206 22.1872 24.0987 22.1872C24.3542 22.1872 25.5596 22.2362 26.2152 23.1086C26.2849 23.199 26.3468 23.2996 26.401 23.408C26.4217 23.4493 26.4397 23.4906 26.4578 23.5293C26.5069 23.6377 26.5456 23.741 26.574 23.8442C26.5869 23.8752 26.5946 23.9088 26.6024 23.9397C26.6153 23.981 26.623 24.0197 26.6307 24.0585C26.6411 24.0998 26.6488 24.1411 26.6566 24.1824C26.6617 24.2211 26.6695 24.2572 26.6746 24.2959C26.6798 24.3398 26.685 24.3863 26.6875 24.4301C26.6953 24.4972 26.7004 24.5644 26.703 24.6315C26.703 24.6469 26.7056 24.6624 26.7056 24.6779C26.703 24.6805 26.703 24.6857 26.7056 24.6882C26.7004 24.7941 26.6979 24.9025 26.6953 25.0135V25.0548C26.6927 25.1554 26.6901 25.2561 26.6901 25.3593V25.5348C26.6901 25.6484 26.6927 25.762 26.6953 25.8781C26.6953 25.9943 26.7004 26.1104 26.7056 26.2292C26.7185 26.6783 26.7469 27.1377 26.7882 27.5997C26.8218 27.9637 26.8785 28.5083 26.974 29.0968C26.1145 29.1174 25.5131 29.1355 25.4305 29.1381C24.5323 29.1381 23.6238 29.7575 23.6238 30.9448C23.6238 31.2701 23.6909 31.6495 23.8277 32.0418C23.3218 31.8327 22.7875 31.3991 22.39 30.4028C22.2119 29.9589 22.0648 29.5072 21.9435 29.009C21.8196 28.5134 21.7189 27.9714 21.6286 27.3468C21.546 26.7635 21.5073 26.1027 21.5305 25.4652ZM40.277 35.2166C40.2744 35.343 40.2693 35.4721 40.2615 35.6011C40.2615 35.6089 40.259 35.6192 40.259 35.6295C40.2512 35.7612 40.2409 35.8928 40.2306 36.0244C40.228 36.0399 40.228 36.0554 40.2254 36.0709C40.1996 36.3548 40.1635 36.6413 40.1222 36.9227C40.1222 36.9278 40.1222 36.9304 40.1196 36.933C39.9699 37.9628 39.7324 38.9333 39.5156 39.576C39.4769 39.6922 39.4382 39.8006 39.402 39.8935C39.384 39.9426 39.3633 39.989 39.3453 40.0303C39.3194 40.0923 39.2962 40.1439 39.2704 40.1878C39.2472 40.2368 39.2239 40.2729 39.2007 40.2962C39.2007 40.2987 39.1955 40.3039 39.193 40.3065L39.1465 40.3684V40.4252C38.6742 42.3946 37.2417 48.2305 28.0194 47.9801C20.702 47.7814 18.4435 43.7058 17.9247 42.4617C16.9878 40.2058 16.469 34.2461 16.469 30.9861C16.469 27.7262 15.7875 24.825 15.7824 24.7992L15.7333 24.5514C15.4288 23.0441 14.9693 20.7624 14.4144 18.3671C14.1692 17.2908 14.3576 16.2661 14.9203 15.626C15.3281 15.164 15.896 14.9239 16.5774 14.9239C16.678 14.9239 16.7813 14.9291 16.8871 14.942C18.5596 15.1072 19.112 17.1876 19.4992 19.1234C19.6153 19.699 19.7082 20.3133 19.7986 20.9069C20.0206 22.3472 20.2477 23.8339 20.8052 25.1115C20.8542 25.2251 20.9239 25.3309 21.0117 25.4316C20.9833 26.1182 21.0298 26.8177 21.1175 27.4191C21.3008 28.7148 21.5382 29.6646 21.9125 30.5964C22.3771 31.7579 23.0766 32.4238 24.1064 32.669C24.5452 33.4795 25.2963 34.2357 26.3933 34.548C27.3302 34.8165 28.4453 34.8165 29.4312 34.8165C30.3191 34.8165 31.1606 34.8165 31.4832 35.0307C32.1724 35.4902 32.1595 35.9728 32.144 36.4374C32.144 36.4994 32.1414 36.5639 32.1414 36.6233H32.6576C32.6576 36.5691 32.6602 36.5097 32.6602 36.4503C32.6757 35.9315 32.6963 35.2191 31.7671 34.6023C31.3154 34.3003 30.4843 34.3003 29.4312 34.3003C28.4814 34.3003 27.4025 34.3003 26.5327 34.0525C25.7454 33.8279 25.1595 33.322 24.7672 32.7516C24.6459 32.5761 24.5426 32.3928 24.4575 32.2122C24.2432 31.7605 24.14 31.3062 24.14 30.9448C24.14 30.0569 24.8085 29.6543 25.4383 29.6543C25.4589 29.6543 26.1171 29.6336 27.0618 29.613C27.2347 29.6078 27.4154 29.6027 27.6038 29.6001C29.1654 29.5665 31.2329 29.5356 32.6318 29.5639C32.8176 29.5691 32.9906 29.5743 33.1506 29.5794C33.5455 29.5949 33.8527 29.6181 34.0282 29.6491C35.1768 29.8582 37.5591 30.7048 39.002 31.9282C39.0329 31.9566 39.0639 31.985 39.0949 32.0134C39.1439 32.0547 39.1904 32.096 39.2368 32.145H39.2394C39.2781 32.1812 39.3169 32.2173 39.3504 32.256C39.3582 32.2612 39.3633 32.2664 39.3659 32.2715C39.3995 32.3051 39.4304 32.336 39.4588 32.3696C39.495 32.4083 39.5285 32.447 39.5621 32.4858C39.593 32.5193 39.6188 32.5529 39.6447 32.5864C39.6731 32.62 39.6963 32.6509 39.7195 32.6845C39.7453 32.7181 39.7686 32.7516 39.7892 32.7852C39.815 32.8187 39.8357 32.8523 39.8537 32.8858C39.8976 32.9503 39.9337 33.0175 39.9673 33.0846C39.9983 33.1465 40.0267 33.2085 40.0525 33.2704C40.0525 33.2782 40.0576 33.2859 40.0602 33.2911C40.0731 33.3246 40.0834 33.3556 40.0938 33.3891C40.1144 33.4537 40.1325 33.5182 40.148 33.5827C40.2564 34.068 40.2925 34.6281 40.277 35.2166Z" fill="black"/>
+</svg>
diff --git a/packages/docs/images/mcp/browserbase-mcp.png b/packages/docs/images/mcp/browserbase-mcp.png
new file mode 100644
index 000000000..107f7584e
Binary files /dev/null and b/packages/docs/images/mcp/browserbase-mcp.png differ
diff --git a/packages/docs/images/mcp/smithery.jpg b/packages/docs/images/mcp/smithery.jpg
new file mode 100644
index 000000000..b54ad7403
Binary files /dev/null and b/packages/docs/images/mcp/smithery.jpg differ
diff --git a/packages/docs/images/pr_draft.png b/packages/docs/images/pr_draft.png
new file mode 100644
index 000000000..58907e3c3
Binary files /dev/null and b/packages/docs/images/pr_draft.png differ
diff --git a/packages/docs/images/quickstart/api-key.png b/packages/docs/images/quickstart/api-key.png
new file mode 100644
index 000000000..000c10e12
Binary files /dev/null and b/packages/docs/images/quickstart/api-key.png differ
diff --git a/packages/docs/images/quickstart/dashboard.png b/packages/docs/images/quickstart/dashboard.png
new file mode 100644
index 000000000..9634b6bb7
Binary files /dev/null and b/packages/docs/images/quickstart/dashboard.png differ
diff --git a/docs/media/stagehand-playwright.png b/packages/docs/images/stagehand-playwright.png
similarity index 100%
rename from docs/media/stagehand-playwright.png
rename to packages/docs/images/stagehand-playwright.png
diff --git a/packages/docs/images/stagehand_nextjs.png b/packages/docs/images/stagehand_nextjs.png
new file mode 100644
index 000000000..3c51a77f1
Binary files /dev/null and b/packages/docs/images/stagehand_nextjs.png differ
diff --git a/packages/docs/images/typescript.svg b/packages/docs/images/typescript.svg
new file mode 100644
index 000000000..7d240790a
--- /dev/null
+++ b/packages/docs/images/typescript.svg
@@ -0,0 +1,10 @@
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+
<!-- Uploaded to: SVG Repo, www.svgrepo.com, Transformed by: SVG Repo Mixer Tools -->
+<svg xmlns="http://www.w3.org/2000/svg" aria-label="TypeScript" role="img" viewBox="-15.36 -15.36 542.72 542.72" width="79px" height="79px" fill="#000000" stroke="#000000" transform="matrix(1, 0, 0, 1, 0, 0)" stroke-width="0.00512">
+
<g id="SVGRepo_bgCarrier" stroke-width="0"/>
+
<g id="SVGRepo_tracerCarrier" stroke-linecap="round" stroke-linejoin="round"/>
+
<g id="SVGRepo_iconCarrier">
+
<rect width="512" height="512" rx="15%" fill="#808080"/>
+
<path fill="#ffffff" d="m233 284h64v-41H118v41h64v183h51zm84 173c8.1 4.2 18 7.3 29 9.4s23 3.1 35 3.1c12 0 23-1.1 34-3.4c11-2.3 20-6.1 28-11c8.1-5.3 15-12 19-21s7.1-19 7.1-32c0-9.1-1.4-17-4.1-24s-6.6-13-12-18c-5.1-5.3-11-10-18-14s-15-8.2-24-12c-6.6-2.7-12-5.3-18-7.9c-5.2-2.6-9.7-5.2-13-7.8c-3.7-2.7-6.5-5.5-8.5-8.4c-2-3-3-6.3-3-10c0-3.4.89-6.5 2.7-9.3s4.3-5.1 7.5-7.1c3.2-2 7.2-3.5 12-4.6c4.7-1.1 9.9-1.6 16-1.6c4.2 0 8.6.31 13 .94c4.6.63 9.3 1.6 14 2.9c4.7 1.3 9.3 2.9 14 4.9c4.4 2 8.5 4.3 12 6.9v-47c-7.6-2.9-16-5.1-25-6.5s-19-2.1-31-2.1c-12 0-23 1.3-34 3.8s-20 6.5-28 12c-8.1 5.4-14 12-19 21c-4.7 8.4-7 18-7 30c0 15 4.3 28 13 38c8.6 11 22 19 39 27c6.9 2.8 13 5.6 19 8.3s11 5.5 15 8.4c4.3 2.9 7.7 6.1 10 9.5c2.5 3.4 3.8 7.4 3.8 12c0 3.2-.78 6.2-2.3 9s-3.9 5.2-7.1 7.2s-7.1 3.6-12 4.8c-4.7 1.1-10 1.7-17 1.7c-11 0-22-1.9-32-5.7c-11-3.8-21-9.5-28.1-15.44z"/>
+
</g>
+
</svg>
\ No newline at end of file
diff --git a/packages/docs/images/typescript_dark.svg b/packages/docs/images/typescript_dark.svg
new file mode 100644
index 000000000..ba46c4bc0
--- /dev/null
+++ b/packages/docs/images/typescript_dark.svg
@@ -0,0 +1,10 @@
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+
<!-- Uploaded to: SVG Repo, www.svgrepo.com, Transformed by: SVG Repo Mixer Tools -->
+<svg xmlns="http://www.w3.org/2000/svg" aria-label="TypeScript" role="img" viewBox="0 0 512 512" width="64px" height="64px" fill="#a4a2a0" stroke="#a4a2a0">
+
<g id="SVGRepo_bgCarrier" stroke-width="0"/>
+
<g id="SVGRepo_tracerCarrier" stroke-linecap="round" stroke-linejoin="round"/>
+
<g id="SVGRepo_iconCarrier">
+
<rect width="512" height="512" rx="15%" fill="#a4a29f"/>
+
<path fill="#191918" d="m233 284h64v-41H118v41h64v183h51zm84 173c8.1 4.2 18 7.3 29 9.4s23 3.1 35 3.1c12 0 23-1.1 34-3.4c11-2.3 20-6.1 28-11c8.1-5.3 15-12 19-21s7.1-19 7.1-32c0-9.1-1.4-17-4.1-24s-6.6-13-12-18c-5.1-5.3-11-10-18-14s-15-8.2-24-12c-6.6-2.7-12-5.3-18-7.9c-5.2-2.6-9.7-5.2-13-7.8c-3.7-2.7-6.5-5.5-8.5-8.4c-2-3-3-6.3-3-10c0-3.4.89-6.5 2.7-9.3s4.3-5.1 7.5-7.1c3.2-2 7.2-3.5 12-4.6c4.7-1.1 9.9-1.6 16-1.6c4.2 0 8.6.31 13 .94c4.6.63 9.3 1.6 14 2.9c4.7 1.3 9.3 2.9 14 4.9c4.4 2 8.5 4.3 12 6.9v-47c-7.6-2.9-16-5.1-25-6.5s-19-2.1-31-2.1c-12 0-23 1.3-34 3.8s-20 6.5-28 12c-8.1 5.4-14 12-19 21c-4.7 8.4-7 18-7 30c0 15 4.3 28 13 38c8.6 11 22 19 39 27c6.9 2.8 13 5.6 19 8.3s11 5.5 15 8.4c4.3 2.9 7.7 6.1 10 9.5c2.5 3.4 3.8 7.4 3.8 12c0 3.2-.78 6.2-2.3 9s-3.9 5.2-7.1 7.2s-7.1 3.6-12 4.8c-4.7 1.1-10 1.7-17 1.7c-11 0-22-1.9-32-5.7c-11-3.8-21-9.5-28.1-15.44z"/>
+
</g>
+
</svg>
\ No newline at end of file
diff --git a/packages/docs/images/typescript_yellow.svg b/packages/docs/images/typescript_yellow.svg
new file mode 100644
index 000000000..23a0de28d
--- /dev/null
+++ b/packages/docs/images/typescript_yellow.svg
@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" width="24" height="24">
+  <rect width="512" height="512" rx="50" fill="#FEC93B"/>
+  <path fill="#1a1a1a" d="m233 284h64v-41H118v41h64v183h51zm84 173c8.1 4.2 18 7.3 29 9.4s23 3.1 35 3.1c12 0 23-1.1 34-3.4c11-2.3 20-6.1 28-11c8.1-5.3 15-12 19-21s7.1-19 7.1-32c0-9.1-1.4-17-4.1-24s-6.6-13-12-18c-5.1-5.3-11-10-18-14s-15-8.2-24-12c-6.6-2.7-12-5.3-18-7.9c-5.2-2.6-9.7-5.2-13-7.8c-3.7-2.7-6.5-5.5-8.5-8.4c-2-3-3-6.3-3-10c0-3.4.89-6.5 2.7-9.3s4.3-5.1 7.5-7.1c3.2-2 7.2-3.5 12-4.6c4.7-1.1 9.9-1.6 16-1.6c4.2 0 8.6.31 13 .94c4.6.63 9.3 1.6 14 2.9c4.7 1.3 9.3 2.9 14 4.9c4.4 2 8.5 4.3 12 6.9v-47c-7.6-2.9-16-5.1-25-6.5s-19-2.1-31-2.1c-12 0-23 1.3-34 3.8s-20 6.5-28 12c-8.1 5.4-14 12-19 21c-4.7 8.4-7 18-7 30c0 15 4.3 28 13 38c8.6 11 22 19 39 27c6.9 2.8 13 5.6 19 8.3s11 5.5 15 8.4c4.3 2.9 7.7 6.1 10 9.5c2.5 3.4 3.8 7.4 3.8 12c0 3.2-.78 6.2-2.3 9s-3.9 5.2-7.1 7.2s-7.1 3.6-12 4.8c-4.7 1.1-10 1.7-17 1.7c-11 0-22-1.9-32-5.7c-11-3.8-21-9.5-28.1-15.44z"/>
+</svg>
\ No newline at end of file
diff --git a/packages/docs/images/windsurf-mcp.png b/packages/docs/images/windsurf-mcp.png
new file mode 100644
index 000000000..cfe877290
Binary files /dev/null and b/packages/docs/images/windsurf-mcp.png differ
diff --git a/packages/docs/language-selector.js b/packages/docs/language-selector.js
new file mode 100644
index 000000000..70e8a3718
--- /dev/null
+++ b/packages/docs/language-selector.js
@@ -0,0 +1,482 @@
+// Language switcher for Stagehand docs
+// Handles: 1) Sidebar language dropdown selection 2) Code block language syncing
+
+(function() {
+  // ============================================
+  // CONFIGURATION
+  // ============================================
+
+  const DROPDOWN_LANGUAGES = ['TypeScript', 'Python', 'Java', 'Go', 'Ruby'];
+
+  const LANGUAGE_MAP = {
+    'TypeScript': 'Javascript',
+    'Python': 'Python',
+    'Java': 'Java',
+    'Go': 'Go',
+    'Ruby': 'Ruby'
+  };
+
+  const CODE_BLOCK_LANGUAGES = ['Javascript', 'Python', 'Go', 'Java', 'Ruby', 'cURL', 'PHP'];
+
+  const SDK_PATH_MAP = {
+    'Python': 'python',
+    'Java': 'java',
+    'Go': 'go',
+    'Ruby': 'ruby'
+  };
+
+  const NAVIGATION_MAP = {
+    'TypeScript': '/v3/first-steps/introduction',
+    'Python': '/v3/sdk/python',
+    'Java': '/v3/sdk/java',
+    'Go': '/v3/sdk/go',
+    'Ruby': '/v3/sdk/ruby'
+  };
+
+  let currentSelectedLanguage = 'TypeScript';
+  let isSelecting = false;
+
+  // ============================================
+  // UTILITIES
+  // ============================================
+
+  // Run callback on next frame (immediate visual update)
+  const onNextFrame = (fn) => requestAnimationFrame(() => requestAnimationFrame(fn));
+
+  const dropdownStyle = document.createElement('style');
+  dropdownStyle.id = 'stagehand-language-style';
+  dropdownStyle.textContent = `
+    /* Hide dropdown during programmatic selection */
+    .stagehand-selecting [role="menu"],
+    .stagehand-selecting [role="listbox"] {
+      opacity: 0 !important;
+      pointer-events: none !important;
+      transition: none !important;
+    }
+    
+    /* Hide version switcher when non-TypeScript language is selected */
+    .stagehand-hide-version-switcher .stagehand-version-switcher {
+      display: none !important;
+    }
+    
+    /* Hide SDK reference items that don't match the selected language */
+    li[id^="/v3/sdk/"].stagehand-sdk-hidden {
+      display: none !important;
+    }
+  `;
+  document.head.appendChild(dropdownStyle);
+  
+  // ============================================
+  // SDK REFERENCE FILTERING
+  // ============================================
+  
+  function updateSDKReferenceVisibility() {
+    // Get the SDK path for the current language
+    const currentSDKPath = SDK_PATH_MAP[currentSelectedLanguage];
+    
+    // Find all SDK reference items in the sidebar
+    const sdkItems = document.querySelectorAll('li[id^="/v3/sdk/"]');
+    
+    sdkItems.forEach(item => {
+      const itemId = item.getAttribute('id') || '';
+      // Extract the language from the id (e.g., "/v3/sdk/python" -> "python")
+      const itemLang = itemId.split('/').pop();
+      
+      if (currentSelectedLanguage === 'TypeScript') {
+        // For TypeScript, hide all SDK references (they don't apply)
+        item.classList.add('stagehand-sdk-hidden');
+      } else if (currentSDKPath && itemLang === currentSDKPath) {
+        // Show the SDK that matches the current language
+        item.classList.remove('stagehand-sdk-hidden');
+      } else {
+        // Hide SDKs that don't match
+        item.classList.add('stagehand-sdk-hidden');
+      }
+    });
+  }
+
+  // ============================================
+  // VERSION SWITCHER VISIBILITY
+  // ============================================
+  
+  function getVersionSwitcher() {
+    // Find the version switcher button (contains "v3" or "v2" and has chevron-down)
+    const buttons = document.querySelectorAll('button');
+    for (const btn of buttons) {
+      const text = (btn.textContent || '').trim().toLowerCase();
+      // Check if it's a version button (v2, v3, etc.) with chevron icon
+      if (/^v\d+$/.test(text) && btn.querySelector('.lucide-chevron-down')) {
+        return btn;
+      }
+    }
+    return null;
+  }
+  
+  function updateVersionSwitcherVisibility() {
+    const versionSwitcher = getVersionSwitcher();
+    
+    if (versionSwitcher) {
+      // Mark the version switcher so we can target it with CSS
+      versionSwitcher.classList.add('stagehand-version-switcher');
+      
+      // Show version switcher only for TypeScript
+      if (currentSelectedLanguage === 'TypeScript') {
+        document.body.classList.remove('stagehand-hide-version-switcher');
+      } else {
+        document.body.classList.add('stagehand-hide-version-switcher');
+      }
+    }
+  }
+  
+  // ============================================
+  // SIDEBAR DROPDOWN FUNCTIONS
+  // ============================================
+  
+  function getDropdownButton() {
+    const buttons = document.querySelectorAll('button');
+    for (const btn of buttons) {
+      const text = (btn.textContent || '').trim();
+      if (DROPDOWN_LANGUAGES.includes(text)) {
+        return btn;
+      }
+    }
+    return null;
+  }
+  
+  function getDropdownMenu() {
+    return document.querySelector('menu[role="menu"], [role="menu"]');
+  }
+  
+  function updateButtonText(newText) {
+    const button = getDropdownButton();
+    if (!button) return;
+    
+    const paragraph = button.querySelector('p');
+    if (paragraph) {
+      paragraph.textContent = newText;
+    }
+  }
+  
+  function updateDropdownCheckIndicator() {
+    const menu = getDropdownMenu();
+    if (!menu) return;
+    
+    const menuItems = menu.querySelectorAll('a, [role="menuitem"]');
+    const checkIconsMap = new Map();
+    let anyCheckIcon = null;
+    
+    for (const item of menuItems) {
+      const text = (item.textContent || '').trim();
+      const checkIcon = item.querySelector('.lucide-check, [class*="lucide-check"], svg[class*="check"]');
+      
+      for (const lang of DROPDOWN_LANGUAGES) {
+        if (text.includes(lang)) {
+          checkIconsMap.set(lang, { item, checkIcon });
+          if (checkIcon) {
+            anyCheckIcon = checkIcon;
+          }
+          break;
+        }
+      }
+    }
+    
+    for (const [lang, { item, checkIcon }] of checkIconsMap) {
+      const shouldBeSelected = lang === currentSelectedLanguage;
+      
+      if (checkIcon) {
+        checkIcon.style.opacity = shouldBeSelected ? '1' : '0';
+        checkIcon.style.visibility = shouldBeSelected ? 'visible' : 'hidden';
+      } else if (shouldBeSelected && anyCheckIcon) {
+        const clonedCheck = anyCheckIcon.cloneNode(true);
+        clonedCheck.style.opacity = '1';
+        clonedCheck.style.visibility = 'visible';
+        
+        const targetSpan = item.querySelector('span:last-child') || item;
+        if (targetSpan.querySelector('.lucide-check, [class*="lucide-check"]') === null) {
+          targetSpan.appendChild(clonedCheck);
+        }
+      }
+    }
+  }
+  
+  // ============================================
+  // CODE BLOCK LANGUAGE SELECTOR FUNCTIONS
+  // ============================================
+  
+  function simulateClick(element) {
+    if (!element) return;
+    const rect = element.getBoundingClientRect();
+    const x = rect.left + rect.width / 2;
+    const y = rect.top + rect.height / 2;
+    
+    ['pointerdown', 'mousedown', 'pointerup', 'mouseup', 'click'].forEach(eventType => {
+      const EventClass = eventType.startsWith('pointer') ? PointerEvent : MouseEvent;
+      element.dispatchEvent(new EventClass(eventType, {
+        view: window, bubbles: true, cancelable: true,
+        clientX: x, clientY: y, button: 0, buttons: 1,
+        isPrimary: true, pointerType: 'mouse'
+      }));
+    });
+  }
+  
+  function getCodeBlockLanguageDropdown() {
+    const paragraphs = document.querySelectorAll('p');
+    
+    for (const p of paragraphs) {
+      const text = (p.textContent || '').trim();
+      if (CODE_BLOCK_LANGUAGES.includes(text)) {
+        const parentDiv = p.closest('div');
+        if (parentDiv && parentDiv.querySelector('.lucide-chevrons-up-down')) {
+          return { element: parentDiv, language: text };
+        }
+      }
+    }
+    return null;
+  }
+  
+  function waitForCodeBlockMenuAndSelect(targetLanguage, attempts = 0) {
+    if (attempts > 30) {
+      document.body.classList.remove('stagehand-selecting');
+      document.body.click();
+      isSelecting = false;
+      return;
+    }
+
+    const menuItems = document.querySelectorAll('[role="menuitem"], [role="option"]');
+
+    if (menuItems.length === 0) {
+      requestAnimationFrame(() => waitForCodeBlockMenuAndSelect(targetLanguage, attempts + 1));
+      return;
+    }
+
+    for (const item of menuItems) {
+      const text = (item.textContent || '').trim();
+      if (text === targetLanguage) {
+        simulateClick(item);
+        onNextFrame(() => {
+          document.body.classList.remove('stagehand-selecting');
+          isSelecting = false;
+        });
+        return;
+      }
+    }
+
+    requestAnimationFrame(() => waitForCodeBlockMenuAndSelect(targetLanguage, attempts + 1));
+  }
+
+  function selectCodeBlockLanguage(targetLanguage) {
+    if (isSelecting) return;
+
+    const current = getCodeBlockLanguageDropdown();
+    if (!current) return;
+    if (current.language === targetLanguage) return;
+
+    isSelecting = true;
+    document.body.classList.add('stagehand-selecting');
+    simulateClick(current.element);
+    requestAnimationFrame(() => waitForCodeBlockMenuAndSelect(targetLanguage));
+  }
+
+  function syncCodeBlockLanguage() {
+    const codeBlockLang = LANGUAGE_MAP[currentSelectedLanguage];
+    if (codeBlockLang) {
+      selectCodeBlockLanguage(codeBlockLang);
+    }
+  }
+  
+  // ============================================
+  // EVENT HANDLERS & OBSERVERS
+  // ============================================
+  
+  function setupDropdownMenuObserver() {
+    const menuObserver = new MutationObserver(() => {
+      const menu = getDropdownMenu();
+      if (menu) {
+        updateDropdownCheckIndicator();
+        onNextFrame(updateDropdownCheckIndicator);
+      }
+    });
+
+    menuObserver.observe(document.body, {
+      subtree: true,
+      childList: true
+    });
+  }
+  
+  function setupMenuClickHandler() {
+    document.addEventListener('click', (e) => {
+      const target = e.target;
+      
+      // Check if we clicked on a sidebar dropdown menu item
+      const menuItem = target.closest('[role="menu"] a, menu a');
+      if (!menuItem) return;
+      
+      const text = (menuItem.textContent || '').trim();
+      
+      // Check if it's one of our language options
+      for (const lang of DROPDOWN_LANGUAGES) {
+        if (text.includes(lang)) {
+          currentSelectedLanguage = lang;
+          
+          // Update the check indicator immediately
+          updateDropdownCheckIndicator();
+          
+          // Update version switcher visibility
+          updateVersionSwitcherVisibility();
+          
+          // Update SDK reference visibility
+          updateSDKReferenceVisibility();
+          
+          // Store in sessionStorage
+          try {
+            sessionStorage.setItem('stagehand-selected-language', lang);
+          } catch (err) {
+            // Ignore storage errors
+          }
+
+          // Navigate to the corresponding SDK page
+          const targetPath = NAVIGATION_MAP[lang];
+          const normalizedPathname = window.location.pathname.replace(/\/$/, '');
+          if (targetPath && !normalizedPathname.endsWith(targetPath)) {
+            e.preventDefault();
+            e.stopPropagation();
+            window.location.href = targetPath;
+            return;
+          }
+
+          // Update button text after menu closes
+          onNextFrame(() => updateButtonText(lang));
+
+          // Sync the code block language selector
+          onNextFrame(syncCodeBlockLanguage);
+
+          break;
+        }
+      }
+    }, true);
+  }
+  
+  function restoreLanguageSelection() {
+    try {
+      const stored = sessionStorage.getItem('stagehand-selected-language');
+      if (stored && DROPDOWN_LANGUAGES.includes(stored)) {
+        currentSelectedLanguage = stored;
+        updateButtonText(stored);
+        updateVersionSwitcherVisibility();
+        updateSDKReferenceVisibility();
+        onNextFrame(syncCodeBlockLanguage);
+      }
+    } catch (err) {
+      // Ignore storage errors
+    }
+
+    // Always update visibility on restore
+    onNextFrame(() => {
+      updateVersionSwitcherVisibility();
+      updateSDKReferenceVisibility();
+    });
+  }
+  
+  function setupPageChangeObserver() {
+    let sdkUpdatePending = false;
+
+    const observer = new MutationObserver(() => {
+      // Check if button needs updating
+      const button = getDropdownButton();
+      if (button) {
+        const currentText = (button.textContent || '').trim();
+        if (currentText !== currentSelectedLanguage && DROPDOWN_LANGUAGES.includes(currentSelectedLanguage)) {
+          updateButtonText(currentSelectedLanguage);
+        }
+      }
+
+      // Re-check version switcher visibility (DOM might have re-rendered)
+      const versionSwitcher = getVersionSwitcher();
+      if (versionSwitcher && !versionSwitcher.classList.contains('stagehand-version-switcher')) {
+        updateVersionSwitcherVisibility();
+      }
+
+      // Check for SDK reference items that need to be hidden (debounced via rAF)
+      const sdkItems = document.querySelectorAll('li[id^="/v3/sdk/"]:not(.stagehand-sdk-processed)');
+      if (sdkItems.length > 0 && !sdkUpdatePending) {
+        sdkUpdatePending = true;
+        onNextFrame(() => {
+          updateSDKReferenceVisibility();
+          document.querySelectorAll('li[id^="/v3/sdk/"]').forEach(item => {
+            item.classList.add('stagehand-sdk-processed');
+          });
+          sdkUpdatePending = false;
+        });
+      }
+    });
+
+    observer.observe(document.body, {
+      subtree: true,
+      childList: true
+    });
+  }
+  
+  // Watch for code block dropdowns appearing and sync them
+  function setupCodeBlockObserver() {
+    let lastCodeBlockDropdown = null;
+
+    const observer = new MutationObserver(() => {
+      const dropdown = getCodeBlockLanguageDropdown();
+      if (dropdown && dropdown.element !== lastCodeBlockDropdown) {
+        lastCodeBlockDropdown = dropdown.element;
+
+        // New code block dropdown appeared, sync it
+        const targetLang = LANGUAGE_MAP[currentSelectedLanguage];
+        if (targetLang && dropdown.language !== targetLang) {
+          onNextFrame(() => selectCodeBlockLanguage(targetLang));
+        }
+      }
+    });
+
+    observer.observe(document.body, {
+      subtree: true,
+      childList: true
+    });
+  }
+  
+  // ============================================
+  // INITIALIZATION
+  // ============================================
+
+  function init() {
+    setupMenuClickHandler();
+    setupDropdownMenuObserver();
+    setupPageChangeObserver();
+    setupCodeBlockObserver();
+
+    restoreLanguageSelection();
+    updateVersionSwitcherVisibility();
+    updateSDKReferenceVisibility();
+  }
+
+  // Initialize on page load
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', init);
+  } else {
+    init();
+  }
+
+  // Re-run when URL changes (SPA navigation)
+  let lastUrl = location.href;
+  const urlObserver = new MutationObserver(() => {
+    if (location.href !== lastUrl) {
+      lastUrl = location.href;
+      // Remove processed class so SDK items get re-evaluated
+      document.querySelectorAll('li[id^="/v3/sdk/"].stagehand-sdk-processed').forEach(item => {
+        item.classList.remove('stagehand-sdk-processed');
+      });
+      onNextFrame(() => {
+        restoreLanguageSelection();
+        syncCodeBlockLanguage();
+        updateVersionSwitcherVisibility();
+        updateSDKReferenceVisibility();
+      });
+    }
+  });
+  urlObserver.observe(document.body, { subtree: true, childList: true });
+})();
diff --git a/packages/docs/logo/dark.svg b/packages/docs/logo/dark.svg
new file mode 100644
index 000000000..a6283786c
--- /dev/null
+++ b/packages/docs/logo/dark.svg
@@ -0,0 +1,55 @@
+<svg width="160" height="24" viewBox="0 0 160 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M7.95343 21.1394C4.89586 21.1304 2.25471 19.458 0.987296 16.2895C-0.280118 13.121 0.108924 9.16314 1.74363 5.61504C4.8012 5.62409 7.44235 7.29648 8.70976 10.465C9.97718 13.6335 9.58814 17.5913 7.95343 21.1394Z" fill="white"/>
+<path d="M7.95343 21.1394C4.89586 21.1304 2.25471 19.458 0.987296 16.2895C-0.280118 13.121 0.108924 9.16314 1.74363 5.61504C4.8012 5.62409 7.44235 7.29648 8.70976 10.465C9.97718 13.6335 9.58814 17.5913 7.95343 21.1394Z" fill="url(#paint0_radial_115_109)"/>
+<path d="M7.95343 21.1394C4.89586 21.1304 2.25471 19.458 0.987296 16.2895C-0.280118 13.121 0.108924 9.16314 1.74363 5.61504C4.8012 5.62409 7.44235 7.29648 8.70976 10.465C9.97718 13.6335 9.58814 17.5913 7.95343 21.1394Z" fill="black" fill-opacity="0.5" style="mix-blend-mode:hard-light"/>
+<path d="M7.95343 21.1394C4.89586 21.1304 2.25471 19.458 0.987296 16.2895C-0.280118 13.121 0.108924 9.16314 1.74363 5.61504C4.8012 5.62409 7.44235 7.29648 8.70976 10.465C9.97718 13.6335 9.58814 17.5913 7.95343 21.1394Z" fill="url(#paint1_linear_115_109)" fill-opacity="0.5" style="mix-blend-mode:hard-light"/>
+<path d="M7.9354 21.1112C4.89702 21.0957 2.27411 19.4306 1.01347 16.279C-0.248375 13.1244 0.135612 9.18218 1.76165 5.64327C4.80004 5.65882 7.42295 7.32385 8.68359 10.4755C9.94543 13.63 9.56144 17.5723 7.9354 21.1112Z" stroke="url(#paint2_linear_115_109)" stroke-opacity="0.05" stroke-width="0.056338"/>
+<path d="M7.31038 21.2574C11.3543 20.2215 14.8836 17.3754 16.6285 13.2361C18.3735 9.09671 17.9448 4.58749 15.8598 0.976291C11.8159 2.01214 8.2866 4.85826 6.54167 8.99762C4.79674 13.137 5.2254 17.6462 7.31038 21.2574Z" fill="white"/>
+<path d="M7.31038 21.2574C11.3543 20.2215 14.8836 17.3754 16.6285 13.2361C18.3735 9.09671 17.9448 4.58749 15.8598 0.976291C11.8159 2.01214 8.2866 4.85826 6.54167 8.99762C4.79674 13.137 5.2254 17.6462 7.31038 21.2574Z" fill="url(#paint3_radial_115_109)"/>
+<path d="M16.6025 13.2251C14.8642 17.349 11.3512 20.1866 7.32411 21.2248C5.25257 17.624 4.82926 13.1324 6.56764 9.00855C8.30603 4.88472 11.819 2.04706 15.8461 1.00889C17.9176 4.60967 18.3409 9.10131 16.6025 13.2251Z" stroke="url(#paint4_linear_115_109)" stroke-opacity="0.05" stroke-width="0.056338"/>
+<path d="M7.23368 21.2069C9.78906 23.2373 13.2102 23.9506 16.5772 22.8141C19.9441 21.6775 22.5058 18.9445 23.7304 15.6382C21.175 13.6078 17.7538 12.8944 14.3869 14.031C11.0199 15.1676 8.45822 17.9006 7.23368 21.2069Z" fill="white"/>
+<path d="M7.23368 21.2069C9.78906 23.2373 13.2102 23.9506 16.5772 22.8141C19.9441 21.6775 22.5058 18.9445 23.7304 15.6382C21.175 13.6078 17.7538 12.8944 14.3869 14.031C11.0199 15.1676 8.45822 17.9006 7.23368 21.2069Z" fill="url(#paint5_radial_115_109)"/>
+<path d="M7.23368 21.2069C9.78906 23.2373 13.2102 23.9506 16.5772 22.8141C19.9441 21.6775 22.5058 18.9445 23.7304 15.6382C21.175 13.6078 17.7538 12.8944 14.3869 14.031C11.0199 15.1676 8.45822 17.9006 7.23368 21.2069Z" fill="black" fill-opacity="0.2" style="mix-blend-mode:hard-light"/>
+<path d="M7.23368 21.2069C9.78906 23.2373 13.2102 23.9506 16.5772 22.8141C19.9441 21.6775 22.5058 18.9445 23.7304 15.6382C21.175 13.6078 17.7538 12.8944 14.3869 14.031C11.0199 15.1676 8.45822 17.9006 7.23368 21.2069Z" fill="url(#paint6_linear_115_109)" fill-opacity="0.5" style="mix-blend-mode:hard-light"/>
+<path d="M16.5682 22.7874C13.2176 23.9184 9.81361 23.2124 7.2672 21.1975C8.49194 17.9068 11.0444 15.189 14.3959 14.0577C17.7465 12.9266 21.1504 13.6326 23.6968 15.6476C22.4721 18.9383 19.9196 21.656 16.5682 22.7874Z" stroke="url(#paint7_linear_115_109)" stroke-opacity="0.05" stroke-width="0.056338"/>
+<path d="M34.2124 19V5.4H39.4924L41.6924 12.2L42.3724 14.74L43.0524 12.2L45.2524 5.4H50.4124V19H46.3324L46.5924 9.98L45.5324 13.68L43.7924 19H40.8324L39.0524 13.6L38.0324 10.02L38.2924 19H34.2124ZM52.4155 7.3V4.6H56.2955V7.3H52.4155ZM52.4155 19V8.14H56.2955V19H52.4155ZM58.1038 19V8.14H61.9838V9.58C62.6638 8.34 63.7438 7.76 65.0038 7.76C66.9638 7.76 68.6238 8.98 68.6238 11.78V19H64.7438V12.56C64.7438 11.34 64.3038 10.86 63.4838 10.86C62.6038 10.86 61.9838 11.58 61.9838 12.88V19H58.1038ZM70.9327 15.22V11.06H69.7327V8.14H70.9327V5.62H74.8127V8.14H76.9327V11.06H74.8127V14.6C74.8127 15.5 75.0327 16.06 76.2127 16.06H76.9327V19C76.4927 19.2 75.6727 19.38 74.6527 19.38C72.1527 19.38 70.9327 17.88 70.9327 15.22Z" fill="url(#paint8_radial_115_109)"/>
+<path d="M87.232 10.519C87.232 13.687 94.1125 11.2285 94.1125 15.832C94.1125 17.9935 92.3635 19.198 89.971 19.198C87.562 19.198 85.912 18.0925 85.417 15.832H87.001C87.364 17.1685 88.3705 17.8945 89.9875 17.8945C91.6705 17.8945 92.5615 17.152 92.5615 16.03C92.5615 12.598 85.681 15.1555 85.681 10.618C85.681 9.001 87.034 7.582 89.509 7.582C91.6705 7.582 93.403 8.6215 93.8155 11.014H92.215C91.8685 9.529 90.9115 8.8855 89.476 8.8855C88.057 8.8855 87.232 9.529 87.232 10.519ZM96.2499 16.4755V11.3935H95.0289V10.2385H96.2499V8.2255H97.7019V10.2385H99.6324V11.3935H97.7019V16.4755C97.7019 17.5315 98.0154 18.0265 99.3024 18.0265H99.5994V19.066C99.4344 19.1485 99.0714 19.198 98.6589 19.198C97.0254 19.198 96.2499 18.3235 96.2499 16.4755ZM102.516 13.093H101.064C101.345 11.1625 102.615 10.024 104.76 10.024C107.103 10.024 108.242 11.3935 108.242 13.4395V16.888C108.242 17.8945 108.324 18.5215 108.555 19H107.021C106.856 18.6535 106.806 18.142 106.79 17.614C106.047 18.7195 104.859 19.198 103.803 19.198C101.988 19.198 100.767 18.3565 100.767 16.69C100.767 15.4855 101.427 14.611 102.714 14.182C103.902 13.786 105.107 13.687 106.79 13.6705V13.4725C106.79 12.0535 106.13 11.278 104.628 11.278C103.374 11.278 102.698 11.971 102.516 13.093ZM102.252 16.657C102.252 17.4655 102.929 17.944 103.952 17.944C105.569 17.944 106.79 16.6735 106.79 15.172V14.7595C103.061 14.7925 102.252 15.5845 102.252 16.657ZM110.787 19V10.2385H112.239V11.5915C112.833 10.519 113.774 10.024 114.83 10.024C115.176 10.024 115.49 10.1065 115.655 10.2385V11.542C115.407 11.4595 115.094 11.4265 114.747 11.4265C112.998 11.4265 112.239 12.5155 112.239 14.0995V19H110.787ZM117.305 16.4755V11.3935H116.084V10.2385H117.305V8.2255H118.757V10.2385H120.688V11.3935H118.757V16.4755C118.757 17.5315 119.071 18.0265 120.358 18.0265H120.655V19.066C120.49 19.1485 120.127 19.198 119.714 19.198C118.081 19.198 117.305 18.3235 117.305 16.4755ZM129.809 16.1455C129.33 18.1915 127.862 19.198 125.865 19.198C123.324 19.198 121.79 17.482 121.79 14.6275C121.79 11.6575 123.324 10.024 125.783 10.024C128.258 10.024 129.743 11.7235 129.743 14.512V14.875H123.275C123.357 16.8385 124.281 17.944 125.865 17.944C127.103 17.944 127.977 17.35 128.291 16.1455H129.809ZM125.783 11.278C124.38 11.278 123.539 12.1525 123.324 13.786H128.225C128.027 12.169 127.152 11.278 125.783 11.278ZM131.843 19V10.2385H133.295V11.5915C133.889 10.519 134.829 10.024 135.885 10.024C136.232 10.024 136.545 10.1065 136.71 10.2385V11.542C136.463 11.4595 136.149 11.4265 135.803 11.4265C134.054 11.4265 133.295 12.5155 133.295 14.0995V19H131.843ZM141.763 19V7.78H143.281V13.192L148.413 7.78H150.327L145.047 13.291L150.459 19H148.413L143.281 13.621V19H141.763ZM152.06 9.067V7.12H153.512V9.067H152.06ZM152.06 19V10.2385H153.512V19H152.06ZM156.178 16.4755V11.3935H154.957V10.2385H156.178V8.2255H157.63V10.2385H159.56V11.3935H157.63V16.4755C157.63 17.5315 157.943 18.0265 159.23 18.0265H159.527V19.066C159.362 19.1485 158.999 19.198 158.587 19.198C156.953 19.198 156.178 18.3235 156.178 16.4755Z" fill="white" fill-opacity="0.55"/>
+<defs>
+<radialGradient id="paint0_radial_115_109" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(-3.00503 15.023) rotate(-10.029) scale(17.9572 17.784)">
+<stop stop-color="#00B0BB"/>
+<stop offset="1" stop-color="#00DB65"/>
+</radialGradient>
+<linearGradient id="paint1_linear_115_109" x1="7.39036" y1="4.81308" x2="1.62975" y2="18.6894" gradientUnits="userSpaceOnUse">
+<stop stop-color="#18E299"/>
+<stop offset="1"/>
+</linearGradient>
+<linearGradient id="paint2_linear_115_109" x1="7.94816" y1="8.01562" x2="1.7612" y2="18.746" gradientUnits="userSpaceOnUse">
+<stop/>
+<stop offset="1" stop-opacity="0"/>
+</linearGradient>
+<radialGradient id="paint3_radial_115_109" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(8.11404 20.8822) rotate(-75.7542) scale(21.6246 23.7772)">
+<stop stop-color="#00BBBB"/>
+<stop offset="0.712616" stop-color="#00DB65"/>
+</radialGradient>
+<linearGradient id="paint4_linear_115_109" x1="7.60205" y1="5.8709" x2="15.5561" y2="16.3719" gradientUnits="userSpaceOnUse">
+<stop/>
+<stop offset="1" stop-opacity="0"/>
+</linearGradient>
+<radialGradient id="paint5_radial_115_109" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(7.84537 21.5181) rotate(-20.3525) scale(18.5603 17.32)">
+<stop stop-color="#00B0BB"/>
+<stop offset="1" stop-color="#00DB65"/>
+</radialGradient>
+<linearGradient id="paint6_linear_115_109" x1="16.8078" y1="13.0071" x2="10.0409" y2="22.9937" gradientUnits="userSpaceOnUse">
+<stop stop-color="#00B1BC"/>
+<stop offset="1"/>
+</linearGradient>
+<linearGradient id="paint7_linear_115_109" x1="16.8078" y1="13.0071" x2="14.1687" y2="23.841" gradientUnits="userSpaceOnUse">
+<stop/>
+<stop offset="1" stop-opacity="0"/>
+</linearGradient>
+<radialGradient id="paint8_radial_115_109" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(47.2781 7) rotate(19.0047) scale(67.5582 85.7506)">
+<stop stop-color="white"/>
+<stop offset="1" stop-color="white" stop-opacity="0.5"/>
+</radialGradient>
+</defs>
+</svg>
diff --git a/packages/docs/logo/dark_logo.png b/packages/docs/logo/dark_logo.png
new file mode 100644
index 000000000..4b7da66e9
Binary files /dev/null and b/packages/docs/logo/dark_logo.png differ
diff --git a/packages/docs/logo/light.svg b/packages/docs/logo/light.svg
new file mode 100644
index 000000000..582b3b95f
--- /dev/null
+++ b/packages/docs/logo/light.svg
@@ -0,0 +1,51 @@
+<svg width="160" height="24" viewBox="0 0 160 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M7.95343 21.1394C4.89586 21.1304 2.25471 19.458 0.987296 16.2895C-0.280118 13.121 0.108924 9.16314 1.74363 5.61504C4.8012 5.62409 7.44235 7.29648 8.70976 10.465C9.97718 13.6335 9.58814 17.5913 7.95343 21.1394Z" fill="white"/>
+<path d="M7.95343 21.1394C4.89586 21.1304 2.25471 19.458 0.987296 16.2895C-0.280118 13.121 0.108924 9.16314 1.74363 5.61504C4.8012 5.62409 7.44235 7.29648 8.70976 10.465C9.97718 13.6335 9.58814 17.5913 7.95343 21.1394Z" fill="url(#paint0_radial_115_86)"/>
+<path d="M7.95343 21.1394C4.89586 21.1304 2.25471 19.458 0.987296 16.2895C-0.280118 13.121 0.108924 9.16314 1.74363 5.61504C4.8012 5.62409 7.44235 7.29648 8.70976 10.465C9.97718 13.6335 9.58814 17.5913 7.95343 21.1394Z" fill="black" fill-opacity="0.5" style="mix-blend-mode:hard-light"/>
+<path d="M7.95343 21.1394C4.89586 21.1304 2.25471 19.458 0.987296 16.2895C-0.280118 13.121 0.108924 9.16314 1.74363 5.61504C4.8012 5.62409 7.44235 7.29648 8.70976 10.465C9.97718 13.6335 9.58814 17.5913 7.95343 21.1394Z" fill="url(#paint1_linear_115_86)" fill-opacity="0.5" style="mix-blend-mode:hard-light"/>
+<path d="M7.9354 21.1112C4.89702 21.0957 2.27411 19.4306 1.01347 16.279C-0.248375 13.1244 0.135612 9.18218 1.76165 5.64327C4.80004 5.65882 7.42295 7.32385 8.68359 10.4755C9.94543 13.63 9.56144 17.5723 7.9354 21.1112Z" stroke="url(#paint2_linear_115_86)" stroke-opacity="0.05" stroke-width="0.056338"/>
+<path d="M7.31038 21.2574C11.3543 20.2215 14.8836 17.3754 16.6285 13.2361C18.3735 9.09671 17.9448 4.58749 15.8598 0.976291C11.8159 2.01214 8.2866 4.85826 6.54167 8.99762C4.79674 13.137 5.2254 17.6462 7.31038 21.2574Z" fill="white"/>
+<path d="M7.31038 21.2574C11.3543 20.2215 14.8836 17.3754 16.6285 13.2361C18.3735 9.09671 17.9448 4.58749 15.8598 0.976291C11.8159 2.01214 8.2866 4.85826 6.54167 8.99762C4.79674 13.137 5.2254 17.6462 7.31038 21.2574Z" fill="url(#paint3_radial_115_86)"/>
+<path d="M16.6025 13.2251C14.8642 17.349 11.3512 20.1866 7.32411 21.2248C5.25257 17.624 4.82926 13.1324 6.56764 9.00855C8.30603 4.88472 11.819 2.04706 15.8461 1.00889C17.9176 4.60967 18.3409 9.10131 16.6025 13.2251Z" stroke="url(#paint4_linear_115_86)" stroke-opacity="0.05" stroke-width="0.056338"/>
+<path d="M7.23368 21.2069C9.78906 23.2373 13.2102 23.9506 16.5772 22.8141C19.9441 21.6775 22.5058 18.9445 23.7304 15.6382C21.175 13.6078 17.7538 12.8944 14.3869 14.031C11.0199 15.1676 8.45822 17.9006 7.23368 21.2069Z" fill="white"/>
+<path d="M7.23368 21.2069C9.78906 23.2373 13.2102 23.9506 16.5772 22.8141C19.9441 21.6775 22.5058 18.9445 23.7304 15.6382C21.175 13.6078 17.7538 12.8944 14.3869 14.031C11.0199 15.1676 8.45822 17.9006 7.23368 21.2069Z" fill="url(#paint5_radial_115_86)"/>
+<path d="M7.23368 21.2069C9.78906 23.2373 13.2102 23.9506 16.5772 22.8141C19.9441 21.6775 22.5058 18.9445 23.7304 15.6382C21.175 13.6078 17.7538 12.8944 14.3869 14.031C11.0199 15.1676 8.45822 17.9006 7.23368 21.2069Z" fill="black" fill-opacity="0.2" style="mix-blend-mode:hard-light"/>
+<path d="M7.23368 21.2069C9.78906 23.2373 13.2102 23.9506 16.5772 22.8141C19.9441 21.6775 22.5058 18.9445 23.7304 15.6382C21.175 13.6078 17.7538 12.8944 14.3869 14.031C11.0199 15.1676 8.45822 17.9006 7.23368 21.2069Z" fill="url(#paint6_linear_115_86)" fill-opacity="0.5" style="mix-blend-mode:hard-light"/>
+<path d="M16.5682 22.7874C13.2176 23.9184 9.81361 23.2124 7.2672 21.1975C8.49194 17.9068 11.0444 15.189 14.3959 14.0577C17.7465 12.9266 21.1504 13.6326 23.6968 15.6476C22.4721 18.9383 19.9196 21.656 16.5682 22.7874Z" stroke="url(#paint7_linear_115_86)" stroke-opacity="0.05" stroke-width="0.056338"/>
+<path d="M34.2124 19V5.4H39.4924L41.6924 12.2L42.3724 14.74L43.0524 12.2L45.2524 5.4H50.4124V19H46.3324L46.5924 9.98L45.5324 13.68L43.7924 19H40.8324L39.0524 13.6L38.0324 10.02L38.2924 19H34.2124ZM52.4155 7.3V4.6H56.2955V7.3H52.4155ZM52.4155 19V8.14H56.2955V19H52.4155ZM58.1038 19V8.14H61.9838V9.58C62.6638 8.34 63.7438 7.76 65.0038 7.76C66.9638 7.76 68.6238 8.98 68.6238 11.78V19H64.7438V12.56C64.7438 11.34 64.3038 10.86 63.4838 10.86C62.6038 10.86 61.9838 11.58 61.9838 12.88V19H58.1038ZM70.9327 15.22V11.06H69.7327V8.14H70.9327V5.62H74.8127V8.14H76.9327V11.06H74.8127V14.6C74.8127 15.5 75.0327 16.06 76.2127 16.06H76.9327V19C76.4927 19.2 75.6727 19.38 74.6527 19.38C72.1527 19.38 70.9327 17.88 70.9327 15.22Z" fill="#001E13"/>
+<path d="M87.232 10.519C87.232 13.687 94.1125 11.2285 94.1125 15.832C94.1125 17.9935 92.3635 19.198 89.971 19.198C87.562 19.198 85.912 18.0925 85.417 15.832H87.001C87.364 17.1685 88.3705 17.8945 89.9875 17.8945C91.6705 17.8945 92.5615 17.152 92.5615 16.03C92.5615 12.598 85.681 15.1555 85.681 10.618C85.681 9.001 87.034 7.582 89.509 7.582C91.6705 7.582 93.403 8.6215 93.8155 11.014H92.215C91.8685 9.529 90.9115 8.8855 89.476 8.8855C88.057 8.8855 87.232 9.529 87.232 10.519ZM96.2499 16.4755V11.3935H95.0289V10.2385H96.2499V8.2255H97.7019V10.2385H99.6324V11.3935H97.7019V16.4755C97.7019 17.5315 98.0154 18.0265 99.3024 18.0265H99.5994V19.066C99.4344 19.1485 99.0714 19.198 98.6589 19.198C97.0254 19.198 96.2499 18.3235 96.2499 16.4755ZM102.516 13.093H101.064C101.345 11.1625 102.615 10.024 104.76 10.024C107.103 10.024 108.242 11.3935 108.242 13.4395V16.888C108.242 17.8945 108.324 18.5215 108.555 19H107.021C106.856 18.6535 106.806 18.142 106.79 17.614C106.047 18.7195 104.859 19.198 103.803 19.198C101.988 19.198 100.767 18.3565 100.767 16.69C100.767 15.4855 101.427 14.611 102.714 14.182C103.902 13.786 105.107 13.687 106.79 13.6705V13.4725C106.79 12.0535 106.13 11.278 104.628 11.278C103.374 11.278 102.698 11.971 102.516 13.093ZM102.252 16.657C102.252 17.4655 102.929 17.944 103.952 17.944C105.569 17.944 106.79 16.6735 106.79 15.172V14.7595C103.061 14.7925 102.252 15.5845 102.252 16.657ZM110.787 19V10.2385H112.239V11.5915C112.833 10.519 113.774 10.024 114.83 10.024C115.176 10.024 115.49 10.1065 115.655 10.2385V11.542C115.407 11.4595 115.094 11.4265 114.747 11.4265C112.998 11.4265 112.239 12.5155 112.239 14.0995V19H110.787ZM117.305 16.4755V11.3935H116.084V10.2385H117.305V8.2255H118.757V10.2385H120.688V11.3935H118.757V16.4755C118.757 17.5315 119.071 18.0265 120.358 18.0265H120.655V19.066C120.49 19.1485 120.127 19.198 119.714 19.198C118.081 19.198 117.305 18.3235 117.305 16.4755ZM129.809 16.1455C129.33 18.1915 127.862 19.198 125.865 19.198C123.324 19.198 121.79 17.482 121.79 14.6275C121.79 11.6575 123.324 10.024 125.783 10.024C128.258 10.024 129.743 11.7235 129.743 14.512V14.875H123.275C123.357 16.8385 124.281 17.944 125.865 17.944C127.103 17.944 127.977 17.35 128.291 16.1455H129.809ZM125.783 11.278C124.38 11.278 123.539 12.1525 123.324 13.786H128.225C128.027 12.169 127.152 11.278 125.783 11.278ZM131.843 19V10.2385H133.295V11.5915C133.889 10.519 134.829 10.024 135.885 10.024C136.232 10.024 136.545 10.1065 136.71 10.2385V11.542C136.463 11.4595 136.149 11.4265 135.803 11.4265C134.054 11.4265 133.295 12.5155 133.295 14.0995V19H131.843ZM141.763 19V7.78H143.281V13.192L148.413 7.78H150.327L145.047 13.291L150.459 19H148.413L143.281 13.621V19H141.763ZM152.06 9.067V7.12H153.512V9.067H152.06ZM152.06 19V10.2385H153.512V19H152.06ZM156.178 16.4755V11.3935H154.957V10.2385H156.178V8.2255H157.63V10.2385H159.56V11.3935H157.63V16.4755C157.63 17.5315 157.943 18.0265 159.23 18.0265H159.527V19.066C159.362 19.1485 158.999 19.198 158.587 19.198C156.953 19.198 156.178 18.3235 156.178 16.4755Z" fill="#002719" fill-opacity="0.6"/>
+<defs>
+<radialGradient id="paint0_radial_115_86" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(-3.00503 15.023) rotate(-10.029) scale(17.9572 17.784)">
+<stop stop-color="#00B0BB"/>
+<stop offset="1" stop-color="#00DB65"/>
+</radialGradient>
+<linearGradient id="paint1_linear_115_86" x1="7.39036" y1="4.81308" x2="1.62975" y2="18.6894" gradientUnits="userSpaceOnUse">
+<stop stop-color="#18E299"/>
+<stop offset="1"/>
+</linearGradient>
+<linearGradient id="paint2_linear_115_86" x1="7.94816" y1="8.01562" x2="1.7612" y2="18.746" gradientUnits="userSpaceOnUse">
+<stop/>
+<stop offset="1" stop-opacity="0"/>
+</linearGradient>
+<radialGradient id="paint3_radial_115_86" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(8.11404 20.8822) rotate(-75.7542) scale(21.6246 23.7772)">
+<stop stop-color="#00BBBB"/>
+<stop offset="0.712616" stop-color="#00DB65"/>
+</radialGradient>
+<linearGradient id="paint4_linear_115_86" x1="7.60205" y1="5.8709" x2="15.5561" y2="16.3719" gradientUnits="userSpaceOnUse">
+<stop/>
+<stop offset="1" stop-opacity="0"/>
+</linearGradient>
+<radialGradient id="paint5_radial_115_86" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(7.84537 21.5181) rotate(-20.3525) scale(18.5603 17.32)">
+<stop stop-color="#00B0BB"/>
+<stop offset="1" stop-color="#00DB65"/>
+</radialGradient>
+<linearGradient id="paint6_linear_115_86" x1="16.8078" y1="13.0071" x2="10.0409" y2="22.9937" gradientUnits="userSpaceOnUse">
+<stop stop-color="#00B1BC"/>
+<stop offset="1"/>
+</linearGradient>
+<linearGradient id="paint7_linear_115_86" x1="16.8078" y1="13.0071" x2="14.1687" y2="23.841" gradientUnits="userSpaceOnUse">
+<stop/>
+<stop offset="1" stop-opacity="0"/>
+</linearGradient>
+</defs>
+</svg>
diff --git a/packages/docs/logo/light_logo.png b/packages/docs/logo/light_logo.png
new file mode 100644
index 000000000..b07691e70
Binary files /dev/null and b/packages/docs/logo/light_logo.png differ
diff --git a/packages/docs/media/create-browser-app.gif b/packages/docs/media/create-browser-app.gif
new file mode 100644
index 000000000..84e346806
Binary files /dev/null and b/packages/docs/media/create-browser-app.gif differ
diff --git a/packages/docs/media/evals-cli.png b/packages/docs/media/evals-cli.png
new file mode 100644
index 000000000..221596e2a
Binary files /dev/null and b/packages/docs/media/evals-cli.png differ
diff --git a/packages/docs/media/google_search.gif b/packages/docs/media/google_search.gif
new file mode 100644
index 000000000..649225df0
Binary files /dev/null and b/packages/docs/media/google_search.gif differ
diff --git a/packages/docs/media/linkedin.gif b/packages/docs/media/linkedin.gif
new file mode 100644
index 000000000..9e5e68222
Binary files /dev/null and b/packages/docs/media/linkedin.gif differ
diff --git a/packages/docs/media/observability.gif b/packages/docs/media/observability.gif
new file mode 100644
index 000000000..b5c4cc4c2
Binary files /dev/null and b/packages/docs/media/observability.gif differ
diff --git a/packages/docs/media/open_operator.gif b/packages/docs/media/open_operator.gif
new file mode 100644
index 000000000..107b9669a
Binary files /dev/null and b/packages/docs/media/open_operator.gif differ
diff --git a/packages/docs/media/stagehand-agent.gif b/packages/docs/media/stagehand-agent.gif
new file mode 100644
index 000000000..95803bb5d
Binary files /dev/null and b/packages/docs/media/stagehand-agent.gif differ
diff --git a/packages/docs/media/stagehand-mcp.png b/packages/docs/media/stagehand-mcp.png
new file mode 100644
index 000000000..0ec27cd3b
Binary files /dev/null and b/packages/docs/media/stagehand-mcp.png differ
diff --git a/packages/docs/package.json b/packages/docs/package.json
new file mode 100644
index 000000000..6d83ef862
--- /dev/null
+++ b/packages/docs/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "@browserbasehq/stagehand-docs",
+  "version": "1.0.0",
+  "description": "",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "dev": "mintlify dev --no-open --port 3002",
+    "upgrade": "mintlify upgrade",
+    "sync-sdk": "node scripts/sync-sdk-docs.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "mintlify": "^4.2.47",
+    "zod": "^4.2.1"
+  },
+  "packageManager": "pnpm@9.15.0+sha512.76e2379760a4328ec4415815bcd6628dee727af3779aaa4c914e3944156c4299921a89f976381ee107d41f12cfa4b66681ca9c718f0668fa0831ed4c6d8ba56c"
+}
diff --git a/packages/docs/pnpm-lock.yaml b/packages/docs/pnpm-lock.yaml
new file mode 100644
index 000000000..500d4264f
--- /dev/null
+++ b/packages/docs/pnpm-lock.yaml
@@ -0,0 +1,6846 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    dependencies:
+      mintlify:
+        specifier: ^4.0.401
+        version: 4.0.453(@types/node@22.13.14)(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      tsx:
+        specifier: ^4.19.2
+        version: 4.19.3
+      zod:
+        specifier: ^3.24.1
+        version: 3.24.2
+
+packages:
+
+  '@asyncapi/parser@3.4.0':
+    resolution: {integrity: sha512-Sxn74oHiZSU6+cVeZy62iPZMFMvKp4jupMFHelSICCMw1qELmUHPvuZSr+ZHDmNGgHcEpzJM5HN02kR7T4g+PQ==}
+
+  '@asyncapi/specs@6.8.1':
+    resolution: {integrity: sha512-czHoAk3PeXTLR+X8IUaD+IpT+g+zUvkcgMDJVothBsan+oHN3jfcFcFUNdOPAAFoUCQN1hXF1dWuphWy05THlA==}
+
+  '@babel/code-frame@7.26.2':
+    resolution: {integrity: sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-validator-identifier@7.25.9':
+    resolution: {integrity: sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==}
+    engines: {node: '>=6.9.0'}
+
+  '@emnapi/runtime@1.4.0':
+    resolution: {integrity: sha512-64WYIf4UYcdLnbKn/umDlNjQDSS8AgZrI/R9+x5ilkUVFxXcA1Ebl+gQLc/6mERA4407Xof0R7wEyEuj091CVw==}
+
+  '@esbuild/aix-ppc64@0.25.1':
+    resolution: {integrity: sha512-kfYGy8IdzTGy+z0vFGvExZtxkFlA4zAxgKEahG9KE1ScBjpQnFsNOX8KTU5ojNru5ed5CVoJYXFtoxaq5nFbjQ==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/android-arm64@0.25.1':
+    resolution: {integrity: sha512-50tM0zCJW5kGqgG7fQ7IHvQOcAn9TKiVRuQ/lN0xR+T2lzEFvAi1ZcS8DiksFcEpf1t/GYOeOfCAgDHFpkiSmA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/android-arm@0.25.1':
+    resolution: {integrity: sha512-dp+MshLYux6j/JjdqVLnMglQlFu+MuVeNrmT5nk6q07wNhCdSnB7QZj+7G8VMUGh1q+vj2Bq8kRsuyA00I/k+Q==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/android-x64@0.25.1':
+    resolution: {integrity: sha512-GCj6WfUtNldqUzYkN/ITtlhwQqGWu9S45vUXs7EIYf+7rCiiqH9bCloatO9VhxsL0Pji+PF4Lz2XXCES+Q8hDw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/darwin-arm64@0.25.1':
+    resolution: {integrity: sha512-5hEZKPf+nQjYoSr/elb62U19/l1mZDdqidGfmFutVUjjUZrOazAtwK+Kr+3y0C/oeJfLlxo9fXb1w7L+P7E4FQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/darwin-x64@0.25.1':
+    resolution: {integrity: sha512-hxVnwL2Dqs3fM1IWq8Iezh0cX7ZGdVhbTfnOy5uURtao5OIVCEyj9xIzemDi7sRvKsuSdtCAhMKarxqtlyVyfA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/freebsd-arm64@0.25.1':
+    resolution: {integrity: sha512-1MrCZs0fZa2g8E+FUo2ipw6jw5qqQiH+tERoS5fAfKnRx6NXH31tXBKI3VpmLijLH6yriMZsxJtaXUyFt/8Y4A==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-x64@0.25.1':
+    resolution: {integrity: sha512-0IZWLiTyz7nm0xuIs0q1Y3QWJC52R8aSXxe40VUxm6BB1RNmkODtW6LHvWRrGiICulcX7ZvyH6h5fqdLu4gkww==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/linux-arm64@0.25.1':
+    resolution: {integrity: sha512-jaN3dHi0/DDPelk0nLcXRm1q7DNJpjXy7yWaWvbfkPvI+7XNSc/lDOnCLN7gzsyzgu6qSAmgSvP9oXAhP973uQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/linux-arm@0.25.1':
+    resolution: {integrity: sha512-NdKOhS4u7JhDKw9G3cY6sWqFcnLITn6SqivVArbzIaf3cemShqfLGHYMx8Xlm/lBit3/5d7kXvriTUGa5YViuQ==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/linux-ia32@0.25.1':
+    resolution: {integrity: sha512-OJykPaF4v8JidKNGz8c/q1lBO44sQNUQtq1KktJXdBLn1hPod5rE/Hko5ugKKZd+D2+o1a9MFGUEIUwO2YfgkQ==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/linux-loong64@0.25.1':
+    resolution: {integrity: sha512-nGfornQj4dzcq5Vp835oM/o21UMlXzn79KobKlcs3Wz9smwiifknLy4xDCLUU0BWp7b/houtdrgUz7nOGnfIYg==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/linux-mips64el@0.25.1':
+    resolution: {integrity: sha512-1osBbPEFYwIE5IVB/0g2X6i1qInZa1aIoj1TdL4AaAb55xIIgbg8Doq6a5BzYWgr+tEcDzYH67XVnTmUzL+nXg==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/linux-ppc64@0.25.1':
+    resolution: {integrity: sha512-/6VBJOwUf3TdTvJZ82qF3tbLuWsscd7/1w+D9LH0W/SqUgM5/JJD0lrJ1fVIfZsqB6RFmLCe0Xz3fmZc3WtyVg==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/linux-riscv64@0.25.1':
+    resolution: {integrity: sha512-nSut/Mx5gnilhcq2yIMLMe3Wl4FK5wx/o0QuuCLMtmJn+WeWYoEGDN1ipcN72g1WHsnIbxGXd4i/MF0gTcuAjQ==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/linux-s390x@0.25.1':
+    resolution: {integrity: sha512-cEECeLlJNfT8kZHqLarDBQso9a27o2Zd2AQ8USAEoGtejOrCYHNtKP8XQhMDJMtthdF4GBmjR2au3x1udADQQQ==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/linux-x64@0.25.1':
+    resolution: {integrity: sha512-xbfUhu/gnvSEg+EGovRc+kjBAkrvtk38RlerAzQxvMzlB4fXpCFCeUAYzJvrnhFtdeyVCDANSjJvOvGYoeKzFA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/netbsd-arm64@0.25.1':
+    resolution: {integrity: sha512-O96poM2XGhLtpTh+s4+nP7YCCAfb4tJNRVZHfIE7dgmax+yMP2WgMd2OecBuaATHKTHsLWHQeuaxMRnCsH8+5g==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-x64@0.25.1':
+    resolution: {integrity: sha512-X53z6uXip6KFXBQ+Krbx25XHV/NCbzryM6ehOAeAil7X7oa4XIq+394PWGnwaSQ2WRA0KI6PUO6hTO5zeF5ijA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/openbsd-arm64@0.25.1':
+    resolution: {integrity: sha512-Na9T3szbXezdzM/Kfs3GcRQNjHzM6GzFBeU1/6IV/npKP5ORtp9zbQjvkDJ47s6BCgaAZnnnu/cY1x342+MvZg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-x64@0.25.1':
+    resolution: {integrity: sha512-T3H78X2h1tszfRSf+txbt5aOp/e7TAz3ptVKu9Oyir3IAOFPGV6O9c2naym5TOriy1l0nNf6a4X5UXRZSGX/dw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/sunos-x64@0.25.1':
+    resolution: {integrity: sha512-2H3RUvcmULO7dIE5EWJH8eubZAI4xw54H1ilJnRNZdeo8dTADEZ21w6J22XBkXqGJbe0+wnNJtw3UXRoLJnFEg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/win32-arm64@0.25.1':
+    resolution: {integrity: sha512-GE7XvrdOzrb+yVKB9KsRMq+7a2U/K5Cf/8grVFRAGJmfADr/e/ODQ134RK2/eeHqYV5eQRFxb1hY7Nr15fv1NQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/win32-ia32@0.25.1':
+    resolution: {integrity: sha512-uOxSJCIcavSiT6UnBhBzE8wy3n0hOkJsBOzy7HDAuTDE++1DJMRRVCPGisULScHL+a/ZwdXPpXD3IyFKjA7K8A==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/win32-x64@0.25.1':
+    resolution: {integrity: sha512-Y1EQdcfwMSeQN/ujR5VayLOJ1BHaK+ssyk0AEzPjC+t1lITgsnccPqFjb6V+LsTp/9Iov4ysfjxLaGJ9RPtkVg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
+  '@img/sharp-darwin-arm64@0.33.5':
+    resolution: {integrity: sha512-UT4p+iz/2H4twwAoLCqfA9UH5pI6DggwKEGuaPy7nCVQ8ZsiY5PIcrRvD1DzuY3qYL07NtIQcWnBSY/heikIFQ==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-darwin-x64@0.33.5':
+    resolution: {integrity: sha512-fyHac4jIc1ANYGRDxtiqelIbdWkIuQaI84Mv45KvGRRxSAa7o7d1ZKAOBaYbnepLC1WqxfpimdeWfvqqSGwR2Q==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-libvips-darwin-arm64@1.0.4':
+    resolution: {integrity: sha512-XblONe153h0O2zuFfTAbQYAX2JhYmDHeWikp1LM9Hul9gVPjFY427k6dFEcOL72O01QxQsWi761svJ/ev9xEDg==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-libvips-darwin-x64@1.0.4':
+    resolution: {integrity: sha512-xnGR8YuZYfJGmWPvmlunFaWJsb9T/AO2ykoP3Fz/0X5XV2aoYBPkX6xqCQvUTKKiLddarLaxpzNe+b1hjeWHAQ==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-libvips-linux-arm64@1.0.4':
+    resolution: {integrity: sha512-9B+taZ8DlyyqzZQnoeIvDVR/2F4EbMepXMc/NdVbkzsJbzkUjhXv/70GQJ7tdLA4YJgNP25zukcxpX2/SueNrA==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-arm@1.0.5':
+    resolution: {integrity: sha512-gvcC4ACAOPRNATg/ov8/MnbxFDJqf/pDePbBnuBDcjsI8PssmjoKMAz4LtLaVi+OnSb5FK/yIOamqDwGmXW32g==}
+    cpu: [arm]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-s390x@1.0.4':
+    resolution: {integrity: sha512-u7Wz6ntiSSgGSGcjZ55im6uvTrOxSIS8/dgoVMoiGE9I6JAfU50yH5BoDlYA1tcuGS7g/QNtetJnxA6QEsCVTA==}
+    cpu: [s390x]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-x64@1.0.4':
+    resolution: {integrity: sha512-MmWmQ3iPFZr0Iev+BAgVMb3ZyC4KeFc3jFxnNbEPas60e1cIfevbtuyf9nDGIzOaW9PdnDciJm+wFFaTlj5xYw==}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-libvips-linuxmusl-arm64@1.0.4':
+    resolution: {integrity: sha512-9Ti+BbTYDcsbp4wfYib8Ctm1ilkugkA/uscUn6UXK1ldpC1JjiXbLfFZtRlBhjPZ5o1NCLiDbg8fhUPKStHoTA==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-libvips-linuxmusl-x64@1.0.4':
+    resolution: {integrity: sha512-viYN1KX9m+/hGkJtvYYp+CCLgnJXwiQB39damAO7WMdKWlIhmYTfHjwSbQeUK/20vY154mwezd9HflVFM1wVSw==}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-linux-arm64@0.33.5':
+    resolution: {integrity: sha512-JMVv+AMRyGOHtO1RFBiJy/MBsgz0x4AWrT6QoEVVTyh1E39TrCUpTRI7mx9VksGX4awWASxqCYLCV4wBZHAYxA==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-linux-arm@0.33.5':
+    resolution: {integrity: sha512-JTS1eldqZbJxjvKaAkxhZmBqPRGmxgu+qFKSInv8moZ2AmT5Yib3EQ1c6gp493HvrvV8QgdOXdyaIBrhvFhBMQ==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@img/sharp-linux-s390x@0.33.5':
+    resolution: {integrity: sha512-y/5PCd+mP4CA/sPDKl2961b+C9d+vPAveS33s6Z3zfASk2j5upL6fXVPZi7ztePZ5CuH+1kW8JtvxgbuXHRa4Q==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [s390x]
+    os: [linux]
+
+  '@img/sharp-linux-x64@0.33.5':
+    resolution: {integrity: sha512-opC+Ok5pRNAzuvq1AG0ar+1owsu842/Ab+4qvU879ippJBHvyY5n2mxF1izXqkPYlGuP/M556uh53jRLJmzTWA==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-linuxmusl-arm64@0.33.5':
+    resolution: {integrity: sha512-XrHMZwGQGvJg2V/oRSUfSAfjfPxO+4DkiRh6p2AFjLQztWUuY/o8Mq0eMQVIY7HJ1CDQUJlxGGZRw1a5bqmd1g==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-linuxmusl-x64@0.33.5':
+    resolution: {integrity: sha512-WT+d/cgqKkkKySYmqoZ8y3pxx7lx9vVejxW/W4DOFMYVSkErR+w7mf2u8m/y4+xHe7yY9DAXQMWQhpnMuFfScw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-wasm32@0.33.5':
+    resolution: {integrity: sha512-ykUW4LVGaMcU9lu9thv85CbRMAwfeadCJHRsg2GmeRa/cJxsVY9Rbd57JcMxBkKHag5U/x7TSBpScF4U8ElVzg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [wasm32]
+
+  '@img/sharp-win32-ia32@0.33.5':
+    resolution: {integrity: sha512-T36PblLaTwuVJ/zw/LaH0PdZkRz5rd3SmMHX8GSmR7vtNSP5Z6bQkExdSK7xGWyxLw4sUknBuugTelgw2faBbQ==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [ia32]
+    os: [win32]
+
+  '@img/sharp-win32-x64@0.33.5':
+    resolution: {integrity: sha512-MpY/o8/8kj+EcnxwvrP4aTJSWw/aZ7JIGR4aBeZkZw5B7/Jn+tY9/VNwtcoGmdT7GfggGIU4kygOMSbYnOrAbg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [win32]
+
+  '@inquirer/checkbox@4.1.4':
+    resolution: {integrity: sha512-d30576EZdApjAMceijXA5jDzRQHT/MygbC+J8I7EqA6f/FRpYxlRtRJbHF8gHeWYeSdOuTEJqonn7QLB1ELezA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/confirm@5.1.8':
+    resolution: {integrity: sha512-dNLWCYZvXDjO3rnQfk2iuJNL4Ivwz/T2+C3+WnNfJKsNGSuOs3wAo2F6e0p946gtSAk31nZMfW+MRmYaplPKsg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/core@10.1.9':
+    resolution: {integrity: sha512-sXhVB8n20NYkUBfDYgizGHlpRVaCRjtuzNZA6xpALIUbkgfd2Hjz+DfEN6+h1BRnuxw0/P4jCIMjMsEOAMwAJw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/editor@4.2.9':
+    resolution: {integrity: sha512-8HjOppAxO7O4wV1ETUlJFg6NDjp/W2NP5FB9ZPAcinAlNT4ZIWOLe2pUVwmmPRSV0NMdI5r/+lflN55AwZOKSw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/expand@4.0.11':
+    resolution: {integrity: sha512-OZSUW4hFMW2TYvX/Sv+NnOZgO8CHT2TU1roUCUIF2T+wfw60XFRRp9MRUPCT06cRnKL+aemt2YmTWwt7rOrNEA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/figures@1.0.11':
+    resolution: {integrity: sha512-eOg92lvrn/aRUqbxRyvpEWnrvRuTYRifixHkYVpJiygTgVSBIHDqLh0SrMQXkafvULg3ck11V7xvR+zcgvpHFw==}
+    engines: {node: '>=18'}
+
+  '@inquirer/input@4.1.8':
+    resolution: {integrity: sha512-WXJI16oOZ3/LiENCAxe8joniNp8MQxF6Wi5V+EBbVA0ZIOpFcL4I9e7f7cXse0HJeIPCWO8Lcgnk98juItCi7Q==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/number@3.0.11':
+    resolution: {integrity: sha512-pQK68CsKOgwvU2eA53AG/4npRTH2pvs/pZ2bFvzpBhrznh8Mcwt19c+nMO7LHRr3Vreu1KPhNBF3vQAKrjIulw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/password@4.0.11':
+    resolution: {integrity: sha512-dH6zLdv+HEv1nBs96Case6eppkRggMe8LoOTl30+Gq5Wf27AO/vHFgStTVz4aoevLdNXqwE23++IXGw4eiOXTg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/prompts@7.4.0':
+    resolution: {integrity: sha512-EZiJidQOT4O5PYtqnu1JbF0clv36oW2CviR66c7ma4LsupmmQlUwmdReGKRp456OWPWMz3PdrPiYg3aCk3op2w==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/rawlist@4.0.11':
+    resolution: {integrity: sha512-uAYtTx0IF/PqUAvsRrF3xvnxJV516wmR6YVONOmCWJbbt87HcDHLfL9wmBQFbNJRv5kCjdYKrZcavDkH3sVJPg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/search@3.0.11':
+    resolution: {integrity: sha512-9CWQT0ikYcg6Ls3TOa7jljsD7PgjcsYEM0bYE+Gkz+uoW9u8eaJCRHJKkucpRE5+xKtaaDbrND+nPDoxzjYyew==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/select@4.1.0':
+    resolution: {integrity: sha512-z0a2fmgTSRN+YBuiK1ROfJ2Nvrpij5lVN3gPDkQGhavdvIVGHGW29LwYZfM/j42Ai2hUghTI/uoBuTbrJk42bA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/type@3.0.5':
+    resolution: {integrity: sha512-ZJpeIYYueOz/i/ONzrfof8g89kNdO2hjGuvULROo3O8rlB2CRtSseE5KeirnyE4t/thAn/EwvS/vuQeJCn+NZg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@jsep-plugin/assignment@1.3.0':
+    resolution: {integrity: sha512-VVgV+CXrhbMI3aSusQyclHkenWSAm95WaiKrMxRFam3JSUiIaQjoMIw2sEs/OX4XifnqeQUN4DYbJjlA8EfktQ==}
+    engines: {node: '>= 10.16.0'}
+    peerDependencies:
+      jsep: ^0.4.0||^1.0.0
+
+  '@jsep-plugin/regex@1.0.4':
+    resolution: {integrity: sha512-q7qL4Mgjs1vByCaTnDFcBnV9HS7GVPJX5vyVoCgZHNSC9rjwIlmbXG5sUuorR5ndfHAIlJ8pVStxvjXHbNvtUg==}
+    engines: {node: '>= 10.16.0'}
+    peerDependencies:
+      jsep: ^0.4.0||^1.0.0
+
+  '@jsep-plugin/ternary@1.1.4':
+    resolution: {integrity: sha512-ck5wiqIbqdMX6WRQztBL7ASDty9YLgJ3sSAK5ZpBzXeySvFGCzIvM6UiAI4hTZ22fEcYQVV/zhUbNscggW+Ukg==}
+    engines: {node: '>= 10.16.0'}
+    peerDependencies:
+      jsep: ^0.4.0||^1.0.0
+
+  '@leichtgewicht/ip-codec@2.0.5':
+    resolution: {integrity: sha512-Vo+PSpZG2/fmgmiNzYK9qWRh8h/CHrwD0mo1h1DzL4yzHNSfWYujGTYsWGreD000gcgmZ7K4Ys6Tx9TxtsKdDw==}
+
+  '@mdx-js/mdx@3.1.0':
+    resolution: {integrity: sha512-/QxEhPAvGwbQmy1Px8F899L5Uc2KZ6JtXwlCgJmjSTBedwOZkByYcBG4GceIGPXRDsmfxhHazuS+hlOShRLeDw==}
+
+  '@mdx-js/react@3.1.0':
+    resolution: {integrity: sha512-QjHtSaoameoalGnKDT3FoIl4+9RwyTmo9ZJGBdLOks/YOiWHoRDI3PUwEzOE7kEmGcV3AFcp9K6dYu9rEuKLAQ==}
+    peerDependencies:
+      '@types/react': '>=16'
+      react: '>=16'
+
+  '@mintlify/cli@4.0.452':
+    resolution: {integrity: sha512-8x/3Re875l5AyoOkHELmlMdmJBrA+gJUFQuINWSQqAz6M/f7MEUzK/gqqL+NYpTxFJBNRZ+QLmncvaM73dE6bw==}
+    engines: {node: '>=18.0.0'}
+    hasBin: true
+
+  '@mintlify/common@1.0.318':
+    resolution: {integrity: sha512-iu1qI9xTpXgxTMlE2bUciHwMnsmQZc5Ps9/+hLCbr6x42U/JWPBtKySJ6wf5q28V+HFLsz1jxUCN4UkBTd/3FQ==}
+
+  '@mintlify/link-rot@3.0.423':
+    resolution: {integrity: sha512-jCGJXD3Ci/2pIjKskPJ9Jx5SQKJ6Zg0y5gafRQtb4ikBw4WR4gZx3bE6Z4d93ipzT8vwzK+aZSdtHxhrg6wSXw==}
+    engines: {node: '>=18.0.0'}
+
+  '@mintlify/mdx@1.0.1':
+    resolution: {integrity: sha512-zrzt8nxoIgJeSUeuJaC8pbd5EHKjCq30qV2HMoqIHLjeE0l7hkMgjBPNWNde7CYDPig1ODS1kPuE5Bnt+/+PIg==}
+    peerDependencies:
+      react: ^18.3.1
+      react-dom: ^18.3.1
+
+  '@mintlify/models@0.0.180':
+    resolution: {integrity: sha512-f5rkVdf7CG6P5PdIFQIhCrP9twU8wwwUKslYsKjhMPmQhPVUf1MrNckyO4JwjGlcXYn23kAAMCvDWPAQFoaPlQ==}
+    engines: {node: '>=18.0.0'}
+
+  '@mintlify/openapi-parser@0.0.7':
+    resolution: {integrity: sha512-3ecbkzPbsnkKVZJypVL0H5pCTR7a4iLv4cP7zbffzAwy+vpH70JmPxNVpPPP62yLrdZlfNcMxu5xKeT7fllgMg==}
+    engines: {node: '>=18'}
+
+  '@mintlify/prebuild@1.0.420':
+    resolution: {integrity: sha512-yu6DPrxxmvVYNppQT+y5YIzbIlYzpyRPJPvt2qQKk4QydmSFXrWbJNMZW+X+A4vfh/jYXn0/3MlRzb5Pre8DFw==}
+
+  '@mintlify/previewing@4.0.443':
+    resolution: {integrity: sha512-pvu44dCumomf8rSfFZQyow9N3LwDlSiPbPeS6gBvh0CCfMXqgVtj+En4sjJbSY4Oa+zU9/YltITu4upWW120Hg==}
+    engines: {node: '>=18.0.0'}
+
+  '@mintlify/scraping@4.0.170':
+    resolution: {integrity: sha512-43LSQGbokeH/12oIlasyYb7BgPhf4StEd9bQnJ6EiutaPyuxoMd+nnRnbJVxhTZlC67rhS3MNJEmncA3h8aNQQ==}
+    engines: {node: '>=18.0.0'}
+    hasBin: true
+
+  '@mintlify/validation@0.1.326':
+    resolution: {integrity: sha512-TJ4hy9DS82Nru0dfXhMRuC+sNRA+vD6vD0+Ar0zgd35b1PoWpQE5cqWm2Am/jk13kLV93rHo0qWy9YCSX9ADYw==}
+
+  '@openapi-contrib/openapi-schema-to-json-schema@3.2.0':
+    resolution: {integrity: sha512-Gj6C0JwCr8arj0sYuslWXUBSP/KnUlEGnPW4qxlXvAl543oaNQgMgIgkQUA6vs5BCCvwTEiL8m/wdWzfl4UvSw==}
+
+  '@puppeteer/browsers@2.3.0':
+    resolution: {integrity: sha512-ioXoq9gPxkss4MYhD+SFaU9p1IHFUX0ILAWFPyjGaBdjLsYAlZw6j1iLA0N/m12uVHLFDfSYNF7EQccjinIMDA==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  '@sindresorhus/is@5.6.0':
+    resolution: {integrity: sha512-TV7t8GKYaJWsn00tFDqBw8+Uqmr8A0fRU1tvTQhyZzGv0sJCGRQL3JGMI3ucuKo3XIZdUP+Lx7/gh2t3lewy7g==}
+    engines: {node: '>=14.16'}
+
+  '@sindresorhus/slugify@2.2.1':
+    resolution: {integrity: sha512-MkngSCRZ8JdSOCHRaYd+D01XhvU3Hjy6MGl06zhOk614hp9EOAp5gIkBeQg7wtmxpitU6eAL4kdiRMcJa2dlrw==}
+    engines: {node: '>=12'}
+
+  '@sindresorhus/transliterate@1.6.0':
+    resolution: {integrity: sha512-doH1gimEu3A46VX6aVxpHTeHrytJAG6HgdxntYnCFiIFHEM/ZGpG8KiZGBChchjQmG0XFIBL552kBTjVcMZXwQ==}
+    engines: {node: '>=12'}
+
+  '@socket.io/component-emitter@3.1.2':
+    resolution: {integrity: sha512-9BCxFwvbGg/RsZK9tjXd8s4UcwR0MWeFQ1XEKIQVVvAGJyINdrqKMcTRyLoK8Rse1GjzLV9cwjWV1olXRWEXVA==}
+
+  '@stoplight/better-ajv-errors@1.0.3':
+    resolution: {integrity: sha512-0p9uXkuB22qGdNfy3VeEhxkU5uwvp/KrBTAbrLBURv6ilxIVwanKwjMc41lQfIVgPGcOkmLbTolfFrSsueu7zA==}
+    engines: {node: ^12.20 || >= 14.13}
+    peerDependencies:
+      ajv: '>=8'
+
+  '@stoplight/json-ref-readers@1.2.2':
+    resolution: {integrity: sha512-nty0tHUq2f1IKuFYsLM4CXLZGHdMn+X/IwEUIpeSOXt0QjMUbL0Em57iJUDzz+2MkWG83smIigNZ3fauGjqgdQ==}
+    engines: {node: '>=8.3.0'}
+
+  '@stoplight/json-ref-resolver@3.1.6':
+    resolution: {integrity: sha512-YNcWv3R3n3U6iQYBsFOiWSuRGE5su1tJSiX6pAPRVk7dP0L7lqCteXGzuVRQ0gMZqUl8v1P0+fAKxF6PLo9B5A==}
+    engines: {node: '>=8.3.0'}
+
+  '@stoplight/json@3.21.0':
+    resolution: {integrity: sha512-5O0apqJ/t4sIevXCO3SBN9AHCEKKR/Zb4gaj7wYe5863jme9g02Q0n/GhM7ZCALkL+vGPTe4ZzTETP8TFtsw3g==}
+    engines: {node: '>=8.3.0'}
+
+  '@stoplight/ordered-object-literal@1.0.5':
+    resolution: {integrity: sha512-COTiuCU5bgMUtbIFBuyyh2/yVVzlr5Om0v5utQDgBCuQUOPgU1DwoffkTfg4UBQOvByi5foF4w4T+H9CoRe5wg==}
+    engines: {node: '>=8'}
+
+  '@stoplight/path@1.3.2':
+    resolution: {integrity: sha512-lyIc6JUlUA8Ve5ELywPC8I2Sdnh1zc1zmbYgVarhXIp9YeAB0ReeqmGEOWNtlHkbP2DAA1AL65Wfn2ncjK/jtQ==}
+    engines: {node: '>=8'}
+
+  '@stoplight/spectral-core@1.19.5':
+    resolution: {integrity: sha512-i+njdliW7bAHGsHEgDvH0To/9IxiYiBELltkZ7ASVy4i+WXtZ40lQXpeRQRwePrBcSgQl0gcZFuKX10nmSHtbw==}
+    engines: {node: ^16.20 || ^18.18 || >= 20.17}
+
+  '@stoplight/spectral-formats@1.8.2':
+    resolution: {integrity: sha512-c06HB+rOKfe7tuxg0IdKDEA5XnjL2vrn/m/OVIIxtINtBzphZrOgtRn7epQ5bQF5SWp84Ue7UJWaGgDwVngMFw==}
+    engines: {node: ^16.20 || ^18.18 || >= 20.17}
+
+  '@stoplight/spectral-functions@1.9.4':
+    resolution: {integrity: sha512-+dgu7QQ1JIZFsNLhNbQLPA9tniIT3KjOc9ORv0LYSCLvZjkWT2bN7vgmathbXsbmhnmhvl15H9sRqUIqzi+qoQ==}
+    engines: {node: ^16.20 || ^18.18 || >= 20.17}
+
+  '@stoplight/spectral-parsers@1.0.5':
+    resolution: {integrity: sha512-ANDTp2IHWGvsQDAY85/jQi9ZrF4mRrA5bciNHX+PUxPr4DwS6iv4h+FVWJMVwcEYdpyoIdyL+SRmHdJfQEPmwQ==}
+    engines: {node: ^16.20 || ^18.18 || >= 20.17}
+
+  '@stoplight/spectral-ref-resolver@1.0.5':
+    resolution: {integrity: sha512-gj3TieX5a9zMW29z3mBlAtDOCgN3GEc1VgZnCVlr5irmR4Qi5LuECuFItAq4pTn5Zu+sW5bqutsCH7D4PkpyAA==}
+    engines: {node: ^16.20 || ^18.18 || >= 20.17}
+
+  '@stoplight/spectral-runtime@1.1.4':
+    resolution: {integrity: sha512-YHbhX3dqW0do6DhiPSgSGQzr6yQLlWybhKwWx0cqxjMwxej3TqLv3BXMfIUYFKKUqIwH4Q2mV8rrMM8qD2N0rQ==}
+    engines: {node: ^16.20 || ^18.18 || >= 20.17}
+
+  '@stoplight/types@13.20.0':
+    resolution: {integrity: sha512-2FNTv05If7ib79VPDA/r9eUet76jewXFH2y2K5vuge6SXbRHtWBhcaRmu+6QpF4/WRNoJj5XYRSwLGXDxysBGA==}
+    engines: {node: ^12.20 || >=14.13}
+
+  '@stoplight/types@13.6.0':
+    resolution: {integrity: sha512-dzyuzvUjv3m1wmhPfq82lCVYGcXG0xUYgqnWfCq3PCVR4BKFhjdkHrnJ+jIDoMKvXb05AZP/ObQF6+NpDo29IQ==}
+    engines: {node: ^12.20 || >=14.13}
+
+  '@stoplight/types@14.1.1':
+    resolution: {integrity: sha512-/kjtr+0t0tjKr+heVfviO9FrU/uGLc+QNX3fHJc19xsCNYqU7lVhaXxDmEID9BZTjG+/r9pK9xP/xU02XGg65g==}
+    engines: {node: ^12.20 || >=14.13}
+
+  '@stoplight/yaml-ast-parser@0.0.50':
+    resolution: {integrity: sha512-Pb6M8TDO9DtSVla9yXSTAxmo9GVEouq5P40DWXdOie69bXogZTkgvopCq+yEvTMA0F6PEvdJmbtTV3ccIp11VQ==}
+
+  '@stoplight/yaml@4.3.0':
+    resolution: {integrity: sha512-JZlVFE6/dYpP9tQmV0/ADfn32L9uFarHWxfcRhReKUnljz1ZiUM5zpX+PH8h5CJs6lao3TuFqnPm9IJJCEkE2w==}
+    engines: {node: '>=10.8'}
+
+  '@szmarczak/http-timer@5.0.1':
+    resolution: {integrity: sha512-+PmQX0PiAYPMeVYe237LJAYvOMYW1j2rH5YROyS3b4CTVJum34HfRvKvAzozHAQG0TnHNdUfY9nCeUyRAs//cw==}
+    engines: {node: '>=14.16'}
+
+  '@tootallnate/quickjs-emscripten@0.23.0':
+    resolution: {integrity: sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==}
+
+  '@types/cors@2.8.17':
+    resolution: {integrity: sha512-8CGDvrBj1zgo2qE+oS3pOCyYNqCPryMWY2bGfwA0dcfopWGgxs+78df0Rs3rc9THP4JkOhLsAa+15VdpAqkcUA==}
+
+  '@types/debug@4.1.12':
+    resolution: {integrity: sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==}
+
+  '@types/es-aggregate-error@1.0.6':
+    resolution: {integrity: sha512-qJ7LIFp06h1QE1aVxbVd+zJP2wdaugYXYfd6JxsyRMrYHaxb6itXPogW2tz+ylUJ1n1b+JF1PHyYCfYHm0dvUg==}
+
+  '@types/estree-jsx@1.0.5':
+    resolution: {integrity: sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==}
+
+  '@types/estree@1.0.7':
+    resolution: {integrity: sha512-w28IoSUCJpidD/TGviZwwMJckNESJZXFu7NBZ5YJ4mEUnNraUn9Pm8HSZm/jDF1pDWYKspWE7oVphigUPRakIQ==}
+
+  '@types/hast@2.3.10':
+    resolution: {integrity: sha512-McWspRw8xx8J9HurkVBfYj0xKoE25tOFlHGdx4MJ5xORQrMGZNqJhVQWaIbm6Oyla5kYOXtDiopzKRJzEOkwJw==}
+
+  '@types/hast@3.0.4':
+    resolution: {integrity: sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==}
+
+  '@types/http-cache-semantics@4.0.4':
+    resolution: {integrity: sha512-1m0bIFVc7eJWyve9S0RnuRgcQqF/Xd5QsUZAZeQFr1Q3/p9JWoQQEqmVy+DPTNpGXwhgIetAoYF8JSc33q29QA==}
+
+  '@types/json-schema@7.0.15':
+    resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==}
+
+  '@types/katex@0.16.7':
+    resolution: {integrity: sha512-HMwFiRujE5PjrgwHQ25+bsLJgowjGjm5Z8FVSf0N6PwgJrwxH0QxzHYDcKsTfV3wva0vzrpqMTJS2jXPr5BMEQ==}
+
+  '@types/mdast@4.0.4':
+    resolution: {integrity: sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==}
+
+  '@types/mdx@2.0.13':
+    resolution: {integrity: sha512-+OWZQfAYyio6YkJb3HLxDrvnx6SWWDbC0zVPfBRzUk0/nqoDyf6dNxQi3eArPe8rJ473nobTMQ/8Zk+LxJ+Yuw==}
+
+  '@types/ms@2.1.0':
+    resolution: {integrity: sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==}
+
+  '@types/nlcst@2.0.3':
+    resolution: {integrity: sha512-vSYNSDe6Ix3q+6Z7ri9lyWqgGhJTmzRjZRqyq15N0Z/1/UnVsno9G/N40NBijoYx2seFDIl0+B2mgAb9mezUCA==}
+
+  '@types/node@22.13.14':
+    resolution: {integrity: sha512-Zs/Ollc1SJ8nKUAgc7ivOEdIBM8JAKgrqqUYi2J997JuKO7/tpQC+WCetQ1sypiKCQWHdvdg9wBNpUPEWZae7w==}
+
+  '@types/prismjs@1.26.5':
+    resolution: {integrity: sha512-AUZTa7hQ2KY5L7AmtSiqxlhWxb4ina0yd8hNbl4TWuqnv/pFP0nDMb3YrfSBf4hJVGLh2YEIBfKaBW/9UEl6IQ==}
+
+  '@types/react@19.0.12':
+    resolution: {integrity: sha512-V6Ar115dBDrjbtXSrS+/Oruobc+qVbbUxDFC1RSbRqLt5SYvxxyIDrSC85RWml54g+jfNeEMZhEj7wW07ONQhA==}
+
+  '@types/unist@2.0.11':
+    resolution: {integrity: sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==}
+
+  '@types/unist@3.0.3':
+    resolution: {integrity: sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==}
+
+  '@types/urijs@1.19.25':
+    resolution: {integrity: sha512-XOfUup9r3Y06nFAZh3WvO0rBU4OtlfPB/vgxpjg+NRdGU6CN6djdc6OEiH+PcqHCY6eFLo9Ista73uarf4gnBg==}
+
+  '@types/yauzl@2.10.3':
+    resolution: {integrity: sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==}
+
+  '@ungap/structured-clone@1.3.0':
+    resolution: {integrity: sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==}
+
+  abort-controller@3.0.0:
+    resolution: {integrity: sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==}
+    engines: {node: '>=6.5'}
+
+  accepts@1.3.8:
+    resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==}
+    engines: {node: '>= 0.6'}
+
+  acorn-jsx@5.3.2:
+    resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
+    peerDependencies:
+      acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
+
+  acorn@8.14.1:
+    resolution: {integrity: sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg==}
+    engines: {node: '>=0.4.0'}
+    hasBin: true
+
+  address@1.2.2:
+    resolution: {integrity: sha512-4B/qKCfeE/ODUaAUpSwfzazo5x29WD4r3vXiWsB7I2mSDAihwEqKO+g8GELZUQSSAo5e1XTYh3ZVfLyxBc12nA==}
+    engines: {node: '>= 10.0.0'}
+
+  agent-base@7.1.3:
+    resolution: {integrity: sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==}
+    engines: {node: '>= 14'}
+
+  aggregate-error@4.0.1:
+    resolution: {integrity: sha512-0poP0T7el6Vq3rstR8Mn4V/IQrpBLO6POkUSrN7RhyY+GF/InCFShQzsQ39T25gkHhLgSLByyAz+Kjb+c2L98w==}
+    engines: {node: '>=12'}
+
+  ajv-draft-04@1.0.0:
+    resolution: {integrity: sha512-mv00Te6nmYbRp5DCwclxtt7yV/joXJPGS7nM+97GdxvuttCOfgI3K4U25zboyeX0O+myI8ERluxQe5wljMmVIw==}
+    peerDependencies:
+      ajv: ^8.5.0
+    peerDependenciesMeta:
+      ajv:
+        optional: true
+
+  ajv-errors@3.0.0:
+    resolution: {integrity: sha512-V3wD15YHfHz6y0KdhYFjyy9vWtEVALT9UrxfN3zqlI6dMioHnJrqOYfyPKol3oqrnCM9uwkcdCwkJ0WUcbLMTQ==}
+    peerDependencies:
+      ajv: ^8.0.1
+
+  ajv-formats@2.1.1:
+    resolution: {integrity: sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==}
+    peerDependencies:
+      ajv: ^8.0.0
+    peerDependenciesMeta:
+      ajv:
+        optional: true
+
+  ajv-formats@3.0.1:
+    resolution: {integrity: sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==}
+    peerDependencies:
+      ajv: ^8.0.0
+    peerDependenciesMeta:
+      ajv:
+        optional: true
+
+  ajv@8.17.1:
+    resolution: {integrity: sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==}
+
+  ansi-escapes@4.3.2:
+    resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==}
+    engines: {node: '>=8'}
+
+  ansi-regex@5.0.1:
+    resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
+    engines: {node: '>=8'}
+
+  ansi-regex@6.1.0:
+    resolution: {integrity: sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==}
+    engines: {node: '>=12'}
+
+  ansi-styles@4.3.0:
+    resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
+    engines: {node: '>=8'}
+
+  anymatch@3.1.3:
+    resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==}
+    engines: {node: '>= 8'}
+
+  argparse@1.0.10:
+    resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==}
+
+  argparse@2.0.1:
+    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
+
+  array-buffer-byte-length@1.0.2:
+    resolution: {integrity: sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==}
+    engines: {node: '>= 0.4'}
+
+  array-flatten@1.1.1:
+    resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==}
+
+  array-iterate@2.0.1:
+    resolution: {integrity: sha512-I1jXZMjAgCMmxT4qxXfPXa6SthSoE8h6gkSI9BGGNv8mP8G/v0blc+qFnZu6K42vTOiuME596QaLO0TP3Lk0xg==}
+
+  arraybuffer.prototype.slice@1.0.4:
+    resolution: {integrity: sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==}
+    engines: {node: '>= 0.4'}
+
+  ast-types@0.13.4:
+    resolution: {integrity: sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==}
+    engines: {node: '>=4'}
+
+  astring@1.9.0:
+    resolution: {integrity: sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg==}
+    hasBin: true
+
+  async-function@1.0.0:
+    resolution: {integrity: sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==}
+    engines: {node: '>= 0.4'}
+
+  asynckit@0.4.0:
+    resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
+
+  available-typed-arrays@1.0.7:
+    resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==}
+    engines: {node: '>= 0.4'}
+
+  avsc@5.7.7:
+    resolution: {integrity: sha512-9cYNccliXZDByFsFliVwk5GvTq058Fj513CiR4E60ndDwmuXzTJEp/Bp8FyuRmGyYupLjHLs+JA9/CBoVS4/NQ==}
+    engines: {node: '>=0.11'}
+
+  axios@1.8.4:
+    resolution: {integrity: sha512-eBSYY4Y68NNlHbHBMdeDmKNtDgXWhQsJcGqzO3iLUM0GraQFSS9cVgPX5I9b3lbdFKyYoAEGAZF1DwhTaljNAw==}
+
+  b4a@1.6.7:
+    resolution: {integrity: sha512-OnAYlL5b7LEkALw87fUVafQw5rVR9RjwGd4KUwNQ6DrrNmaVaUCgLipfVlzrPQ4tWOR9P0IXGNOx50jYCCdSJg==}
+
+  bail@2.0.2:
+    resolution: {integrity: sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==}
+
+  balanced-match@1.0.2:
+    resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
+
+  bare-events@2.5.4:
+    resolution: {integrity: sha512-+gFfDkR8pj4/TrWCGUGWmJIkBwuxPS5F+a5yWjOHQt2hHvNZd5YLzadjmDUtFmMM4y429bnKLa8bYBMHcYdnQA==}
+
+  bare-fs@4.0.2:
+    resolution: {integrity: sha512-S5mmkMesiduMqnz51Bfh0Et9EX0aTCJxhsI4bvzFFLs8Z1AV8RDHadfY5CyLwdoLHgXbNBEN1gQcbEtGwuvixw==}
+    engines: {bare: '>=1.16.0'}
+    peerDependencies:
+      bare-buffer: '*'
+    peerDependenciesMeta:
+      bare-buffer:
+        optional: true
+
+  bare-os@3.6.1:
+    resolution: {integrity: sha512-uaIjxokhFidJP+bmmvKSgiMzj2sV5GPHaZVAIktcxcpCyBFFWO+YlikVAdhmUo2vYFvFhOXIAlldqV29L8126g==}
+    engines: {bare: '>=1.14.0'}
+
+  bare-path@3.0.0:
+    resolution: {integrity: sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==}
+
+  bare-stream@2.6.5:
+    resolution: {integrity: sha512-jSmxKJNJmHySi6hC42zlZnq00rga4jjxcgNZjY9N5WlOe/iOoGRtdwGsHzQv2RlH2KOYMwGUXhf2zXd32BA9RA==}
+    peerDependencies:
+      bare-buffer: '*'
+      bare-events: '*'
+    peerDependenciesMeta:
+      bare-buffer:
+        optional: true
+      bare-events:
+        optional: true
+
+  base64-js@1.5.1:
+    resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
+
+  base64id@2.0.0:
+    resolution: {integrity: sha512-lGe34o6EHj9y3Kts9R4ZYs/Gr+6N7MCaMlIFA3F1R2O5/m7K06AxfSeO5530PEERE6/WyEg3lsuyw4GHlPZHog==}
+    engines: {node: ^4.5.0 || >= 5.9}
+
+  basic-ftp@5.0.5:
+    resolution: {integrity: sha512-4Bcg1P8xhUuqcii/S0Z9wiHIrQVPMermM1any+MX5GeGD7faD3/msQUDGLol9wOcz4/jbg/WJnGqoJF6LiBdtg==}
+    engines: {node: '>=10.0.0'}
+
+  better-opn@3.0.2:
+    resolution: {integrity: sha512-aVNobHnJqLiUelTaHat9DZ1qM2w0C0Eym4LPI/3JxOnSokGVdsl1T1kN7TFvsEAD8G47A6VKQ0TVHqbBnYMJlQ==}
+    engines: {node: '>=12.0.0'}
+
+  binary-extensions@2.3.0:
+    resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==}
+    engines: {node: '>=8'}
+
+  bl@5.1.0:
+    resolution: {integrity: sha512-tv1ZJHLfTDnXE6tMHv73YgSJaWR2AFuPwMntBe7XL/GBFHnT0CLnsHMogfk5+GzCDC5ZWarSCYaIGATZt9dNsQ==}
+
+  body-parser@1.20.3:
+    resolution: {integrity: sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==}
+    engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}
+
+  brace-expansion@1.1.11:
+    resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==}
+
+  braces@3.0.3:
+    resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
+    engines: {node: '>=8'}
+
+  buffer-crc32@0.2.13:
+    resolution: {integrity: sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==}
+
+  buffer@5.7.1:
+    resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==}
+
+  buffer@6.0.3:
+    resolution: {integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==}
+
+  bytes@3.1.2:
+    resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==}
+    engines: {node: '>= 0.8'}
+
+  cacheable-lookup@7.0.0:
+    resolution: {integrity: sha512-+qJyx4xiKra8mZrcwhjMRMUhD5NR1R8esPkzIYxX96JiecFoxAXFuz/GpR3+ev4PE1WamHip78wV0vcmPQtp8w==}
+    engines: {node: '>=14.16'}
+
+  cacheable-request@10.2.14:
+    resolution: {integrity: sha512-zkDT5WAF4hSSoUgyfg5tFIxz8XQK+25W/TLVojJTMKBaxevLBBtLxgqguAuVQB8PVW79FVjHcU+GJ9tVbDZ9mQ==}
+    engines: {node: '>=14.16'}
+
+  call-bind-apply-helpers@1.0.2:
+    resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==}
+    engines: {node: '>= 0.4'}
+
+  call-bind@1.0.8:
+    resolution: {integrity: sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==}
+    engines: {node: '>= 0.4'}
+
+  call-bound@1.0.4:
+    resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==}
+    engines: {node: '>= 0.4'}
+
+  callsites@3.1.0:
+    resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
+    engines: {node: '>=6'}
+
+  ccount@2.0.1:
+    resolution: {integrity: sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==}
+
+  chalk@5.4.1:
+    resolution: {integrity: sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==}
+    engines: {node: ^12.17.0 || ^14.13 || >=16.0.0}
+
+  character-entities-html4@2.1.0:
+    resolution: {integrity: sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==}
+
+  character-entities-legacy@3.0.0:
+    resolution: {integrity: sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==}
+
+  character-entities@2.0.2:
+    resolution: {integrity: sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==}
+
+  character-reference-invalid@2.0.1:
+    resolution: {integrity: sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==}
+
+  chardet@0.7.0:
+    resolution: {integrity: sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==}
+
+  chokidar@3.6.0:
+    resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==}
+    engines: {node: '>= 8.10.0'}
+
+  chownr@2.0.0:
+    resolution: {integrity: sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==}
+    engines: {node: '>=10'}
+
+  chromium-bidi@0.6.3:
+    resolution: {integrity: sha512-qXlsCmpCZJAnoTYI83Iu6EdYQpMYdVkCfq08KDh2pmlVqK5t5IA9mGs4/LwCwp4fqisSOMXZxP3HIh8w8aRn0A==}
+    peerDependencies:
+      devtools-protocol: '*'
+
+  clean-stack@4.2.0:
+    resolution: {integrity: sha512-LYv6XPxoyODi36Dp976riBtSY27VmFo+MKqEU9QCCWyTrdEPDog+RWA7xQWHi6Vbp61j5c4cdzzX1NidnwtUWg==}
+    engines: {node: '>=12'}
+
+  cli-cursor@4.0.0:
+    resolution: {integrity: sha512-VGtlMu3x/4DOtIUwEkRezxUZ2lBacNJCHash0N0WeZDBS+7Ux1dm3XWAgWYxLJFMMdOeXMHXorshEFhbMSGelg==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  cli-spinners@2.9.2:
+    resolution: {integrity: sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==}
+    engines: {node: '>=6'}
+
+  cli-width@4.1.0:
+    resolution: {integrity: sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==}
+    engines: {node: '>= 12'}
+
+  cliui@8.0.1:
+    resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==}
+    engines: {node: '>=12'}
+
+  clone@1.0.4:
+    resolution: {integrity: sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==}
+    engines: {node: '>=0.8'}
+
+  collapse-white-space@2.1.0:
+    resolution: {integrity: sha512-loKTxY1zCOuG4j9f6EPnuyyYkf58RnhhWTvRoZEokgB+WbdXehfjFviyOVYkqzEWz1Q5kRiZdBYS5SwxbQYwzw==}
+
+  color-convert@2.0.1:
+    resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
+    engines: {node: '>=7.0.0'}
+
+  color-name@1.1.4:
+    resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
+
+  color-string@1.9.1:
+    resolution: {integrity: sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==}
+
+  color@4.2.3:
+    resolution: {integrity: sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==}
+    engines: {node: '>=12.5.0'}
+
+  combined-stream@1.0.8:
+    resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==}
+    engines: {node: '>= 0.8'}
+
+  comma-separated-tokens@2.0.3:
+    resolution: {integrity: sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==}
+
+  commander@8.3.0:
+    resolution: {integrity: sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==}
+    engines: {node: '>= 12'}
+
+  concat-map@0.0.1:
+    resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
+
+  content-disposition@0.5.4:
+    resolution: {integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==}
+    engines: {node: '>= 0.6'}
+
+  content-type@1.0.5:
+    resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==}
+    engines: {node: '>= 0.6'}
+
+  cookie-signature@1.0.6:
+    resolution: {integrity: sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==}
+
+  cookie@0.7.1:
+    resolution: {integrity: sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==}
+    engines: {node: '>= 0.6'}
+
+  cookie@0.7.2:
+    resolution: {integrity: sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==}
+    engines: {node: '>= 0.6'}
+
+  cors@2.8.5:
+    resolution: {integrity: sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==}
+    engines: {node: '>= 0.10'}
+
+  cosmiconfig@9.0.0:
+    resolution: {integrity: sha512-itvL5h8RETACmOTFc4UfIyB2RfEHi71Ax6E/PivVxq9NseKbOWpeyHEOIbmAw1rs8Ak0VursQNww7lf7YtUwzg==}
+    engines: {node: '>=14'}
+    peerDependencies:
+      typescript: '>=4.9.5'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+
+  csstype@3.1.3:
+    resolution: {integrity: sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==}
+
+  data-uri-to-buffer@6.0.2:
+    resolution: {integrity: sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw==}
+    engines: {node: '>= 14'}
+
+  data-view-buffer@1.0.2:
+    resolution: {integrity: sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==}
+    engines: {node: '>= 0.4'}
+
+  data-view-byte-length@1.0.2:
+    resolution: {integrity: sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==}
+    engines: {node: '>= 0.4'}
+
+  data-view-byte-offset@1.0.1:
+    resolution: {integrity: sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==}
+    engines: {node: '>= 0.4'}
+
+  debug@2.6.9:
+    resolution: {integrity: sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  debug@4.3.7:
+    resolution: {integrity: sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  debug@4.4.0:
+    resolution: {integrity: sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  decode-named-character-reference@1.1.0:
+    resolution: {integrity: sha512-Wy+JTSbFThEOXQIR2L6mxJvEs+veIzpmqD7ynWxMXGpnk3smkHQOp6forLdHsKpAMW9iJpaBBIxz285t1n1C3w==}
+
+  decompress-response@6.0.0:
+    resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==}
+    engines: {node: '>=10'}
+
+  defaults@1.0.4:
+    resolution: {integrity: sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==}
+
+  defer-to-connect@2.0.1:
+    resolution: {integrity: sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==}
+    engines: {node: '>=10'}
+
+  define-data-property@1.1.4:
+    resolution: {integrity: sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==}
+    engines: {node: '>= 0.4'}
+
+  define-lazy-prop@2.0.0:
+    resolution: {integrity: sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==}
+    engines: {node: '>=8'}
+
+  define-properties@1.2.1:
+    resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==}
+    engines: {node: '>= 0.4'}
+
+  degenerator@5.0.1:
+    resolution: {integrity: sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ==}
+    engines: {node: '>= 14'}
+
+  delayed-stream@1.0.0:
+    resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==}
+    engines: {node: '>=0.4.0'}
+
+  depd@2.0.0:
+    resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==}
+    engines: {node: '>= 0.8'}
+
+  dependency-graph@0.11.0:
+    resolution: {integrity: sha512-JeMq7fEshyepOWDfcfHK06N3MhyPhz++vtqWhMT5O9A3K42rdsEDpfdVqjaqaAhsw6a+ZqeDvQVtD0hFHQWrzg==}
+    engines: {node: '>= 0.6.0'}
+
+  dequal@2.0.3:
+    resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==}
+    engines: {node: '>=6'}
+
+  destroy@1.2.0:
+    resolution: {integrity: sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==}
+    engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}
+
+  detect-libc@2.0.3:
+    resolution: {integrity: sha512-bwy0MGW55bG41VqxxypOsdSdGqLwXPI/focwgTYCFMbdUiBAxLg9CFzG08sz2aqzknwiX7Hkl0bQENjg8iLByw==}
+    engines: {node: '>=8'}
+
+  detect-port@1.6.1:
+    resolution: {integrity: sha512-CmnVc+Hek2egPx1PeTFVta2W78xy2K/9Rkf6cC4T59S50tVnzKj+tnx5mmx5lwvCkujZ4uRrpRSuV+IVs3f90Q==}
+    engines: {node: '>= 4.0.0'}
+    hasBin: true
+
+  devlop@1.1.0:
+    resolution: {integrity: sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==}
+
+  devtools-protocol@0.0.1312386:
+    resolution: {integrity: sha512-DPnhUXvmvKT2dFA/j7B+riVLUt9Q6RKJlcppojL5CoRywJJKLDYnRlw0gTFKfgDPHP5E04UoB71SxoJlVZy8FA==}
+
+  dns-packet@5.6.1:
+    resolution: {integrity: sha512-l4gcSouhcgIKRvyy99RNVOgxXiicE+2jZoNmaNmZ6JXiGajBOJAesk1OBlJuM5k2c+eudGdLxDqXuPCKIj6kpw==}
+    engines: {node: '>=6'}
+
+  dns-socket@4.2.2:
+    resolution: {integrity: sha512-BDeBd8najI4/lS00HSKpdFia+OvUMytaVjfzR9n5Lq8MlZRSvtbI+uLtx1+XmQFls5wFU9dssccTmQQ6nfpjdg==}
+    engines: {node: '>=6'}
+
+  dunder-proto@1.0.1:
+    resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==}
+    engines: {node: '>= 0.4'}
+
+  ee-first@1.1.1:
+    resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==}
+
+  emoji-regex@8.0.0:
+    resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
+
+  encodeurl@1.0.2:
+    resolution: {integrity: sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==}
+    engines: {node: '>= 0.8'}
+
+  encodeurl@2.0.0:
+    resolution: {integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==}
+    engines: {node: '>= 0.8'}
+
+  end-of-stream@1.4.4:
+    resolution: {integrity: sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==}
+
+  engine.io-parser@5.2.3:
+    resolution: {integrity: sha512-HqD3yTBfnBxIrbnM1DoD6Pcq8NECnh8d4As1Qgh0z5Gg3jRRIqijury0CL3ghu/edArpUYiYqQiDUQBIs4np3Q==}
+    engines: {node: '>=10.0.0'}
+
+  engine.io@6.6.4:
+    resolution: {integrity: sha512-ZCkIjSYNDyGn0R6ewHDtXgns/Zre/NT6Agvq1/WobF7JXgFff4SeDroKiCO3fNJreU9YG429Sc81o4w5ok/W5g==}
+    engines: {node: '>=10.2.0'}
+
+  entities@4.5.0:
+    resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==}
+    engines: {node: '>=0.12'}
+
+  env-paths@2.2.1:
+    resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==}
+    engines: {node: '>=6'}
+
+  error-ex@1.3.2:
+    resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==}
+
+  es-abstract@1.23.9:
+    resolution: {integrity: sha512-py07lI0wjxAC/DcfK1S6G7iANonniZwTISvdPzk9hzeH0IZIshbuuFxLIU96OyF89Yb9hiqWn8M/bY83KY5vzA==}
+    engines: {node: '>= 0.4'}
+
+  es-aggregate-error@1.0.13:
+    resolution: {integrity: sha512-KkzhUUuD2CUMqEc8JEqsXEMDHzDPE8RCjZeUBitsnB1eNcAJWQPiciKsMXe3Yytj4Flw1XLl46Qcf9OxvZha7A==}
+    engines: {node: '>= 0.4'}
+
+  es-define-property@1.0.1:
+    resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==}
+    engines: {node: '>= 0.4'}
+
+  es-errors@1.3.0:
+    resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==}
+    engines: {node: '>= 0.4'}
+
+  es-object-atoms@1.1.1:
+    resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==}
+    engines: {node: '>= 0.4'}
+
+  es-set-tostringtag@2.1.0:
+    resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==}
+    engines: {node: '>= 0.4'}
+
+  es-to-primitive@1.3.0:
+    resolution: {integrity: sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==}
+    engines: {node: '>= 0.4'}
+
+  esast-util-from-estree@2.0.0:
+    resolution: {integrity: sha512-4CyanoAudUSBAn5K13H4JhsMH6L9ZP7XbLVe/dKybkxMO7eDyLsT8UHl9TRNrU2Gr9nz+FovfSIjuXWJ81uVwQ==}
+
+  esast-util-from-js@2.0.1:
+    resolution: {integrity: sha512-8Ja+rNJ0Lt56Pcf3TAmpBZjmx8ZcK5Ts4cAzIOjsjevg9oSXJnl6SUQ2EevU8tv3h6ZLWmoKL5H4fgWvdvfETw==}
+
+  esbuild@0.25.1:
+    resolution: {integrity: sha512-BGO5LtrGC7vxnqucAe/rmvKdJllfGaYWdyABvyMoXQlfYMb2bbRuReWR5tEGE//4LcNJj9XrkovTqNYRFZHAMQ==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  escalade@3.2.0:
+    resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
+    engines: {node: '>=6'}
+
+  escape-html@1.0.3:
+    resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==}
+
+  escape-string-regexp@5.0.0:
+    resolution: {integrity: sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==}
+    engines: {node: '>=12'}
+
+  escodegen@2.1.0:
+    resolution: {integrity: sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==}
+    engines: {node: '>=6.0'}
+    hasBin: true
+
+  esprima@4.0.1:
+    resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==}
+    engines: {node: '>=4'}
+    hasBin: true
+
+  estraverse@5.3.0:
+    resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==}
+    engines: {node: '>=4.0'}
+
+  estree-util-attach-comments@3.0.0:
+    resolution: {integrity: sha512-cKUwm/HUcTDsYh/9FgnuFqpfquUbwIqwKM26BVCGDPVgvaCl/nDCCjUfiLlx6lsEZ3Z4RFxNbOQ60pkaEwFxGw==}
+
+  estree-util-build-jsx@3.0.1:
+    resolution: {integrity: sha512-8U5eiL6BTrPxp/CHbs2yMgP8ftMhR5ww1eIKoWRMlqvltHF8fZn5LRDvTKuxD3DUn+shRbLGqXemcP51oFCsGQ==}
+
+  estree-util-is-identifier-name@3.0.0:
+    resolution: {integrity: sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg==}
+
+  estree-util-scope@1.0.0:
+    resolution: {integrity: sha512-2CAASclonf+JFWBNJPndcOpA8EMJwa0Q8LUFJEKqXLW6+qBvbFZuF5gItbQOs/umBUkjviCSDCbBwU2cXbmrhQ==}
+
+  estree-util-to-js@2.0.0:
+    resolution: {integrity: sha512-WDF+xj5rRWmD5tj6bIqRi6CkLIXbbNQUcxQHzGysQzvHmdYG2G7p/Tf0J0gpxGgkeMZNTIjT/AoSvC9Xehcgdg==}
+
+  estree-util-visit@2.0.0:
+    resolution: {integrity: sha512-m5KgiH85xAhhW8Wta0vShLcUvOsh3LLPI2YVwcbio1l7E09NTLL1EyMZFM1OyWowoH0skScNbhOPl4kcBgzTww==}
+
+  estree-walker@3.0.3:
+    resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
+
+  esutils@2.0.3:
+    resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
+    engines: {node: '>=0.10.0'}
+
+  etag@1.8.1:
+    resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==}
+    engines: {node: '>= 0.6'}
+
+  event-target-shim@5.0.1:
+    resolution: {integrity: sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==}
+    engines: {node: '>=6'}
+
+  express@4.21.2:
+    resolution: {integrity: sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==}
+    engines: {node: '>= 0.10.0'}
+
+  extend-shallow@2.0.1:
+    resolution: {integrity: sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==}
+    engines: {node: '>=0.10.0'}
+
+  extend@3.0.2:
+    resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==}
+
+  external-editor@3.1.0:
+    resolution: {integrity: sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==}
+    engines: {node: '>=4'}
+
+  extract-zip@2.0.1:
+    resolution: {integrity: sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==}
+    engines: {node: '>= 10.17.0'}
+    hasBin: true
+
+  fast-deep-equal@3.1.3:
+    resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
+
+  fast-fifo@1.3.2:
+    resolution: {integrity: sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==}
+
+  fast-memoize@2.5.2:
+    resolution: {integrity: sha512-Ue0LwpDYErFbmNnZSF0UH6eImUwDmogUO1jyE+JbN2gsQz/jICm1Ve7t9QT0rNSsfJt+Hs4/S3GnsDVjL4HVrw==}
+
+  fast-uri@3.0.6:
+    resolution: {integrity: sha512-Atfo14OibSv5wAp4VWNsFYE1AchQRTv9cBGWET4pZWHzYshFSS9NQI6I57rdKn9croWVMbYFbLhJ+yJvmZIIHw==}
+
+  fault@2.0.1:
+    resolution: {integrity: sha512-WtySTkS4OKev5JtpHXnib4Gxiurzh5NCGvWrFaZ34m6JehfTUhKZvn9njTfw48t6JumVQOmrKqpmGcdwxnhqBQ==}
+
+  favicons@7.2.0:
+    resolution: {integrity: sha512-k/2rVBRIRzOeom3wI9jBPaSEvoTSQEW4iM0EveBmBBKFxO8mSyyRWtDlfC3VnEfu0avmjrMzy8/ZFPSe6F71Hw==}
+    engines: {node: '>=14.0.0'}
+
+  fd-slicer@1.1.0:
+    resolution: {integrity: sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==}
+
+  fill-range@7.1.1:
+    resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
+    engines: {node: '>=8'}
+
+  finalhandler@1.3.1:
+    resolution: {integrity: sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==}
+    engines: {node: '>= 0.8'}
+
+  follow-redirects@1.15.9:
+    resolution: {integrity: sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==}
+    engines: {node: '>=4.0'}
+    peerDependencies:
+      debug: '*'
+    peerDependenciesMeta:
+      debug:
+        optional: true
+
+  for-each@0.3.5:
+    resolution: {integrity: sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==}
+    engines: {node: '>= 0.4'}
+
+  form-data-encoder@2.1.4:
+    resolution: {integrity: sha512-yDYSgNMraqvnxiEXO4hi88+YZxaHC6QKzb5N84iRCTDeRO7ZALpir/lVmf/uXUhnwUr2O4HU8s/n6x+yNjQkHw==}
+    engines: {node: '>= 14.17'}
+
+  form-data@4.0.2:
+    resolution: {integrity: sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w==}
+    engines: {node: '>= 6'}
+
+  format@0.2.2:
+    resolution: {integrity: sha512-wzsgA6WOq+09wrU1tsJ09udeR/YZRaeArL9e1wPbFg3GG2yDnC2ldKpxs4xunpFF9DgqCqOIra3bc1HWrJ37Ww==}
+    engines: {node: '>=0.4.x'}
+
+  forwarded@0.2.0:
+    resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==}
+    engines: {node: '>= 0.6'}
+
+  fresh@0.5.2:
+    resolution: {integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==}
+    engines: {node: '>= 0.6'}
+
+  fs-extra@11.3.0:
+    resolution: {integrity: sha512-Z4XaCL6dUDHfP/jT25jJKMmtxvuwbkrD1vNSMFlo9lNLY2c5FHYSQgHPRZUjAB26TpDEoW9HCOgplrdbaPV/ew==}
+    engines: {node: '>=14.14'}
+
+  fs-minipass@2.1.0:
+    resolution: {integrity: sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==}
+    engines: {node: '>= 8'}
+
+  fsevents@2.3.3:
+    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
+  function-bind@1.1.2:
+    resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==}
+
+  function.prototype.name@1.1.8:
+    resolution: {integrity: sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q==}
+    engines: {node: '>= 0.4'}
+
+  functions-have-names@1.2.3:
+    resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==}
+
+  gcd@0.0.1:
+    resolution: {integrity: sha512-VNx3UEGr+ILJTiMs1+xc5SX1cMgJCrXezKPa003APUWNqQqaF6n25W8VcR7nHN6yRWbvvUTwCpZCFJeWC2kXlw==}
+
+  get-caller-file@2.0.5:
+    resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==}
+    engines: {node: 6.* || 8.* || >= 10.*}
+
+  get-intrinsic@1.3.0:
+    resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==}
+    engines: {node: '>= 0.4'}
+
+  get-proto@1.0.1:
+    resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==}
+    engines: {node: '>= 0.4'}
+
+  get-stream@5.2.0:
+    resolution: {integrity: sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==}
+    engines: {node: '>=8'}
+
+  get-stream@6.0.1:
+    resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==}
+    engines: {node: '>=10'}
+
+  get-symbol-description@1.1.0:
+    resolution: {integrity: sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==}
+    engines: {node: '>= 0.4'}
+
+  get-tsconfig@4.10.0:
+    resolution: {integrity: sha512-kGzZ3LWWQcGIAmg6iWvXn0ei6WDtV26wzHRMwDSzmAbcXrTEXxHy6IehI6/4eT6VRKyMP1eF1VqwrVUmE/LR7A==}
+
+  get-uri@6.0.4:
+    resolution: {integrity: sha512-E1b1lFFLvLgak2whF2xDBcOy6NLVGZBqqjJjsIhvopKfWWEi64pLVTWWehV8KlLerZkfNTA95sTe2OdJKm1OzQ==}
+    engines: {node: '>= 14'}
+
+  glob-parent@5.1.2:
+    resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
+    engines: {node: '>= 6'}
+
+  globalthis@1.0.4:
+    resolution: {integrity: sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==}
+    engines: {node: '>= 0.4'}
+
+  gopd@1.2.0:
+    resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==}
+    engines: {node: '>= 0.4'}
+
+  got@12.6.1:
+    resolution: {integrity: sha512-mThBblvlAF1d4O5oqyvN+ZxLAYwIJK7bpMxgYqPD9okW0C3qm5FFn7k811QrcuEBwaogR3ngOFoCfs6mRv7teQ==}
+    engines: {node: '>=14.16'}
+
+  got@13.0.0:
+    resolution: {integrity: sha512-XfBk1CxOOScDcMr9O1yKkNaQyy865NbYs+F7dr4H0LZMVgCj2Le59k6PqbNHoL5ToeaEQUYh6c6yMfVcc6SJxA==}
+    engines: {node: '>=16'}
+
+  graceful-fs@4.2.11:
+    resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
+
+  gray-matter@4.0.3:
+    resolution: {integrity: sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q==}
+    engines: {node: '>=6.0'}
+
+  has-bigints@1.1.0:
+    resolution: {integrity: sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==}
+    engines: {node: '>= 0.4'}
+
+  has-property-descriptors@1.0.2:
+    resolution: {integrity: sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==}
+
+  has-proto@1.2.0:
+    resolution: {integrity: sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==}
+    engines: {node: '>= 0.4'}
+
+  has-symbols@1.1.0:
+    resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==}
+    engines: {node: '>= 0.4'}
+
+  has-tostringtag@1.0.2:
+    resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==}
+    engines: {node: '>= 0.4'}
+
+  hasown@2.0.2:
+    resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
+    engines: {node: '>= 0.4'}
+
+  hast-util-embedded@3.0.0:
+    resolution: {integrity: sha512-naH8sld4Pe2ep03qqULEtvYr7EjrLK2QHY8KJR6RJkTUjPGObe1vnx585uzem2hGra+s1q08DZZpfgDVYRbaXA==}
+
+  hast-util-from-dom@5.0.1:
+    resolution: {integrity: sha512-N+LqofjR2zuzTjCPzyDUdSshy4Ma6li7p/c3pA78uTwzFgENbgbUrm2ugwsOdcjI1muO+o6Dgzp9p8WHtn/39Q==}
+
+  hast-util-from-html-isomorphic@2.0.0:
+    resolution: {integrity: sha512-zJfpXq44yff2hmE0XmwEOzdWin5xwH+QIhMLOScpX91e/NSGPsAzNCvLQDIEPyO2TXi+lBmU6hjLIhV8MwP2kw==}
+
+  hast-util-from-html@2.0.3:
+    resolution: {integrity: sha512-CUSRHXyKjzHov8yKsQjGOElXy/3EKpyX56ELnkHH34vDVw1N1XSQ1ZcAvTyAPtGqLTuKP/uxM+aLkSPqF/EtMw==}
+
+  hast-util-from-parse5@8.0.3:
+    resolution: {integrity: sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg==}
+
+  hast-util-has-property@3.0.0:
+    resolution: {integrity: sha512-MNilsvEKLFpV604hwfhVStK0usFY/QmM5zX16bo7EjnAEGofr5YyI37kzopBlZJkHD4t887i+q/C8/tr5Q94cA==}
+
+  hast-util-is-body-ok-link@3.0.1:
+    resolution: {integrity: sha512-0qpnzOBLztXHbHQenVB8uNuxTnm/QBFUOmdOSsEn7GnBtyY07+ENTWVFBAnXd/zEgd9/SUG3lRY7hSIBWRgGpQ==}
+
+  hast-util-is-element@3.0.0:
+    resolution: {integrity: sha512-Val9mnv2IWpLbNPqc/pUem+a7Ipj2aHacCwgNfTiK0vJKl0LF+4Ba4+v1oPHFpf3bLYmreq0/l3Gud9S5OH42g==}
+
+  hast-util-minify-whitespace@1.0.1:
+    resolution: {integrity: sha512-L96fPOVpnclQE0xzdWb/D12VT5FabA7SnZOUMtL1DbXmYiHJMXZvFkIZfiMmTCNJHUeO2K9UYNXoVyfz+QHuOw==}
+
+  hast-util-parse-selector@3.1.1:
+    resolution: {integrity: sha512-jdlwBjEexy1oGz0aJ2f4GKMaVKkA9jwjr4MjAAI22E5fM/TXVZHuS5OpONtdeIkRKqAaryQ2E9xNQxijoThSZA==}
+
+  hast-util-parse-selector@4.0.0:
+    resolution: {integrity: sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==}
+
+  hast-util-phrasing@3.0.1:
+    resolution: {integrity: sha512-6h60VfI3uBQUxHqTyMymMZnEbNl1XmEGtOxxKYL7stY2o601COo62AWAYBQR9lZbYXYSBoxag8UpPRXK+9fqSQ==}
+
+  hast-util-to-estree@3.1.3:
+    resolution: {integrity: sha512-48+B/rJWAp0jamNbAAf9M7Uf//UVqAoMmgXhBdxTDJLGKY+LRnZ99qcG+Qjl5HfMpYNzS5v4EAwVEF34LeAj7w==}
+
+  hast-util-to-html@9.0.5:
+    resolution: {integrity: sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw==}
+
+  hast-util-to-jsx-runtime@2.3.6:
+    resolution: {integrity: sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==}
+
+  hast-util-to-mdast@10.1.2:
+    resolution: {integrity: sha512-FiCRI7NmOvM4y+f5w32jPRzcxDIz+PUqDwEqn1A+1q2cdp3B8Gx7aVrXORdOKjMNDQsD1ogOr896+0jJHW1EFQ==}
+
+  hast-util-to-string@3.0.1:
+    resolution: {integrity: sha512-XelQVTDWvqcl3axRfI0xSeoVKzyIFPwsAGSLIsKdJKQMXDYJS4WYrBNF/8J7RdhIcFI2BOHgAifggsvsxp/3+A==}
+
+  hast-util-to-text@4.0.2:
+    resolution: {integrity: sha512-KK6y/BN8lbaq654j7JgBydev7wuNMcID54lkRav1P0CaE1e47P72AWWPiGKXTJU271ooYzcvTAn/Zt0REnvc7A==}
+
+  hast-util-whitespace@3.0.0:
+    resolution: {integrity: sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==}
+
+  hastscript@7.2.0:
+    resolution: {integrity: sha512-TtYPq24IldU8iKoJQqvZOuhi5CyCQRAbvDOX0x1eW6rsHSxa/1i2CCiptNTotGHJ3VoHRGmqiv6/D3q113ikkw==}
+
+  hastscript@9.0.1:
+    resolution: {integrity: sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==}
+
+  html-void-elements@3.0.0:
+    resolution: {integrity: sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==}
+
+  http-cache-semantics@4.1.1:
+    resolution: {integrity: sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==}
+
+  http-errors@2.0.0:
+    resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==}
+    engines: {node: '>= 0.8'}
+
+  http-proxy-agent@7.0.2:
+    resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==}
+    engines: {node: '>= 14'}
+
+  http2-wrapper@2.2.1:
+    resolution: {integrity: sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ==}
+    engines: {node: '>=10.19.0'}
+
+  https-proxy-agent@7.0.6:
+    resolution: {integrity: sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==}
+    engines: {node: '>= 14'}
+
+  iconv-lite@0.4.24:
+    resolution: {integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==}
+    engines: {node: '>=0.10.0'}
+
+  ieee754@1.2.1:
+    resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==}
+
+  immer@9.0.21:
+    resolution: {integrity: sha512-bc4NBHqOqSfRW7POMkHd51LvClaeMXpm8dx0e8oE2GORbq5aRK7Bxl4FyzVLdGtLmvLKL7BTDBG5ACQm4HWjTA==}
+
+  import-fresh@3.3.1:
+    resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==}
+    engines: {node: '>=6'}
+
+  indent-string@5.0.0:
+    resolution: {integrity: sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg==}
+    engines: {node: '>=12'}
+
+  inherits@2.0.4:
+    resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
+
+  inline-style-parser@0.2.4:
+    resolution: {integrity: sha512-0aO8FkhNZlj/ZIbNi7Lxxr12obT7cL1moPfE4tg1LkX7LlLfC6DeX4l2ZEud1ukP9jNQyNnfzQVqwbwmAATY4Q==}
+
+  inquirer@12.5.0:
+    resolution: {integrity: sha512-aiBBq5aKF1k87MTxXDylLfwpRwToShiHrSv4EmB07EYyLgmnjEz5B3rn0aGw1X3JA/64Ngf2T54oGwc+BCsPIQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  internal-slot@1.1.0:
+    resolution: {integrity: sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==}
+    engines: {node: '>= 0.4'}
+
+  ip-address@9.0.5:
+    resolution: {integrity: sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==}
+    engines: {node: '>= 12'}
+
+  ip-regex@4.3.0:
+    resolution: {integrity: sha512-B9ZWJxHHOHUhUjCPrMpLD4xEq35bUTClHM1S6CBU5ixQnkZmwipwgc96vAd7AAGM9TGHvJR+Uss+/Ak6UphK+Q==}
+    engines: {node: '>=8'}
+
+  ipaddr.js@1.9.1:
+    resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==}
+    engines: {node: '>= 0.10'}
+
+  is-absolute-url@4.0.1:
+    resolution: {integrity: sha512-/51/TKE88Lmm7Gc4/8btclNXWS+g50wXhYJq8HWIBAGUBnoAdRu1aXeh364t/O7wXDAcTJDP8PNuNKWUDWie+A==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  is-alphabetical@2.0.1:
+    resolution: {integrity: sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ==}
+
+  is-alphanumerical@2.0.1:
+    resolution: {integrity: sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==}
+
+  is-array-buffer@3.0.5:
+    resolution: {integrity: sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==}
+    engines: {node: '>= 0.4'}
+
+  is-arrayish@0.2.1:
+    resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==}
+
+  is-arrayish@0.3.2:
+    resolution: {integrity: sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ==}
+
+  is-async-function@2.1.1:
+    resolution: {integrity: sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==}
+    engines: {node: '>= 0.4'}
+
+  is-bigint@1.1.0:
+    resolution: {integrity: sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==}
+    engines: {node: '>= 0.4'}
+
+  is-binary-path@2.1.0:
+    resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==}
+    engines: {node: '>=8'}
+
+  is-boolean-object@1.2.2:
+    resolution: {integrity: sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==}
+    engines: {node: '>= 0.4'}
+
+  is-callable@1.2.7:
+    resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==}
+    engines: {node: '>= 0.4'}
+
+  is-data-view@1.0.2:
+    resolution: {integrity: sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==}
+    engines: {node: '>= 0.4'}
+
+  is-date-object@1.1.0:
+    resolution: {integrity: sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==}
+    engines: {node: '>= 0.4'}
+
+  is-decimal@2.0.1:
+    resolution: {integrity: sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A==}
+
+  is-docker@2.2.1:
+    resolution: {integrity: sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==}
+    engines: {node: '>=8'}
+    hasBin: true
+
+  is-extendable@0.1.1:
+    resolution: {integrity: sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==}
+    engines: {node: '>=0.10.0'}
+
+  is-extglob@2.1.1:
+    resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
+    engines: {node: '>=0.10.0'}
+
+  is-finalizationregistry@1.1.1:
+    resolution: {integrity: sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==}
+    engines: {node: '>= 0.4'}
+
+  is-fullwidth-code-point@3.0.0:
+    resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==}
+    engines: {node: '>=8'}
+
+  is-generator-function@1.1.0:
+    resolution: {integrity: sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ==}
+    engines: {node: '>= 0.4'}
+
+  is-glob@4.0.3:
+    resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
+    engines: {node: '>=0.10.0'}
+
+  is-hexadecimal@2.0.1:
+    resolution: {integrity: sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg==}
+
+  is-interactive@2.0.0:
+    resolution: {integrity: sha512-qP1vozQRI+BMOPcjFzrjXuQvdak2pHNUMZoeG2eRbiSqyvbEf/wQtEOTOX1guk6E3t36RkaqiSt8A/6YElNxLQ==}
+    engines: {node: '>=12'}
+
+  is-ip@3.1.0:
+    resolution: {integrity: sha512-35vd5necO7IitFPjd/YBeqwWnyDWbuLH9ZXQdMfDA8TEo7pv5X8yfrvVO3xbJbLUlERCMvf6X0hTUamQxCYJ9Q==}
+    engines: {node: '>=8'}
+
+  is-map@2.0.3:
+    resolution: {integrity: sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==}
+    engines: {node: '>= 0.4'}
+
+  is-number-object@1.1.1:
+    resolution: {integrity: sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==}
+    engines: {node: '>= 0.4'}
+
+  is-number@7.0.0:
+    resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
+    engines: {node: '>=0.12.0'}
+
+  is-online@10.0.0:
+    resolution: {integrity: sha512-WCPdKwNDjXJJmUubf2VHLMDBkUZEtuOvpXUfUnUFbEnM6In9ByiScL4f4jKACz/fsb2qDkesFerW3snf/AYz3A==}
+    engines: {node: '>=14.16'}
+
+  is-plain-obj@4.1.0:
+    resolution: {integrity: sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==}
+    engines: {node: '>=12'}
+
+  is-regex@1.2.1:
+    resolution: {integrity: sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==}
+    engines: {node: '>= 0.4'}
+
+  is-set@2.0.3:
+    resolution: {integrity: sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==}
+    engines: {node: '>= 0.4'}
+
+  is-shared-array-buffer@1.0.4:
+    resolution: {integrity: sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==}
+    engines: {node: '>= 0.4'}
+
+  is-string@1.1.1:
+    resolution: {integrity: sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==}
+    engines: {node: '>= 0.4'}
+
+  is-symbol@1.1.1:
+    resolution: {integrity: sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==}
+    engines: {node: '>= 0.4'}
+
+  is-typed-array@1.1.15:
+    resolution: {integrity: sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==}
+    engines: {node: '>= 0.4'}
+
+  is-unicode-supported@1.3.0:
+    resolution: {integrity: sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ==}
+    engines: {node: '>=12'}
+
+  is-weakmap@2.0.2:
+    resolution: {integrity: sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==}
+    engines: {node: '>= 0.4'}
+
+  is-weakref@1.1.1:
+    resolution: {integrity: sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==}
+    engines: {node: '>= 0.4'}
+
+  is-weakset@2.0.4:
+    resolution: {integrity: sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==}
+    engines: {node: '>= 0.4'}
+
+  is-wsl@2.2.0:
+    resolution: {integrity: sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==}
+    engines: {node: '>=8'}
+
+  isarray@2.0.5:
+    resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==}
+
+  js-tokens@4.0.0:
+    resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
+
+  js-yaml@3.14.1:
+    resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==}
+    hasBin: true
+
+  js-yaml@4.1.0:
+    resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==}
+    hasBin: true
+
+  jsbn@1.1.0:
+    resolution: {integrity: sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==}
+
+  jsep@1.4.0:
+    resolution: {integrity: sha512-B7qPcEVE3NVkmSJbaYxvv4cHkVW7DQsZz13pUMrfS8z8Q/BuShN+gcTXrUlPiGqM2/t/EEaI030bpxMqY8gMlw==}
+    engines: {node: '>= 10.16.0'}
+
+  json-buffer@3.0.1:
+    resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==}
+
+  json-parse-even-better-errors@2.3.1:
+    resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==}
+
+  json-schema-traverse@1.0.0:
+    resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==}
+
+  jsonc-parser@2.2.1:
+    resolution: {integrity: sha512-o6/yDBYccGvTz1+QFevz6l6OBZ2+fMVu2JZ9CIhzsYRX4mjaK5IyX9eldUdCmga16zlgQxyrj5pt9kzuj2C02w==}
+
+  jsonfile@6.1.0:
+    resolution: {integrity: sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==}
+
+  jsonpath-plus@10.3.0:
+    resolution: {integrity: sha512-8TNmfeTCk2Le33A3vRRwtuworG/L5RrgMvdjhKZxvyShO+mBu2fP50OWUjRLNtvw344DdDarFh9buFAZs5ujeA==}
+    engines: {node: '>=18.0.0'}
+    hasBin: true
+
+  jsonpointer@5.0.1:
+    resolution: {integrity: sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==}
+    engines: {node: '>=0.10.0'}
+
+  katex@0.16.21:
+    resolution: {integrity: sha512-XvqR7FgOHtWupfMiigNzmh+MgUVmDGU2kXZm899ZkPfcuoPuFxyHmXsgATDpFZDAXCI8tvinaVcDo8PIIJSo4A==}
+    hasBin: true
+
+  keyv@4.5.4:
+    resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
+
+  kind-of@6.0.3:
+    resolution: {integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==}
+    engines: {node: '>=0.10.0'}
+
+  lcm@0.0.3:
+    resolution: {integrity: sha512-TB+ZjoillV6B26Vspf9l2L/vKaRY/4ep3hahcyVkCGFgsTNRUQdc24bQeNFiZeoxH0vr5+7SfNRMQuPHv/1IrQ==}
+
+  leven@3.1.0:
+    resolution: {integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==}
+    engines: {node: '>=6'}
+
+  leven@4.0.0:
+    resolution: {integrity: sha512-puehA3YKku3osqPlNuzGDUHq8WpwXupUg1V6NXdV38G+gr+gkBwFC8g1b/+YcIvp8gnqVIus+eJCH/eGsRmJNw==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  lines-and-columns@1.2.4:
+    resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
+
+  lodash.topath@4.5.2:
+    resolution: {integrity: sha512-1/W4dM+35DwvE/iEd1M9ekewOSTlpFekhw9mhAtrwjVqUr83/ilQiyAvmg4tVX7Unkcfl1KC+i9WdaT4B6aQcg==}
+
+  lodash@4.17.21:
+    resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==}
+
+  log-symbols@5.1.0:
+    resolution: {integrity: sha512-l0x2DvrW294C9uDCoQe1VSU4gf529FkSZ6leBl4TiqZH/e+0R7hSfHQBNut2mNygDgHwvYHfFLn6Oxb3VWj2rA==}
+    engines: {node: '>=12'}
+
+  longest-streak@3.1.0:
+    resolution: {integrity: sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==}
+
+  loose-envify@1.4.0:
+    resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==}
+    hasBin: true
+
+  lowercase-keys@3.0.0:
+    resolution: {integrity: sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  lru-cache@7.18.3:
+    resolution: {integrity: sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==}
+    engines: {node: '>=12'}
+
+  markdown-extensions@2.0.0:
+    resolution: {integrity: sha512-o5vL7aDWatOTX8LzaS1WMoaoxIiLRQJuIKKe2wAw6IeULDHaqbiqiggmx+pKvZDb1Sj+pE46Sn1T7lCqfFtg1Q==}
+    engines: {node: '>=16'}
+
+  markdown-table@3.0.4:
+    resolution: {integrity: sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw==}
+
+  math-intrinsics@1.1.0:
+    resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}
+    engines: {node: '>= 0.4'}
+
+  mdast-util-find-and-replace@3.0.2:
+    resolution: {integrity: sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg==}
+
+  mdast-util-from-markdown@2.0.2:
+    resolution: {integrity: sha512-uZhTV/8NBuw0WHkPTrCqDOl0zVe1BIng5ZtHoDk49ME1qqcjYmmLmOf0gELgcRMxN4w2iuIeVso5/6QymSrgmA==}
+
+  mdast-util-frontmatter@2.0.1:
+    resolution: {integrity: sha512-LRqI9+wdgC25P0URIJY9vwocIzCcksduHQ9OF2joxQoyTNVduwLAFUzjoopuRJbJAReaKrNQKAZKL3uCMugWJA==}
+
+  mdast-util-gfm-autolink-literal@2.0.1:
+    resolution: {integrity: sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ==}
+
+  mdast-util-gfm-footnote@2.1.0:
+    resolution: {integrity: sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ==}
+
+  mdast-util-gfm-strikethrough@2.0.0:
+    resolution: {integrity: sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg==}
+
+  mdast-util-gfm-table@2.0.0:
+    resolution: {integrity: sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg==}
+
+  mdast-util-gfm-task-list-item@2.0.0:
+    resolution: {integrity: sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ==}
+
+  mdast-util-gfm@3.1.0:
+    resolution: {integrity: sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==}
+
+  mdast-util-math@3.0.0:
+    resolution: {integrity: sha512-Tl9GBNeG/AhJnQM221bJR2HPvLOSnLE/T9cJI9tlc6zwQk2nPk/4f0cHkOdEixQPC/j8UtKDdITswvLAy1OZ1w==}
+
+  mdast-util-mdx-expression@2.0.1:
+    resolution: {integrity: sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==}
+
+  mdast-util-mdx-jsx@3.2.0:
+    resolution: {integrity: sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==}
+
+  mdast-util-mdx@3.0.0:
+    resolution: {integrity: sha512-JfbYLAW7XnYTTbUsmpu0kdBUVe+yKVJZBItEjwyYJiDJuZ9w4eeaqks4HQO+R7objWgS2ymV60GYpI14Ug554w==}
+
+  mdast-util-mdxjs-esm@2.0.1:
+    resolution: {integrity: sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg==}
+
+  mdast-util-phrasing@4.1.0:
+    resolution: {integrity: sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==}
+
+  mdast-util-to-hast@13.2.0:
+    resolution: {integrity: sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA==}
+
+  mdast-util-to-markdown@2.1.2:
+    resolution: {integrity: sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==}
+
+  mdast-util-to-string@4.0.0:
+    resolution: {integrity: sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==}
+
+  media-typer@0.3.0:
+    resolution: {integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==}
+    engines: {node: '>= 0.6'}
+
+  merge-descriptors@1.0.3:
+    resolution: {integrity: sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==}
+
+  methods@1.1.2:
+    resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==}
+    engines: {node: '>= 0.6'}
+
+  micromark-core-commonmark@2.0.3:
+    resolution: {integrity: sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==}
+
+  micromark-extension-frontmatter@2.0.0:
+    resolution: {integrity: sha512-C4AkuM3dA58cgZha7zVnuVxBhDsbttIMiytjgsM2XbHAB2faRVaHRle40558FBN+DJcrLNCoqG5mlrpdU4cRtg==}
+
+  micromark-extension-gfm-autolink-literal@2.1.0:
+    resolution: {integrity: sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw==}
+
+  micromark-extension-gfm-footnote@2.1.0:
+    resolution: {integrity: sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw==}
+
+  micromark-extension-gfm-strikethrough@2.1.0:
+    resolution: {integrity: sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw==}
+
+  micromark-extension-gfm-table@2.1.1:
+    resolution: {integrity: sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg==}
+
+  micromark-extension-gfm-tagfilter@2.0.0:
+    resolution: {integrity: sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg==}
+
+  micromark-extension-gfm-task-list-item@2.1.0:
+    resolution: {integrity: sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw==}
+
+  micromark-extension-gfm@3.0.0:
+    resolution: {integrity: sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w==}
+
+  micromark-extension-math@3.1.0:
+    resolution: {integrity: sha512-lvEqd+fHjATVs+2v/8kg9i5Q0AP2k85H0WUOwpIVvUML8BapsMvh1XAogmQjOCsLpoKRCVQqEkQBB3NhVBcsOg==}
+
+  micromark-extension-mdx-expression@3.0.1:
+    resolution: {integrity: sha512-dD/ADLJ1AeMvSAKBwO22zG22N4ybhe7kFIZ3LsDI0GlsNr2A3KYxb0LdC1u5rj4Nw+CHKY0RVdnHX8vj8ejm4Q==}
+
+  micromark-extension-mdx-jsx@3.0.2:
+    resolution: {integrity: sha512-e5+q1DjMh62LZAJOnDraSSbDMvGJ8x3cbjygy2qFEi7HCeUT4BDKCvMozPozcD6WmOt6sVvYDNBKhFSz3kjOVQ==}
+
+  micromark-extension-mdx-md@2.0.0:
+    resolution: {integrity: sha512-EpAiszsB3blw4Rpba7xTOUptcFeBFi+6PY8VnJ2hhimH+vCQDirWgsMpz7w1XcZE7LVrSAUGb9VJpG9ghlYvYQ==}
+
+  micromark-extension-mdxjs-esm@3.0.0:
+    resolution: {integrity: sha512-DJFl4ZqkErRpq/dAPyeWp15tGrcrrJho1hKK5uBS70BCtfrIFg81sqcTVu3Ta+KD1Tk5vAtBNElWxtAa+m8K9A==}
+
+  micromark-extension-mdxjs@3.0.0:
+    resolution: {integrity: sha512-A873fJfhnJ2siZyUrJ31l34Uqwy4xIFmvPY1oj+Ean5PHcPBYzEsvqvWGaWcfEIr11O5Dlw3p2y0tZWpKHDejQ==}
+
+  micromark-factory-destination@2.0.1:
+    resolution: {integrity: sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==}
+
+  micromark-factory-label@2.0.1:
+    resolution: {integrity: sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==}
+
+  micromark-factory-mdx-expression@2.0.3:
+    resolution: {integrity: sha512-kQnEtA3vzucU2BkrIa8/VaSAsP+EJ3CKOvhMuJgOEGg9KDC6OAY6nSnNDVRiVNRqj7Y4SlSzcStaH/5jge8JdQ==}
+
+  micromark-factory-space@2.0.1:
+    resolution: {integrity: sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==}
+
+  micromark-factory-title@2.0.1:
+    resolution: {integrity: sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==}
+
+  micromark-factory-whitespace@2.0.1:
+    resolution: {integrity: sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==}
+
+  micromark-util-character@2.1.1:
+    resolution: {integrity: sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==}
+
+  micromark-util-chunked@2.0.1:
+    resolution: {integrity: sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==}
+
+  micromark-util-classify-character@2.0.1:
+    resolution: {integrity: sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==}
+
+  micromark-util-combine-extensions@2.0.1:
+    resolution: {integrity: sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==}
+
+  micromark-util-decode-numeric-character-reference@2.0.2:
+    resolution: {integrity: sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==}
+
+  micromark-util-decode-string@2.0.1:
+    resolution: {integrity: sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==}
+
+  micromark-util-encode@2.0.1:
+    resolution: {integrity: sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==}
+
+  micromark-util-events-to-acorn@2.0.3:
+    resolution: {integrity: sha512-jmsiEIiZ1n7X1Rr5k8wVExBQCg5jy4UXVADItHmNk1zkwEVhBuIUKRu3fqv+hs4nxLISi2DQGlqIOGiFxgbfHg==}
+
+  micromark-util-html-tag-name@2.0.1:
+    resolution: {integrity: sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA==}
+
+  micromark-util-normalize-identifier@2.0.1:
+    resolution: {integrity: sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==}
+
+  micromark-util-resolve-all@2.0.1:
+    resolution: {integrity: sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==}
+
+  micromark-util-sanitize-uri@2.0.1:
+    resolution: {integrity: sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==}
+
+  micromark-util-subtokenize@2.1.0:
+    resolution: {integrity: sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA==}
+
+  micromark-util-symbol@2.0.1:
+    resolution: {integrity: sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==}
+
+  micromark-util-types@2.0.2:
+    resolution: {integrity: sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==}
+
+  micromark@4.0.2:
+    resolution: {integrity: sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA==}
+
+  mime-db@1.52.0:
+    resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==}
+    engines: {node: '>= 0.6'}
+
+  mime-types@2.1.35:
+    resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==}
+    engines: {node: '>= 0.6'}
+
+  mime@1.6.0:
+    resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==}
+    engines: {node: '>=4'}
+    hasBin: true
+
+  mimic-fn@2.1.0:
+    resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==}
+    engines: {node: '>=6'}
+
+  mimic-response@3.1.0:
+    resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==}
+    engines: {node: '>=10'}
+
+  mimic-response@4.0.0:
+    resolution: {integrity: sha512-e5ISH9xMYU0DzrT+jl8q2ze9D6eWBto+I8CNpe+VI+K2J/F/k3PdkdTdz4wvGVH4NTpo+NRYTVIuMQEMMcsLqg==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  minimatch@3.1.2:
+    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
+
+  minipass@3.3.6:
+    resolution: {integrity: sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==}
+    engines: {node: '>=8'}
+
+  minipass@5.0.0:
+    resolution: {integrity: sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==}
+    engines: {node: '>=8'}
+
+  minizlib@2.1.2:
+    resolution: {integrity: sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==}
+    engines: {node: '>= 8'}
+
+  mintlify@4.0.453:
+    resolution: {integrity: sha512-jAnEcn/dmjcYyoDzYzmKyJN+VkqMcA5T27DkoZ+e4JGG0ynOZ3XuUyyv7MTJXjZXP6d7Ssa/11+x5kQ9sivWlQ==}
+    engines: {node: '>=18.0.0'}
+    hasBin: true
+
+  mitt@3.0.1:
+    resolution: {integrity: sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==}
+
+  mkdirp@1.0.4:
+    resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  ms@2.0.0:
+    resolution: {integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==}
+
+  ms@2.1.3:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+
+  mute-stream@2.0.0:
+    resolution: {integrity: sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA==}
+    engines: {node: ^18.17.0 || >=20.5.0}
+
+  negotiator@0.6.3:
+    resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==}
+    engines: {node: '>= 0.6'}
+
+  netmask@2.0.2:
+    resolution: {integrity: sha512-dBpDMdxv9Irdq66304OLfEmQ9tbNRFnFTuZiLo+bD+r332bBmMJ8GBLXklIXXgxd3+v9+KUnZaUR5PJMa75Gsg==}
+    engines: {node: '>= 0.4.0'}
+
+  next-mdx-remote-client@1.1.0:
+    resolution: {integrity: sha512-RuKP5Xe/cdgpeQOw1OqY6/t29DgjPQxvSUXpjr5OXB6gZpCnXrrruT6c+OwF2sskOA2jGjUbxVoavrB8CbGmQQ==}
+    engines: {node: '>=18.18.0'}
+    peerDependencies:
+      react: '>= 18.3.0 < 19.0.0'
+      react-dom: '>= 18.3.0 < 19.0.0'
+
+  nimma@0.2.3:
+    resolution: {integrity: sha512-1ZOI8J+1PKKGceo/5CT5GfQOG6H8I2BencSK06YarZ2wXwH37BSSUWldqJmMJYA5JfqDqffxDXynt6f11AyKcA==}
+    engines: {node: ^12.20 || >=14.13}
+
+  nlcst-to-string@4.0.0:
+    resolution: {integrity: sha512-YKLBCcUYKAg0FNlOBT6aI91qFmSiFKiluk655WzPF+DDMA02qIyy8uiRqI8QXtcFpEvll12LpL5MXqEmAZ+dcA==}
+
+  node-fetch@2.6.7:
+    resolution: {integrity: sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==}
+    engines: {node: 4.x || >=6.0.0}
+    peerDependencies:
+      encoding: ^0.1.0
+    peerDependenciesMeta:
+      encoding:
+        optional: true
+
+  node-fetch@2.7.0:
+    resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==}
+    engines: {node: 4.x || >=6.0.0}
+    peerDependencies:
+      encoding: ^0.1.0
+    peerDependenciesMeta:
+      encoding:
+        optional: true
+
+  normalize-path@3.0.0:
+    resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
+    engines: {node: '>=0.10.0'}
+
+  normalize-url@8.0.1:
+    resolution: {integrity: sha512-IO9QvjUMWxPQQhs60oOu10CRkWCiZzSUkzbXGGV9pviYl1fXYcvkzQ5jV9z8Y6un8ARoVRl4EtC6v6jNqbaJ/w==}
+    engines: {node: '>=14.16'}
+
+  object-assign@4.1.1:
+    resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==}
+    engines: {node: '>=0.10.0'}
+
+  object-inspect@1.13.4:
+    resolution: {integrity: sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==}
+    engines: {node: '>= 0.4'}
+
+  object-keys@1.1.1:
+    resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==}
+    engines: {node: '>= 0.4'}
+
+  object.assign@4.1.7:
+    resolution: {integrity: sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==}
+    engines: {node: '>= 0.4'}
+
+  on-finished@2.4.1:
+    resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==}
+    engines: {node: '>= 0.8'}
+
+  once@1.4.0:
+    resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
+
+  onetime@5.1.2:
+    resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==}
+    engines: {node: '>=6'}
+
+  open@8.4.2:
+    resolution: {integrity: sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==}
+    engines: {node: '>=12'}
+
+  openapi-types@12.1.3:
+    resolution: {integrity: sha512-N4YtSYJqghVu4iek2ZUvcN/0aqH1kRDuNqzcycDxhOUpg7GdvLa2F3DgS6yBNhInhv2r/6I0Flkn7CqL8+nIcw==}
+
+  ora@6.3.1:
+    resolution: {integrity: sha512-ERAyNnZOfqM+Ao3RAvIXkYh5joP220yf59gVe2X/cI6SiCxIdi4c9HZKZD8R6q/RDXEje1THBju6iExiSsgJaQ==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  os-tmpdir@1.0.2:
+    resolution: {integrity: sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==}
+    engines: {node: '>=0.10.0'}
+
+  own-keys@1.0.1:
+    resolution: {integrity: sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==}
+    engines: {node: '>= 0.4'}
+
+  p-any@4.0.0:
+    resolution: {integrity: sha512-S/B50s+pAVe0wmEZHmBs/9yJXeZ5KhHzOsgKzt0hRdgkoR3DxW9ts46fcsWi/r3VnzsnkKS7q4uimze+zjdryw==}
+    engines: {node: '>=12.20'}
+
+  p-cancelable@3.0.0:
+    resolution: {integrity: sha512-mlVgR3PGuzlo0MmTdk4cXqXWlwQDLnONTAg6sm62XkMJEiRxN3GL3SffkYvqwonbkJBcrI7Uvv5Zh9yjvn2iUw==}
+    engines: {node: '>=12.20'}
+
+  p-some@6.0.0:
+    resolution: {integrity: sha512-CJbQCKdfSX3fIh8/QKgS+9rjm7OBNUTmwWswAFQAhc8j1NR1dsEDETUEuVUtQHZpV+J03LqWBEwvu0g1Yn+TYg==}
+    engines: {node: '>=12.20'}
+
+  p-timeout@5.1.0:
+    resolution: {integrity: sha512-auFDyzzzGZZZdHz3BtET9VEz0SE/uMEAx7uWfGPucfzEwwe/xH0iVeZibQmANYE/hp9T2+UUZT5m+BKyrDp3Ew==}
+    engines: {node: '>=12'}
+
+  pac-proxy-agent@7.2.0:
+    resolution: {integrity: sha512-TEB8ESquiLMc0lV8vcd5Ql/JAKAoyzHFXaStwjkzpOpC5Yv+pIzLfHvjTSdf3vpa2bMiUQrg9i6276yn8666aA==}
+    engines: {node: '>= 14'}
+
+  pac-resolver@7.0.1:
+    resolution: {integrity: sha512-5NPgf87AT2STgwa2ntRMr45jTKrYBGkVU36yT0ig/n/GMAa3oPqhZfIQ2kMEimReg0+t9kZViDVZ83qfVUlckg==}
+    engines: {node: '>= 14'}
+
+  parent-module@1.0.1:
+    resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
+    engines: {node: '>=6'}
+
+  parse-entities@4.0.2:
+    resolution: {integrity: sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw==}
+
+  parse-json@5.2.0:
+    resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==}
+    engines: {node: '>=8'}
+
+  parse-latin@7.0.0:
+    resolution: {integrity: sha512-mhHgobPPua5kZ98EF4HWiH167JWBfl4pvAIXXdbaVohtK7a6YBOy56kvhCqduqyo/f3yrHFWmqmiMg/BkBkYYQ==}
+
+  parse5@7.2.1:
+    resolution: {integrity: sha512-BuBYQYlv1ckiPdQi/ohiivi9Sagc9JG+Ozs0r7b/0iK3sKmrb0b9FdWdBbOdx6hBCM/F9Ir82ofnBhtZOjCRPQ==}
+
+  parseurl@1.3.3:
+    resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==}
+    engines: {node: '>= 0.8'}
+
+  path-to-regexp@0.1.12:
+    resolution: {integrity: sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==}
+
+  pend@1.2.0:
+    resolution: {integrity: sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==}
+
+  picocolors@1.1.1:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+  picomatch@2.3.1:
+    resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
+    engines: {node: '>=8.6'}
+
+  pony-cause@1.1.1:
+    resolution: {integrity: sha512-PxkIc/2ZpLiEzQXu5YRDOUgBlfGYBY8156HY5ZcRAwwonMk5W/MrJP2LLkG/hF7GEQzaHo2aS7ho6ZLCOvf+6g==}
+    engines: {node: '>=12.0.0'}
+
+  possible-typed-array-names@1.1.0:
+    resolution: {integrity: sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==}
+    engines: {node: '>= 0.4'}
+
+  progress@2.0.3:
+    resolution: {integrity: sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==}
+    engines: {node: '>=0.4.0'}
+
+  property-information@6.5.0:
+    resolution: {integrity: sha512-PgTgs/BlvHxOu8QuEN7wi5A0OmXaBcHpmCSTehcs6Uuu9IkDIEo13Hy7n898RHfrQ49vKCoGeWZSaAK01nwVig==}
+
+  property-information@7.0.0:
+    resolution: {integrity: sha512-7D/qOz/+Y4X/rzSB6jKxKUsQnphO046ei8qxG59mtM3RG3DHgTK81HrxrmoDVINJb8NKT5ZsRbwHvQ6B68Iyhg==}
+
+  proxy-addr@2.0.7:
+    resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==}
+    engines: {node: '>= 0.10'}
+
+  proxy-agent@6.5.0:
+    resolution: {integrity: sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A==}
+    engines: {node: '>= 14'}
+
+  proxy-from-env@1.1.0:
+    resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==}
+
+  public-ip@5.0.0:
+    resolution: {integrity: sha512-xaH3pZMni/R2BG7ZXXaWS9Wc9wFlhyDVJF47IJ+3ali0TGv+2PsckKxbmo+rnx3ZxiV2wblVhtdS3bohAP6GGw==}
+    engines: {node: ^14.13.1 || >=16.0.0}
+
+  pump@3.0.2:
+    resolution: {integrity: sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw==}
+
+  puppeteer-core@22.15.0:
+    resolution: {integrity: sha512-cHArnywCiAAVXa3t4GGL2vttNxh7GqXtIYGym99egkNJ3oG//wL9LkvO4WE8W1TJe95t1F1ocu9X4xWaGsOKOA==}
+    engines: {node: '>=18'}
+
+  puppeteer@22.15.0:
+    resolution: {integrity: sha512-XjCY1SiSEi1T7iSYuxS82ft85kwDJUS7wj1Z0eGVXKdtr5g4xnVcbjwxhq5xBnpK/E7x1VZZoJDxpjAOasHT4Q==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  qs@6.13.0:
+    resolution: {integrity: sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==}
+    engines: {node: '>=0.6'}
+
+  quick-lru@5.1.1:
+    resolution: {integrity: sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==}
+    engines: {node: '>=10'}
+
+  range-parser@1.2.1:
+    resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==}
+    engines: {node: '>= 0.6'}
+
+  raw-body@2.5.2:
+    resolution: {integrity: sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==}
+    engines: {node: '>= 0.8'}
+
+  react-dom@18.3.1:
+    resolution: {integrity: sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==}
+    peerDependencies:
+      react: ^18.3.1
+
+  react@18.3.1:
+    resolution: {integrity: sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==}
+    engines: {node: '>=0.10.0'}
+
+  readable-stream@3.6.2:
+    resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==}
+    engines: {node: '>= 6'}
+
+  readdirp@3.6.0:
+    resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==}
+    engines: {node: '>=8.10.0'}
+
+  recma-build-jsx@1.0.0:
+    resolution: {integrity: sha512-8GtdyqaBcDfva+GUKDr3nev3VpKAhup1+RvkMvUxURHpW7QyIvk9F5wz7Vzo06CEMSilw6uArgRqhpiUcWp8ew==}
+
+  recma-jsx@1.0.0:
+    resolution: {integrity: sha512-5vwkv65qWwYxg+Atz95acp8DMu1JDSqdGkA2Of1j6rCreyFUE/gp15fC8MnGEuG1W68UKjM6x6+YTWIh7hZM/Q==}
+
+  recma-parse@1.0.0:
+    resolution: {integrity: sha512-OYLsIGBB5Y5wjnSnQW6t3Xg7q3fQ7FWbw/vcXtORTnyaSFscOtABg+7Pnz6YZ6c27fG1/aN8CjfwoUEUIdwqWQ==}
+
+  recma-stringify@1.0.0:
+    resolution: {integrity: sha512-cjwII1MdIIVloKvC9ErQ+OgAtwHBmcZ0Bg4ciz78FtbT8In39aAYbaA7zvxQ61xVMSPE8WxhLwLbhif4Js2C+g==}
+
+  reflect.getprototypeof@1.0.10:
+    resolution: {integrity: sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==}
+    engines: {node: '>= 0.4'}
+
+  refractor@4.9.0:
+    resolution: {integrity: sha512-nEG1SPXFoGGx+dcjftjv8cAjEusIh6ED1xhf5DG3C0x/k+rmZ2duKnc3QLpt6qeHv5fPb8uwN3VWN2BT7fr3Og==}
+
+  regexp.prototype.flags@1.5.4:
+    resolution: {integrity: sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==}
+    engines: {node: '>= 0.4'}
+
+  rehype-katex@7.0.1:
+    resolution: {integrity: sha512-OiM2wrZ/wuhKkigASodFoo8wimG3H12LWQaH8qSPVJn9apWKFSH3YOCtbKpBorTVw/eI7cuT21XBbvwEswbIOA==}
+
+  rehype-minify-whitespace@6.0.2:
+    resolution: {integrity: sha512-Zk0pyQ06A3Lyxhe9vGtOtzz3Z0+qZ5+7icZ/PL/2x1SHPbKao5oB/g/rlc6BCTajqBb33JcOe71Ye1oFsuYbnw==}
+
+  rehype-parse@9.0.1:
+    resolution: {integrity: sha512-ksCzCD0Fgfh7trPDxr2rSylbwq9iYDkSn8TCDmEJ49ljEUBxDVCzCHv7QNzZOfODanX4+bWQ4WZqLCRWYLfhag==}
+
+  rehype-recma@1.0.0:
+    resolution: {integrity: sha512-lqA4rGUf1JmacCNWWZx0Wv1dHqMwxzsDWYMTowuplHF3xH0N/MmrZ/G3BDZnzAkRmxDadujCjaKM2hqYdCBOGw==}
+
+  remark-frontmatter@5.0.0:
+    resolution: {integrity: sha512-XTFYvNASMe5iPN0719nPrdItC9aU0ssC4v14mH1BCi1u0n1gAocqcujWUrByftZTbLhRtiKRyjYTSIOcr69UVQ==}
+
+  remark-gfm@4.0.1:
+    resolution: {integrity: sha512-1quofZ2RQ9EWdeN34S79+KExV1764+wCUGop5CPL1WGdD0ocPpu91lzPGbwWMECpEpd42kJGQwzRfyov9j4yNg==}
+
+  remark-math@6.0.0:
+    resolution: {integrity: sha512-MMqgnP74Igy+S3WwnhQ7kqGlEerTETXMvJhrUzDikVZ2/uogJCb+WHUg97hK9/jcfc0dkD73s3LN8zU49cTEtA==}
+
+  remark-mdx-remove-esm@1.1.0:
+    resolution: {integrity: sha512-oN3F9QRuPKSdzZi+wvEodBVjKwya63sl403pWzJvm0+c503iUjCDR+JAnP3Ho/4205IWbQ2NujPQi/B9kU6ZrA==}
+
+  remark-mdx@3.1.0:
+    resolution: {integrity: sha512-Ngl/H3YXyBV9RcRNdlYsZujAmhsxwzxpDzpDEhFBVAGthS4GDgnctpDjgFl/ULx5UEDzqtW1cyBSNKqYYrqLBA==}
+
+  remark-parse@11.0.0:
+    resolution: {integrity: sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==}
+
+  remark-rehype@11.1.1:
+    resolution: {integrity: sha512-g/osARvjkBXb6Wo0XvAeXQohVta8i84ACbenPpoSsxTOQH/Ae0/RGP4WZgnMH5pMLpsj4FG7OHmcIcXxpza8eQ==}
+
+  remark-smartypants@3.0.2:
+    resolution: {integrity: sha512-ILTWeOriIluwEvPjv67v7Blgrcx+LZOkAUVtKI3putuhlZm84FnqDORNXPPm+HY3NdZOMhyDwZ1E+eZB/Df5dA==}
+    engines: {node: '>=16.0.0'}
+
+  remark-stringify@11.0.0:
+    resolution: {integrity: sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw==}
+
+  remark@15.0.1:
+    resolution: {integrity: sha512-Eht5w30ruCXgFmxVUSlNWQ9iiimq07URKeFS3hNc8cUWy1llX4KDWfyEDZRycMc+znsN9Ux5/tJ/BFdgdOwA3A==}
+
+  require-directory@2.1.1:
+    resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==}
+    engines: {node: '>=0.10.0'}
+
+  require-from-string@2.0.2:
+    resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==}
+    engines: {node: '>=0.10.0'}
+
+  resolve-alpn@1.2.1:
+    resolution: {integrity: sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==}
+
+  resolve-from@4.0.0:
+    resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
+    engines: {node: '>=4'}
+
+  resolve-pkg-maps@1.0.0:
+    resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
+
+  responselike@3.0.0:
+    resolution: {integrity: sha512-40yHxbNcl2+rzXvZuVkrYohathsSJlMTXKryG5y8uciHv1+xDLHQpgjG64JUO9nrEq2jGLH6IZ8BcZyw3wrweg==}
+    engines: {node: '>=14.16'}
+
+  restore-cursor@4.0.0:
+    resolution: {integrity: sha512-I9fPXU9geO9bHOt9pHHOhOkYerIMsmVaWB0rA2AI9ERh/+x/i7MV5HKBNrg+ljO5eoPVgCcnFuRjJ9uH6I/3eg==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  retext-latin@4.0.0:
+    resolution: {integrity: sha512-hv9woG7Fy0M9IlRQloq/N6atV82NxLGveq+3H2WOi79dtIYWN8OaxogDm77f8YnVXJL2VD3bbqowu5E3EMhBYA==}
+
+  retext-smartypants@6.2.0:
+    resolution: {integrity: sha512-kk0jOU7+zGv//kfjXEBjdIryL1Acl4i9XNkHxtM7Tm5lFiCog576fjNC9hjoR7LTKQ0DsPWy09JummSsH1uqfQ==}
+
+  retext-stringify@4.0.0:
+    resolution: {integrity: sha512-rtfN/0o8kL1e+78+uxPTqu1Klt0yPzKuQ2BfWwwfgIUSayyzxpM1PJzkKt4V8803uB9qSy32MvI7Xep9khTpiA==}
+
+  retext@9.0.0:
+    resolution: {integrity: sha512-sbMDcpHCNjvlheSgMfEcVrZko3cDzdbe1x/e7G66dFp0Ff7Mldvi2uv6JkJQzdRcvLYE8CA8Oe8siQx8ZOgTcA==}
+
+  run-async@3.0.0:
+    resolution: {integrity: sha512-540WwVDOMxA6dN6We19EcT9sc3hkXPw5mzRNGM3FkdN/vtE9NFvj5lFAPNwUDmJjXidm3v7TC1cTE7t17Ulm1Q==}
+    engines: {node: '>=0.12.0'}
+
+  rxjs@7.8.2:
+    resolution: {integrity: sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==}
+
+  safe-array-concat@1.1.3:
+    resolution: {integrity: sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==}
+    engines: {node: '>=0.4'}
+
+  safe-buffer@5.2.1:
+    resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}
+
+  safe-push-apply@1.0.0:
+    resolution: {integrity: sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==}
+    engines: {node: '>= 0.4'}
+
+  safe-regex-test@1.1.0:
+    resolution: {integrity: sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==}
+    engines: {node: '>= 0.4'}
+
+  safe-stable-stringify@1.1.1:
+    resolution: {integrity: sha512-ERq4hUjKDbJfE4+XtZLFPCDi8Vb1JqaxAPTxWFLBx8XcAlf9Bda/ZJdVezs/NAfsMQScyIlUMx+Yeu7P7rx5jw==}
+
+  safer-buffer@2.1.2:
+    resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
+
+  sax@1.4.1:
+    resolution: {integrity: sha512-+aWOz7yVScEGoKNd4PA10LZ8sk0A/z5+nXQG5giUO5rprX9jgYsTdov9qCchZiPIZezbZH+jRut8nPodFAX4Jg==}
+
+  scheduler@0.23.2:
+    resolution: {integrity: sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==}
+
+  section-matter@1.0.0:
+    resolution: {integrity: sha512-vfD3pmTzGpufjScBh50YHKzEu2lxBWhVEHsNGoEXmCmn2hKGfeNLYMzCJpe8cD7gqX7TJluOVpBkAequ6dgMmA==}
+    engines: {node: '>=4'}
+
+  semver@7.7.1:
+    resolution: {integrity: sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  send@0.19.0:
+    resolution: {integrity: sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==}
+    engines: {node: '>= 0.8.0'}
+
+  serialize-error@12.0.0:
+    resolution: {integrity: sha512-ZYkZLAvKTKQXWuh5XpBw7CdbSzagarX39WyZ2H07CDLC5/KfsRGlIXV8d4+tfqX1M7916mRqR1QfNHSij+c9Pw==}
+    engines: {node: '>=18'}
+
+  serve-static@1.16.2:
+    resolution: {integrity: sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==}
+    engines: {node: '>= 0.8.0'}
+
+  set-function-length@1.2.2:
+    resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==}
+    engines: {node: '>= 0.4'}
+
+  set-function-name@2.0.2:
+    resolution: {integrity: sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==}
+    engines: {node: '>= 0.4'}
+
+  set-proto@1.0.0:
+    resolution: {integrity: sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==}
+    engines: {node: '>= 0.4'}
+
+  setprototypeof@1.2.0:
+    resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==}
+
+  sharp@0.33.5:
+    resolution: {integrity: sha512-haPVm1EkS9pgvHrQ/F3Xy+hgcuMV0Wm9vfIBSiwZ05k+xgb0PkBQpGsAA/oWdDobNaZTH5ppvHtzCFbnSEwHVw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+
+  side-channel-list@1.0.0:
+    resolution: {integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==}
+    engines: {node: '>= 0.4'}
+
+  side-channel-map@1.0.1:
+    resolution: {integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==}
+    engines: {node: '>= 0.4'}
+
+  side-channel-weakmap@1.0.2:
+    resolution: {integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==}
+    engines: {node: '>= 0.4'}
+
+  side-channel@1.1.0:
+    resolution: {integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==}
+    engines: {node: '>= 0.4'}
+
+  signal-exit@3.0.7:
+    resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==}
+
+  signal-exit@4.1.0:
+    resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
+    engines: {node: '>=14'}
+
+  simple-eval@1.0.1:
+    resolution: {integrity: sha512-LH7FpTAkeD+y5xQC4fzS+tFtaNlvt3Ib1zKzvhjv/Y+cioV4zIuw4IZr2yhRLu67CWL7FR9/6KXKnjRoZTvGGQ==}
+    engines: {node: '>=12'}
+
+  simple-swizzle@0.2.2:
+    resolution: {integrity: sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg==}
+
+  smart-buffer@4.2.0:
+    resolution: {integrity: sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==}
+    engines: {node: '>= 6.0.0', npm: '>= 3.0.0'}
+
+  socket.io-adapter@2.5.5:
+    resolution: {integrity: sha512-eLDQas5dzPgOWCk9GuuJC2lBqItuhKI4uxGgo9aIV7MYbk2h9Q6uULEh8WBzThoI7l+qU9Ast9fVUmkqPP9wYg==}
+
+  socket.io-parser@4.2.4:
+    resolution: {integrity: sha512-/GbIKmo8ioc+NIWIhwdecY0ge+qVBSMdgxGygevmdHj24bsfgtCmcUUcQ5ZzcylGFHsN3k4HB4Cgkl96KVnuew==}
+    engines: {node: '>=10.0.0'}
+
+  socket.io@4.8.1:
+    resolution: {integrity: sha512-oZ7iUCxph8WYRHHcjBEc9unw3adt5CmSNlppj/5Q4k2RIrhl8Z5yY2Xr4j9zj0+wzVZ0bxmYoGSzKJnRl6A4yg==}
+    engines: {node: '>=10.2.0'}
+
+  socks-proxy-agent@8.0.5:
+    resolution: {integrity: sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==}
+    engines: {node: '>= 14'}
+
+  socks@2.8.4:
+    resolution: {integrity: sha512-D3YaD0aRxR3mEcqnidIs7ReYJFVzWdd6fXJYUM8ixcQcJRGTka/b3saV0KflYhyVJXKhb947GndU35SxYNResQ==}
+    engines: {node: '>= 10.0.0', npm: '>= 3.0.0'}
+
+  source-map@0.6.1:
+    resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
+    engines: {node: '>=0.10.0'}
+
+  source-map@0.7.4:
+    resolution: {integrity: sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA==}
+    engines: {node: '>= 8'}
+
+  space-separated-tokens@2.0.2:
+    resolution: {integrity: sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==}
+
+  sprintf-js@1.0.3:
+    resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
+
+  sprintf-js@1.1.3:
+    resolution: {integrity: sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==}
+
+  statuses@2.0.1:
+    resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==}
+    engines: {node: '>= 0.8'}
+
+  stdin-discarder@0.1.0:
+    resolution: {integrity: sha512-xhV7w8S+bUwlPTb4bAOUQhv8/cSS5offJuX8GQGq32ONF0ZtDWKfkdomM3HMRA+LhX6um/FZ0COqlwsjD53LeQ==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  streamx@2.22.0:
+    resolution: {integrity: sha512-sLh1evHOzBy/iWRiR6d1zRcLao4gGZr3C1kzNz4fopCOKJb6xD9ub8Mpi9Mr1R6id5o43S+d93fI48UC5uM9aw==}
+
+  string-width@4.2.3:
+    resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
+    engines: {node: '>=8'}
+
+  string.prototype.trim@1.2.10:
+    resolution: {integrity: sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==}
+    engines: {node: '>= 0.4'}
+
+  string.prototype.trimend@1.0.9:
+    resolution: {integrity: sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==}
+    engines: {node: '>= 0.4'}
+
+  string.prototype.trimstart@1.0.8:
+    resolution: {integrity: sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==}
+    engines: {node: '>= 0.4'}
+
+  string_decoder@1.3.0:
+    resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==}
+
+  stringify-entities@4.0.4:
+    resolution: {integrity: sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==}
+
+  strip-ansi@6.0.1:
+    resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
+    engines: {node: '>=8'}
+
+  strip-ansi@7.1.0:
+    resolution: {integrity: sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==}
+    engines: {node: '>=12'}
+
+  strip-bom-string@1.0.0:
+    resolution: {integrity: sha512-uCC2VHvQRYu+lMh4My/sFNmF2klFymLX1wHJeXnbEJERpV/ZsVuonzerjfrGpIGF7LBVa1O7i9kjiWvJiFck8g==}
+    engines: {node: '>=0.10.0'}
+
+  style-to-js@1.1.16:
+    resolution: {integrity: sha512-/Q6ld50hKYPH3d/r6nr117TZkHR0w0kGGIVfpG9N6D8NymRPM9RqCUv4pRpJ62E5DqOYx2AFpbZMyCPnjQCnOw==}
+
+  style-to-object@1.0.8:
+    resolution: {integrity: sha512-xT47I/Eo0rwJmaXC4oilDGDWLohVhR6o/xAQcPQN8q6QBuZVL8qMYL85kLmST5cPjAorwvqIA4qXTRQoYHaL6g==}
+
+  tar-fs@3.0.8:
+    resolution: {integrity: sha512-ZoROL70jptorGAlgAYiLoBLItEKw/fUxg9BSYK/dF/GAGYFJOJJJMvjPAKDJraCXFwadD456FCuvLWgfhMsPwg==}
+
+  tar-stream@3.1.7:
+    resolution: {integrity: sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==}
+
+  tar@6.2.1:
+    resolution: {integrity: sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==}
+    engines: {node: '>=10'}
+
+  text-decoder@1.2.3:
+    resolution: {integrity: sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA==}
+
+  through@2.3.8:
+    resolution: {integrity: sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==}
+
+  tmp@0.0.33:
+    resolution: {integrity: sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==}
+    engines: {node: '>=0.6.0'}
+
+  to-regex-range@5.0.1:
+    resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
+    engines: {node: '>=8.0'}
+
+  toidentifier@1.0.1:
+    resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==}
+    engines: {node: '>=0.6'}
+
+  tr46@0.0.3:
+    resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==}
+
+  traverse@0.6.11:
+    resolution: {integrity: sha512-vxXDZg8/+p3gblxB6BhhG5yWVn1kGRlaL8O78UDXc3wRnPizB5g83dcvWV1jpDMIPnjZjOFuxlMmE82XJ4407w==}
+    engines: {node: '>= 0.4'}
+
+  trim-lines@3.0.1:
+    resolution: {integrity: sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==}
+
+  trim-trailing-lines@2.1.0:
+    resolution: {integrity: sha512-5UR5Biq4VlVOtzqkm2AZlgvSlDJtME46uV0br0gENbwN4l5+mMKT4b9gJKqWtuL2zAIqajGJGuvbCbcAJUZqBg==}
+
+  trough@2.2.0:
+    resolution: {integrity: sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==}
+
+  tslib@1.14.1:
+    resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==}
+
+  tslib@2.8.1:
+    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
+
+  tsx@4.19.3:
+    resolution: {integrity: sha512-4H8vUNGNjQ4V2EOoGw005+c+dGuPSnhpPBPHBtsZdGZBk/iJb4kguGlPWaZTZ3q5nMtFOEsY0nRDlh9PJyd6SQ==}
+    engines: {node: '>=18.0.0'}
+    hasBin: true
+
+  type-fest@0.21.3:
+    resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==}
+    engines: {node: '>=10'}
+
+  type-fest@4.38.0:
+    resolution: {integrity: sha512-2dBz5D5ycHIoliLYLi0Q2V7KRaDlH0uWIvmk7TYlAg5slqwiPv1ezJdZm1QEM0xgk29oYWMCbIG7E6gHpvChlg==}
+    engines: {node: '>=16'}
+
+  type-is@1.6.18:
+    resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==}
+    engines: {node: '>= 0.6'}
+
+  typed-array-buffer@1.0.3:
+    resolution: {integrity: sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==}
+    engines: {node: '>= 0.4'}
+
+  typed-array-byte-length@1.0.3:
+    resolution: {integrity: sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==}
+    engines: {node: '>= 0.4'}
+
+  typed-array-byte-offset@1.0.4:
+    resolution: {integrity: sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==}
+    engines: {node: '>= 0.4'}
+
+  typed-array-length@1.0.7:
+    resolution: {integrity: sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==}
+    engines: {node: '>= 0.4'}
+
+  typedarray.prototype.slice@1.0.5:
+    resolution: {integrity: sha512-q7QNVDGTdl702bVFiI5eY4l/HkgCM6at9KhcFbgUAzezHFbOVy4+0O/lCjsABEQwbZPravVfBIiBVGo89yzHFg==}
+    engines: {node: '>= 0.4'}
+
+  unbox-primitive@1.1.0:
+    resolution: {integrity: sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==}
+    engines: {node: '>= 0.4'}
+
+  unbzip2-stream@1.4.3:
+    resolution: {integrity: sha512-mlExGW4w71ebDJviH16lQLtZS32VKqsSfk80GCfUlwT/4/hNRFsoscrF/c++9xinkMzECL1uL9DDwXqFWkruPg==}
+
+  undici-types@6.20.0:
+    resolution: {integrity: sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==}
+
+  unified@11.0.5:
+    resolution: {integrity: sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==}
+
+  unist-builder@4.0.0:
+    resolution: {integrity: sha512-wmRFnH+BLpZnTKpc5L7O67Kac89s9HMrtELpnNaE6TAobq5DTZZs5YaTQfAZBA9bFPECx2uVAPO31c+GVug8mg==}
+
+  unist-util-find-after@5.0.0:
+    resolution: {integrity: sha512-amQa0Ep2m6hE2g72AugUItjbuM8X8cGQnFoHk0pGfrFeT9GZhzN5SW8nRsiGKK7Aif4CrACPENkA6P/Lw6fHGQ==}
+
+  unist-util-is@5.2.1:
+    resolution: {integrity: sha512-u9njyyfEh43npf1M+yGKDGVPbY/JWEemg5nH05ncKPfi+kBbKBJoTdsogMu33uhytuLlv9y0O7GH7fEdwLdLQw==}
+
+  unist-util-is@6.0.0:
+    resolution: {integrity: sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw==}
+
+  unist-util-map@4.0.0:
+    resolution: {integrity: sha512-HJs1tpkSmRJUzj6fskQrS5oYhBYlmtcvy4SepdDEEsL04FjBrgF0Mgggvxc1/qGBGgW7hRh9+UBK1aqTEnBpIA==}
+
+  unist-util-modify-children@4.0.0:
+    resolution: {integrity: sha512-+tdN5fGNddvsQdIzUF3Xx82CU9sMM+fA0dLgR9vOmT0oPT2jH+P1nd5lSqfCfXAw+93NhcXNY2qqvTUtE4cQkw==}
+
+  unist-util-position-from-estree@2.0.0:
+    resolution: {integrity: sha512-KaFVRjoqLyF6YXCbVLNad/eS4+OfPQQn2yOd7zF/h5T/CSL2v8NpN6a5TPvtbXthAGw5nG+PuTtq+DdIZr+cRQ==}
+
+  unist-util-position@5.0.0:
+    resolution: {integrity: sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==}
+
+  unist-util-remove-position@5.0.0:
+    resolution: {integrity: sha512-Hp5Kh3wLxv0PHj9m2yZhhLt58KzPtEYKQQ4yxfYFEO7EvHwzyDYnduhHnY1mDxoqr7VUwVuHXk9RXKIiYS1N8Q==}
+
+  unist-util-remove@4.0.0:
+    resolution: {integrity: sha512-b4gokeGId57UVRX/eVKej5gXqGlc9+trkORhFJpu9raqZkZhU0zm8Doi05+HaiBsMEIJowL+2WtQ5ItjsngPXg==}
+
+  unist-util-stringify-position@4.0.0:
+    resolution: {integrity: sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==}
+
+  unist-util-visit-children@3.0.0:
+    resolution: {integrity: sha512-RgmdTfSBOg04sdPcpTSD1jzoNBjt9a80/ZCzp5cI9n1qPzLZWF9YdvWGN2zmTumP1HWhXKdUWexjy/Wy/lJ7tA==}
+
+  unist-util-visit-parents@5.1.3:
+    resolution: {integrity: sha512-x6+y8g7wWMyQhL1iZfhIPhDAs7Xwbn9nRosDXl7qoPTSCy0yNxnKc+hWokFifWQIDGi154rdUqKvbCa4+1kLhg==}
+
+  unist-util-visit-parents@6.0.1:
+    resolution: {integrity: sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw==}
+
+  unist-util-visit@4.1.2:
+    resolution: {integrity: sha512-MSd8OUGISqHdVvfY9TPhyK2VdUrPgxkUtWSuMHF6XAAFuL4LokseigBnZtPnJMu+FbynTkFNnFlyjxpVKujMRg==}
+
+  unist-util-visit@5.0.0:
+    resolution: {integrity: sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==}
+
+  universalify@2.0.1:
+    resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==}
+    engines: {node: '>= 10.0.0'}
+
+  unpipe@1.0.0:
+    resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==}
+    engines: {node: '>= 0.8'}
+
+  urijs@1.19.11:
+    resolution: {integrity: sha512-HXgFDgDommxn5/bIv0cnQZsPhHDA90NPHD6+c/v21U5+Sx5hoP8+dP9IZXBU1gIfvdRfhG8cel9QNPeionfcCQ==}
+
+  urlpattern-polyfill@10.0.0:
+    resolution: {integrity: sha512-H/A06tKD7sS1O1X2SshBVeA5FLycRpjqiBeqGKmBwBDBy28EnRjORxTNe269KSSr5un5qyWi1iL61wLxpd+ZOg==}
+
+  util-deprecate@1.0.2:
+    resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}
+
+  utility-types@3.11.0:
+    resolution: {integrity: sha512-6Z7Ma2aVEWisaL6TvBCy7P8rm2LQoPv6dJ7ecIaIixHcwfbJ0x7mWdbcwlIM5IGQxPZSFYeqRCqlOOeKoJYMkw==}
+    engines: {node: '>= 4'}
+
+  utils-merge@1.0.1:
+    resolution: {integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==}
+    engines: {node: '>= 0.4.0'}
+
+  vary@1.1.2:
+    resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==}
+    engines: {node: '>= 0.8'}
+
+  vfile-location@5.0.3:
+    resolution: {integrity: sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg==}
+
+  vfile-matter@5.0.1:
+    resolution: {integrity: sha512-o6roP82AiX0XfkyTHyRCMXgHfltUNlXSEqCIS80f+mbAyiQBE2fxtDVMtseyytGx75sihiJFo/zR6r/4LTs2Cw==}
+
+  vfile-message@4.0.2:
+    resolution: {integrity: sha512-jRDZ1IMLttGj41KcZvlrYAaI3CfqpLpfpf+Mfig13viT6NKvRzWZ+lXz0Y5D60w6uJIBAOGq9mSHf0gktF0duw==}
+
+  vfile@6.0.3:
+    resolution: {integrity: sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==}
+
+  wcwidth@1.0.1:
+    resolution: {integrity: sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==}
+
+  web-namespaces@2.0.1:
+    resolution: {integrity: sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==}
+
+  webidl-conversions@3.0.1:
+    resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
+
+  whatwg-url@5.0.0:
+    resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==}
+
+  which-boxed-primitive@1.1.1:
+    resolution: {integrity: sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==}
+    engines: {node: '>= 0.4'}
+
+  which-builtin-type@1.2.1:
+    resolution: {integrity: sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==}
+    engines: {node: '>= 0.4'}
+
+  which-collection@1.0.2:
+    resolution: {integrity: sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==}
+    engines: {node: '>= 0.4'}
+
+  which-typed-array@1.1.19:
+    resolution: {integrity: sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==}
+    engines: {node: '>= 0.4'}
+
+  wrap-ansi@6.2.0:
+    resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==}
+    engines: {node: '>=8'}
+
+  wrap-ansi@7.0.0:
+    resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==}
+    engines: {node: '>=10'}
+
+  wrappy@1.0.2:
+    resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
+
+  ws@8.17.1:
+    resolution: {integrity: sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==}
+    engines: {node: '>=10.0.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: '>=5.0.2'
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+
+  ws@8.18.1:
+    resolution: {integrity: sha512-RKW2aJZMXeMxVpnZ6bck+RswznaxmzdULiBr6KY7XkTnW8uvt0iT9H5DkHUChXrc+uurzwa0rVI16n/Xzjdz1w==}
+    engines: {node: '>=10.0.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: '>=5.0.2'
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+
+  xml2js@0.6.2:
+    resolution: {integrity: sha512-T4rieHaC1EXcES0Kxxj4JWgaUQHDk+qwHcYOCFHfiwKz7tOVPLq7Hjq9dM1WCMhylqMEfP7hMcOIChvotiZegA==}
+    engines: {node: '>=4.0.0'}
+
+  xmlbuilder@11.0.1:
+    resolution: {integrity: sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA==}
+    engines: {node: '>=4.0'}
+
+  y18n@5.0.8:
+    resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==}
+    engines: {node: '>=10'}
+
+  yallist@4.0.0:
+    resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==}
+
+  yaml@2.7.0:
+    resolution: {integrity: sha512-+hSoy/QHluxmC9kCIJyL/uyFmLmc+e5CFR5Wa+bpIhIj85LVb9ZH2nVnqrHoSvKogwODv0ClqZkmiSSaIH5LTA==}
+    engines: {node: '>= 14'}
+    hasBin: true
+
+  yargs-parser@21.1.1:
+    resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==}
+    engines: {node: '>=12'}
+
+  yargs@17.7.2:
+    resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==}
+    engines: {node: '>=12'}
+
+  yauzl@2.10.0:
+    resolution: {integrity: sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==}
+
+  yoctocolors-cjs@2.1.2:
+    resolution: {integrity: sha512-cYVsTjKl8b+FrnidjibDWskAv7UKOfcwaVZdp/it9n1s9fU3IkgDbhdIRKCW4JDsAlECJY0ytoVPT3sK6kideA==}
+    engines: {node: '>=18'}
+
+  zod-to-json-schema@3.24.5:
+    resolution: {integrity: sha512-/AuWwMP+YqiPbsJx5D6TfgRTc4kTLjsh5SOcd4bLsfUg2RcEXrFMJl1DGgdHy2aCfsIA/cr/1JM0xcB2GZji8g==}
+    peerDependencies:
+      zod: ^3.24.1
+
+  zod@3.23.8:
+    resolution: {integrity: sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==}
+
+  zod@3.24.2:
+    resolution: {integrity: sha512-lY7CDW43ECgW9u1TcT3IoXHflywfVqDYze4waEz812jR/bZ8FHDsl7pFQoSZTz5N+2NqRXs8GBwnAwo3ZNxqhQ==}
+
+  zwitch@2.0.4:
+    resolution: {integrity: sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==}
+
+snapshots:
+
+  '@asyncapi/parser@3.4.0':
+    dependencies:
+      '@asyncapi/specs': 6.8.1
+      '@openapi-contrib/openapi-schema-to-json-schema': 3.2.0
+      '@stoplight/json': 3.21.0
+      '@stoplight/json-ref-readers': 1.2.2
+      '@stoplight/json-ref-resolver': 3.1.6
+      '@stoplight/spectral-core': 1.19.5
+      '@stoplight/spectral-functions': 1.9.4
+      '@stoplight/spectral-parsers': 1.0.5
+      '@stoplight/spectral-ref-resolver': 1.0.5
+      '@stoplight/types': 13.20.0
+      '@types/json-schema': 7.0.15
+      '@types/urijs': 1.19.25
+      ajv: 8.17.1
+      ajv-errors: 3.0.0(ajv@8.17.1)
+      ajv-formats: 2.1.1(ajv@8.17.1)
+      avsc: 5.7.7
+      js-yaml: 4.1.0
+      jsonpath-plus: 10.3.0
+      node-fetch: 2.6.7
+    transitivePeerDependencies:
+      - encoding
+
+  '@asyncapi/specs@6.8.1':
+    dependencies:
+      '@types/json-schema': 7.0.15
+
+  '@babel/code-frame@7.26.2':
+    dependencies:
+      '@babel/helper-validator-identifier': 7.25.9
+      js-tokens: 4.0.0
+      picocolors: 1.1.1
+
+  '@babel/helper-validator-identifier@7.25.9': {}
+
+  '@emnapi/runtime@1.4.0':
+    dependencies:
+      tslib: 2.8.1
+    optional: true
+
+  '@esbuild/aix-ppc64@0.25.1':
+    optional: true
+
+  '@esbuild/android-arm64@0.25.1':
+    optional: true
+
+  '@esbuild/android-arm@0.25.1':
+    optional: true
+
+  '@esbuild/android-x64@0.25.1':
+    optional: true
+
+  '@esbuild/darwin-arm64@0.25.1':
+    optional: true
+
+  '@esbuild/darwin-x64@0.25.1':
+    optional: true
+
+  '@esbuild/freebsd-arm64@0.25.1':
+    optional: true
+
+  '@esbuild/freebsd-x64@0.25.1':
+    optional: true
+
+  '@esbuild/linux-arm64@0.25.1':
+    optional: true
+
+  '@esbuild/linux-arm@0.25.1':
+    optional: true
+
+  '@esbuild/linux-ia32@0.25.1':
+    optional: true
+
+  '@esbuild/linux-loong64@0.25.1':
+    optional: true
+
+  '@esbuild/linux-mips64el@0.25.1':
+    optional: true
+
+  '@esbuild/linux-ppc64@0.25.1':
+    optional: true
+
+  '@esbuild/linux-riscv64@0.25.1':
+    optional: true
+
+  '@esbuild/linux-s390x@0.25.1':
+    optional: true
+
+  '@esbuild/linux-x64@0.25.1':
+    optional: true
+
+  '@esbuild/netbsd-arm64@0.25.1':
+    optional: true
+
+  '@esbuild/netbsd-x64@0.25.1':
+    optional: true
+
+  '@esbuild/openbsd-arm64@0.25.1':
+    optional: true
+
+  '@esbuild/openbsd-x64@0.25.1':
+    optional: true
+
+  '@esbuild/sunos-x64@0.25.1':
+    optional: true
+
+  '@esbuild/win32-arm64@0.25.1':
+    optional: true
+
+  '@esbuild/win32-ia32@0.25.1':
+    optional: true
+
+  '@esbuild/win32-x64@0.25.1':
+    optional: true
+
+  '@img/sharp-darwin-arm64@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-arm64': 1.0.4
+    optional: true
+
+  '@img/sharp-darwin-x64@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-x64': 1.0.4
+    optional: true
+
+  '@img/sharp-libvips-darwin-arm64@1.0.4':
+    optional: true
+
+  '@img/sharp-libvips-darwin-x64@1.0.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm64@1.0.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm@1.0.5':
+    optional: true
+
+  '@img/sharp-libvips-linux-s390x@1.0.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-x64@1.0.4':
+    optional: true
+
+  '@img/sharp-libvips-linuxmusl-arm64@1.0.4':
+    optional: true
+
+  '@img/sharp-libvips-linuxmusl-x64@1.0.4':
+    optional: true
+
+  '@img/sharp-linux-arm64@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm64': 1.0.4
+    optional: true
+
+  '@img/sharp-linux-arm@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm': 1.0.5
+    optional: true
+
+  '@img/sharp-linux-s390x@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-s390x': 1.0.4
+    optional: true
+
+  '@img/sharp-linux-x64@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-x64': 1.0.4
+    optional: true
+
+  '@img/sharp-linuxmusl-arm64@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-arm64': 1.0.4
+    optional: true
+
+  '@img/sharp-linuxmusl-x64@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-x64': 1.0.4
+    optional: true
+
+  '@img/sharp-wasm32@0.33.5':
+    dependencies:
+      '@emnapi/runtime': 1.4.0
+    optional: true
+
+  '@img/sharp-win32-ia32@0.33.5':
+    optional: true
+
+  '@img/sharp-win32-x64@0.33.5':
+    optional: true
+
+  '@inquirer/checkbox@4.1.4(@types/node@22.13.14)':
+    dependencies:
+      '@inquirer/core': 10.1.9(@types/node@22.13.14)
+      '@inquirer/figures': 1.0.11
+      '@inquirer/type': 3.0.5(@types/node@22.13.14)
+      ansi-escapes: 4.3.2
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 22.13.14
+
+  '@inquirer/confirm@5.1.8(@types/node@22.13.14)':
+    dependencies:
+      '@inquirer/core': 10.1.9(@types/node@22.13.14)
+      '@inquirer/type': 3.0.5(@types/node@22.13.14)
+    optionalDependencies:
+      '@types/node': 22.13.14
+
+  '@inquirer/core@10.1.9(@types/node@22.13.14)':
+    dependencies:
+      '@inquirer/figures': 1.0.11
+      '@inquirer/type': 3.0.5(@types/node@22.13.14)
+      ansi-escapes: 4.3.2
+      cli-width: 4.1.0
+      mute-stream: 2.0.0
+      signal-exit: 4.1.0
+      wrap-ansi: 6.2.0
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 22.13.14
+
+  '@inquirer/editor@4.2.9(@types/node@22.13.14)':
+    dependencies:
+      '@inquirer/core': 10.1.9(@types/node@22.13.14)
+      '@inquirer/type': 3.0.5(@types/node@22.13.14)
+      external-editor: 3.1.0
+    optionalDependencies:
+      '@types/node': 22.13.14
+
+  '@inquirer/expand@4.0.11(@types/node@22.13.14)':
+    dependencies:
+      '@inquirer/core': 10.1.9(@types/node@22.13.14)
+      '@inquirer/type': 3.0.5(@types/node@22.13.14)
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 22.13.14
+
+  '@inquirer/figures@1.0.11': {}
+
+  '@inquirer/input@4.1.8(@types/node@22.13.14)':
+    dependencies:
+      '@inquirer/core': 10.1.9(@types/node@22.13.14)
+      '@inquirer/type': 3.0.5(@types/node@22.13.14)
+    optionalDependencies:
+      '@types/node': 22.13.14
+
+  '@inquirer/number@3.0.11(@types/node@22.13.14)':
+    dependencies:
+      '@inquirer/core': 10.1.9(@types/node@22.13.14)
+      '@inquirer/type': 3.0.5(@types/node@22.13.14)
+    optionalDependencies:
+      '@types/node': 22.13.14
+
+  '@inquirer/password@4.0.11(@types/node@22.13.14)':
+    dependencies:
+      '@inquirer/core': 10.1.9(@types/node@22.13.14)
+      '@inquirer/type': 3.0.5(@types/node@22.13.14)
+      ansi-escapes: 4.3.2
+    optionalDependencies:
+      '@types/node': 22.13.14
+
+  '@inquirer/prompts@7.4.0(@types/node@22.13.14)':
+    dependencies:
+      '@inquirer/checkbox': 4.1.4(@types/node@22.13.14)
+      '@inquirer/confirm': 5.1.8(@types/node@22.13.14)
+      '@inquirer/editor': 4.2.9(@types/node@22.13.14)
+      '@inquirer/expand': 4.0.11(@types/node@22.13.14)
+      '@inquirer/input': 4.1.8(@types/node@22.13.14)
+      '@inquirer/number': 3.0.11(@types/node@22.13.14)
+      '@inquirer/password': 4.0.11(@types/node@22.13.14)
+      '@inquirer/rawlist': 4.0.11(@types/node@22.13.14)
+      '@inquirer/search': 3.0.11(@types/node@22.13.14)
+      '@inquirer/select': 4.1.0(@types/node@22.13.14)
+    optionalDependencies:
+      '@types/node': 22.13.14
+
+  '@inquirer/rawlist@4.0.11(@types/node@22.13.14)':
+    dependencies:
+      '@inquirer/core': 10.1.9(@types/node@22.13.14)
+      '@inquirer/type': 3.0.5(@types/node@22.13.14)
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 22.13.14
+
+  '@inquirer/search@3.0.11(@types/node@22.13.14)':
+    dependencies:
+      '@inquirer/core': 10.1.9(@types/node@22.13.14)
+      '@inquirer/figures': 1.0.11
+      '@inquirer/type': 3.0.5(@types/node@22.13.14)
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 22.13.14
+
+  '@inquirer/select@4.1.0(@types/node@22.13.14)':
+    dependencies:
+      '@inquirer/core': 10.1.9(@types/node@22.13.14)
+      '@inquirer/figures': 1.0.11
+      '@inquirer/type': 3.0.5(@types/node@22.13.14)
+      ansi-escapes: 4.3.2
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 22.13.14
+
+  '@inquirer/type@3.0.5(@types/node@22.13.14)':
+    optionalDependencies:
+      '@types/node': 22.13.14
+
+  '@jsep-plugin/assignment@1.3.0(jsep@1.4.0)':
+    dependencies:
+      jsep: 1.4.0
+
+  '@jsep-plugin/regex@1.0.4(jsep@1.4.0)':
+    dependencies:
+      jsep: 1.4.0
+
+  '@jsep-plugin/ternary@1.1.4(jsep@1.4.0)':
+    dependencies:
+      jsep: 1.4.0
+
+  '@leichtgewicht/ip-codec@2.0.5': {}
+
+  '@mdx-js/mdx@3.1.0(acorn@8.14.1)':
+    dependencies:
+      '@types/estree': 1.0.7
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdx': 2.0.13
+      collapse-white-space: 2.1.0
+      devlop: 1.1.0
+      estree-util-is-identifier-name: 3.0.0
+      estree-util-scope: 1.0.0
+      estree-walker: 3.0.3
+      hast-util-to-jsx-runtime: 2.3.6
+      markdown-extensions: 2.0.0
+      recma-build-jsx: 1.0.0
+      recma-jsx: 1.0.0(acorn@8.14.1)
+      recma-stringify: 1.0.0
+      rehype-recma: 1.0.0
+      remark-mdx: 3.1.0
+      remark-parse: 11.0.0
+      remark-rehype: 11.1.1
+      source-map: 0.7.4
+      unified: 11.0.5
+      unist-util-position-from-estree: 2.0.0
+      unist-util-stringify-position: 4.0.0
+      unist-util-visit: 5.0.0
+      vfile: 6.0.3
+    transitivePeerDependencies:
+      - acorn
+      - supports-color
+
+  '@mdx-js/react@3.1.0(@types/react@19.0.12)(react@18.3.1)':
+    dependencies:
+      '@types/mdx': 2.0.13
+      '@types/react': 19.0.12
+      react: 18.3.1
+
+  '@mintlify/cli@4.0.452(@types/node@22.13.14)(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+    dependencies:
+      '@mintlify/common': 1.0.318(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@mintlify/link-rot': 3.0.423(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@mintlify/models': 0.0.180
+      '@mintlify/prebuild': 1.0.420(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@mintlify/previewing': 4.0.443(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@mintlify/validation': 0.1.326
+      chalk: 5.4.1
+      detect-port: 1.6.1
+      fs-extra: 11.3.0
+      inquirer: 12.5.0(@types/node@22.13.14)
+      js-yaml: 4.1.0
+      ora: 6.3.1
+      yargs: 17.7.2
+    transitivePeerDependencies:
+      - '@types/node'
+      - '@types/react'
+      - bare-buffer
+      - bufferutil
+      - debug
+      - encoding
+      - react
+      - react-dom
+      - supports-color
+      - typescript
+      - utf-8-validate
+
+  '@mintlify/common@1.0.318(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+    dependencies:
+      '@asyncapi/parser': 3.4.0
+      '@mintlify/mdx': 1.0.1(@types/react@19.0.12)(acorn@8.14.1)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@mintlify/models': 0.0.180
+      '@mintlify/openapi-parser': 0.0.7
+      '@mintlify/validation': 0.1.326
+      '@sindresorhus/slugify': 2.2.1
+      acorn: 8.14.1
+      estree-util-to-js: 2.0.0
+      estree-walker: 3.0.3
+      gray-matter: 4.0.3
+      hast-util-from-html: 2.0.3
+      hast-util-to-html: 9.0.5
+      hast-util-to-text: 4.0.2
+      is-absolute-url: 4.0.1
+      js-yaml: 4.1.0
+      lodash: 4.17.21
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-mdx: 3.0.0
+      mdast-util-mdx-jsx: 3.2.0
+      micromark-extension-mdx-jsx: 3.0.2
+      openapi-types: 12.1.3
+      remark: 15.0.1
+      remark-frontmatter: 5.0.0
+      remark-gfm: 4.0.1
+      remark-math: 6.0.0
+      remark-mdx: 3.1.0
+      unified: 11.0.5
+      unist-builder: 4.0.0
+      unist-util-map: 4.0.0
+      unist-util-remove: 4.0.0
+      unist-util-remove-position: 5.0.0
+      unist-util-visit: 5.0.0
+      unist-util-visit-parents: 6.0.1
+      vfile: 6.0.3
+    transitivePeerDependencies:
+      - '@types/react'
+      - debug
+      - encoding
+      - react
+      - react-dom
+      - supports-color
+
+  '@mintlify/link-rot@3.0.423(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+    dependencies:
+      '@mintlify/common': 1.0.318(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@mintlify/prebuild': 1.0.420(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      fs-extra: 11.3.0
+      is-absolute-url: 4.0.1
+      unist-util-visit: 4.1.2
+    transitivePeerDependencies:
+      - '@types/react'
+      - bare-buffer
+      - bufferutil
+      - debug
+      - encoding
+      - react
+      - react-dom
+      - supports-color
+      - typescript
+      - utf-8-validate
+
+  '@mintlify/mdx@1.0.1(@types/react@19.0.12)(acorn@8.14.1)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      hast-util-to-string: 3.0.1
+      next-mdx-remote-client: 1.1.0(@types/react@19.0.12)(acorn@8.14.1)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      react: 18.3.1
+      react-dom: 18.3.1(react@18.3.1)
+      refractor: 4.9.0
+      rehype-katex: 7.0.1
+      remark-gfm: 4.0.1
+      remark-math: 6.0.0
+      remark-smartypants: 3.0.2
+      unified: 11.0.5
+      unist-util-visit: 5.0.0
+    transitivePeerDependencies:
+      - '@types/react'
+      - acorn
+      - supports-color
+
+  '@mintlify/models@0.0.180':
+    dependencies:
+      axios: 1.8.4
+      openapi-types: 12.1.3
+    transitivePeerDependencies:
+      - debug
+
+  '@mintlify/openapi-parser@0.0.7':
+    dependencies:
+      ajv: 8.17.1
+      ajv-draft-04: 1.0.0(ajv@8.17.1)
+      ajv-formats: 3.0.1(ajv@8.17.1)
+      jsonpointer: 5.0.1
+      leven: 4.0.0
+      yaml: 2.7.0
+
+  '@mintlify/prebuild@1.0.420(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+    dependencies:
+      '@mintlify/common': 1.0.318(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@mintlify/openapi-parser': 0.0.7
+      '@mintlify/scraping': 4.0.170(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@mintlify/validation': 0.1.326
+      axios: 1.8.4
+      chalk: 5.4.1
+      favicons: 7.2.0
+      fs-extra: 11.3.0
+      gray-matter: 4.0.3
+      is-absolute-url: 4.0.1
+      js-yaml: 4.1.0
+      openapi-types: 12.1.3
+      unist-util-visit: 4.1.2
+    transitivePeerDependencies:
+      - '@types/react'
+      - bare-buffer
+      - bufferutil
+      - debug
+      - encoding
+      - react
+      - react-dom
+      - supports-color
+      - typescript
+      - utf-8-validate
+
+  '@mintlify/previewing@4.0.443(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+    dependencies:
+      '@mintlify/common': 1.0.318(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@mintlify/prebuild': 1.0.420(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@mintlify/validation': 0.1.326
+      better-opn: 3.0.2
+      chalk: 5.4.1
+      chokidar: 3.6.0
+      express: 4.21.2
+      fs-extra: 11.3.0
+      got: 13.0.0
+      gray-matter: 4.0.3
+      is-absolute-url: 4.0.1
+      is-online: 10.0.0
+      js-yaml: 4.1.0
+      openapi-types: 12.1.3
+      ora: 6.3.1
+      socket.io: 4.8.1
+      tar: 6.2.1
+      unist-util-visit: 4.1.2
+      yargs: 17.7.2
+    transitivePeerDependencies:
+      - '@types/react'
+      - bare-buffer
+      - bufferutil
+      - debug
+      - encoding
+      - react
+      - react-dom
+      - supports-color
+      - typescript
+      - utf-8-validate
+
+  '@mintlify/scraping@4.0.170(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+    dependencies:
+      '@mintlify/common': 1.0.318(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@mintlify/openapi-parser': 0.0.7
+      fs-extra: 11.3.0
+      hast-util-to-mdast: 10.1.2
+      js-yaml: 4.1.0
+      mdast-util-mdx-jsx: 3.2.0
+      puppeteer: 22.15.0
+      rehype-parse: 9.0.1
+      remark-gfm: 4.0.1
+      remark-mdx: 3.1.0
+      remark-parse: 11.0.0
+      remark-stringify: 11.0.0
+      traverse: 0.6.11
+      unified: 11.0.5
+      unist-util-visit: 5.0.0
+      yargs: 17.7.2
+      zod: 3.24.2
+    transitivePeerDependencies:
+      - '@types/react'
+      - bare-buffer
+      - bufferutil
+      - debug
+      - encoding
+      - react
+      - react-dom
+      - supports-color
+      - typescript
+      - utf-8-validate
+
+  '@mintlify/validation@0.1.326':
+    dependencies:
+      '@mintlify/models': 0.0.180
+      is-absolute-url: 4.0.1
+      lcm: 0.0.3
+      lodash: 4.17.21
+      openapi-types: 12.1.3
+      zod: 3.24.2
+      zod-to-json-schema: 3.24.5(zod@3.24.2)
+    transitivePeerDependencies:
+      - debug
+
+  '@openapi-contrib/openapi-schema-to-json-schema@3.2.0':
+    dependencies:
+      fast-deep-equal: 3.1.3
+
+  '@puppeteer/browsers@2.3.0':
+    dependencies:
+      debug: 4.4.0
+      extract-zip: 2.0.1
+      progress: 2.0.3
+      proxy-agent: 6.5.0
+      semver: 7.7.1
+      tar-fs: 3.0.8
+      unbzip2-stream: 1.4.3
+      yargs: 17.7.2
+    transitivePeerDependencies:
+      - bare-buffer
+      - supports-color
+
+  '@sindresorhus/is@5.6.0': {}
+
+  '@sindresorhus/slugify@2.2.1':
+    dependencies:
+      '@sindresorhus/transliterate': 1.6.0
+      escape-string-regexp: 5.0.0
+
+  '@sindresorhus/transliterate@1.6.0':
+    dependencies:
+      escape-string-regexp: 5.0.0
+
+  '@socket.io/component-emitter@3.1.2': {}
+
+  '@stoplight/better-ajv-errors@1.0.3(ajv@8.17.1)':
+    dependencies:
+      ajv: 8.17.1
+      jsonpointer: 5.0.1
+      leven: 3.1.0
+
+  '@stoplight/json-ref-readers@1.2.2':
+    dependencies:
+      node-fetch: 2.6.7
+      tslib: 1.14.1
+    transitivePeerDependencies:
+      - encoding
+
+  '@stoplight/json-ref-resolver@3.1.6':
+    dependencies:
+      '@stoplight/json': 3.21.0
+      '@stoplight/path': 1.3.2
+      '@stoplight/types': 13.20.0
+      '@types/urijs': 1.19.25
+      dependency-graph: 0.11.0
+      fast-memoize: 2.5.2
+      immer: 9.0.21
+      lodash: 4.17.21
+      tslib: 2.8.1
+      urijs: 1.19.11
+
+  '@stoplight/json@3.21.0':
+    dependencies:
+      '@stoplight/ordered-object-literal': 1.0.5
+      '@stoplight/path': 1.3.2
+      '@stoplight/types': 13.20.0
+      jsonc-parser: 2.2.1
+      lodash: 4.17.21
+      safe-stable-stringify: 1.1.1
+
+  '@stoplight/ordered-object-literal@1.0.5': {}
+
+  '@stoplight/path@1.3.2': {}
+
+  '@stoplight/spectral-core@1.19.5':
+    dependencies:
+      '@stoplight/better-ajv-errors': 1.0.3(ajv@8.17.1)
+      '@stoplight/json': 3.21.0
+      '@stoplight/path': 1.3.2
+      '@stoplight/spectral-parsers': 1.0.5
+      '@stoplight/spectral-ref-resolver': 1.0.5
+      '@stoplight/spectral-runtime': 1.1.4
+      '@stoplight/types': 13.6.0
+      '@types/es-aggregate-error': 1.0.6
+      '@types/json-schema': 7.0.15
+      ajv: 8.17.1
+      ajv-errors: 3.0.0(ajv@8.17.1)
+      ajv-formats: 2.1.1(ajv@8.17.1)
+      es-aggregate-error: 1.0.13
+      jsonpath-plus: 10.3.0
+      lodash: 4.17.21
+      lodash.topath: 4.5.2
+      minimatch: 3.1.2
+      nimma: 0.2.3
+      pony-cause: 1.1.1
+      simple-eval: 1.0.1
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - encoding
+
+  '@stoplight/spectral-formats@1.8.2':
+    dependencies:
+      '@stoplight/json': 3.21.0
+      '@stoplight/spectral-core': 1.19.5
+      '@types/json-schema': 7.0.15
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - encoding
+
+  '@stoplight/spectral-functions@1.9.4':
+    dependencies:
+      '@stoplight/better-ajv-errors': 1.0.3(ajv@8.17.1)
+      '@stoplight/json': 3.21.0
+      '@stoplight/spectral-core': 1.19.5
+      '@stoplight/spectral-formats': 1.8.2
+      '@stoplight/spectral-runtime': 1.1.4
+      ajv: 8.17.1
+      ajv-draft-04: 1.0.0(ajv@8.17.1)
+      ajv-errors: 3.0.0(ajv@8.17.1)
+      ajv-formats: 2.1.1(ajv@8.17.1)
+      lodash: 4.17.21
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - encoding
+
+  '@stoplight/spectral-parsers@1.0.5':
+    dependencies:
+      '@stoplight/json': 3.21.0
+      '@stoplight/types': 14.1.1
+      '@stoplight/yaml': 4.3.0
+      tslib: 2.8.1
+
+  '@stoplight/spectral-ref-resolver@1.0.5':
+    dependencies:
+      '@stoplight/json-ref-readers': 1.2.2
+      '@stoplight/json-ref-resolver': 3.1.6
+      '@stoplight/spectral-runtime': 1.1.4
+      dependency-graph: 0.11.0
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - encoding
+
+  '@stoplight/spectral-runtime@1.1.4':
+    dependencies:
+      '@stoplight/json': 3.21.0
+      '@stoplight/path': 1.3.2
+      '@stoplight/types': 13.20.0
+      abort-controller: 3.0.0
+      lodash: 4.17.21
+      node-fetch: 2.7.0
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - encoding
+
+  '@stoplight/types@13.20.0':
+    dependencies:
+      '@types/json-schema': 7.0.15
+      utility-types: 3.11.0
+
+  '@stoplight/types@13.6.0':
+    dependencies:
+      '@types/json-schema': 7.0.15
+      utility-types: 3.11.0
+
+  '@stoplight/types@14.1.1':
+    dependencies:
+      '@types/json-schema': 7.0.15
+      utility-types: 3.11.0
+
+  '@stoplight/yaml-ast-parser@0.0.50': {}
+
+  '@stoplight/yaml@4.3.0':
+    dependencies:
+      '@stoplight/ordered-object-literal': 1.0.5
+      '@stoplight/types': 14.1.1
+      '@stoplight/yaml-ast-parser': 0.0.50
+      tslib: 2.8.1
+
+  '@szmarczak/http-timer@5.0.1':
+    dependencies:
+      defer-to-connect: 2.0.1
+
+  '@tootallnate/quickjs-emscripten@0.23.0': {}
+
+  '@types/cors@2.8.17':
+    dependencies:
+      '@types/node': 22.13.14
+
+  '@types/debug@4.1.12':
+    dependencies:
+      '@types/ms': 2.1.0
+
+  '@types/es-aggregate-error@1.0.6':
+    dependencies:
+      '@types/node': 22.13.14
+
+  '@types/estree-jsx@1.0.5':
+    dependencies:
+      '@types/estree': 1.0.7
+
+  '@types/estree@1.0.7': {}
+
+  '@types/hast@2.3.10':
+    dependencies:
+      '@types/unist': 2.0.11
+
+  '@types/hast@3.0.4':
+    dependencies:
+      '@types/unist': 3.0.3
+
+  '@types/http-cache-semantics@4.0.4': {}
+
+  '@types/json-schema@7.0.15': {}
+
+  '@types/katex@0.16.7': {}
+
+  '@types/mdast@4.0.4':
+    dependencies:
+      '@types/unist': 3.0.3
+
+  '@types/mdx@2.0.13': {}
+
+  '@types/ms@2.1.0': {}
+
+  '@types/nlcst@2.0.3':
+    dependencies:
+      '@types/unist': 3.0.3
+
+  '@types/node@22.13.14':
+    dependencies:
+      undici-types: 6.20.0
+
+  '@types/prismjs@1.26.5': {}
+
+  '@types/react@19.0.12':
+    dependencies:
+      csstype: 3.1.3
+
+  '@types/unist@2.0.11': {}
+
+  '@types/unist@3.0.3': {}
+
+  '@types/urijs@1.19.25': {}
+
+  '@types/yauzl@2.10.3':
+    dependencies:
+      '@types/node': 22.13.14
+    optional: true
+
+  '@ungap/structured-clone@1.3.0': {}
+
+  abort-controller@3.0.0:
+    dependencies:
+      event-target-shim: 5.0.1
+
+  accepts@1.3.8:
+    dependencies:
+      mime-types: 2.1.35
+      negotiator: 0.6.3
+
+  acorn-jsx@5.3.2(acorn@8.14.1):
+    dependencies:
+      acorn: 8.14.1
+
+  acorn@8.14.1: {}
+
+  address@1.2.2: {}
+
+  agent-base@7.1.3: {}
+
+  aggregate-error@4.0.1:
+    dependencies:
+      clean-stack: 4.2.0
+      indent-string: 5.0.0
+
+  ajv-draft-04@1.0.0(ajv@8.17.1):
+    optionalDependencies:
+      ajv: 8.17.1
+
+  ajv-errors@3.0.0(ajv@8.17.1):
+    dependencies:
+      ajv: 8.17.1
+
+  ajv-formats@2.1.1(ajv@8.17.1):
+    optionalDependencies:
+      ajv: 8.17.1
+
+  ajv-formats@3.0.1(ajv@8.17.1):
+    optionalDependencies:
+      ajv: 8.17.1
+
+  ajv@8.17.1:
+    dependencies:
+      fast-deep-equal: 3.1.3
+      fast-uri: 3.0.6
+      json-schema-traverse: 1.0.0
+      require-from-string: 2.0.2
+
+  ansi-escapes@4.3.2:
+    dependencies:
+      type-fest: 0.21.3
+
+  ansi-regex@5.0.1: {}
+
+  ansi-regex@6.1.0: {}
+
+  ansi-styles@4.3.0:
+    dependencies:
+      color-convert: 2.0.1
+
+  anymatch@3.1.3:
+    dependencies:
+      normalize-path: 3.0.0
+      picomatch: 2.3.1
+
+  argparse@1.0.10:
+    dependencies:
+      sprintf-js: 1.0.3
+
+  argparse@2.0.1: {}
+
+  array-buffer-byte-length@1.0.2:
+    dependencies:
+      call-bound: 1.0.4
+      is-array-buffer: 3.0.5
+
+  array-flatten@1.1.1: {}
+
+  array-iterate@2.0.1: {}
+
+  arraybuffer.prototype.slice@1.0.4:
+    dependencies:
+      array-buffer-byte-length: 1.0.2
+      call-bind: 1.0.8
+      define-properties: 1.2.1
+      es-abstract: 1.23.9
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      is-array-buffer: 3.0.5
+
+  ast-types@0.13.4:
+    dependencies:
+      tslib: 2.8.1
+
+  astring@1.9.0: {}
+
+  async-function@1.0.0: {}
+
+  asynckit@0.4.0: {}
+
+  available-typed-arrays@1.0.7:
+    dependencies:
+      possible-typed-array-names: 1.1.0
+
+  avsc@5.7.7: {}
+
+  axios@1.8.4:
+    dependencies:
+      follow-redirects: 1.15.9
+      form-data: 4.0.2
+      proxy-from-env: 1.1.0
+    transitivePeerDependencies:
+      - debug
+
+  b4a@1.6.7: {}
+
+  bail@2.0.2: {}
+
+  balanced-match@1.0.2: {}
+
+  bare-events@2.5.4:
+    optional: true
+
+  bare-fs@4.0.2:
+    dependencies:
+      bare-events: 2.5.4
+      bare-path: 3.0.0
+      bare-stream: 2.6.5(bare-events@2.5.4)
+    optional: true
+
+  bare-os@3.6.1:
+    optional: true
+
+  bare-path@3.0.0:
+    dependencies:
+      bare-os: 3.6.1
+    optional: true
+
+  bare-stream@2.6.5(bare-events@2.5.4):
+    dependencies:
+      streamx: 2.22.0
+    optionalDependencies:
+      bare-events: 2.5.4
+    optional: true
+
+  base64-js@1.5.1: {}
+
+  base64id@2.0.0: {}
+
+  basic-ftp@5.0.5: {}
+
+  better-opn@3.0.2:
+    dependencies:
+      open: 8.4.2
+
+  binary-extensions@2.3.0: {}
+
+  bl@5.1.0:
+    dependencies:
+      buffer: 6.0.3
+      inherits: 2.0.4
+      readable-stream: 3.6.2
+
+  body-parser@1.20.3:
+    dependencies:
+      bytes: 3.1.2
+      content-type: 1.0.5
+      debug: 2.6.9
+      depd: 2.0.0
+      destroy: 1.2.0
+      http-errors: 2.0.0
+      iconv-lite: 0.4.24
+      on-finished: 2.4.1
+      qs: 6.13.0
+      raw-body: 2.5.2
+      type-is: 1.6.18
+      unpipe: 1.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  brace-expansion@1.1.11:
+    dependencies:
+      balanced-match: 1.0.2
+      concat-map: 0.0.1
+
+  braces@3.0.3:
+    dependencies:
+      fill-range: 7.1.1
+
+  buffer-crc32@0.2.13: {}
+
+  buffer@5.7.1:
+    dependencies:
+      base64-js: 1.5.1
+      ieee754: 1.2.1
+
+  buffer@6.0.3:
+    dependencies:
+      base64-js: 1.5.1
+      ieee754: 1.2.1
+
+  bytes@3.1.2: {}
+
+  cacheable-lookup@7.0.0: {}
+
+  cacheable-request@10.2.14:
+    dependencies:
+      '@types/http-cache-semantics': 4.0.4
+      get-stream: 6.0.1
+      http-cache-semantics: 4.1.1
+      keyv: 4.5.4
+      mimic-response: 4.0.0
+      normalize-url: 8.0.1
+      responselike: 3.0.0
+
+  call-bind-apply-helpers@1.0.2:
+    dependencies:
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+
+  call-bind@1.0.8:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-define-property: 1.0.1
+      get-intrinsic: 1.3.0
+      set-function-length: 1.2.2
+
+  call-bound@1.0.4:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      get-intrinsic: 1.3.0
+
+  callsites@3.1.0: {}
+
+  ccount@2.0.1: {}
+
+  chalk@5.4.1: {}
+
+  character-entities-html4@2.1.0: {}
+
+  character-entities-legacy@3.0.0: {}
+
+  character-entities@2.0.2: {}
+
+  character-reference-invalid@2.0.1: {}
+
+  chardet@0.7.0: {}
+
+  chokidar@3.6.0:
+    dependencies:
+      anymatch: 3.1.3
+      braces: 3.0.3
+      glob-parent: 5.1.2
+      is-binary-path: 2.1.0
+      is-glob: 4.0.3
+      normalize-path: 3.0.0
+      readdirp: 3.6.0
+    optionalDependencies:
+      fsevents: 2.3.3
+
+  chownr@2.0.0: {}
+
+  chromium-bidi@0.6.3(devtools-protocol@0.0.1312386):
+    dependencies:
+      devtools-protocol: 0.0.1312386
+      mitt: 3.0.1
+      urlpattern-polyfill: 10.0.0
+      zod: 3.23.8
+
+  clean-stack@4.2.0:
+    dependencies:
+      escape-string-regexp: 5.0.0
+
+  cli-cursor@4.0.0:
+    dependencies:
+      restore-cursor: 4.0.0
+
+  cli-spinners@2.9.2: {}
+
+  cli-width@4.1.0: {}
+
+  cliui@8.0.1:
+    dependencies:
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+      wrap-ansi: 7.0.0
+
+  clone@1.0.4: {}
+
+  collapse-white-space@2.1.0: {}
+
+  color-convert@2.0.1:
+    dependencies:
+      color-name: 1.1.4
+
+  color-name@1.1.4: {}
+
+  color-string@1.9.1:
+    dependencies:
+      color-name: 1.1.4
+      simple-swizzle: 0.2.2
+
+  color@4.2.3:
+    dependencies:
+      color-convert: 2.0.1
+      color-string: 1.9.1
+
+  combined-stream@1.0.8:
+    dependencies:
+      delayed-stream: 1.0.0
+
+  comma-separated-tokens@2.0.3: {}
+
+  commander@8.3.0: {}
+
+  concat-map@0.0.1: {}
+
+  content-disposition@0.5.4:
+    dependencies:
+      safe-buffer: 5.2.1
+
+  content-type@1.0.5: {}
+
+  cookie-signature@1.0.6: {}
+
+  cookie@0.7.1: {}
+
+  cookie@0.7.2: {}
+
+  cors@2.8.5:
+    dependencies:
+      object-assign: 4.1.1
+      vary: 1.1.2
+
+  cosmiconfig@9.0.0:
+    dependencies:
+      env-paths: 2.2.1
+      import-fresh: 3.3.1
+      js-yaml: 4.1.0
+      parse-json: 5.2.0
+
+  csstype@3.1.3: {}
+
+  data-uri-to-buffer@6.0.2: {}
+
+  data-view-buffer@1.0.2:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-data-view: 1.0.2
+
+  data-view-byte-length@1.0.2:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-data-view: 1.0.2
+
+  data-view-byte-offset@1.0.1:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-data-view: 1.0.2
+
+  debug@2.6.9:
+    dependencies:
+      ms: 2.0.0
+
+  debug@4.3.7:
+    dependencies:
+      ms: 2.1.3
+
+  debug@4.4.0:
+    dependencies:
+      ms: 2.1.3
+
+  decode-named-character-reference@1.1.0:
+    dependencies:
+      character-entities: 2.0.2
+
+  decompress-response@6.0.0:
+    dependencies:
+      mimic-response: 3.1.0
+
+  defaults@1.0.4:
+    dependencies:
+      clone: 1.0.4
+
+  defer-to-connect@2.0.1: {}
+
+  define-data-property@1.1.4:
+    dependencies:
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
+      gopd: 1.2.0
+
+  define-lazy-prop@2.0.0: {}
+
+  define-properties@1.2.1:
+    dependencies:
+      define-data-property: 1.1.4
+      has-property-descriptors: 1.0.2
+      object-keys: 1.1.1
+
+  degenerator@5.0.1:
+    dependencies:
+      ast-types: 0.13.4
+      escodegen: 2.1.0
+      esprima: 4.0.1
+
+  delayed-stream@1.0.0: {}
+
+  depd@2.0.0: {}
+
+  dependency-graph@0.11.0: {}
+
+  dequal@2.0.3: {}
+
+  destroy@1.2.0: {}
+
+  detect-libc@2.0.3: {}
+
+  detect-port@1.6.1:
+    dependencies:
+      address: 1.2.2
+      debug: 4.4.0
+    transitivePeerDependencies:
+      - supports-color
+
+  devlop@1.1.0:
+    dependencies:
+      dequal: 2.0.3
+
+  devtools-protocol@0.0.1312386: {}
+
+  dns-packet@5.6.1:
+    dependencies:
+      '@leichtgewicht/ip-codec': 2.0.5
+
+  dns-socket@4.2.2:
+    dependencies:
+      dns-packet: 5.6.1
+
+  dunder-proto@1.0.1:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-errors: 1.3.0
+      gopd: 1.2.0
+
+  ee-first@1.1.1: {}
+
+  emoji-regex@8.0.0: {}
+
+  encodeurl@1.0.2: {}
+
+  encodeurl@2.0.0: {}
+
+  end-of-stream@1.4.4:
+    dependencies:
+      once: 1.4.0
+
+  engine.io-parser@5.2.3: {}
+
+  engine.io@6.6.4:
+    dependencies:
+      '@types/cors': 2.8.17
+      '@types/node': 22.13.14
+      accepts: 1.3.8
+      base64id: 2.0.0
+      cookie: 0.7.2
+      cors: 2.8.5
+      debug: 4.3.7
+      engine.io-parser: 5.2.3
+      ws: 8.17.1
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  entities@4.5.0: {}
+
+  env-paths@2.2.1: {}
+
+  error-ex@1.3.2:
+    dependencies:
+      is-arrayish: 0.2.1
+
+  es-abstract@1.23.9:
+    dependencies:
+      array-buffer-byte-length: 1.0.2
+      arraybuffer.prototype.slice: 1.0.4
+      available-typed-arrays: 1.0.7
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      data-view-buffer: 1.0.2
+      data-view-byte-length: 1.0.2
+      data-view-byte-offset: 1.0.1
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.1
+      es-set-tostringtag: 2.1.0
+      es-to-primitive: 1.3.0
+      function.prototype.name: 1.1.8
+      get-intrinsic: 1.3.0
+      get-proto: 1.0.1
+      get-symbol-description: 1.1.0
+      globalthis: 1.0.4
+      gopd: 1.2.0
+      has-property-descriptors: 1.0.2
+      has-proto: 1.2.0
+      has-symbols: 1.1.0
+      hasown: 2.0.2
+      internal-slot: 1.1.0
+      is-array-buffer: 3.0.5
+      is-callable: 1.2.7
+      is-data-view: 1.0.2
+      is-regex: 1.2.1
+      is-shared-array-buffer: 1.0.4
+      is-string: 1.1.1
+      is-typed-array: 1.1.15
+      is-weakref: 1.1.1
+      math-intrinsics: 1.1.0
+      object-inspect: 1.13.4
+      object-keys: 1.1.1
+      object.assign: 4.1.7
+      own-keys: 1.0.1
+      regexp.prototype.flags: 1.5.4
+      safe-array-concat: 1.1.3
+      safe-push-apply: 1.0.0
+      safe-regex-test: 1.1.0
+      set-proto: 1.0.0
+      string.prototype.trim: 1.2.10
+      string.prototype.trimend: 1.0.9
+      string.prototype.trimstart: 1.0.8
+      typed-array-buffer: 1.0.3
+      typed-array-byte-length: 1.0.3
+      typed-array-byte-offset: 1.0.4
+      typed-array-length: 1.0.7
+      unbox-primitive: 1.1.0
+      which-typed-array: 1.1.19
+
+  es-aggregate-error@1.0.13:
+    dependencies:
+      define-data-property: 1.1.4
+      define-properties: 1.2.1
+      es-abstract: 1.23.9
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+      globalthis: 1.0.4
+      has-property-descriptors: 1.0.2
+      set-function-name: 2.0.2
+
+  es-define-property@1.0.1: {}
+
+  es-errors@1.3.0: {}
+
+  es-object-atoms@1.1.1:
+    dependencies:
+      es-errors: 1.3.0
+
+  es-set-tostringtag@2.1.0:
+    dependencies:
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      has-tostringtag: 1.0.2
+      hasown: 2.0.2
+
+  es-to-primitive@1.3.0:
+    dependencies:
+      is-callable: 1.2.7
+      is-date-object: 1.1.0
+      is-symbol: 1.1.1
+
+  esast-util-from-estree@2.0.0:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      devlop: 1.1.0
+      estree-util-visit: 2.0.0
+      unist-util-position-from-estree: 2.0.0
+
+  esast-util-from-js@2.0.1:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      acorn: 8.14.1
+      esast-util-from-estree: 2.0.0
+      vfile-message: 4.0.2
+
+  esbuild@0.25.1:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.25.1
+      '@esbuild/android-arm': 0.25.1
+      '@esbuild/android-arm64': 0.25.1
+      '@esbuild/android-x64': 0.25.1
+      '@esbuild/darwin-arm64': 0.25.1
+      '@esbuild/darwin-x64': 0.25.1
+      '@esbuild/freebsd-arm64': 0.25.1
+      '@esbuild/freebsd-x64': 0.25.1
+      '@esbuild/linux-arm': 0.25.1
+      '@esbuild/linux-arm64': 0.25.1
+      '@esbuild/linux-ia32': 0.25.1
+      '@esbuild/linux-loong64': 0.25.1
+      '@esbuild/linux-mips64el': 0.25.1
+      '@esbuild/linux-ppc64': 0.25.1
+      '@esbuild/linux-riscv64': 0.25.1
+      '@esbuild/linux-s390x': 0.25.1
+      '@esbuild/linux-x64': 0.25.1
+      '@esbuild/netbsd-arm64': 0.25.1
+      '@esbuild/netbsd-x64': 0.25.1
+      '@esbuild/openbsd-arm64': 0.25.1
+      '@esbuild/openbsd-x64': 0.25.1
+      '@esbuild/sunos-x64': 0.25.1
+      '@esbuild/win32-arm64': 0.25.1
+      '@esbuild/win32-ia32': 0.25.1
+      '@esbuild/win32-x64': 0.25.1
+
+  escalade@3.2.0: {}
+
+  escape-html@1.0.3: {}
+
+  escape-string-regexp@5.0.0: {}
+
+  escodegen@2.1.0:
+    dependencies:
+      esprima: 4.0.1
+      estraverse: 5.3.0
+      esutils: 2.0.3
+    optionalDependencies:
+      source-map: 0.6.1
+
+  esprima@4.0.1: {}
+
+  estraverse@5.3.0: {}
+
+  estree-util-attach-comments@3.0.0:
+    dependencies:
+      '@types/estree': 1.0.7
+
+  estree-util-build-jsx@3.0.1:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      devlop: 1.1.0
+      estree-util-is-identifier-name: 3.0.0
+      estree-walker: 3.0.3
+
+  estree-util-is-identifier-name@3.0.0: {}
+
+  estree-util-scope@1.0.0:
+    dependencies:
+      '@types/estree': 1.0.7
+      devlop: 1.1.0
+
+  estree-util-to-js@2.0.0:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      astring: 1.9.0
+      source-map: 0.7.4
+
+  estree-util-visit@2.0.0:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/unist': 3.0.3
+
+  estree-walker@3.0.3:
+    dependencies:
+      '@types/estree': 1.0.7
+
+  esutils@2.0.3: {}
+
+  etag@1.8.1: {}
+
+  event-target-shim@5.0.1: {}
+
+  express@4.21.2:
+    dependencies:
+      accepts: 1.3.8
+      array-flatten: 1.1.1
+      body-parser: 1.20.3
+      content-disposition: 0.5.4
+      content-type: 1.0.5
+      cookie: 0.7.1
+      cookie-signature: 1.0.6
+      debug: 2.6.9
+      depd: 2.0.0
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      etag: 1.8.1
+      finalhandler: 1.3.1
+      fresh: 0.5.2
+      http-errors: 2.0.0
+      merge-descriptors: 1.0.3
+      methods: 1.1.2
+      on-finished: 2.4.1
+      parseurl: 1.3.3
+      path-to-regexp: 0.1.12
+      proxy-addr: 2.0.7
+      qs: 6.13.0
+      range-parser: 1.2.1
+      safe-buffer: 5.2.1
+      send: 0.19.0
+      serve-static: 1.16.2
+      setprototypeof: 1.2.0
+      statuses: 2.0.1
+      type-is: 1.6.18
+      utils-merge: 1.0.1
+      vary: 1.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  extend-shallow@2.0.1:
+    dependencies:
+      is-extendable: 0.1.1
+
+  extend@3.0.2: {}
+
+  external-editor@3.1.0:
+    dependencies:
+      chardet: 0.7.0
+      iconv-lite: 0.4.24
+      tmp: 0.0.33
+
+  extract-zip@2.0.1:
+    dependencies:
+      debug: 4.4.0
+      get-stream: 5.2.0
+      yauzl: 2.10.0
+    optionalDependencies:
+      '@types/yauzl': 2.10.3
+    transitivePeerDependencies:
+      - supports-color
+
+  fast-deep-equal@3.1.3: {}
+
+  fast-fifo@1.3.2: {}
+
+  fast-memoize@2.5.2: {}
+
+  fast-uri@3.0.6: {}
+
+  fault@2.0.1:
+    dependencies:
+      format: 0.2.2
+
+  favicons@7.2.0:
+    dependencies:
+      escape-html: 1.0.3
+      sharp: 0.33.5
+      xml2js: 0.6.2
+
+  fd-slicer@1.1.0:
+    dependencies:
+      pend: 1.2.0
+
+  fill-range@7.1.1:
+    dependencies:
+      to-regex-range: 5.0.1
+
+  finalhandler@1.3.1:
+    dependencies:
+      debug: 2.6.9
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      on-finished: 2.4.1
+      parseurl: 1.3.3
+      statuses: 2.0.1
+      unpipe: 1.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  follow-redirects@1.15.9: {}
+
+  for-each@0.3.5:
+    dependencies:
+      is-callable: 1.2.7
+
+  form-data-encoder@2.1.4: {}
+
+  form-data@4.0.2:
+    dependencies:
+      asynckit: 0.4.0
+      combined-stream: 1.0.8
+      es-set-tostringtag: 2.1.0
+      mime-types: 2.1.35
+
+  format@0.2.2: {}
+
+  forwarded@0.2.0: {}
+
+  fresh@0.5.2: {}
+
+  fs-extra@11.3.0:
+    dependencies:
+      graceful-fs: 4.2.11
+      jsonfile: 6.1.0
+      universalify: 2.0.1
+
+  fs-minipass@2.1.0:
+    dependencies:
+      minipass: 3.3.6
+
+  fsevents@2.3.3:
+    optional: true
+
+  function-bind@1.1.2: {}
+
+  function.prototype.name@1.1.8:
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      define-properties: 1.2.1
+      functions-have-names: 1.2.3
+      hasown: 2.0.2
+      is-callable: 1.2.7
+
+  functions-have-names@1.2.3: {}
+
+  gcd@0.0.1: {}
+
+  get-caller-file@2.0.5: {}
+
+  get-intrinsic@1.3.0:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.1
+      function-bind: 1.1.2
+      get-proto: 1.0.1
+      gopd: 1.2.0
+      has-symbols: 1.1.0
+      hasown: 2.0.2
+      math-intrinsics: 1.1.0
+
+  get-proto@1.0.1:
+    dependencies:
+      dunder-proto: 1.0.1
+      es-object-atoms: 1.1.1
+
+  get-stream@5.2.0:
+    dependencies:
+      pump: 3.0.2
+
+  get-stream@6.0.1: {}
+
+  get-symbol-description@1.1.0:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+
+  get-tsconfig@4.10.0:
+    dependencies:
+      resolve-pkg-maps: 1.0.0
+
+  get-uri@6.0.4:
+    dependencies:
+      basic-ftp: 5.0.5
+      data-uri-to-buffer: 6.0.2
+      debug: 4.4.0
+    transitivePeerDependencies:
+      - supports-color
+
+  glob-parent@5.1.2:
+    dependencies:
+      is-glob: 4.0.3
+
+  globalthis@1.0.4:
+    dependencies:
+      define-properties: 1.2.1
+      gopd: 1.2.0
+
+  gopd@1.2.0: {}
+
+  got@12.6.1:
+    dependencies:
+      '@sindresorhus/is': 5.6.0
+      '@szmarczak/http-timer': 5.0.1
+      cacheable-lookup: 7.0.0
+      cacheable-request: 10.2.14
+      decompress-response: 6.0.0
+      form-data-encoder: 2.1.4
+      get-stream: 6.0.1
+      http2-wrapper: 2.2.1
+      lowercase-keys: 3.0.0
+      p-cancelable: 3.0.0
+      responselike: 3.0.0
+
+  got@13.0.0:
+    dependencies:
+      '@sindresorhus/is': 5.6.0
+      '@szmarczak/http-timer': 5.0.1
+      cacheable-lookup: 7.0.0
+      cacheable-request: 10.2.14
+      decompress-response: 6.0.0
+      form-data-encoder: 2.1.4
+      get-stream: 6.0.1
+      http2-wrapper: 2.2.1
+      lowercase-keys: 3.0.0
+      p-cancelable: 3.0.0
+      responselike: 3.0.0
+
+  graceful-fs@4.2.11: {}
+
+  gray-matter@4.0.3:
+    dependencies:
+      js-yaml: 3.14.1
+      kind-of: 6.0.3
+      section-matter: 1.0.0
+      strip-bom-string: 1.0.0
+
+  has-bigints@1.1.0: {}
+
+  has-property-descriptors@1.0.2:
+    dependencies:
+      es-define-property: 1.0.1
+
+  has-proto@1.2.0:
+    dependencies:
+      dunder-proto: 1.0.1
+
+  has-symbols@1.1.0: {}
+
+  has-tostringtag@1.0.2:
+    dependencies:
+      has-symbols: 1.1.0
+
+  hasown@2.0.2:
+    dependencies:
+      function-bind: 1.1.2
+
+  hast-util-embedded@3.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+      hast-util-is-element: 3.0.0
+
+  hast-util-from-dom@5.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      hastscript: 9.0.1
+      web-namespaces: 2.0.1
+
+  hast-util-from-html-isomorphic@2.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+      hast-util-from-dom: 5.0.1
+      hast-util-from-html: 2.0.3
+      unist-util-remove-position: 5.0.0
+
+  hast-util-from-html@2.0.3:
+    dependencies:
+      '@types/hast': 3.0.4
+      devlop: 1.1.0
+      hast-util-from-parse5: 8.0.3
+      parse5: 7.2.1
+      vfile: 6.0.3
+      vfile-message: 4.0.2
+
+  hast-util-from-parse5@8.0.3:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      devlop: 1.1.0
+      hastscript: 9.0.1
+      property-information: 7.0.0
+      vfile: 6.0.3
+      vfile-location: 5.0.3
+      web-namespaces: 2.0.1
+
+  hast-util-has-property@3.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+
+  hast-util-is-body-ok-link@3.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+
+  hast-util-is-element@3.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+
+  hast-util-minify-whitespace@1.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      hast-util-embedded: 3.0.0
+      hast-util-is-element: 3.0.0
+      hast-util-whitespace: 3.0.0
+      unist-util-is: 6.0.0
+
+  hast-util-parse-selector@3.1.1:
+    dependencies:
+      '@types/hast': 2.3.10
+
+  hast-util-parse-selector@4.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+
+  hast-util-phrasing@3.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      hast-util-embedded: 3.0.0
+      hast-util-has-property: 3.0.0
+      hast-util-is-body-ok-link: 3.0.1
+      hast-util-is-element: 3.0.0
+
+  hast-util-to-estree@3.1.3:
+    dependencies:
+      '@types/estree': 1.0.7
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      comma-separated-tokens: 2.0.3
+      devlop: 1.1.0
+      estree-util-attach-comments: 3.0.0
+      estree-util-is-identifier-name: 3.0.0
+      hast-util-whitespace: 3.0.0
+      mdast-util-mdx-expression: 2.0.1
+      mdast-util-mdx-jsx: 3.2.0
+      mdast-util-mdxjs-esm: 2.0.1
+      property-information: 7.0.0
+      space-separated-tokens: 2.0.2
+      style-to-js: 1.1.16
+      unist-util-position: 5.0.0
+      zwitch: 2.0.4
+    transitivePeerDependencies:
+      - supports-color
+
+  hast-util-to-html@9.0.5:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      ccount: 2.0.1
+      comma-separated-tokens: 2.0.3
+      hast-util-whitespace: 3.0.0
+      html-void-elements: 3.0.0
+      mdast-util-to-hast: 13.2.0
+      property-information: 7.0.0
+      space-separated-tokens: 2.0.2
+      stringify-entities: 4.0.4
+      zwitch: 2.0.4
+
+  hast-util-to-jsx-runtime@2.3.6:
+    dependencies:
+      '@types/estree': 1.0.7
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      comma-separated-tokens: 2.0.3
+      devlop: 1.1.0
+      estree-util-is-identifier-name: 3.0.0
+      hast-util-whitespace: 3.0.0
+      mdast-util-mdx-expression: 2.0.1
+      mdast-util-mdx-jsx: 3.2.0
+      mdast-util-mdxjs-esm: 2.0.1
+      property-information: 7.0.0
+      space-separated-tokens: 2.0.2
+      style-to-js: 1.1.16
+      unist-util-position: 5.0.0
+      vfile-message: 4.0.2
+    transitivePeerDependencies:
+      - supports-color
+
+  hast-util-to-mdast@10.1.2:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      '@ungap/structured-clone': 1.3.0
+      hast-util-phrasing: 3.0.1
+      hast-util-to-html: 9.0.5
+      hast-util-to-text: 4.0.2
+      hast-util-whitespace: 3.0.0
+      mdast-util-phrasing: 4.1.0
+      mdast-util-to-hast: 13.2.0
+      mdast-util-to-string: 4.0.0
+      rehype-minify-whitespace: 6.0.2
+      trim-trailing-lines: 2.1.0
+      unist-util-position: 5.0.0
+      unist-util-visit: 5.0.0
+
+  hast-util-to-string@3.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+
+  hast-util-to-text@4.0.2:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      hast-util-is-element: 3.0.0
+      unist-util-find-after: 5.0.0
+
+  hast-util-whitespace@3.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+
+  hastscript@7.2.0:
+    dependencies:
+      '@types/hast': 2.3.10
+      comma-separated-tokens: 2.0.3
+      hast-util-parse-selector: 3.1.1
+      property-information: 6.5.0
+      space-separated-tokens: 2.0.2
+
+  hastscript@9.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      comma-separated-tokens: 2.0.3
+      hast-util-parse-selector: 4.0.0
+      property-information: 7.0.0
+      space-separated-tokens: 2.0.2
+
+  html-void-elements@3.0.0: {}
+
+  http-cache-semantics@4.1.1: {}
+
+  http-errors@2.0.0:
+    dependencies:
+      depd: 2.0.0
+      inherits: 2.0.4
+      setprototypeof: 1.2.0
+      statuses: 2.0.1
+      toidentifier: 1.0.1
+
+  http-proxy-agent@7.0.2:
+    dependencies:
+      agent-base: 7.1.3
+      debug: 4.4.0
+    transitivePeerDependencies:
+      - supports-color
+
+  http2-wrapper@2.2.1:
+    dependencies:
+      quick-lru: 5.1.1
+      resolve-alpn: 1.2.1
+
+  https-proxy-agent@7.0.6:
+    dependencies:
+      agent-base: 7.1.3
+      debug: 4.4.0
+    transitivePeerDependencies:
+      - supports-color
+
+  iconv-lite@0.4.24:
+    dependencies:
+      safer-buffer: 2.1.2
+
+  ieee754@1.2.1: {}
+
+  immer@9.0.21: {}
+
+  import-fresh@3.3.1:
+    dependencies:
+      parent-module: 1.0.1
+      resolve-from: 4.0.0
+
+  indent-string@5.0.0: {}
+
+  inherits@2.0.4: {}
+
+  inline-style-parser@0.2.4: {}
+
+  inquirer@12.5.0(@types/node@22.13.14):
+    dependencies:
+      '@inquirer/core': 10.1.9(@types/node@22.13.14)
+      '@inquirer/prompts': 7.4.0(@types/node@22.13.14)
+      '@inquirer/type': 3.0.5(@types/node@22.13.14)
+      ansi-escapes: 4.3.2
+      mute-stream: 2.0.0
+      run-async: 3.0.0
+      rxjs: 7.8.2
+    optionalDependencies:
+      '@types/node': 22.13.14
+
+  internal-slot@1.1.0:
+    dependencies:
+      es-errors: 1.3.0
+      hasown: 2.0.2
+      side-channel: 1.1.0
+
+  ip-address@9.0.5:
+    dependencies:
+      jsbn: 1.1.0
+      sprintf-js: 1.1.3
+
+  ip-regex@4.3.0: {}
+
+  ipaddr.js@1.9.1: {}
+
+  is-absolute-url@4.0.1: {}
+
+  is-alphabetical@2.0.1: {}
+
+  is-alphanumerical@2.0.1:
+    dependencies:
+      is-alphabetical: 2.0.1
+      is-decimal: 2.0.1
+
+  is-array-buffer@3.0.5:
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      get-intrinsic: 1.3.0
+
+  is-arrayish@0.2.1: {}
+
+  is-arrayish@0.3.2: {}
+
+  is-async-function@2.1.1:
+    dependencies:
+      async-function: 1.0.0
+      call-bound: 1.0.4
+      get-proto: 1.0.1
+      has-tostringtag: 1.0.2
+      safe-regex-test: 1.1.0
+
+  is-bigint@1.1.0:
+    dependencies:
+      has-bigints: 1.1.0
+
+  is-binary-path@2.1.0:
+    dependencies:
+      binary-extensions: 2.3.0
+
+  is-boolean-object@1.2.2:
+    dependencies:
+      call-bound: 1.0.4
+      has-tostringtag: 1.0.2
+
+  is-callable@1.2.7: {}
+
+  is-data-view@1.0.2:
+    dependencies:
+      call-bound: 1.0.4
+      get-intrinsic: 1.3.0
+      is-typed-array: 1.1.15
+
+  is-date-object@1.1.0:
+    dependencies:
+      call-bound: 1.0.4
+      has-tostringtag: 1.0.2
+
+  is-decimal@2.0.1: {}
+
+  is-docker@2.2.1: {}
+
+  is-extendable@0.1.1: {}
+
+  is-extglob@2.1.1: {}
+
+  is-finalizationregistry@1.1.1:
+    dependencies:
+      call-bound: 1.0.4
+
+  is-fullwidth-code-point@3.0.0: {}
+
+  is-generator-function@1.1.0:
+    dependencies:
+      call-bound: 1.0.4
+      get-proto: 1.0.1
+      has-tostringtag: 1.0.2
+      safe-regex-test: 1.1.0
+
+  is-glob@4.0.3:
+    dependencies:
+      is-extglob: 2.1.1
+
+  is-hexadecimal@2.0.1: {}
+
+  is-interactive@2.0.0: {}
+
+  is-ip@3.1.0:
+    dependencies:
+      ip-regex: 4.3.0
+
+  is-map@2.0.3: {}
+
+  is-number-object@1.1.1:
+    dependencies:
+      call-bound: 1.0.4
+      has-tostringtag: 1.0.2
+
+  is-number@7.0.0: {}
+
+  is-online@10.0.0:
+    dependencies:
+      got: 12.6.1
+      p-any: 4.0.0
+      p-timeout: 5.1.0
+      public-ip: 5.0.0
+
+  is-plain-obj@4.1.0: {}
+
+  is-regex@1.2.1:
+    dependencies:
+      call-bound: 1.0.4
+      gopd: 1.2.0
+      has-tostringtag: 1.0.2
+      hasown: 2.0.2
+
+  is-set@2.0.3: {}
+
+  is-shared-array-buffer@1.0.4:
+    dependencies:
+      call-bound: 1.0.4
+
+  is-string@1.1.1:
+    dependencies:
+      call-bound: 1.0.4
+      has-tostringtag: 1.0.2
+
+  is-symbol@1.1.1:
+    dependencies:
+      call-bound: 1.0.4
+      has-symbols: 1.1.0
+      safe-regex-test: 1.1.0
+
+  is-typed-array@1.1.15:
+    dependencies:
+      which-typed-array: 1.1.19
+
+  is-unicode-supported@1.3.0: {}
+
+  is-weakmap@2.0.2: {}
+
+  is-weakref@1.1.1:
+    dependencies:
+      call-bound: 1.0.4
+
+  is-weakset@2.0.4:
+    dependencies:
+      call-bound: 1.0.4
+      get-intrinsic: 1.3.0
+
+  is-wsl@2.2.0:
+    dependencies:
+      is-docker: 2.2.1
+
+  isarray@2.0.5: {}
+
+  js-tokens@4.0.0: {}
+
+  js-yaml@3.14.1:
+    dependencies:
+      argparse: 1.0.10
+      esprima: 4.0.1
+
+  js-yaml@4.1.0:
+    dependencies:
+      argparse: 2.0.1
+
+  jsbn@1.1.0: {}
+
+  jsep@1.4.0: {}
+
+  json-buffer@3.0.1: {}
+
+  json-parse-even-better-errors@2.3.1: {}
+
+  json-schema-traverse@1.0.0: {}
+
+  jsonc-parser@2.2.1: {}
+
+  jsonfile@6.1.0:
+    dependencies:
+      universalify: 2.0.1
+    optionalDependencies:
+      graceful-fs: 4.2.11
+
+  jsonpath-plus@10.3.0:
+    dependencies:
+      '@jsep-plugin/assignment': 1.3.0(jsep@1.4.0)
+      '@jsep-plugin/regex': 1.0.4(jsep@1.4.0)
+      jsep: 1.4.0
+
+  jsonpointer@5.0.1: {}
+
+  katex@0.16.21:
+    dependencies:
+      commander: 8.3.0
+
+  keyv@4.5.4:
+    dependencies:
+      json-buffer: 3.0.1
+
+  kind-of@6.0.3: {}
+
+  lcm@0.0.3:
+    dependencies:
+      gcd: 0.0.1
+
+  leven@3.1.0: {}
+
+  leven@4.0.0: {}
+
+  lines-and-columns@1.2.4: {}
+
+  lodash.topath@4.5.2: {}
+
+  lodash@4.17.21: {}
+
+  log-symbols@5.1.0:
+    dependencies:
+      chalk: 5.4.1
+      is-unicode-supported: 1.3.0
+
+  longest-streak@3.1.0: {}
+
+  loose-envify@1.4.0:
+    dependencies:
+      js-tokens: 4.0.0
+
+  lowercase-keys@3.0.0: {}
+
+  lru-cache@7.18.3: {}
+
+  markdown-extensions@2.0.0: {}
+
+  markdown-table@3.0.4: {}
+
+  math-intrinsics@1.1.0: {}
+
+  mdast-util-find-and-replace@3.0.2:
+    dependencies:
+      '@types/mdast': 4.0.4
+      escape-string-regexp: 5.0.0
+      unist-util-is: 6.0.0
+      unist-util-visit-parents: 6.0.1
+
+  mdast-util-from-markdown@2.0.2:
+    dependencies:
+      '@types/mdast': 4.0.4
+      '@types/unist': 3.0.3
+      decode-named-character-reference: 1.1.0
+      devlop: 1.1.0
+      mdast-util-to-string: 4.0.0
+      micromark: 4.0.2
+      micromark-util-decode-numeric-character-reference: 2.0.2
+      micromark-util-decode-string: 2.0.1
+      micromark-util-normalize-identifier: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+      unist-util-stringify-position: 4.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-frontmatter@2.0.1:
+    dependencies:
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      escape-string-regexp: 5.0.0
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+      micromark-extension-frontmatter: 2.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-autolink-literal@2.0.1:
+    dependencies:
+      '@types/mdast': 4.0.4
+      ccount: 2.0.1
+      devlop: 1.1.0
+      mdast-util-find-and-replace: 3.0.2
+      micromark-util-character: 2.1.1
+
+  mdast-util-gfm-footnote@2.1.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+      micromark-util-normalize-identifier: 2.0.1
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-strikethrough@2.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-table@2.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      markdown-table: 3.0.4
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-task-list-item@2.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm@3.1.0:
+    dependencies:
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-gfm-autolink-literal: 2.0.1
+      mdast-util-gfm-footnote: 2.1.0
+      mdast-util-gfm-strikethrough: 2.0.0
+      mdast-util-gfm-table: 2.0.0
+      mdast-util-gfm-task-list-item: 2.0.0
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-math@3.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      longest-streak: 3.1.0
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+      unist-util-remove-position: 5.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdx-expression@2.0.1:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdx-jsx@3.2.0:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      '@types/unist': 3.0.3
+      ccount: 2.0.1
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+      parse-entities: 4.0.2
+      stringify-entities: 4.0.4
+      unist-util-stringify-position: 4.0.0
+      vfile-message: 4.0.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdx@3.0.0:
+    dependencies:
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-mdx-expression: 2.0.1
+      mdast-util-mdx-jsx: 3.2.0
+      mdast-util-mdxjs-esm: 2.0.1
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdxjs-esm@2.0.1:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-phrasing@4.1.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      unist-util-is: 6.0.0
+
+  mdast-util-to-hast@13.2.0:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      '@ungap/structured-clone': 1.3.0
+      devlop: 1.1.0
+      micromark-util-sanitize-uri: 2.0.1
+      trim-lines: 3.0.1
+      unist-util-position: 5.0.0
+      unist-util-visit: 5.0.0
+      vfile: 6.0.3
+
+  mdast-util-to-markdown@2.1.2:
+    dependencies:
+      '@types/mdast': 4.0.4
+      '@types/unist': 3.0.3
+      longest-streak: 3.1.0
+      mdast-util-phrasing: 4.1.0
+      mdast-util-to-string: 4.0.0
+      micromark-util-classify-character: 2.0.1
+      micromark-util-decode-string: 2.0.1
+      unist-util-visit: 5.0.0
+      zwitch: 2.0.4
+
+  mdast-util-to-string@4.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+
+  media-typer@0.3.0: {}
+
+  merge-descriptors@1.0.3: {}
+
+  methods@1.1.2: {}
+
+  micromark-core-commonmark@2.0.3:
+    dependencies:
+      decode-named-character-reference: 1.1.0
+      devlop: 1.1.0
+      micromark-factory-destination: 2.0.1
+      micromark-factory-label: 2.0.1
+      micromark-factory-space: 2.0.1
+      micromark-factory-title: 2.0.1
+      micromark-factory-whitespace: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-chunked: 2.0.1
+      micromark-util-classify-character: 2.0.1
+      micromark-util-html-tag-name: 2.0.1
+      micromark-util-normalize-identifier: 2.0.1
+      micromark-util-resolve-all: 2.0.1
+      micromark-util-subtokenize: 2.1.0
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-frontmatter@2.0.0:
+    dependencies:
+      fault: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-autolink-literal@2.1.0:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-sanitize-uri: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-footnote@2.1.0:
+    dependencies:
+      devlop: 1.1.0
+      micromark-core-commonmark: 2.0.3
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-normalize-identifier: 2.0.1
+      micromark-util-sanitize-uri: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-strikethrough@2.1.0:
+    dependencies:
+      devlop: 1.1.0
+      micromark-util-chunked: 2.0.1
+      micromark-util-classify-character: 2.0.1
+      micromark-util-resolve-all: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-table@2.1.1:
+    dependencies:
+      devlop: 1.1.0
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-tagfilter@2.0.0:
+    dependencies:
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-task-list-item@2.1.0:
+    dependencies:
+      devlop: 1.1.0
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm@3.0.0:
+    dependencies:
+      micromark-extension-gfm-autolink-literal: 2.1.0
+      micromark-extension-gfm-footnote: 2.1.0
+      micromark-extension-gfm-strikethrough: 2.1.0
+      micromark-extension-gfm-table: 2.1.1
+      micromark-extension-gfm-tagfilter: 2.0.0
+      micromark-extension-gfm-task-list-item: 2.1.0
+      micromark-util-combine-extensions: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-math@3.1.0:
+    dependencies:
+      '@types/katex': 0.16.7
+      devlop: 1.1.0
+      katex: 0.16.21
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-mdx-expression@3.0.1:
+    dependencies:
+      '@types/estree': 1.0.7
+      devlop: 1.1.0
+      micromark-factory-mdx-expression: 2.0.3
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-events-to-acorn: 2.0.3
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-mdx-jsx@3.0.2:
+    dependencies:
+      '@types/estree': 1.0.7
+      devlop: 1.1.0
+      estree-util-is-identifier-name: 3.0.0
+      micromark-factory-mdx-expression: 2.0.3
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-events-to-acorn: 2.0.3
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+      vfile-message: 4.0.2
+
+  micromark-extension-mdx-md@2.0.0:
+    dependencies:
+      micromark-util-types: 2.0.2
+
+  micromark-extension-mdxjs-esm@3.0.0:
+    dependencies:
+      '@types/estree': 1.0.7
+      devlop: 1.1.0
+      micromark-core-commonmark: 2.0.3
+      micromark-util-character: 2.1.1
+      micromark-util-events-to-acorn: 2.0.3
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+      unist-util-position-from-estree: 2.0.0
+      vfile-message: 4.0.2
+
+  micromark-extension-mdxjs@3.0.0:
+    dependencies:
+      acorn: 8.14.1
+      acorn-jsx: 5.3.2(acorn@8.14.1)
+      micromark-extension-mdx-expression: 3.0.1
+      micromark-extension-mdx-jsx: 3.0.2
+      micromark-extension-mdx-md: 2.0.0
+      micromark-extension-mdxjs-esm: 3.0.0
+      micromark-util-combine-extensions: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-factory-destination@2.0.1:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-factory-label@2.0.1:
+    dependencies:
+      devlop: 1.1.0
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-factory-mdx-expression@2.0.3:
+    dependencies:
+      '@types/estree': 1.0.7
+      devlop: 1.1.0
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-events-to-acorn: 2.0.3
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+      unist-util-position-from-estree: 2.0.0
+      vfile-message: 4.0.2
+
+  micromark-factory-space@2.0.1:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-types: 2.0.2
+
+  micromark-factory-title@2.0.1:
+    dependencies:
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-factory-whitespace@2.0.1:
+    dependencies:
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-util-character@2.1.1:
+    dependencies:
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-util-chunked@2.0.1:
+    dependencies:
+      micromark-util-symbol: 2.0.1
+
+  micromark-util-classify-character@2.0.1:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-util-combine-extensions@2.0.1:
+    dependencies:
+      micromark-util-chunked: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-util-decode-numeric-character-reference@2.0.2:
+    dependencies:
+      micromark-util-symbol: 2.0.1
+
+  micromark-util-decode-string@2.0.1:
+    dependencies:
+      decode-named-character-reference: 1.1.0
+      micromark-util-character: 2.1.1
+      micromark-util-decode-numeric-character-reference: 2.0.2
+      micromark-util-symbol: 2.0.1
+
+  micromark-util-encode@2.0.1: {}
+
+  micromark-util-events-to-acorn@2.0.3:
+    dependencies:
+      '@types/estree': 1.0.7
+      '@types/unist': 3.0.3
+      devlop: 1.1.0
+      estree-util-visit: 2.0.0
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+      vfile-message: 4.0.2
+
+  micromark-util-html-tag-name@2.0.1: {}
+
+  micromark-util-normalize-identifier@2.0.1:
+    dependencies:
+      micromark-util-symbol: 2.0.1
+
+  micromark-util-resolve-all@2.0.1:
+    dependencies:
+      micromark-util-types: 2.0.2
+
+  micromark-util-sanitize-uri@2.0.1:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-encode: 2.0.1
+      micromark-util-symbol: 2.0.1
+
+  micromark-util-subtokenize@2.1.0:
+    dependencies:
+      devlop: 1.1.0
+      micromark-util-chunked: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-util-symbol@2.0.1: {}
+
+  micromark-util-types@2.0.2: {}
+
+  micromark@4.0.2:
+    dependencies:
+      '@types/debug': 4.1.12
+      debug: 4.4.0
+      decode-named-character-reference: 1.1.0
+      devlop: 1.1.0
+      micromark-core-commonmark: 2.0.3
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-chunked: 2.0.1
+      micromark-util-combine-extensions: 2.0.1
+      micromark-util-decode-numeric-character-reference: 2.0.2
+      micromark-util-encode: 2.0.1
+      micromark-util-normalize-identifier: 2.0.1
+      micromark-util-resolve-all: 2.0.1
+      micromark-util-sanitize-uri: 2.0.1
+      micromark-util-subtokenize: 2.1.0
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mime-db@1.52.0: {}
+
+  mime-types@2.1.35:
+    dependencies:
+      mime-db: 1.52.0
+
+  mime@1.6.0: {}
+
+  mimic-fn@2.1.0: {}
+
+  mimic-response@3.1.0: {}
+
+  mimic-response@4.0.0: {}
+
+  minimatch@3.1.2:
+    dependencies:
+      brace-expansion: 1.1.11
+
+  minipass@3.3.6:
+    dependencies:
+      yallist: 4.0.0
+
+  minipass@5.0.0: {}
+
+  minizlib@2.1.2:
+    dependencies:
+      minipass: 3.3.6
+      yallist: 4.0.0
+
+  mintlify@4.0.453(@types/node@22.13.14)(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1):
+    dependencies:
+      '@mintlify/cli': 4.0.452(@types/node@22.13.14)(@types/react@19.0.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+    transitivePeerDependencies:
+      - '@types/node'
+      - '@types/react'
+      - bare-buffer
+      - bufferutil
+      - debug
+      - encoding
+      - react
+      - react-dom
+      - supports-color
+      - typescript
+      - utf-8-validate
+
+  mitt@3.0.1: {}
+
+  mkdirp@1.0.4: {}
+
+  ms@2.0.0: {}
+
+  ms@2.1.3: {}
+
+  mute-stream@2.0.0: {}
+
+  negotiator@0.6.3: {}
+
+  netmask@2.0.2: {}
+
+  next-mdx-remote-client@1.1.0(@types/react@19.0.12)(acorn@8.14.1)(react-dom@18.3.1(react@18.3.1))(react@18.3.1):
+    dependencies:
+      '@babel/code-frame': 7.26.2
+      '@mdx-js/mdx': 3.1.0(acorn@8.14.1)
+      '@mdx-js/react': 3.1.0(@types/react@19.0.12)(react@18.3.1)
+      react: 18.3.1
+      react-dom: 18.3.1(react@18.3.1)
+      remark-mdx-remove-esm: 1.1.0
+      serialize-error: 12.0.0
+      vfile: 6.0.3
+      vfile-matter: 5.0.1
+    transitivePeerDependencies:
+      - '@types/react'
+      - acorn
+      - supports-color
+
+  nimma@0.2.3:
+    dependencies:
+      '@jsep-plugin/regex': 1.0.4(jsep@1.4.0)
+      '@jsep-plugin/ternary': 1.1.4(jsep@1.4.0)
+      astring: 1.9.0
+      jsep: 1.4.0
+    optionalDependencies:
+      jsonpath-plus: 10.3.0
+      lodash.topath: 4.5.2
+
+  nlcst-to-string@4.0.0:
+    dependencies:
+      '@types/nlcst': 2.0.3
+
+  node-fetch@2.6.7:
+    dependencies:
+      whatwg-url: 5.0.0
+
+  node-fetch@2.7.0:
+    dependencies:
+      whatwg-url: 5.0.0
+
+  normalize-path@3.0.0: {}
+
+  normalize-url@8.0.1: {}
+
+  object-assign@4.1.1: {}
+
+  object-inspect@1.13.4: {}
+
+  object-keys@1.1.1: {}
+
+  object.assign@4.1.7:
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      define-properties: 1.2.1
+      es-object-atoms: 1.1.1
+      has-symbols: 1.1.0
+      object-keys: 1.1.1
+
+  on-finished@2.4.1:
+    dependencies:
+      ee-first: 1.1.1
+
+  once@1.4.0:
+    dependencies:
+      wrappy: 1.0.2
+
+  onetime@5.1.2:
+    dependencies:
+      mimic-fn: 2.1.0
+
+  open@8.4.2:
+    dependencies:
+      define-lazy-prop: 2.0.0
+      is-docker: 2.2.1
+      is-wsl: 2.2.0
+
+  openapi-types@12.1.3: {}
+
+  ora@6.3.1:
+    dependencies:
+      chalk: 5.4.1
+      cli-cursor: 4.0.0
+      cli-spinners: 2.9.2
+      is-interactive: 2.0.0
+      is-unicode-supported: 1.3.0
+      log-symbols: 5.1.0
+      stdin-discarder: 0.1.0
+      strip-ansi: 7.1.0
+      wcwidth: 1.0.1
+
+  os-tmpdir@1.0.2: {}
+
+  own-keys@1.0.1:
+    dependencies:
+      get-intrinsic: 1.3.0
+      object-keys: 1.1.1
+      safe-push-apply: 1.0.0
+
+  p-any@4.0.0:
+    dependencies:
+      p-cancelable: 3.0.0
+      p-some: 6.0.0
+
+  p-cancelable@3.0.0: {}
+
+  p-some@6.0.0:
+    dependencies:
+      aggregate-error: 4.0.1
+      p-cancelable: 3.0.0
+
+  p-timeout@5.1.0: {}
+
+  pac-proxy-agent@7.2.0:
+    dependencies:
+      '@tootallnate/quickjs-emscripten': 0.23.0
+      agent-base: 7.1.3
+      debug: 4.4.0
+      get-uri: 6.0.4
+      http-proxy-agent: 7.0.2
+      https-proxy-agent: 7.0.6
+      pac-resolver: 7.0.1
+      socks-proxy-agent: 8.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  pac-resolver@7.0.1:
+    dependencies:
+      degenerator: 5.0.1
+      netmask: 2.0.2
+
+  parent-module@1.0.1:
+    dependencies:
+      callsites: 3.1.0
+
+  parse-entities@4.0.2:
+    dependencies:
+      '@types/unist': 2.0.11
+      character-entities-legacy: 3.0.0
+      character-reference-invalid: 2.0.1
+      decode-named-character-reference: 1.1.0
+      is-alphanumerical: 2.0.1
+      is-decimal: 2.0.1
+      is-hexadecimal: 2.0.1
+
+  parse-json@5.2.0:
+    dependencies:
+      '@babel/code-frame': 7.26.2
+      error-ex: 1.3.2
+      json-parse-even-better-errors: 2.3.1
+      lines-and-columns: 1.2.4
+
+  parse-latin@7.0.0:
+    dependencies:
+      '@types/nlcst': 2.0.3
+      '@types/unist': 3.0.3
+      nlcst-to-string: 4.0.0
+      unist-util-modify-children: 4.0.0
+      unist-util-visit-children: 3.0.0
+      vfile: 6.0.3
+
+  parse5@7.2.1:
+    dependencies:
+      entities: 4.5.0
+
+  parseurl@1.3.3: {}
+
+  path-to-regexp@0.1.12: {}
+
+  pend@1.2.0: {}
+
+  picocolors@1.1.1: {}
+
+  picomatch@2.3.1: {}
+
+  pony-cause@1.1.1: {}
+
+  possible-typed-array-names@1.1.0: {}
+
+  progress@2.0.3: {}
+
+  property-information@6.5.0: {}
+
+  property-information@7.0.0: {}
+
+  proxy-addr@2.0.7:
+    dependencies:
+      forwarded: 0.2.0
+      ipaddr.js: 1.9.1
+
+  proxy-agent@6.5.0:
+    dependencies:
+      agent-base: 7.1.3
+      debug: 4.4.0
+      http-proxy-agent: 7.0.2
+      https-proxy-agent: 7.0.6
+      lru-cache: 7.18.3
+      pac-proxy-agent: 7.2.0
+      proxy-from-env: 1.1.0
+      socks-proxy-agent: 8.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  proxy-from-env@1.1.0: {}
+
+  public-ip@5.0.0:
+    dependencies:
+      dns-socket: 4.2.2
+      got: 12.6.1
+      is-ip: 3.1.0
+
+  pump@3.0.2:
+    dependencies:
+      end-of-stream: 1.4.4
+      once: 1.4.0
+
+  puppeteer-core@22.15.0:
+    dependencies:
+      '@puppeteer/browsers': 2.3.0
+      chromium-bidi: 0.6.3(devtools-protocol@0.0.1312386)
+      debug: 4.4.0
+      devtools-protocol: 0.0.1312386
+      ws: 8.18.1
+    transitivePeerDependencies:
+      - bare-buffer
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  puppeteer@22.15.0:
+    dependencies:
+      '@puppeteer/browsers': 2.3.0
+      cosmiconfig: 9.0.0
+      devtools-protocol: 0.0.1312386
+      puppeteer-core: 22.15.0
+    transitivePeerDependencies:
+      - bare-buffer
+      - bufferutil
+      - supports-color
+      - typescript
+      - utf-8-validate
+
+  qs@6.13.0:
+    dependencies:
+      side-channel: 1.1.0
+
+  quick-lru@5.1.1: {}
+
+  range-parser@1.2.1: {}
+
+  raw-body@2.5.2:
+    dependencies:
+      bytes: 3.1.2
+      http-errors: 2.0.0
+      iconv-lite: 0.4.24
+      unpipe: 1.0.0
+
+  react-dom@18.3.1(react@18.3.1):
+    dependencies:
+      loose-envify: 1.4.0
+      react: 18.3.1
+      scheduler: 0.23.2
+
+  react@18.3.1:
+    dependencies:
+      loose-envify: 1.4.0
+
+  readable-stream@3.6.2:
+    dependencies:
+      inherits: 2.0.4
+      string_decoder: 1.3.0
+      util-deprecate: 1.0.2
+
+  readdirp@3.6.0:
+    dependencies:
+      picomatch: 2.3.1
+
+  recma-build-jsx@1.0.0:
+    dependencies:
+      '@types/estree': 1.0.7
+      estree-util-build-jsx: 3.0.1
+      vfile: 6.0.3
+
+  recma-jsx@1.0.0(acorn@8.14.1):
+    dependencies:
+      acorn-jsx: 5.3.2(acorn@8.14.1)
+      estree-util-to-js: 2.0.0
+      recma-parse: 1.0.0
+      recma-stringify: 1.0.0
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - acorn
+
+  recma-parse@1.0.0:
+    dependencies:
+      '@types/estree': 1.0.7
+      esast-util-from-js: 2.0.1
+      unified: 11.0.5
+      vfile: 6.0.3
+
+  recma-stringify@1.0.0:
+    dependencies:
+      '@types/estree': 1.0.7
+      estree-util-to-js: 2.0.0
+      unified: 11.0.5
+      vfile: 6.0.3
+
+  reflect.getprototypeof@1.0.10:
+    dependencies:
+      call-bind: 1.0.8
+      define-properties: 1.2.1
+      es-abstract: 1.23.9
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.1
+      get-intrinsic: 1.3.0
+      get-proto: 1.0.1
+      which-builtin-type: 1.2.1
+
+  refractor@4.9.0:
+    dependencies:
+      '@types/hast': 2.3.10
+      '@types/prismjs': 1.26.5
+      hastscript: 7.2.0
+      parse-entities: 4.0.2
+
+  regexp.prototype.flags@1.5.4:
+    dependencies:
+      call-bind: 1.0.8
+      define-properties: 1.2.1
+      es-errors: 1.3.0
+      get-proto: 1.0.1
+      gopd: 1.2.0
+      set-function-name: 2.0.2
+
+  rehype-katex@7.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/katex': 0.16.7
+      hast-util-from-html-isomorphic: 2.0.0
+      hast-util-to-text: 4.0.2
+      katex: 0.16.21
+      unist-util-visit-parents: 6.0.1
+      vfile: 6.0.3
+
+  rehype-minify-whitespace@6.0.2:
+    dependencies:
+      '@types/hast': 3.0.4
+      hast-util-minify-whitespace: 1.0.1
+
+  rehype-parse@9.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      hast-util-from-html: 2.0.3
+      unified: 11.0.5
+
+  rehype-recma@1.0.0:
+    dependencies:
+      '@types/estree': 1.0.7
+      '@types/hast': 3.0.4
+      hast-util-to-estree: 3.1.3
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-frontmatter@5.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-frontmatter: 2.0.1
+      micromark-extension-frontmatter: 2.0.0
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-gfm@4.0.1:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-gfm: 3.1.0
+      micromark-extension-gfm: 3.0.0
+      remark-parse: 11.0.0
+      remark-stringify: 11.0.0
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-math@6.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-math: 3.0.0
+      micromark-extension-math: 3.1.0
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-mdx-remove-esm@1.1.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-mdxjs-esm: 2.0.1
+      unist-util-remove: 4.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-mdx@3.1.0:
+    dependencies:
+      mdast-util-mdx: 3.0.0
+      micromark-extension-mdxjs: 3.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-parse@11.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-from-markdown: 2.0.2
+      micromark-util-types: 2.0.2
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-rehype@11.1.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      mdast-util-to-hast: 13.2.0
+      unified: 11.0.5
+      vfile: 6.0.3
+
+  remark-smartypants@3.0.2:
+    dependencies:
+      retext: 9.0.0
+      retext-smartypants: 6.2.0
+      unified: 11.0.5
+      unist-util-visit: 5.0.0
+
+  remark-stringify@11.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-to-markdown: 2.1.2
+      unified: 11.0.5
+
+  remark@15.0.1:
+    dependencies:
+      '@types/mdast': 4.0.4
+      remark-parse: 11.0.0
+      remark-stringify: 11.0.0
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  require-directory@2.1.1: {}
+
+  require-from-string@2.0.2: {}
+
+  resolve-alpn@1.2.1: {}
+
+  resolve-from@4.0.0: {}
+
+  resolve-pkg-maps@1.0.0: {}
+
+  responselike@3.0.0:
+    dependencies:
+      lowercase-keys: 3.0.0
+
+  restore-cursor@4.0.0:
+    dependencies:
+      onetime: 5.1.2
+      signal-exit: 3.0.7
+
+  retext-latin@4.0.0:
+    dependencies:
+      '@types/nlcst': 2.0.3
+      parse-latin: 7.0.0
+      unified: 11.0.5
+
+  retext-smartypants@6.2.0:
+    dependencies:
+      '@types/nlcst': 2.0.3
+      nlcst-to-string: 4.0.0
+      unist-util-visit: 5.0.0
+
+  retext-stringify@4.0.0:
+    dependencies:
+      '@types/nlcst': 2.0.3
+      nlcst-to-string: 4.0.0
+      unified: 11.0.5
+
+  retext@9.0.0:
+    dependencies:
+      '@types/nlcst': 2.0.3
+      retext-latin: 4.0.0
+      retext-stringify: 4.0.0
+      unified: 11.0.5
+
+  run-async@3.0.0: {}
+
+  rxjs@7.8.2:
+    dependencies:
+      tslib: 2.8.1
+
+  safe-array-concat@1.1.3:
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      get-intrinsic: 1.3.0
+      has-symbols: 1.1.0
+      isarray: 2.0.5
+
+  safe-buffer@5.2.1: {}
+
+  safe-push-apply@1.0.0:
+    dependencies:
+      es-errors: 1.3.0
+      isarray: 2.0.5
+
+  safe-regex-test@1.1.0:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-regex: 1.2.1
+
+  safe-stable-stringify@1.1.1: {}
+
+  safer-buffer@2.1.2: {}
+
+  sax@1.4.1: {}
+
+  scheduler@0.23.2:
+    dependencies:
+      loose-envify: 1.4.0
+
+  section-matter@1.0.0:
+    dependencies:
+      extend-shallow: 2.0.1
+      kind-of: 6.0.3
+
+  semver@7.7.1: {}
+
+  send@0.19.0:
+    dependencies:
+      debug: 2.6.9
+      depd: 2.0.0
+      destroy: 1.2.0
+      encodeurl: 1.0.2
+      escape-html: 1.0.3
+      etag: 1.8.1
+      fresh: 0.5.2
+      http-errors: 2.0.0
+      mime: 1.6.0
+      ms: 2.1.3
+      on-finished: 2.4.1
+      range-parser: 1.2.1
+      statuses: 2.0.1
+    transitivePeerDependencies:
+      - supports-color
+
+  serialize-error@12.0.0:
+    dependencies:
+      type-fest: 4.38.0
+
+  serve-static@1.16.2:
+    dependencies:
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      parseurl: 1.3.3
+      send: 0.19.0
+    transitivePeerDependencies:
+      - supports-color
+
+  set-function-length@1.2.2:
+    dependencies:
+      define-data-property: 1.1.4
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+      get-intrinsic: 1.3.0
+      gopd: 1.2.0
+      has-property-descriptors: 1.0.2
+
+  set-function-name@2.0.2:
+    dependencies:
+      define-data-property: 1.1.4
+      es-errors: 1.3.0
+      functions-have-names: 1.2.3
+      has-property-descriptors: 1.0.2
+
+  set-proto@1.0.0:
+    dependencies:
+      dunder-proto: 1.0.1
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.1
+
+  setprototypeof@1.2.0: {}
+
+  sharp@0.33.5:
+    dependencies:
+      color: 4.2.3
+      detect-libc: 2.0.3
+      semver: 7.7.1
+    optionalDependencies:
+      '@img/sharp-darwin-arm64': 0.33.5
+      '@img/sharp-darwin-x64': 0.33.5
+      '@img/sharp-libvips-darwin-arm64': 1.0.4
+      '@img/sharp-libvips-darwin-x64': 1.0.4
+      '@img/sharp-libvips-linux-arm': 1.0.5
+      '@img/sharp-libvips-linux-arm64': 1.0.4
+      '@img/sharp-libvips-linux-s390x': 1.0.4
+      '@img/sharp-libvips-linux-x64': 1.0.4
+      '@img/sharp-libvips-linuxmusl-arm64': 1.0.4
+      '@img/sharp-libvips-linuxmusl-x64': 1.0.4
+      '@img/sharp-linux-arm': 0.33.5
+      '@img/sharp-linux-arm64': 0.33.5
+      '@img/sharp-linux-s390x': 0.33.5
+      '@img/sharp-linux-x64': 0.33.5
+      '@img/sharp-linuxmusl-arm64': 0.33.5
+      '@img/sharp-linuxmusl-x64': 0.33.5
+      '@img/sharp-wasm32': 0.33.5
+      '@img/sharp-win32-ia32': 0.33.5
+      '@img/sharp-win32-x64': 0.33.5
+
+  side-channel-list@1.0.0:
+    dependencies:
+      es-errors: 1.3.0
+      object-inspect: 1.13.4
+
+  side-channel-map@1.0.1:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      object-inspect: 1.13.4
+
+  side-channel-weakmap@1.0.2:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      object-inspect: 1.13.4
+      side-channel-map: 1.0.1
+
+  side-channel@1.1.0:
+    dependencies:
+      es-errors: 1.3.0
+      object-inspect: 1.13.4
+      side-channel-list: 1.0.0
+      side-channel-map: 1.0.1
+      side-channel-weakmap: 1.0.2
+
+  signal-exit@3.0.7: {}
+
+  signal-exit@4.1.0: {}
+
+  simple-eval@1.0.1:
+    dependencies:
+      jsep: 1.4.0
+
+  simple-swizzle@0.2.2:
+    dependencies:
+      is-arrayish: 0.3.2
+
+  smart-buffer@4.2.0: {}
+
+  socket.io-adapter@2.5.5:
+    dependencies:
+      debug: 4.3.7
+      ws: 8.17.1
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  socket.io-parser@4.2.4:
+    dependencies:
+      '@socket.io/component-emitter': 3.1.2
+      debug: 4.3.7
+    transitivePeerDependencies:
+      - supports-color
+
+  socket.io@4.8.1:
+    dependencies:
+      accepts: 1.3.8
+      base64id: 2.0.0
+      cors: 2.8.5
+      debug: 4.3.7
+      engine.io: 6.6.4
+      socket.io-adapter: 2.5.5
+      socket.io-parser: 4.2.4
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  socks-proxy-agent@8.0.5:
+    dependencies:
+      agent-base: 7.1.3
+      debug: 4.4.0
+      socks: 2.8.4
+    transitivePeerDependencies:
+      - supports-color
+
+  socks@2.8.4:
+    dependencies:
+      ip-address: 9.0.5
+      smart-buffer: 4.2.0
+
+  source-map@0.6.1:
+    optional: true
+
+  source-map@0.7.4: {}
+
+  space-separated-tokens@2.0.2: {}
+
+  sprintf-js@1.0.3: {}
+
+  sprintf-js@1.1.3: {}
+
+  statuses@2.0.1: {}
+
+  stdin-discarder@0.1.0:
+    dependencies:
+      bl: 5.1.0
+
+  streamx@2.22.0:
+    dependencies:
+      fast-fifo: 1.3.2
+      text-decoder: 1.2.3
+    optionalDependencies:
+      bare-events: 2.5.4
+
+  string-width@4.2.3:
+    dependencies:
+      emoji-regex: 8.0.0
+      is-fullwidth-code-point: 3.0.0
+      strip-ansi: 6.0.1
+
+  string.prototype.trim@1.2.10:
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      define-data-property: 1.1.4
+      define-properties: 1.2.1
+      es-abstract: 1.23.9
+      es-object-atoms: 1.1.1
+      has-property-descriptors: 1.0.2
+
+  string.prototype.trimend@1.0.9:
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      define-properties: 1.2.1
+      es-object-atoms: 1.1.1
+
+  string.prototype.trimstart@1.0.8:
+    dependencies:
+      call-bind: 1.0.8
+      define-properties: 1.2.1
+      es-object-atoms: 1.1.1
+
+  string_decoder@1.3.0:
+    dependencies:
+      safe-buffer: 5.2.1
+
+  stringify-entities@4.0.4:
+    dependencies:
+      character-entities-html4: 2.1.0
+      character-entities-legacy: 3.0.0
+
+  strip-ansi@6.0.1:
+    dependencies:
+      ansi-regex: 5.0.1
+
+  strip-ansi@7.1.0:
+    dependencies:
+      ansi-regex: 6.1.0
+
+  strip-bom-string@1.0.0: {}
+
+  style-to-js@1.1.16:
+    dependencies:
+      style-to-object: 1.0.8
+
+  style-to-object@1.0.8:
+    dependencies:
+      inline-style-parser: 0.2.4
+
+  tar-fs@3.0.8:
+    dependencies:
+      pump: 3.0.2
+      tar-stream: 3.1.7
+    optionalDependencies:
+      bare-fs: 4.0.2
+      bare-path: 3.0.0
+    transitivePeerDependencies:
+      - bare-buffer
+
+  tar-stream@3.1.7:
+    dependencies:
+      b4a: 1.6.7
+      fast-fifo: 1.3.2
+      streamx: 2.22.0
+
+  tar@6.2.1:
+    dependencies:
+      chownr: 2.0.0
+      fs-minipass: 2.1.0
+      minipass: 5.0.0
+      minizlib: 2.1.2
+      mkdirp: 1.0.4
+      yallist: 4.0.0
+
+  text-decoder@1.2.3:
+    dependencies:
+      b4a: 1.6.7
+
+  through@2.3.8: {}
+
+  tmp@0.0.33:
+    dependencies:
+      os-tmpdir: 1.0.2
+
+  to-regex-range@5.0.1:
+    dependencies:
+      is-number: 7.0.0
+
+  toidentifier@1.0.1: {}
+
+  tr46@0.0.3: {}
+
+  traverse@0.6.11:
+    dependencies:
+      gopd: 1.2.0
+      typedarray.prototype.slice: 1.0.5
+      which-typed-array: 1.1.19
+
+  trim-lines@3.0.1: {}
+
+  trim-trailing-lines@2.1.0: {}
+
+  trough@2.2.0: {}
+
+  tslib@1.14.1: {}
+
+  tslib@2.8.1: {}
+
+  tsx@4.19.3:
+    dependencies:
+      esbuild: 0.25.1
+      get-tsconfig: 4.10.0
+    optionalDependencies:
+      fsevents: 2.3.3
+
+  type-fest@0.21.3: {}
+
+  type-fest@4.38.0: {}
+
+  type-is@1.6.18:
+    dependencies:
+      media-typer: 0.3.0
+      mime-types: 2.1.35
+
+  typed-array-buffer@1.0.3:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-typed-array: 1.1.15
+
+  typed-array-byte-length@1.0.3:
+    dependencies:
+      call-bind: 1.0.8
+      for-each: 0.3.5
+      gopd: 1.2.0
+      has-proto: 1.2.0
+      is-typed-array: 1.1.15
+
+  typed-array-byte-offset@1.0.4:
+    dependencies:
+      available-typed-arrays: 1.0.7
+      call-bind: 1.0.8
+      for-each: 0.3.5
+      gopd: 1.2.0
+      has-proto: 1.2.0
+      is-typed-array: 1.1.15
+      reflect.getprototypeof: 1.0.10
+
+  typed-array-length@1.0.7:
+    dependencies:
+      call-bind: 1.0.8
+      for-each: 0.3.5
+      gopd: 1.2.0
+      is-typed-array: 1.1.15
+      possible-typed-array-names: 1.1.0
+      reflect.getprototypeof: 1.0.10
+
+  typedarray.prototype.slice@1.0.5:
+    dependencies:
+      call-bind: 1.0.8
+      define-properties: 1.2.1
+      es-abstract: 1.23.9
+      es-errors: 1.3.0
+      get-proto: 1.0.1
+      math-intrinsics: 1.1.0
+      typed-array-buffer: 1.0.3
+      typed-array-byte-offset: 1.0.4
+
+  unbox-primitive@1.1.0:
+    dependencies:
+      call-bound: 1.0.4
+      has-bigints: 1.1.0
+      has-symbols: 1.1.0
+      which-boxed-primitive: 1.1.1
+
+  unbzip2-stream@1.4.3:
+    dependencies:
+      buffer: 5.7.1
+      through: 2.3.8
+
+  undici-types@6.20.0: {}
+
+  unified@11.0.5:
+    dependencies:
+      '@types/unist': 3.0.3
+      bail: 2.0.2
+      devlop: 1.1.0
+      extend: 3.0.2
+      is-plain-obj: 4.1.0
+      trough: 2.2.0
+      vfile: 6.0.3
+
+  unist-builder@4.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-find-after@5.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-is: 6.0.0
+
+  unist-util-is@5.2.1:
+    dependencies:
+      '@types/unist': 2.0.11
+
+  unist-util-is@6.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-map@4.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-modify-children@4.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+      array-iterate: 2.0.1
+
+  unist-util-position-from-estree@2.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-position@5.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-remove-position@5.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-visit: 5.0.0
+
+  unist-util-remove@4.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-is: 6.0.0
+      unist-util-visit-parents: 6.0.1
+
+  unist-util-stringify-position@4.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-visit-children@3.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-visit-parents@5.1.3:
+    dependencies:
+      '@types/unist': 2.0.11
+      unist-util-is: 5.2.1
+
+  unist-util-visit-parents@6.0.1:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-is: 6.0.0
+
+  unist-util-visit@4.1.2:
+    dependencies:
+      '@types/unist': 2.0.11
+      unist-util-is: 5.2.1
+      unist-util-visit-parents: 5.1.3
+
+  unist-util-visit@5.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-is: 6.0.0
+      unist-util-visit-parents: 6.0.1
+
+  universalify@2.0.1: {}
+
+  unpipe@1.0.0: {}
+
+  urijs@1.19.11: {}
+
+  urlpattern-polyfill@10.0.0: {}
+
+  util-deprecate@1.0.2: {}
+
+  utility-types@3.11.0: {}
+
+  utils-merge@1.0.1: {}
+
+  vary@1.1.2: {}
+
+  vfile-location@5.0.3:
+    dependencies:
+      '@types/unist': 3.0.3
+      vfile: 6.0.3
+
+  vfile-matter@5.0.1:
+    dependencies:
+      vfile: 6.0.3
+      yaml: 2.7.0
+
+  vfile-message@4.0.2:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-stringify-position: 4.0.0
+
+  vfile@6.0.3:
+    dependencies:
+      '@types/unist': 3.0.3
+      vfile-message: 4.0.2
+
+  wcwidth@1.0.1:
+    dependencies:
+      defaults: 1.0.4
+
+  web-namespaces@2.0.1: {}
+
+  webidl-conversions@3.0.1: {}
+
+  whatwg-url@5.0.0:
+    dependencies:
+      tr46: 0.0.3
+      webidl-conversions: 3.0.1
+
+  which-boxed-primitive@1.1.1:
+    dependencies:
+      is-bigint: 1.1.0
+      is-boolean-object: 1.2.2
+      is-number-object: 1.1.1
+      is-string: 1.1.1
+      is-symbol: 1.1.1
+
+  which-builtin-type@1.2.1:
+    dependencies:
+      call-bound: 1.0.4
+      function.prototype.name: 1.1.8
+      has-tostringtag: 1.0.2
+      is-async-function: 2.1.1
+      is-date-object: 1.1.0
+      is-finalizationregistry: 1.1.1
+      is-generator-function: 1.1.0
+      is-regex: 1.2.1
+      is-weakref: 1.1.1
+      isarray: 2.0.5
+      which-boxed-primitive: 1.1.1
+      which-collection: 1.0.2
+      which-typed-array: 1.1.19
+
+  which-collection@1.0.2:
+    dependencies:
+      is-map: 2.0.3
+      is-set: 2.0.3
+      is-weakmap: 2.0.2
+      is-weakset: 2.0.4
+
+  which-typed-array@1.1.19:
+    dependencies:
+      available-typed-arrays: 1.0.7
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      for-each: 0.3.5
+      get-proto: 1.0.1
+      gopd: 1.2.0
+      has-tostringtag: 1.0.2
+
+  wrap-ansi@6.2.0:
+    dependencies:
+      ansi-styles: 4.3.0
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+
+  wrap-ansi@7.0.0:
+    dependencies:
+      ansi-styles: 4.3.0
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+
+  wrappy@1.0.2: {}
+
+  ws@8.17.1: {}
+
+  ws@8.18.1: {}
+
+  xml2js@0.6.2:
+    dependencies:
+      sax: 1.4.1
+      xmlbuilder: 11.0.1
+
+  xmlbuilder@11.0.1: {}
+
+  y18n@5.0.8: {}
+
+  yallist@4.0.0: {}
+
+  yaml@2.7.0: {}
+
+  yargs-parser@21.1.1: {}
+
+  yargs@17.7.2:
+    dependencies:
+      cliui: 8.0.1
+      escalade: 3.2.0
+      get-caller-file: 2.0.5
+      require-directory: 2.1.1
+      string-width: 4.2.3
+      y18n: 5.0.8
+      yargs-parser: 21.1.1
+
+  yauzl@2.10.0:
+    dependencies:
+      buffer-crc32: 0.2.13
+      fd-slicer: 1.1.0
+
+  yoctocolors-cjs@2.1.2: {}
+
+  zod-to-json-schema@3.24.5(zod@3.24.2):
+    dependencies:
+      zod: 3.24.2
+
+  zod@3.23.8: {}
+
+  zod@3.24.2: {}
+
+  zwitch@2.0.4: {}
diff --git a/packages/docs/scripts/runtimePaths.js b/packages/docs/scripts/runtimePaths.js
new file mode 100644
index 000000000..7d26efd58
--- /dev/null
+++ b/packages/docs/scripts/runtimePaths.js
@@ -0,0 +1,106 @@
+/**
+ * Keep this file in sync with:
+ * - /packages/core/lib/v3/runtimePaths.ts
+ * - /packages/server-v3/scripts/runtimePaths.ts
+ * - /packages/server-v4/scripts/runtimePaths.ts
+ * - /packages/evals/runtimePaths.ts
+ * - /packages/docs/scripts/runtimePaths.js
+ */
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PACKAGE_SEGMENT = "/packages/docs/";
+const EVAL_FRAMES = new Set(["[eval]", "[eval]-wrapper"]);
+const INTERNAL_FRAME_NAMES = new Set([
+  "readCallsites",
+  "readCallsitePath",
+  "resolveCallerFilePath",
+  "getCurrentFilePath",
+  "getCurrentDirPath",
+  "getRepoRootDir",
+  "isMainModule",
+]);
+
+const normalizePath = (value) => {
+  const input = value.startsWith("file://") ? fileURLToPath(value) : value;
+  return path.resolve(input).replaceAll("\\", "/");
+};
+
+const readCallsites = () => {
+  const previousPrepare = Error.prepareStackTrace;
+  try {
+    Error.prepareStackTrace = (_, stack) => stack;
+    return new Error().stack ?? [];
+  } finally {
+    Error.prepareStackTrace = previousPrepare;
+  }
+};
+
+const readCallsitePath = (callsite) => {
+  const rawPath =
+    callsite.getFileName?.() ?? callsite.getScriptNameOrSourceURL?.();
+  if (!rawPath) return null;
+  if (rawPath.startsWith("node:")) return null;
+  if (EVAL_FRAMES.has(rawPath)) return null;
+  return normalizePath(rawPath);
+};
+
+const isInternalCallsite = (callsite) => {
+  const functionName = callsite.getFunctionName?.();
+  if (functionName && INTERNAL_FRAME_NAMES.has(functionName)) return true;
+
+  const methodName = callsite.getMethodName?.();
+  if (methodName && INTERNAL_FRAME_NAMES.has(methodName)) return true;
+
+  const callsiteString = callsite.toString?.() ?? "";
+  for (const frameName of INTERNAL_FRAME_NAMES) {
+    if (callsiteString.includes(`${frameName} (`)) return true;
+    if (callsiteString.includes(`.${frameName} (`)) return true;
+  }
+  return false;
+};
+
+const resolveCallerFilePath = () => {
+  const packageCandidates = [];
+  const fallbackCandidates = [];
+
+  for (const callsite of readCallsites()) {
+    const filePath = readCallsitePath(callsite);
+    if (!filePath) continue;
+    if (isInternalCallsite(callsite)) continue;
+    if (filePath.includes(PACKAGE_SEGMENT)) {
+      packageCandidates.push(filePath);
+      continue;
+    }
+    fallbackCandidates.push(filePath);
+  }
+
+  const packageCandidate = packageCandidates[0];
+  if (packageCandidate) return packageCandidate;
+
+  const fallbackCandidate = fallbackCandidates[0];
+  if (fallbackCandidate) return fallbackCandidate;
+
+  throw new Error("Unable to resolve caller file path.");
+};
+
+export const getCurrentFilePath = () => resolveCallerFilePath();
+
+export const getCurrentDirPath = () => path.dirname(getCurrentFilePath());
+
+export const getRepoRootDir = () => {
+  const currentFilePath = getCurrentFilePath();
+  const index = currentFilePath.lastIndexOf(PACKAGE_SEGMENT);
+  if (index === -1) {
+    throw new Error(
+      `Unable to determine repo root from ${currentFilePath} (missing ${PACKAGE_SEGMENT}).`,
+    );
+  }
+  return currentFilePath.slice(0, index);
+};
+
+export const isMainModule = () => {
+  const entryScript = process.argv.at(1);
+  if (!entryScript) return false;
+  return normalizePath(entryScript) === getCurrentFilePath();
+};
diff --git a/packages/docs/scripts/sync-sdk-docs.js b/packages/docs/scripts/sync-sdk-docs.js
new file mode 100644
index 000000000..22149c116
--- /dev/null
+++ b/packages/docs/scripts/sync-sdk-docs.js
@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+
+/**
+ * Script to sync SDK documentation from GitHub READMEs
+ * 
+ * Usage: node scripts/sync-sdk-docs.js
+ * 
+ * This script fetches README.md files from each language SDK repo
+ * and generates MDX files for the docs.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import https from "node:https";
+import { getCurrentDirPath } from "./runtimePaths.js";
+
+const currentDir = getCurrentDirPath();
+
+// SDK repos configuration
+const SDK_REPOS = {
+  java: {
+    repo: 'browserbase/stagehand-java',
+    title: 'Java SDK',
+    description: 'Official Stagehand SDK for Java',
+    outputPath: 'v3/sdk/java.mdx'
+  },
+  python: {
+    repo: 'browserbase/stagehand-python',
+    title: 'Python SDK',
+    description: 'Official Stagehand SDK for Python',
+    outputPath: 'v3/sdk/python.mdx'
+  },
+  ruby: {
+    repo: 'browserbase/stagehand-ruby',
+    title: 'Ruby SDK',
+    description: 'Official Stagehand SDK for Ruby',
+    outputPath: 'v3/sdk/ruby.mdx'
+  },
+  go: {
+    repo: 'browserbase/stagehand-go',
+    title: 'Go SDK',
+    description: 'Official Stagehand SDK for Go',
+    outputPath: 'v3/sdk/go.mdx'
+  }
+};
+
+/**
+ * Fetch content from a URL
+ */
+function fetchUrl(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, {
+      headers: {
+        'User-Agent': 'Stagehand-Docs-Sync'
+      }
+    }, (res) => {
+      // Handle redirects
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        fetchUrl(res.headers.location).then(resolve).catch(reject);
+        return;
+      }
+      
+      if (res.statusCode !== 200) {
+        reject(new Error(`HTTP ${res.statusCode}: ${url}`));
+        return;
+      }
+      
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => resolve(data));
+      res.on('error', reject);
+    }).on('error', reject);
+  });
+}
+
+/**
+ * Process README content for MDX compatibility
+ */
+function processReadmeContent(content, config) {
+  let processed = content;
+  
+  // Remove HTML comments
+  processed = processed.replace(/<!--[\s\S]*?-->/g, '');
+  
+  // Remove entire HTML blocks with picture/source tags (badge sections)
+  processed = processed.replace(/<div[^>]*>[\s\S]*?<\/div>/gi, '');
+  processed = processed.replace(/<p[^>]*align[^>]*>[\s\S]*?<\/p>/gi, '');
+  processed = processed.replace(/<picture>[\s\S]*?<\/picture>/gi, '');
+  
+  // Remove standalone HTML tags
+  processed = processed.replace(/<a[^>]*>[\s]*<img[^>]*>[\s]*<\/a>/gi, '');
+  processed = processed.replace(/<img[^>]*badge[^>]*>/gi, '');
+  processed = processed.replace(/<img[^>]*shields\.io[^>]*>/gi, '');
+  processed = processed.replace(/<a[^>]*>\s*<picture>[\s\S]*?<\/picture>\s*<\/a>/gi, '');
+  
+  // Remove badge images in markdown format
+  processed = processed.replace(/^\s*(\[!\[.*?\]\(.*?\)\]\(.*?\)\s*)+/gm, '');
+  processed = processed.replace(/^\s*!\[.*?\]\(https:\/\/.*?badge.*?\)\s*/gm, '');
+  processed = processed.replace(/\[!\[.*?\]\(.*?badge.*?\)\]\(.*?\)/g, '');
+  
+  // Remove standalone anchor img tags
+  processed = processed.replace(/<a[^>]*href[^>]*><img[^>]*><\/a>/gi, '');
+  
+  // Clean up <code> tags with backticks inside (common in Go docs)
+  processed = processed.replace(/<code>\\`([^`]*?)\\`<\/code>/g, '`$1`');
+  processed = processed.replace(/<code>`([^`]*?)`<\/code>/g, '`$1`');
+  processed = processed.replace(/<code>([^<]*?)<\/code>/g, '`$1`');
+  
+  // Fix malformed links with parentheses in URL (Go docs issue)
+  processed = processed.replace(/\[([^\]]+)\]\(([^)]+)\(([^)]+)\)([^)]*)\)/g, '[$1]($2)');
+  
+  // Convert relative links to absolute GitHub links
+  const repoUrl = `https://github.com/${config.repo}`;
+  processed = processed.replace(/\]\((?!http)(?!#)(?!mailto)([^)]+)\)/g, `](${repoUrl}/blob/main/$1)`);
+  
+  // Fix code block language hints for MDX
+  processed = processed.replace(/```kotlin/g, '```java');
+  
+  // Remove the first H1 if it exists (we'll add our own title)
+  processed = processed.replace(/^#\s+.*\n+/, '');
+  
+  // Clean up excessive newlines
+  processed = processed.replace(/\n{4,}/g, '\n\n\n');
+  
+  // Remove any remaining inline HTML img tags
+  processed = processed.replace(/<img[^>]*>/gi, '');
+  
+  // Remove any remaining <a> tags that are empty or just whitespace
+  processed = processed.replace(/<a[^>]*>\s*<\/a>/gi, '');
+  
+  // Clean up lines that are just whitespace
+  processed = processed.replace(/^\s+$/gm, '');
+  
+  return processed.trim();
+}
+
+/**
+ * Generate MDX frontmatter
+ */
+function generateFrontmatter(config) {
+  return `---
+title: "${config.title}"
+description: "${config.description}"
+---
+
+<Note>
+  This documentation is automatically synced from the [${config.title} GitHub repository](https://github.com/${config.repo}).
+</Note>
+
+`;
+}
+
+/**
+ * Sync a single SDK's documentation
+ */
+async function syncSdk(language, config) {
+  const rawUrl = `https://raw.githubusercontent.com/${config.repo}/main/README.md`;
+  
+  console.log(`Fetching ${language} SDK docs from ${rawUrl}...`);
+  
+  try {
+    const readme = await fetchUrl(rawUrl);
+    const processedContent = processReadmeContent(readme, config);
+    const frontmatter = generateFrontmatter(config);
+    const mdxContent = frontmatter + processedContent;
+    
+    // Ensure directory exists
+    const outputDir = path.dirname(`${currentDir}/../${config.outputPath}`);
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+    
+    // Write MDX file
+    const outputFile = `${currentDir}/../${config.outputPath}`;
+    fs.writeFileSync(outputFile, mdxContent, 'utf8');
+    
+    console.log(`✓ ${language} SDK docs written to ${config.outputPath}`);
+    return true;
+  } catch (error) {
+    console.error(`✗ Failed to sync ${language} SDK: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  console.log('Syncing SDK documentation from GitHub...\n');
+  
+  const results = await Promise.all(
+    Object.entries(SDK_REPOS).map(([lang, config]) => syncSdk(lang, config))
+  );
+  
+  const successCount = results.filter(Boolean).length;
+  const totalCount = results.length;
+  
+  console.log(`\nDone! ${successCount}/${totalCount} SDKs synced successfully.`);
+  
+  if (successCount < totalCount) {
+    process.exit(1);
+  }
+}
+
+main().catch(error => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});
diff --git a/packages/docs/snippets/excalidraw.mdx b/packages/docs/snippets/excalidraw.mdx
new file mode 100644
index 000000000..17bc8e7a9
--- /dev/null
+++ b/packages/docs/snippets/excalidraw.mdx
@@ -0,0 +1,21 @@
+export const Excalidraw = ({ url, className = "w-full" }) => {
+	return (
+		<>
+			<div className="dark:hidden" >
+				<iframe
+					src={url + `?darkMode=false`}
+					className={className}
+					allowFullScreen
+				></iframe>
+			</div>
+
+			<div className="hidden dark:block">
+				<iframe
+					src={url + `?darkMode=true`}
+					className={className}
+					allowFullScreen
+				></iframe>
+			</div>
+		</>
+	)
+}
\ No newline at end of file
diff --git a/packages/docs/snippets/v3-banner.mdx b/packages/docs/snippets/v3-banner.mdx
new file mode 100644
index 000000000..01ca5b521
--- /dev/null
+++ b/packages/docs/snippets/v3-banner.mdx
@@ -0,0 +1,10 @@
+{/* 
+  V3Banner - Currently a no-op component
+  
+  This component is imported across 50+ pages in v3 docs.
+  Keeping it as a no-op rather than removing allows us to easily 
+  add a new banner message in the future without editing every file.
+  
+  To add a banner, replace the null return with your JSX content.
+*/}
+export const V3Banner = () => null;
diff --git a/packages/docs/v2/basics/act.mdx b/packages/docs/v2/basics/act.mdx
new file mode 100644
index 000000000..4ac521be0
--- /dev/null
+++ b/packages/docs/v2/basics/act.mdx
@@ -0,0 +1,505 @@
+---
+title: Act
+description: 'Interact with a web page'
+---
+
+## What is `act()`?
+``` typescript
+page.act("click on add to cart")
+```
+`act` enables Stagehand to perform **individual** actions on a web page. Use it to build self-healing and deterministic automations that adapt to website changes. 
+
+## Why use `act()`?
+
+<CardGroup cols={2}>
+  <Card title="Natural Language Instructions" icon="wand-magic-sparkles" href="#using-act">
+    Write automation in plain English. No selectors or complex syntax.
+  </Card>
+  <Card title="Precise Control" icon="crosshairs" href="#best-practices">
+    Build automations step by step. Define exactly what happens at every moment.
+  </Card>
+  <Card title="Self-Healing" icon="bandage" href="#ensure-reliable-actions">
+    Actions automatically adapt when websites change.
+  </Card>
+  <Card title="Caching" icon="repeat" href="#reduce-model-costs">
+    Cache actions to avoid LLM calls and ensure consistent execution across runs.
+  </Card>
+</CardGroup>
+
+## Using `act()`
+
+Use `act` to perform single actions in your automation. Here's how to click a button:
+
+<CodeGroup>
+```typescript TypeScript
+await page.goto("https://example-store.com");
+await page.act("click the add to cart button");
+```
+
+```python Python
+await page.goto("https://example-store.com")
+await page.act("click the add to cart button")
+```
+</CodeGroup>
+
+With `act`, breaking complex actions into small, single-step actions works best. If you need to orchestrate multi-step flows, use multiple `act` commands or `agent`.
+
+<Accordion title="Suggested actions">
+
+| Action | Example instruction |
+|--------|---------------------|
+| Click | `click the button` |
+| Fill | `fill the field with <value>` |
+| Type | `type <text> into the search box` |
+| Press | `press <key> in the search field` |
+| Scroll | `scroll to <position>` |
+| Select from dropdown | `select <value> from the dropdown` |
+</Accordion>
+
+<Tabs>
+<Tab title="Do this">
+Break your task into single-step actions.
+
+<CodeGroup>
+```typescript TypeScript
+// Break it into single-step actions
+await page.act("open the filters panel");
+await page.act("choose 4-star rating");
+await page.act("click the apply button");
+```
+
+```python Python
+# Break it into single-step actions
+await page.act("open the filters panel")
+await page.act("choose 4-star rating")
+await page.act("click the apply button")
+```
+</CodeGroup>
+</Tab>
+
+<Tab title="Don't do this">
+For multi-step tasks, use [`agent()`](/v2/basics/agent) instead.
+
+<CodeGroup>
+```typescript TypeScript
+// Too complex - trying to do multiple things at once
+await page.act("open the filters panel, choose 4-star rating, and click apply");
+```
+
+```python Python
+# Too complex - trying to do multiple things at once
+await page.act("open the filters panel, choose 4-star rating, and click apply")
+```
+</CodeGroup>
+</Tab>
+</Tabs>
+
+### Advanced Configuration
+
+For advanced scenarios, you can configure additional options:
+
+<CodeGroup>
+```typescript TypeScript
+// Dynamic food search with advanced options
+const foodItem = "organic quinoa";
+
+await page.act({
+  action: "Type %foodItem% in the search box and press enter",
+  variables: {
+    foodItem: foodItem
+  },
+  modelName: "google/gemini-2.5-pro",
+  modelClientOptions: {
+    modelApiKey: process.env.GOOGLE_API_KEY,
+  },
+  iframes: true, // Search within iframes if needed
+  domSettleTimeoutMs: 45000, // Wait longer for dynamic content
+  timeoutMs: 60000 // Extended timeout for slow-loading forms
+});
+```
+
+```python Python
+# Dynamic food search with advanced options
+food_item = "organic quinoa"
+
+await page.act({
+  "action": "Type %foodItem% in the search box and press enter",
+  "variables": {
+    "foodItem": food_item
+  },
+  "modelName": "google/gemini-2.5-pro",
+  "modelClientOptions": {
+    "modelApiKey": os.environ.get("GOOGLE_API_KEY")
+  },
+  "iframes": True, # Search within iframes if needed
+  "domSettleTimeoutMs": 45000, # Wait longer for dynamic content
+  "timeoutMs": 60000 # Extended timeout for slow-loading forms
+})
+```
+</CodeGroup>
+  
+<Note>
+Shadow DOM support is now available! Set `experimental: true` in your Stagehand configuration to enable it. See the [configuration guide](/v2/configuration/browser) for more details.
+</Note>
+
+
+
+
+
+## Best practices
+
+### Ensure reliable actions
+
+Use `observe()` to discover candidate actions on the current page and plan reliably. It returns a list of suggested actions (with selector, description, method, and arguments). You can pass an observed action directly to `act` to execute it.
+
+<CodeGroup>
+```typescript TypeScript
+const [action] = await page.observe("click the login button");
+
+if (action) {
+  await page.act(action);
+}
+```
+
+```python Python
+results = await page.observe("click the login button")
+
+if results:
+    await page.act(results[0])
+```
+</CodeGroup>
+
+<Card title="Analyze pages with observe()" icon="magnifying-glass" iconType="sharp-solid" href="/v2/basics/observe">
+  Plan actions with `observe()` before executing with `act`.
+</Card>
+
+### Reduce model costs
+
+Cache observed actions to avoid repeated LLM calls and ensure consistent execution.
+
+<CodeGroup>
+```typescript TypeScript
+// Cost-optimized actions with caching
+const actionCache = new Map();
+
+const getCachedAction = async (instruction: string) => {
+  if (actionCache.has(instruction)) {
+    return actionCache.get(instruction);
+  }
+  
+  const [action] = await page.observe(instruction);
+  actionCache.set(instruction, action);
+  return action;
+};
+
+// Reuse cached actions
+const loginAction = await getCachedAction("click the login button");
+await page.act(loginAction);
+```
+
+```python Python
+# Cost-optimized actions with caching
+action_cache = {}
+
+async def get_cached_action(instruction: str):
+    if instruction in action_cache:
+        return action_cache[instruction]
+    
+    results = await page.observe(instruction)
+    if results:
+        action = results[0]
+        action_cache[instruction] = action
+        return action
+    
+    return None
+
+# Reuse cached actions
+login_action = await get_cached_action("click the login button")
+if login_action:
+    await page.act(login_action)
+```
+</CodeGroup>
+
+<Card title="Complete caching guide" icon="database" iconType="sharp-solid" href="/v2/best-practices/caching">
+  Learn advanced caching techniques and patterns for optimal performance.
+</Card>
+
+### Secure your automations
+
+Variables will not be shared with LLM providers. Use them for passwords, API keys, and other sensitive data.
+
+
+<Note>
+Load sensitive data from environment variables using `.env` files. Never hardcode API keys, passwords, or other secrets directly in your code.
+</Note>
+
+<CodeGroup>
+```typescript TypeScript
+await page.act({
+  action: "enter %username% in the email field",
+  variables: {
+    username: "user@example.com"
+  }
+});
+
+await page.act({
+  action: "enter %password% in the password field",
+  variables: {
+    password: process.env.USER_PASSWORD
+  }
+});
+```
+
+```python Python
+# If using Python, set `use_api: true` in your Stagehand configuration
+
+await page.act(
+  "enter %username% in the email field",
+  variables={
+      "username": "user@example.com"
+  }
+)
+
+await page.act(
+  "enter %password% in the password field",
+  variables={
+      "password": os.environ.get("USER_PASSWORD")
+  }
+)
+```
+</CodeGroup>
+
+<Warning>
+When handling sensitive data, set `verbose: 0` in your Stagehand configuration to prevent secrets from appearing in logs. See the [configuration guide](/v2/configuration/browser) for more details.
+</Warning>
+
+<Card title="User Data Best Practices" icon="shield-check" iconType="sharp-solid" href="/v2/best-practices/user-data">
+  Complete guide to securing your browser automations with best practices and configurations.
+</Card>
+
+## Troubleshooting
+
+<AccordionGroup>
+
+
+<Accordion title="Method not supported">
+**Problem**: `act` fails with "method not supported" error
+
+**Solutions**:
+- Use clear and detailed instructions for what you want to accomplish
+- Review our [evals](https://stagehand.dev/evals) to find the best models for your use case
+- Use [`observe()`](/v2/basics/observe) and verify the resulting action is within a list of expected actions
+
+**Solution 1: Validate with observe**
+
+<CodeGroup>
+```typescript TypeScript
+const prompt = "click the submit button";
+const expectedMethod = "click";
+
+try {
+  await page.act(prompt);
+} catch (error) {
+  if (error.message.includes("method not supported")) {
+    // Observe the same prompt to get the planned action
+    const [action] = await page.observe(prompt);
+    
+    if (action && action.method === expectedMethod) {
+      await page.act(action);
+    } else {
+      throw new Error(`Unsupported method: expected "${expectedMethod}", got "${action?.method}"`);
+    }
+  } else {
+    throw error;
+  }
+}
+```
+
+```python Python
+prompt = "click the submit button"
+expected_method = "click"
+
+try:
+    await page.act(prompt)
+except Exception as error:
+    if "method not supported" in str(error):
+        # Observe the same prompt to get the planned action
+        results = await page.observe(prompt)
+        
+        if results and results[0].method == expected_method:
+            await page.act(results[0])
+        else:
+            method = results[0].method if results else "unknown"
+            raise Exception(f'Unsupported method: expected "{expected_method}", got "{method}"')
+    else:
+        raise error
+```
+</CodeGroup>
+
+**Solution 2: Retry with exponential backoff**
+
+<CodeGroup>
+```typescript TypeScript
+// Retry with exponential backoff for intermittent issues
+const prompt = "click the submit button";
+const maxRetries = 3;
+
+for (let attempt = 0; attempt <= maxRetries; attempt++) {
+  try {
+    await page.act(prompt, { timeoutMs: 10000 + (attempt * 5000) });
+    break; // Success, exit retry loop
+  } catch (error) {
+    if (error.message.includes("method not supported") && attempt < maxRetries) {
+      // Exponential backoff: wait 2^attempt seconds
+      const delay = Math.pow(2, attempt) * 1000;
+      console.log(`Retry ${attempt + 1}/${maxRetries} after ${delay}ms`);
+      await new Promise(resolve => setTimeout(resolve, delay));
+    } else {
+      throw error;
+    }
+  }
+}
+```
+
+```python Python
+# Retry with exponential backoff for intermittent issues
+import asyncio
+
+prompt = "click the submit button"
+max_retries = 3
+
+for attempt in range(max_retries + 1):
+    try:
+        timeout = 10000 + (attempt * 5000)
+        await page.act(prompt, {"timeoutMs": timeout})
+        break  # Success, exit retry loop
+    except Exception as error:
+        if "method not supported" in str(error) and attempt < max_retries:
+            # Exponential backoff: wait 2^attempt seconds
+            delay = 2 ** attempt
+            print(f"Retry {attempt + 1}/{max_retries} after {delay}s")
+            await asyncio.sleep(delay)
+        else:
+            raise error
+```
+</CodeGroup>
+
+</Accordion>
+
+<Accordion title="Action failed or timed out">
+**Problem**: `act` times out or fails to complete action (often due to element not found)
+
+**Solutions**:
+- Ensure page has fully loaded
+- Check if content is in iframes: [Learn more about working with iframes](/v2/best-practices/working-with-iframes)
+- Increase action timeout
+- Use `observe()` first to verify element exists
+
+<CodeGroup>
+```typescript TypeScript
+// Handle timeout and element not found issues
+try {
+  await page.act("click the submit button", { timeout: 30000 });
+} catch (error) {
+  // Check if page is fully loaded
+  await page.waitForLoadState('domcontentloaded');
+  
+  // Use observe to check element state
+  const [element] = await page.observe("find the submit button");
+  
+  if (element) {
+    console.log("Element found, trying more specific instruction");
+    await page.act("click the submit button at the bottom of the form");
+  } else {
+    console.log("Element not found, trying alternative selector");
+    await page.act("click the button with text 'Submit'");
+  }
+}
+```
+
+```python Python
+# Handle timeout and element not found issues
+try:
+    await page.act("click the submit button", {"timeout": 30000})
+except Exception as error:
+    # Check if page is fully loaded
+    await page.wait_for_load_state('domcontentloaded')
+    
+    # Use observe to check element state
+    results = await page.observe("find the submit button")
+    
+    if results:
+        print("Element found, trying more specific instruction")
+        await page.act("click the submit button at the bottom of the form")
+    else:
+        print("Element not found, trying alternative selector")
+        await page.act("click the button with text 'Submit'")
+```
+</CodeGroup>
+</Accordion>
+
+<Accordion title="Incorrect element selected">
+**Problem**: `act` performs action on wrong element
+
+**Solutions**:
+- Be more specific in instructions: include visual cues, position, or context
+- Use `observe()` to preview which element will be selected
+- Add contextual information: "the search button in the header"
+- Use unique identifiers when available
+
+<CodeGroup>
+```typescript TypeScript
+// More precise element targeting
+// Instead of:
+await page.act("click the button");
+
+// Use specific context:
+await page.act("click the red 'Delete' button next to the user John Smith");
+
+// Or preview with observe first:
+const [action] = await page.observe("click the submit button in the checkout form");
+if (action.description.includes("checkout")) {
+  await page.act(action);
+}
+```
+
+```python Python
+# More precise element targeting
+# Instead of:
+await page.act("click the button")
+
+# Use specific context:
+await page.act("click the red 'Delete' button next to the user John Smith")
+
+# Or preview with observe first:
+results = await page.observe("click the submit button in the checkout form")
+if results and "checkout" in results[0].description:
+    await page.act(results[0])
+```
+</CodeGroup>
+</Accordion>
+
+
+
+</AccordionGroup>
+
+## Next steps
+
+<CardGroup cols={2}>
+
+  <Card title="Orchestrate complex workflows with Agent" icon="robot" iconType="sharp-solid" href="/v2/basics/agent">
+    Use `Agent` to autonomously execute multi-step tasks and complex workflows.
+  </Card>
+
+   <Card title="Caching actions" icon="bolt" iconType="sharp-solid" href="/v2/best-practices/caching">
+    Speed up repeated automations by caching actions.
+  </Card>
+
+  <Card title="Extract data with extract()" icon="table" iconType="sharp-solid" href="/v2/basics/extract">
+    Use `extract` with a data schema to pull clean, typed data from any page.
+  </Card>
+
+  <Card title="Working with iframes" icon="frame" iconType="sharp-solid" href="/v2/best-practices/working-with-iframes">
+    Learn best practices for interacting with elements inside iframes.
+  </Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/basics/agent.mdx b/packages/docs/v2/basics/agent.mdx
new file mode 100644
index 000000000..d55781ef0
--- /dev/null
+++ b/packages/docs/v2/basics/agent.mdx
@@ -0,0 +1,313 @@
+---
+title: Agent
+description: 'Automate complex workflows with AI powered browser agents'
+---
+
+## What is `agent()?`
+
+``` typescript
+agent.execute("apply for a job at browserbase")
+```
+`agent` turns high level tasks into **fully autonomous** browser workflows. You can customize the agent by specifying the LLM provider and model, setting custom instructions for behavior, and configuring max steps.
+
+<img src="/images/agent.gif" alt="Agent" />
+
+## Why use `agent()`?
+
+<CardGroup cols={2}>
+  <Card title="Multi-Step Workflows" icon="route" href="#agent-execution-configuration">
+    Execute complex sequences automatically.
+  </Card>
+  <Card title="Visual Understanding" icon="eye" href="/v2/best-practices/computer-use">
+    Sees and understands web interfaces like humans do using computer vision.
+  </Card>
+</CardGroup>
+
+
+## Using `agent()`
+
+There are two ways to create agents in Stagehand:
+
+### Computer Use Agents
+
+Use computer use agents with specialized models from OpenAI or Anthropic: 
+
+<CodeGroup>
+```typescript TypeScript
+const agent = stagehand.agent({
+  provider: "anthropic",
+  model: "claude-sonnet-4-20250514",
+  instructions: "You are a helpful assistant that can use a web browser.",
+  options: {
+    apiKey: process.env.ANTHROPIC_API_KEY,
+  },
+});
+await agent.execute("apply for a job at Browserbase")
+```
+
+```python Python
+agent = stagehand.agent(
+    model="claude-sonnet-4-20250514",
+    instructions="You are a helpful assistant that can use a web browser.",
+    options={
+        "api_key": os.getenv("ANTHROPIC_API_KEY"),
+    },
+)
+await agent.execute("apply for a job at Browserbase")
+```
+</CodeGroup>
+
+<Callout icon="code" color="#6ec202" iconType="regular">View or run the example template [here](https://www.browserbase.com/templates/gemini-cua)</Callout>
+
+### Use Stagehand Agent with Any LLM
+
+Use the agent without specifying a provider to utilize any model or LLM provider:
+
+<Note>Non CUA agents are currently only supported in TypeScript</Note>
+
+```typescript TypeScript
+const agent = stagehand.agent();
+await agent.execute("apply for a job at Browserbase")
+```
+
+
+## MCP Integrations
+
+Agents can be enhanced with external tools and services through MCP (Model Context Protocol) integrations. This allows your agent to access external APIs and data sources beyond just browser interactions.
+
+<CodeGroup>
+```typescript TypeScript (Pass URL)
+const agent = stagehand.agent({
+  provider: "openai",
+  model: "computer-use-preview",
+  integrations: [
+    `https://mcp.exa.ai/mcp?exaApiKey=${process.env.EXA_API_KEY}`,
+  ],
+  instructions: `You have access to web search through Exa. Use it to find current information before browsing.`,
+  options: {
+    apiKey: process.env.OPENAI_API_KEY,
+  },
+});
+
+await agent.execute("Search for the best headphones of 2025 and go through checkout for the top recommendation");
+```
+
+```typescript TypeScript (Create Connection)
+import { connectToMCPServer } from "@browserbasehq/stagehand";
+
+const supabaseClient = await connectToMCPServer(
+  `https://server.smithery.ai/@supabase-community/supabase-mcp/mcp?api_key=${process.env.SMITHERY_API_KEY}`
+);
+
+const agent = stagehand.agent({
+  provider: "openai",
+  model: "computer-use-preview",
+  integrations: [supabaseClient],
+  instructions: `You can interact with Supabase databases. Use these tools to store and retrieve data.`,
+  options: {
+    apiKey: process.env.OPENAI_API_KEY,
+  },
+});
+
+await agent.execute("Search for restaurants and save the first result to the database");
+```
+</CodeGroup>
+
+<Tip>
+MCP integrations enable agents to be more powerful by combining browser automation with external APIs, databases, and services. The agent can intelligently decide when to use browser actions versus external tools.
+</Tip>
+
+<Warning>
+Stagehand uses a 1288x711 viewport by default (the optimal size for Computer Use Agents). Other viewport sizes may reduce performance. If you need to modify the viewport, you can edit in the [Browser Configuration](/v2/configuration/browser).
+</Warning>
+
+
+## Available Models
+
+Use specialized computer use models (e.g., `computer-use-preview` from OpenAI or `claude-sonnet-4-20250514` from Anthropic)
+
+<Card title="Available Models" icon="robot" href="/v2/configuration/models">
+  Check out the guide on how to use different models with Stagehand.
+</Card>
+
+## Agent Execution Configuration
+
+Control the maximum number of steps the agent can take to complete the task using the `maxSteps` parameter.
+
+<CodeGroup>
+```typescript TypeScript
+// Set maxSteps to control how many actions the agent can take
+await agent.execute({
+  instruction: "Sign me up for a library card",
+  maxSteps: 15 // Agent will stop after 15 steps if task isn't complete
+});
+```
+
+```python Python
+# Set max_steps to control how many actions the agent can take
+result = await agent.execute({
+    "instruction": "Sign me up for a library card",
+    "max_steps": 15  # Agent will stop after 15 steps if task isn't complete
+})
+```
+</CodeGroup>
+
+For complex tasks, increase the `maxSteps` limit and check task success.
+
+<CodeGroup>
+```typescript TypeScript
+// Complex multi-step task requiring more actions
+const result = await agent.execute({
+  instruction: "Find and apply for software engineering jobs, filtering by remote work and saving 3 applications",
+  maxSteps: 30, // Higher limit for complex workflows
+});
+
+// Check if the task completed successfully
+if (result.success === true) {
+  console.log("Task completed successfully!");
+} else {
+  console.log("Task failed or was incomplete");
+}
+```
+
+```python Python
+# Complex multi-step task requiring more actions
+result = await agent.execute({
+    "instruction": "Find and apply for software engineering jobs, filtering by remote work and saving 3 applications",
+    "max_steps": 30  # Higher limit for complex workflows
+})
+
+# Check if the task completed successfully
+if result.success == True:
+    print("Task completed successfully!")
+else:
+    print("Task failed or was incomplete")
+```
+</CodeGroup>
+
+## Best Practices
+
+Following these best practices will improve your agent's success rate, reduce execution time, and minimize unexpected errors during task completion.
+
+### Start on the Right Page
+Navigate to your target page before executing tasks:
+
+<Tabs>
+<Tab title="Do this">
+<CodeGroup>
+```typescript TypeScript
+await page.goto('https://github.com/browserbase/stagehand');
+await agent.execute('Get me the latest PR on the stagehand repo');
+```
+
+```python Python
+await page.goto("https://github.com/browserbase/stagehand")
+result = await agent.execute("Get me the latest PR on the stagehand repo")
+```
+</CodeGroup>
+</Tab>
+
+<Tab title="Don't do this">
+<CodeGroup>
+```typescript TypeScript
+await agent.execute('Go to GitHub and find the latest PR on browserbase/stagehand');
+```
+
+```python Python
+result = await agent.execute("Go to GitHub and find the latest PR on browserbase/stagehand")
+```
+</CodeGroup>
+</Tab>
+</Tabs>
+
+
+### Be Specific
+Provide detailed instructions for better results:
+
+<Tabs>
+<Tab title="Do this">
+<CodeGroup>
+```typescript TypeScript
+await agent.execute("Find Italian restaurants in Brooklyn that are open after 10pm and have outdoor seating");
+```
+
+```python Python
+result = await agent.execute("Find Italian restaurants in Brooklyn that are open after 10pm and have outdoor seating")
+```
+</CodeGroup>
+</Tab>
+
+<Tab title="Don't do this">
+<CodeGroup>
+```typescript TypeScript
+await agent.execute("Find a restaurant");
+```
+
+```python Python
+result = await agent.execute("Find a restaurant")
+```
+</CodeGroup>
+</Tab>
+</Tabs>
+
+## Troubleshooting
+
+<AccordionGroup>
+
+
+<Accordion title="Agent is stopping before completing the task">
+**Problem**: Agent stops before finishing the requested task
+
+**Solutions**:
+- Check if the agent is hitting the maxSteps limit (default is 20)
+- Increase maxSteps for complex tasks: `maxSteps: 30` or higher
+- Break very complex tasks into smaller sequential executions
+
+```typescript
+// Increase maxSteps for complex tasks
+await agent.execute({
+  instruction: "Complete the multi-page registration form with all required information",
+  maxSteps: 40 // Increased limit for complex task
+});
+
+// Or break into smaller tasks with success checking
+const firstResult = await agent.execute({
+  instruction: "Fill out page 1 of the registration form", 
+  maxSteps: 15
+});
+
+// Only proceed if the first task was successful
+if (firstResult.success === true) {
+  await agent.execute({
+    instruction: "Navigate to page 2 and complete remaining fields",
+    maxSteps: 15
+  });
+} else {
+  console.log("First task failed, stopping execution");
+}
+```
+</Accordion>
+
+<Accordion title="Agent is failing to click the proper elements">
+**Problem**: Agent clicks on wrong elements or fails to interact with the correct UI components
+
+**Solutions**:
+- Ensure proper viewport size: Stagehand uses `1288x711` by default (optimal for Computer Use models)
+- Avoid changing viewport dimensions as other sizes may reduce performance
+</Accordion>
+
+
+</AccordionGroup>
+
+
+## Next steps
+
+<CardGroup cols={2}>
+<Card title="Act" icon="play" href="/v2/basics/act">
+  Execute actions efficiently using observe results
+</Card>
+
+<Card title="Extract" icon="download" href="/v2/basics/extract">
+  Extract structured data from observed elements
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/basics/extract.mdx b/packages/docs/v2/basics/extract.mdx
new file mode 100644
index 000000000..33f0f9134
--- /dev/null
+++ b/packages/docs/v2/basics/extract.mdx
@@ -0,0 +1,433 @@
+---
+title: Extract
+description: Extract structured data from a webpage
+---
+
+## What is `extract()`?
+
+```typescript
+page.extract("extract the name of the repository");
+```
+
+`extract` grabs structured data from a webpage. You can define your schema with [zod](https://github.com/colinhacks/zod) (TypeScript) or [pydantic](https://github.com/pydantic/pydantic) (Python). If you do not want to define a schema, you can also call `extract` with just a [natural language prompt](#prompt-only-extraction), or call `extract` [with no parameters](#extract-with-no-parameters).
+
+## Why use `extract()`?
+
+<CardGroup cols={2}>
+  <Card title="Structured" icon="brackets-curly" href="#list-of-objects-extraction">
+    Turn messy webpage data into clean objects that follow a schema.
+  </Card>
+  <Card title="Resilient" icon="dumbbell" href="#extract-with-context">
+    Build resilient extractions that don't break when the website changes
+  </Card>
+</CardGroup>
+
+<Note>
+For TypeScript, the extract schemas are defined using zod schemas.
+
+For Python, the extract schemas are defined using pydantic models.
+</Note>
+
+## Using `extract()`
+
+### Single object Extraction
+
+Here is how an `extract` call might look for a single object:
+
+<CodeGroup>
+```typescript TypeScript
+import { z } from 'zod/v3';
+
+const item = await page.extract({
+  instruction: "extract the price of the item",
+  schema: z.object({
+    price: z.number(),
+  }),
+});
+```
+
+```python Python
+from pydantic import BaseModel
+
+class Extraction(BaseModel):
+    price: float
+
+item = await page.extract(
+    "extract the price of the item", 
+    schema=Extraction
+)
+```
+</CodeGroup>
+
+Your output schema will look like:
+```Example
+{ price: number }
+```
+
+### List of objects Extraction
+
+Here is how an `extract` call might look for a list of objects.
+
+<CodeGroup>
+```typescript TypeScript
+import { z } from 'zod/v3';
+
+const apartments = await page.extract({
+  instruction:
+    "Extract ALL the apartment listings and their details, including address, price, and square feet.",
+  schema: z.object({
+    list_of_apartments: z.array(
+      z.object({
+        address: z.string(),
+        price: z.string(),
+        square_feet: z.string(),
+      }),
+    ),
+  })
+})
+
+console.log("the apartment list is: ", apartments);
+```
+
+```python Python
+from pydantic import BaseModel
+
+class Apartment(BaseModel):
+    address: str
+    price: str
+    square_feet: str
+
+class Apartments(BaseModel):
+    list_of_apartments: list[Apartment]
+
+apartments = await page.extract(
+    "Extract ALL the apartment listings and their details as a list, including address, price, and square feet for each apartment",
+    schema=Apartments
+)
+
+print("the apartment list is: ", apartments)
+```
+</CodeGroup>
+
+Your output schema will look like:
+```Example
+list_of_apartments: [
+    {
+      address: "street address here",
+      price: "$1234.00",
+      square_feet: "700"
+    },
+    {
+        address: "another address here",
+        price: "1010.00",
+        square_feet: "500"
+    },
+    ...
+]
+```
+
+### Prompt-only Extraction
+
+You can call `extract` with just a natural language prompt:
+
+<CodeGroup>
+```typescript TypeScript
+const result = await page.extract("extract the name of the repository");
+```
+
+```python Python
+result = await page.extract("extract the name of the repository")
+```
+</CodeGroup>
+
+When you call `extract` with just a prompt, your output schema will look like:
+```Example
+{ extraction: string }
+```
+
+### Extract with no parameters
+
+Here is how you can call `extract` with no parameters.
+
+<CodeGroup>
+```typescript TypeScript
+const pageText = await page.extract();
+```
+
+```python Python
+pageText = await page.extract()
+```
+</CodeGroup>
+
+Output schema:
+```Example
+{ pageText: string }
+```
+
+Calling `extract` with no parameters will return hierarchical tree representation of the root DOM. This will not be passed through an LLM. It will look something like this:
+
+```
+Accessibility Tree:
+[0-2] RootWebArea: What is Stagehand? - 🤘 Stagehand
+  [0-37] scrollable
+    [0-118] body
+      [0-241] scrollable
+        [0-242] div
+          [0-244] link: 🤘 Stagehand home page light logo
+            [0-245] span
+              [0-246] StaticText: 🤘 Stagehand
+              [0-247] StaticText: home page
+```
+
+## Best practices
+
+
+### Extract with Context
+
+You can provide additional context to your schema to help the model extract the data more accurately.
+
+<CodeGroup>
+```typescript TypeScript
+import { z } from 'zod/v3';
+
+const apartments = await page.extract({
+ instruction:
+   "Extract ALL the apartment listings and their details, including address, price, and square feet.",
+ schema: z.object({
+   list_of_apartments: z.array(
+     z.object({
+       address: z.string().describe("the address of the apartment"),
+       price: z.string().describe("the price of the apartment"),
+       square_feet: z.string().describe("the square footage of the apartment"),
+     }),
+   ),
+ })
+})
+```
+
+```python Python
+from pydantic import BaseModel, Field
+
+class Apartment(BaseModel):
+    address: str = Field(..., description="the address of the apartment")
+    price: str = Field(..., description="the price of the apartment")
+    square_feet: str = Field(..., description="the square footage of the apartment")
+
+class Apartments(BaseModel):
+    list_of_apartments: list[Apartment]
+
+apartments = await page.extract(
+    "Extract ALL the apartment listings and their details as a list. For each apartment, include: the address of the apartment, the price of the apartment, and the square footage of the apartment",
+    schema=Apartments
+)
+```
+</CodeGroup>
+
+### Link Extraction
+<Note>
+To extract links or URLs, in the TypeScript version of Stagehand, you'll need to define the relevant field as `z.string().url()`.
+In Python, you'll need to define it as `HttpUrl`.
+</Note>
+
+Here is how an `extract` call might look for extracting a link or URL. This also works for image links.
+
+<CodeGroup>
+```typescript TypeScript
+import { z } from 'zod/v3';
+
+const extraction = await page.extract({
+  instruction: "extract the link to the 'contact us' page",
+  schema: z.object({
+    link: z.string().url(), // note the usage of z.string().url() here
+  }),
+});
+
+console.log("the link to the contact us page is: ", extraction.link);
+```
+
+```python Python
+from pydantic import BaseModel, HttpUrl
+
+class Extraction(BaseModel):
+    link: HttpUrl # note the usage of HttpUrl here
+
+extraction = await page.extract(
+    "extract the link to the 'contact us' page", 
+    schema=Extraction
+)
+
+print("the link to the contact us page is: ", extraction.link)
+```
+</CodeGroup>
+
+<Tip>
+Inside Stagehand, extracting links works by asking the LLM to select an ID. Stagehand looks up that ID in a mapping of IDs -> URLs. When logging the LLM trace, you should expect to see IDs. The actual URLs will be included in the final `ExtractResult`.
+</Tip>
+
+## Troubleshooting
+
+<AccordionGroup>
+<Accordion title="Empty or partial results">
+**Problem**: `extract()` returns empty or incomplete data
+
+**Solutions**:
+- **Check your instruction clarity**: Make sure your instruction is specific and describes exactly what data you want to extract
+- **Verify the data exists**: Use `page.observe()` first to confirm the data is present on the page
+- **Wait for dynamic content**: If the page loads content dynamically, use `page.act("wait for the content to load")` before extracting
+
+**Solution: Wait for content before extracting**
+<CodeGroup>
+```typescript TypeScript
+// Wait for content before extracting
+await page.act("wait for the product listings to load");
+const products = await page.extract({
+  instruction: "extract all product names and prices",
+  schema: z.object({
+    products: z.array(z.object({
+      name: z.string(),
+      price: z.string()
+    }))
+  })
+});
+```
+
+```python Python
+# Wait for content before extracting
+await page.act("wait for the product listings to load")
+products = await page.extract(
+    "extract all product names and prices",
+    schema=ProductList
+)
+```
+</CodeGroup>
+</Accordion>
+
+<Accordion title="Schema validation errors">
+**Problem**: Getting schema validation errors or type mismatches
+
+**Solutions**:
+- **Use optional fields**: Make fields optional with `z.optional()` (TypeScript) or `Optional[type]` (Python) if the data might not always be present
+- **Use flexible types**: Consider using `z.string()` instead of `z.number()` for prices that might include currency symbols
+- **Add descriptions**: Use `.describe()` (TypeScript) or `Field(description="...")` (Python) to help the model understand field requirements
+
+**Solution: More flexible schema**
+<CodeGroup>
+```typescript TypeScript
+const schema = z.object({
+  price: z.string().describe("price including currency symbol, e.g., '$19.99'"),
+  availability: z.string().optional().describe("stock status if available"),
+  rating: z.number().optional()
+});
+```
+
+```python Python
+class FlexibleProduct(BaseModel):
+    price: str = Field(description="price including currency symbol, e.g., '$19.99'")
+    availability: Optional[str] = Field(default=None, description="stock status if available")
+    rating: Optional[float] = None
+```
+</CodeGroup>
+</Accordion>
+
+<Accordion title="Inconsistent results">
+**Problem**: Extraction results vary between runs
+
+**Solutions**:
+- **Be more specific in instructions**: Instead of "extract prices", use "extract the numerical price value for each item"
+- **Use context in schema descriptions**: Add field descriptions to guide the model
+- **Combine with observe**: Use `page.observe()` to understand the page structure first
+
+**Solution: Validate with observe first**
+<CodeGroup>
+```typescript TypeScript
+// First observe to understand the page structure
+const elements = await page.observe("find all product listings");
+console.log("Found elements:", elements.map(e => e.description));
+
+// Then extract with specific targeting
+const products = await page.extract({
+  instruction: "extract name and price from each product listing shown on the page",
+  schema: z.object({
+    products: z.array(z.object({
+      name: z.string().describe("the product title or name"),
+      price: z.string().describe("the price as displayed, including currency")
+    }))
+  })
+});
+```
+
+```python Python
+# First observe to understand the page structure
+elements = await page.observe("find all product listings")
+print("Found elements:", [e.description for e in elements])
+
+# Then extract with specific targeting
+products = await page.extract(
+    "extract name and price from each product listing shown on the page",
+    schema=ProductSchema
+)
+```
+</CodeGroup>
+</Accordion>
+
+<Accordion title="Performance issues">
+**Problem**: Extraction is slow or timing out
+
+**Solutions**:
+- **Reduce scope**: Extract smaller chunks of data in multiple calls rather than everything at once
+- **Use targeted instructions**: Be specific about which part of the page to focus on
+- **Consider pagination**: For large datasets, extract one page at a time
+- **Increase timeout**: Use `timeoutMs` parameter for complex extractions
+
+**Solution: Break down large extractions**
+<CodeGroup>
+```typescript TypeScript
+// Instead of extracting everything at once
+const allData = [];
+const pageNumbers = [1, 2, 3, 4, 5];
+
+for (const pageNum of pageNumbers) {
+  await page.act(`navigate to page ${pageNum}`);
+  
+  const pageData = await page.extract({
+    instruction: "extract product data from the current page only",
+    schema: ProductPageSchema,
+    timeoutMs: 60000 // 60 second timeout
+  });
+  
+  allData.push(...pageData.products);
+}
+```
+
+```python Python
+# Instead of extracting everything at once
+all_data = []
+page_numbers = [1, 2, 3, 4, 5]
+
+for page_num in page_numbers:
+    await page.act(f"navigate to page {page_num}")
+    
+    page_data = await page.extract(
+        "extract product data from the current page only",
+        schema=ProductPageSchema,
+        timeout_ms=60000  # 60 second timeout
+    )
+    
+    all_data.extend(page_data.products)
+```
+</CodeGroup>
+</Accordion>
+</AccordionGroup>
+
+## Next steps
+
+<CardGroup cols={2}>
+
+  <Card title="Act" icon="play" href="/v2/basics/act">
+    Execute actions efficiently using observe results
+  </Card>
+
+  <Card title="Observe" icon="magnifying-glass" href="/v2/basics/observe">
+    Analyze pages with observe()
+  </Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/basics/observe.mdx b/packages/docs/v2/basics/observe.mdx
new file mode 100644
index 000000000..adecd2158
--- /dev/null
+++ b/packages/docs/v2/basics/observe.mdx
@@ -0,0 +1,266 @@
+---
+title: Observe
+sidebarTitle: Observe
+description: 'Find suggested actions for your workflows'
+---
+
+## What is `observe()`?
+``` typescript
+page.observe("Find the login button")
+```
+
+`observe` allows you to turn any page into a checklist of reliable, executable actions. It discovers key elements, ranks likely next steps, and returns structured actions (selector, method, args) you can run instantly with `act` or use to precisely target `extract` so workflows are faster, cheaper, and more resilient.
+
+## Why use `observe()`?
+
+<CardGroup cols={2}>
+  <Card title="Explore" icon="compass" href="/v2/basics/observe#observe-with-act">
+    When you're unsure what's on a page or need to discover available actions
+  </Card>
+  <Card title="Plan" icon="map" href="/v2/basics/observe#plan-ahead">
+    When building complex workflows, plan ahead all the actions you'll need to take
+  </Card>
+  <Card title="Cache" icon="database" href="/v2/best-practices/caching">
+    When you want to remember actions for the future and avoid LLM calls
+  </Card>
+    <Card title="Validate" icon="check" href="/v2/basics/observe#observe-with-act">
+    Before performing critical actions to ensure elements exist
+  </Card>
+</CardGroup>
+
+## Using `observe()`
+
+Calling `observe` supercharges other Stagehand methods. Use it to plan workflows, speed up `act`, and precisely target `extract`. Using `observe` helps you explore what's possible on a page by giving you a list of suggested actions.
+
+<CodeGroup>
+```typescript TypeScript
+// Plan & validate
+const buttons = await page.observe("Find the log in / sign up buttons");
+```
+```python Python
+# Plan & validate
+buttons = await page.observe("Find the log in / sign up buttons")
+```
+</CodeGroup>
+
+This will return a list of suggestions with the following structure
+```json
+{
+  "selector": "xpath=/html/body/header/div/button[1]",
+  "description": "Log in button in the top right corner",
+  "method": "click",
+  "arguments": []
+}
+```
+
+### Observe with Act
+
+You can **validate** the action (method, selector, arguments...) and then pass it to `act` to **avoid extra LLM inference**.
+
+<Note>
+**Performance Tip**: Acting on multiple `observe` suggestions will minimize the number of LLM calls for multi-step actions and speed up your workflow 2-3x.
+</Note>
+
+<CodeGroup>
+```typescript TypeScript
+await page.act(buttons[0]); // No LLM!
+```
+```python Python
+await page.act(buttons[0]) # No LLM!
+```
+</CodeGroup>
+
+#### Plan ahead
+
+You can use multiple suggestions from `observe` to preview a batch of actions. For example, when filling a form you could ask `observe` to find all the fields and then pass them in to `act`. **Call the LLM once, act multiple times**.
+
+<CodeGroup>
+```typescript TypeScript
+const fields = await page.observe("Find all the fields in the form");
+for (const field of fields) {
+  await page.act(field); // No LLM!
+}
+```
+```python Python
+fields = await page.observe("Find all the fields in the form")
+for field in fields:
+  await page.act(field) # No LLM!
+```
+</CodeGroup>
+
+### Observe and Extract
+
+Using `observe` to focus `extract` on a specific section of the page (like a table, a form, a list...) minimizes the context needed for an extraction. 
+<Tip>
+**Savings Tip**: Pass the selector to `extract` to reduce LLM token usage by 10x for verbose websites!
+</Tip>
+
+<CodeGroup>
+```typescript TypeScript
+// Use observe to validate elements before extraction
+const [ table ] = await page.observe("Find the data table");
+
+const { data } = await page.extract({
+  instruction: "Extract data from the table",
+  schema: z.object({
+    data: z.string()
+  }),
+  selector: table.selector // Reduce context scope needed for extraction
+});
+```
+```python Python
+# Use observe to validate elements before extraction
+[ table ] = await page.observe("Find the data table")
+
+extraction = await page.extract(
+  "Extract data from the table",
+  schema=Data, # Pydantic schema
+  selector=table.selector # Reduce context scope needed for extraction
+)
+```
+</CodeGroup>
+
+## Best Practices
+
+### Choose the right commands
+
+<Tabs>
+<Tab title="Do this">
+
+- Use `observe` when a yes/no answer will gate an action (e.g., "Find the Submit button"), then conditionally `act`.
+- Use `extract` for information-only questions (e.g., "What’s the page title?", "How many results are listed?").
+
+</Tab>
+
+<Tab title="Don't do this">
+
+- Don’t call `extract` to locate elements you plan to click next.
+- Don’t call `observe` to answer info-only questions that won’t lead to an action.
+
+</Tab>
+</Tabs>
+- **Discover and plan with `observe`**: Use `observe("Find…")` to map actionable elements and preview next steps.
+- **Scope `extract` with selectors from `observe`**: First `observe("Find the data table")`, then pass `selector` to `extract` to reduce tokens and boost accuracy.
+
+### Conserve LLM tokens
+
+Optimize performance by directly passing `ObserveResult` to `act` (e.g., `await page.act(results[0])`) to save LLM tokens. Batch operations by using `observe` once to find elements, then act on each. Cache and reuse stable `observe` results for familiar pages, using self-healing if layouts change.
+
+<Card title="Build your own cache" icon="database" href="/v2/best-practices/caching">
+  Check out the guide on how to build your own action cache
+</Card>
+
+### Improve Accuracy
+
+Be precise with instructions, e.g., "Find the primary CTA in the hero" for better results. For iframes, set `iframes: true` and wait for `networkidle`. Use `observe` selectors in `extract` to limit context.
+
+<Card title="Prompting Best Practices" icon="robot" href="/v2/best-practices/prompting-best-practices">
+  Check out the guide on how to improve the accuracy of your results
+</Card>
+
+### Action Validation
+
+Before performing critical actions, validate the suggestion's `method`, `selector`, and `arguments` to prevent misclicks. If a direct `act` fails, use `observe` with the same prompt to verify the method, then proceed with the suggested action.
+
+<CodeGroup>
+```typescript TypeScript
+const prompt = "click the submit button";
+const expectedMethod = "click";
+
+try {
+  await page.act(prompt);
+} catch (error) {
+  if (error.message.includes("method not supported")) {
+    // Observe the same prompt to get the planned action
+    const [action] = await page.observe(prompt);
+    
+    if (action && action.method === expectedMethod) {
+      await page.act(action);
+    } else {
+      throw new Error(`Unsupported method: expected "${expectedMethod}", got "${action?.method}"`);
+    }
+  } else {
+    throw error;
+  }
+}
+```
+
+```python Python
+prompt = "click the submit button"
+expected_method = "click"
+
+try:
+    await page.act(prompt)
+except Exception as error:
+    if "method not supported" in str(error):
+        # Observe the same prompt to get the planned action
+        results = await page.observe(prompt)
+        
+        if results and results[0].method == expected_method:
+            await page.act(results[0])
+        else:
+            method = results[0].method if results else "unknown"
+            raise Exception(f'Unsupported method: expected "{expected_method}", got "{method}"')
+    else:
+        raise error
+```
+</CodeGroup>
+
+## Troubleshooting
+
+<AccordionGroup>
+<Accordion title="No elements found">
+**Problem**: `observe` returns empty array
+
+**Solutions**:
+- Make sure the element exists on the page
+- Use explicit instructions to find the element
+- Ensure page has fully loaded
+- Look at the [debugging logs](/v2/configuration/logging), if the element is there then the LLM might be hallucinating/not catching it. 
+</Accordion>
+
+<Accordion title="Inaccurate element descriptions">
+**Problem**: Descriptions don't match actual elements
+
+**Solutions**:
+- Use more capable models: check [evals](https://stagehand.dev/evals) for the best models for your use case
+- Provide more specific instructions
+- Log inference to file (see [debugging logs](/v2/configuration/logging#llm-inference-logging)) to get an LLM trace
+
+</Accordion>
+<Accordion title="Wrong method identified">
+**Problem**: The method identified is not valid
+
+**Solutions**:
+- Check the [supported actions](/v2/basics/act)
+- Provide more specific instructions
+- Validate the method, if invalid override with one of the supported ones
+
+</Accordion>
+</AccordionGroup>
+
+
+## Next Steps
+
+<CardGroup cols={2}>
+<Card title="Act Overview" icon="play" href="/v2/basics/act">
+Execute actions efficiently using `observe` results
+</Card>
+
+<Card title="Extract Data" icon="download" href="/v2/basics/extract">  
+Extract structured data from observed elements
+</Card>
+
+<Card title="Observability" icon="chart-line" href="/v2/configuration/observability">
+Monitor and debug observation performance  
+</Card>
+
+<Card title="Best Practices" icon="star" href="/v2/best-practices/prompting-best-practices">
+Advanced patterns and optimization techniques
+</Card>
+</CardGroup>
+
+
+
+
+
diff --git a/packages/docs/v2/best-practices/agent-fallbacks.mdx b/packages/docs/v2/best-practices/agent-fallbacks.mdx
new file mode 100644
index 000000000..85441debe
--- /dev/null
+++ b/packages/docs/v2/best-practices/agent-fallbacks.mdx
@@ -0,0 +1,74 @@
+---
+title: Agent Fallbacks
+description: "A failsafe when unexpected page changes add extra steps"
+---
+
+## When to use
+
+Use an agent fallback as a failsafe when a one step action unexpectedly becomes a multi-step flow.
+
+## How it works
+
+1. [`act()`](/v2/basics/act) is attempted for the direct action
+2. If it fails, [`agent()`](/v2/basics/agent) figures out the new path
+3. Agent completes all needed steps (open menu → click button)
+
+### Example scenario
+
+**Before**: Sign in button was in the header  
+**After**: Sign in now requires: Click account menu → Click "Sign in" option
+
+A single `act("click sign in")` can't handle this change. The agent fallback can discover and execute both steps.
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+try {
+  await page.act("click the 'Sign In' button");
+} catch (err) {
+  console.log("Agent fallback triggered");
+
+  const agent = stagehand.agent({
+    provider: "anthropic",
+    model: "claude-sonnet-4-20250514",
+    instructions: "You are a helpful assistant that can use a web browser.",
+  });
+
+  const result = await agent.execute({
+    instruction: "Find and click Sign In button",
+    maxSteps: 10,
+  });
+
+  console.log(result.success ? "Agent fallback success" : "Agent fallback failed");
+
+  if (!result.success) throw err;
+}
+```
+
+```python Python
+from stagehand import Stagehand
+
+try:
+    await page.act("click the 'Sign In' button")
+except Exception as err:
+    print("Agent fallback triggered")
+
+    agent = stagehand.agent({
+        "provider": "anthropic",
+        "model": "claude-sonnet-4-20250514",
+        "instructions": "Complete the action, handling any new steps required.",
+    })
+
+    result = await agent.execute({
+        "instruction": "Find and click Sign In button",
+        "max_steps": 10,
+    })
+
+    print("Agent fallback success" if result.success else "Agent fallback failed")
+
+    if not result.success:
+        raise err
+```
+</CodeGroup>
+
diff --git a/packages/docs/v2/best-practices/build-agent.mdx b/packages/docs/v2/best-practices/build-agent.mdx
new file mode 100644
index 000000000..160022757
--- /dev/null
+++ b/packages/docs/v2/best-practices/build-agent.mdx
@@ -0,0 +1,209 @@
+---
+title: 'Build a web browsing agent'
+description: 'Build an AI agent that can autonomously control a browser with Stagehand'
+---
+import { Excalidraw } from '/snippets/excalidraw.mdx';
+
+Stagehand gives AI agents powerful tools to control a browser completely autonomously. Watch below as a Stagehand agent autonomously navigates to a URL, takes actions on the page, and extracts structured data to answer a question.
+There's quite a few ways to build an agent with Stagehand. Let's look at a few of them.
+
+![Agent](/media/stagehand-agent.gif)
+
+## Stagehand MCP
+
+The above example is a Claude agent that uses Stagehand to control a browser. At this time of writing, [multimodal tool calling](https://sdk.vercel.ai/docs/ai-sdk-core/tools-and-tool-calling#multi-modal-tool-results) is only supported in Claude 3.5/3.7 Sonnet. 
+This means Claude is intelligent enough to know when to request a browser screenshot, and it can then use that screenshot to make decisions about what actions to take next.
+
+<CardGroup>
+<Card title="Browserbase MCP" href="https://github.com/browserbase/mcp-server-browserbase/" icon="hand-horns">
+Control a browser with Browserbase MCP powered by Stagehand
+</Card>
+</CardGroup>
+
+What's really interesting about this is that the agent is able to reason about the browser state and take actions separate from one another! 
+Claude is able to reason about the browser state, while Stagehand is able to take actions on the page with GPT-4o-mini or a computer use model.
+Stagehand is even smart enough to know when to use GPT-4o-mini and when to use a computer use model, i.e. on iframe detection.
+
+<Excalidraw className="w-full aspect-video" url="https://link.excalidraw.com/readonly/GWQWmWUBqMBEAamlWsIM?darkMode=true" />
+
+We've found great success from having Claude as the "Trajectory" agent calling Stagehand tools when it sees fit! 
+While MCP is really nascent, we're excited to see where it goes.
+
+## Stagehand + Computer Use Models
+
+Stagehand lets you leverage powerful computer use APIs from OpenAI and Anthropic with just one line of code. 
+
+<CodeGroup>
+```typescript TypeScript
+await page.goto("https://github.com/browserbase/stagehand");
+
+// Create a Computer Use agent with just one line of code!
+const agent = stagehand.agent({
+	provider: "openai",
+	model: "computer-use-preview"
+});
+
+// Use the agent to execute a task
+const result = await agent.execute("Extract the top contributor's username");
+console.log(result);
+```
+```python Python
+await page.goto("https://github.com/browserbase/stagehand-python")
+
+# Create a Computer Use agent with just one line of code!
+agent = stagehand.agent(
+    model="computer-use-preview"
+)
+
+# Use the agent to execute a task
+result = await agent.execute("Extract the top contributor's username")
+print(result)
+```
+</CodeGroup>
+
+<CardGroup>
+<Card title="Stagehand + Computer Use Docs" href="/best-practices/computer-use" icon="scroll">
+Check out our docs page for instructions on how to use computer use models with Stagehand.
+</Card>
+<Card title="CUA Browser Demo" href="https://cua.browserbase.com/" icon="brain-circuit">
+Check out a live demo of a Browserbase browser controlled by OpenAI's Computer Using Agent (CUA) model.
+</Card>
+</CardGroup>
+
+## Sequential Tool Calling (Open Operator)
+
+In January 2025, Browserbase released [Open Operator](https://operator.browserbase.com). 
+Open Operator is able to reason about the browser state and take actions accordingly to accomplish larger tasks like "order me a pizza".
+It works by calling Stagehand tools in sequence:
+
+1. If there's no URL, go to a default URL.
+1. Examine the browser state. Ask an LLM to reason about what to do next.
+1. Use `page.act()` to execute the LLM-suggested action.
+1. Repeat
+
+<Excalidraw className="w-full" url="https://link.excalidraw.com/readonly/dKh5sB1gEM1EjVqRCGKn" />
+
+Incorporating `stagehand.agent` into your browser automation is as easy as adding a single line of code:
+
+<Note>
+Python currently supports `stagehand.agent` with Computer Use Agent (CUA) models. The default implementation is coming soon. 
+</Note>
+
+<CodeGroup>
+```typescript TypeScript
+await stagehand.page.goto("https://github.com/browserbase/stagehand");
+
+// Open Operator will use the default LLM from Stagehand config
+const operator = stagehand.agent();
+const { message, actions } = await operator.execute(
+	"Extract the top contributor's username"
+);
+
+console.log(message);
+```
+</CodeGroup>
+
+### Replay the agent's actions
+
+You can replay the agent's actions exactly the same way you would with a regular Stagehand agent. You can even automatically cache the actions to avoid unnecessary LLM calls on a repeated run.
+
+Let's use the `replay` function below to save the actions to a Stagehand script file, which will reproduce the same actions the agent did, with cached actions built in.
+
+<Accordion title="utils.ts">
+```typescript
+import { AgentAction, AgentResult } from "@browserbasehq/stagehand";
+import { exec } from "child_process";
+import fs from "fs/promises";
+
+export async function replay(result: AgentResult) {
+  const history = result.actions;
+  const replay = history
+    .map((action: AgentAction) => {
+      switch (action.type) {
+        case "act":
+          if (!action.playwrightArguments) {
+            throw new Error("No playwright arguments provided");
+          }
+          return `await page.act(${JSON.stringify(
+            action.playwrightArguments
+          )})`;
+        case "extract":
+          return `await page.extract("${action.parameters}")`;
+        case "goto":
+          return `await page.goto("${action.parameters}")`;
+        case "wait":
+          return `await page.waitForTimeout(${parseInt(
+            action.parameters as string
+          )})`;
+        case "navback":
+          return `await page.goBack()`;
+        case "refresh":
+          return `await page.reload()`;
+        case "close":
+          return `await stagehand.close()`;
+        default:
+          return `await stagehand.oops()`;
+      }
+    })
+    .join("\n");
+
+  console.log("Replay:");
+  const boilerplate = `
+import { Page, BrowserContext, Stagehand } from "@browserbasehq/stagehand";
+
+export async function main(stagehand: Stagehand) {
+    const page = stagehand.page
+	${replay}
+}
+  `;
+  await fs.writeFile("replay.ts", boilerplate);
+
+  // Format the replay file with prettier
+  await new Promise((resolve, reject) => {
+    exec(
+      "npx prettier --write replay.ts",
+      (error: any, stdout: any, stderr: any) => {
+        if (error) {
+          console.error(`Error formatting replay.ts: ${error}`);
+          reject(error);
+          return;
+        }
+        resolve(stdout);
+      }
+    );
+  });
+}
+```
+</Accordion>
+
+Here's the replay output of an instruction like `"Get me the stock price of NVDA"`:
+
+```typescript {14-22} replay.ts
+import { Page, BrowserContext, Stagehand } from "@browserbasehq/stagehand";
+
+export async function main({
+  page,
+  context,
+  stagehand,
+}: {
+  page: Page; // Playwright Page with act, extract, and observe methods
+  context: BrowserContext; // Playwright BrowserContext
+  stagehand: Stagehand; // Stagehand instance
+}) {
+  await page.goto("https://www.google.com");
+
+  // Replay will default to Playwright first to avoid unnecessary LLM calls!
+  // If the Playwright action fails, Stagehand AI will take over and self-heal
+  await page.act({
+    description: "The search combobox where users can type their queries.",
+    method: "fill",
+    arguments: ["NVDA stock price"],
+    selector:
+      "xpath=/html/body[1]/div[1]/div[3]/form[1]/div[1]/div[1]/div[1]/div[1]/div[2]/textarea[1]",
+  });
+  await page.extract(
+    "the displayed NVDA stock price in the search suggestions",
+  );
+  await stagehand.close();
+}
+```
\ No newline at end of file
diff --git a/packages/docs/v2/best-practices/caching.mdx b/packages/docs/v2/best-practices/caching.mdx
new file mode 100644
index 000000000..6835192b0
--- /dev/null
+++ b/packages/docs/v2/best-practices/caching.mdx
@@ -0,0 +1,206 @@
+---
+title: Caching Actions
+description: You can cache actions in Stagehand to avoid redundant LLM calls.
+---
+
+Caching actions in Stagehand is useful for actions that are expensive to run, or when the underlying DOM structure is not expected to change.
+
+## Using `observe` to preview an action
+`observe` lets you preview an action before taking it. If you are satisfied with the action preview, you can run it in `page.act` with no further LLM calls.
+
+<CodeGroup>
+```typescript TypeScript
+const [actionPreview] = await page.observe("Click the quickstart link");
+
+/** actionPreview is a JSON-ified version of a Playwright action:
+{
+	description: "The quickstart link",
+	method: "click",
+	selector: "/html/body/div[1]/div[1]/a",
+	arguments: [],
+}
+**/
+
+// NO LLM INFERENCE when calling act on the preview
+await page.act(actionPreview)
+```
+
+```python Python
+actions = await page.observe("Click the quickstart link")
+action_preview = actions[0]
+
+# action_preview is a dictionary version of a Playwright action:
+# {
+#	"description": "The quickstart link",
+#	"method": "click",
+#	"selector": "/html/body/div[1]/div[1]/a",
+#	"arguments": [],
+# }
+
+# NO LLM INFERENCE when calling act on the preview
+await page.act(action_preview)
+```
+</CodeGroup>
+
+## Simple caching
+
+Let's use a simple file-based cache for this example. We'll write a getter and a setter functions that can read and write to a JSON file:
+
+<CodeGroup>
+```typescript TypeScript
+// Get the cached value (undefined if it doesn't exist)
+async function getCache(key: string): Promise<ObserveResult | undefined> {
+  try {
+    const cache = await readFile("cache.json");
+    const parsed = JSON.parse(cache);
+    return parsed[key];
+  } catch {
+    return undefined;
+  }
+}
+
+// Set the cache value
+async function setCache(key: string, value: ObserveResult): Promise<void> {
+  const cache = await readFile("cache.json");
+  const parsed = JSON.parse(cache);
+  parsed[key] = value;
+  await writeFile("cache.json", JSON.stringify(parsed));
+}
+```
+
+```python Python
+# Get the cached value (None if it doesn't exist)
+async def get_cache(key: str) -> Optional[Dict[str, Any]]:
+    try:
+        async with aiofiles.open("cache.json", 'r') as f:
+            cache_content = await f.read()
+            parsed = json.loads(cache_content)
+            return parsed.get(key)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return None
+
+# Set the cache value
+async def set_cache(key: str, value: Dict[str, Any]) -> None:
+    try:
+        async with aiofiles.open("cache.json", 'r') as f:
+            cache_content = await f.read()
+            parsed = json.loads(cache_content)
+    except (FileNotFoundError, json.JSONDecodeError):
+        parsed = {}
+    
+    parsed[key] = value
+    
+    async with aiofiles.open("cache.json", 'w') as f:
+        await f.write(json.dumps(parsed))
+```
+</CodeGroup>
+
+### Act with cache
+Let's write a function that will check the cache, get the action, and run it. If the action fails, we'll attempt to "self-heal", i.e. retry it with `page.act` directly.
+
+<CodeGroup>
+```typescript TypeScript
+// Check the cache, get the action, and run it
+// If selfHeal is true, we'll attempt to self-heal if the action fails
+async function actWithCache(page: Page, key: string, prompt: string, selfHeal = false) {
+	try {
+		const cacheExists = await getCache(key);
+
+		let action: ObserveResult;
+		if (cacheExists) {
+		// Get the cached action
+		action = await getCache(prompt);
+		} else {
+		// Get the observe result (the action)
+		[action] = await page.observe(prompt);
+
+		// Cache the action
+		await setCache(prompt, action);
+		}
+
+		// Run the action (no LLM inference)
+		await page.act(action);
+	} catch (e) {
+		console.error(e);
+		// in selfHeal mode, we'll retry the action
+		if (selfHeal) {
+			console.log("Attempting to self-heal...");
+			await page.act(prompt);
+		}
+		else {
+			throw e;
+		}
+	}
+}
+```
+
+```python Python
+# Check the cache, get the action, and run it
+# If self_heal is true, we'll attempt to self-heal if the action fails
+async def act_with_cache(page, key: str, prompt: str, self_heal: bool = False):
+    try:
+        cache_exists = await get_cache(key)
+
+        if cache_exists:
+            # Get the cached action
+            action = await get_cache(prompt)
+        else:
+            # Get the observe result (the action)
+            actions = await page.observe(prompt)
+            action = actions[0]
+
+            # Cache the action
+            await set_cache(prompt, action)
+
+        # Run the action (no LLM inference)
+        await page.act(action)
+    except Exception as e:
+        print(f"Error: {e}")
+        # in self_heal mode, we'll retry the action
+        if self_heal:
+            print("Attempting to self-heal...")
+            await page.act(prompt)
+        else:
+            raise e
+```
+</CodeGroup>
+
+You can now use `actWithCache` to run an action with caching:
+
+<CodeGroup>
+```typescript TypeScript
+const prompt = "Click the quickstart link";
+const key = prompt; // Simple cache key
+// Attempt cached action or self-heal
+await actWithCache(page, key, prompt);
+```
+
+```python Python
+prompt = "Click the quickstart link"
+key = prompt  # Simple cache key
+# Attempt cached action or self-heal
+await act_with_cache(page, key, prompt)
+```
+</CodeGroup>
+
+## Advanced caching
+
+The above example is simple, but you may want to cache actions based on the page contents. Also, if you have duplicate prompts, you should use a more unique key.
+
+We want to leave caching logic up to you, but give you all the tools you need to implement your own caching strategy.
+
+You can directly access the DOM and accessibility tree from Playwright's page object. Here's an example of how to access the page content:
+
+<CodeGroup>
+```typescript TypeScript
+// Get the page content
+const pageContent = await page.content();
+```
+
+```python Python
+# Get the page content
+page_content = await page.content()
+```
+</CodeGroup>
+
+You may also want to use the accessibility tree, the DOM, or any other information to create a more unique key. You can do this as you please, with very similar logic to the above example.
\ No newline at end of file
diff --git a/packages/docs/v2/best-practices/computer-use.mdx b/packages/docs/v2/best-practices/computer-use.mdx
new file mode 100644
index 000000000..b0c9cb8eb
--- /dev/null
+++ b/packages/docs/v2/best-practices/computer-use.mdx
@@ -0,0 +1,199 @@
+---
+title: Computer Use Agents
+description: Incorporate Computer Use APIs from Anthropic and OpenAI with one line of code in Stagehand.
+---
+
+## What is a Computer Use Agent?
+
+<iframe
+  width="100%"
+  height="400"
+  src="https://www.youtube.com/embed/ODaHJzOyVCQ"
+  title="YouTube video player"
+  frameborder="0"
+  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+  allowfullscreen
+></iframe>
+You might've heard of [Claude Computer Use](https://www.anthropic.com/news/3-5-models-and-computer-use) or [OpenAI's Computer Using Agent](https://openai.com/index/computer-using-agent/).
+
+These are powerful tools that can convert natural language into actions on the computer. However, you'd otherwise need to write your own code to convert these actions into Playwright commands.
+
+Stagehand not only handles the execution of Computer Use outputs, but also lets you hot-swap between OpenAI and Anthropic models with one line of code.
+
+## How to use a Computer Use Agent in Stagehand
+
+Stagehand lets you use Computer Use Agents with one line of code:
+
+<Note>
+**IMPORTANT! Configure your browser dimensions**
+
+Computer Use Agents will often return XY-coordinates to click on the screen, so you'll need to configure your browser dimensions.
+
+If not specified, the default browser dimensions are 1024x768. You can also configure the browser dimensions in the `browserbaseSessionCreateParams` or `localBrowserLaunchOptions` options.
+</Note>
+
+
+### Configuring browser dimensions
+
+Browser configuration differs by environment:
+
+<Tabs>
+<Tab title="BROWSERBASE">
+<CodeGroup>  
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+	env: "BROWSERBASE",
+  	apiKey: process.env.BROWSERBASE_API_KEY /* API key for authentication */,
+    projectId: process.env.BROWSERBASE_PROJECT_ID /* Project identifier */,
+  
+    browserbaseSessionCreateParams: {
+      projectId: process.env.BROWSERBASE_PROJECT_ID!,
+      browserSettings: {
+		blockAds: true,
+        viewport: {
+          width: 1024,
+          height: 768,
+        },
+      },
+  	},
+});
+
+await stagehand.init();
+```
+```python Python
+import os
+from stagehand import Stagehand, StagehandConfig
+
+stagehand = Stagehand(StagehandConfig(
+    env="BROWSERBASE",
+    api_key=os.getenv("BROWSERBASE_API_KEY"),  # API key for authentication
+    project_id=os.getenv("BROWSERBASE_PROJECT_ID"),  # Project identifier
+    
+    browserbase_session_create_params={
+        "projectId": os.getenv("BROWSERBASE_PROJECT_ID"),
+        "browserSettings": {
+            "blockAds": True,
+            "viewport": {
+                "width": 1024,
+                "height": 768,
+            },
+        },
+    },
+))
+
+await stagehand.init()
+```
+</CodeGroup>
+</Tab>
+<Tab title="LOCAL">
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  localBrowserLaunchOptions: {
+    headless: false,
+    viewport: {
+      width: 1024,
+      height: 768,
+    },
+  }
+});
+
+await stagehand.init();
+```
+```python Python
+from stagehand import Stagehand, StagehandConfig
+
+stagehand = Stagehand(StagehandConfig(
+    env="LOCAL",
+    local_browser_launch_options={
+        "headless": False,
+        "viewport": {
+            "width": 1024,
+            "height": 768,
+        },
+    }
+))
+
+await stagehand.init()
+```
+</CodeGroup>
+</Tab>
+</Tabs>
+
+### Direct your Computer Use Agent
+
+Call `execute` on the agent to assign a task to the agent.
+
+<CodeGroup>
+```typescript TypeScript
+// Navigate to a website
+await stagehand.page.goto("https://www.google.com");
+
+const agent = stagehand.agent({
+	// You can use either OpenAI or Anthropic
+	provider: "anthropic",
+	// The model to use (computer-use-preview for OpenAI)
+	model: "claude-sonnet-4-20250514",
+
+	// Customize the system prompt
+	instructions: `You are a helpful assistant that can use a web browser.
+	Do not ask follow up questions, the user will trust your judgement.`,
+
+	// Customize the API key
+	options: {
+		apiKey: process.env.ANTHROPIC_API_KEY,
+	},
+});
+
+// Execute the agent
+await agent.execute("Apply for a library card at the San Francisco Public Library");
+```
+
+```python Python
+import os
+
+# Navigate to a website
+await stagehand.page.goto("https://www.google.com")
+
+agent = stagehand.agent({
+    # The model to use
+    model="computer-use-preview",
+
+    # Customize the system prompt
+    instructions="You are a helpful assistant that can use a web browser. Do not ask follow up questions, the user will trust your judgement.",
+
+    # Customize the API key
+    options={
+        "apiKey": os.getenv("ANTHROPIC_API_KEY"),
+    },
+})
+
+# Execute the agent
+await agent.execute("Apply for a library card at the San Francisco Public Library")
+```
+</CodeGroup>
+
+You can also define the maximum number of steps the agent can take with:
+
+<CodeGroup>
+```typescript TypeScript
+await agent.execute({
+	instructions: "Apply for a library card at the San Francisco Public Library",
+	maxSteps: 10,
+});
+```
+
+```python Python
+await agent.execute(
+	"Apply for a library card at the San Francisco Public Library",
+	max_steps=10,
+)
+```
+</CodeGroup> 
+
+<Callout icon="code" color="#6ec202" iconType="regular">View or run the example templates [here](https://www.browserbase.com/templates?category=Computer+Use+Agents)</Callout>
diff --git a/packages/docs/v2/best-practices/contributing.mdx b/packages/docs/v2/best-practices/contributing.mdx
new file mode 100644
index 000000000..62a2e2f06
--- /dev/null
+++ b/packages/docs/v2/best-practices/contributing.mdx
@@ -0,0 +1,52 @@
+---
+title: 'Contribute to Stagehand'
+description: 'Best practices for making a meaningful contribution to Stagehand'
+---
+
+# Codeowners and Subject-Matter Experts
+
+Any contribution must be explicitly approved by a codeowner. Officially, Stagehand codeowners are as follows:
+
+- [**Paul Klein**](https://github.com/pkiv)
+- [**Miguel Gonzalez**](https://github.com/miguelg719)
+- [**Sean McGuire**](https://github.com/seanmcguire12)
+- [**Anirudh Kamath**](https://github.com/kamath)
+- [**Sameel Arif**](https://github.com/sameelarif)
+- [**Filip Michalsky**](https://github.com/filip-michalsky)
+
+Special thanks to [Jeremy Press](https://github.com/jeremypress), [Navid Pour](https://github.com/navidkpr), and [all the contributors](https://github.com/browserbase/stagehand/graphs/contributors) for your help in making Stagehand the best browser automation framework.
+
+***Please do not hesitate to reach out to anyone listed here in the [public Discord server](https://stagehand.dev/discord)***
+
+## General Workflow
+
+Get listed as [one of our beloved contributors](https://github.com/browserbase/stagehand/graphs/contributors)!
+
+1. **Discuss your proposed contribution before starting.** Not doing this runs you the risk of entirely discarding something you put considerable time and effort into. You can DM Miguel on [Discord](https://stagehand.dev/discord) for a 1on1 call.
+2. **Open a Pull Request.** Create a fork of this repository, and follow [GitHub’s instructions to create a Pull Request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request-from-a-fork). This allows our team to review your contribution and leave comments. 
+3. **Wait for Review**. We'll do our best to get to your contribution as soon as possible. If it's been 2-3 days and you have yet to receive any comments, DM Miguel on [Discord](https://stagehand.dev/discord)
+4. **Merge into `evals` branch.** We don’t let external contributors [run our CI via GitHub Actions](https://github.com/browserbase/stagehand/blob/main/.github/workflows/ci.yml) to prevent spam and misuse. If your contribution passes an initial screen, we’ll run our evals on it
+    1. By default, all PRs run the following tests that you can also run from the repo source:
+        1. Lint (`npm run lint`) - Runs `prettier` and `eslint`. If this fails, you can most likely run `npm run format` to fix some simple linting errors.
+        2. Build (`npm run build`) - Lints and builds TS → JS in `dist/`
+        3. End-to-End (`npm run e2e`) - These are deterministic end-to-end Playwright tests to ensure the integrity of basic Playwright functionality of [`stagehand.page`](http://stagehand.page) and `stagehand.context` as well as compatibility with the Browserbase API
+        4. Combination (`npm run evals category combination`) - This runs AI-based end-to-end tests using combinations of `act`, `extract`, and `observe` 
+    2. If you’re changing anything about `act`, `extract`, or `observe` itself, we might also run specific act/extract/observe evals to ensure existing functionality doesn’t significantly drop.
+    
+    ![CI](/images/CI.png)
+    
+5. **Cleanup and merge to main**. Once it’s in `evals`, unfortunately the original contributor can’t make any further changes. The internal Stagehand team will be responsible for cleaning up the code and bringing it into main. 
+
+## Contribution Guidelines
+
+1. **Use draft PRs.** If your PR is a work in progress, please convert it to a draft (see below) while you’re working on it, and mark it for review/add reviewers when you’re ready. This helps us prevent clutter in the review queue.
+    
+    ![Draft PR](/images/pr_draft.png)
+    
+2. **Provide a reproducible test plan.** Include an eval (preferred) or example. We can’t merge your PR if we can’t run anything that specifically highlights your contribution. 
+    1. Write a script in [`evals/tasks`](https://github.com/browserbase/stagehand/tree/v2/evals/tasks) as `someTask.ts`
+    2. Add your script to [`evals.config.json`](https://github.com/browserbase/stagehand/blob/v2/evals/evals.config.json) with default category `combination` (*or act/extract/observe if you’re* *only* *testing* *act/extract/observe*).
+3. **Add a changeset.** Run `npx changeset` in TS or `uvx changeset` in Python to add a changeset that will directly reflect in the `CHANGELOG` in the upcoming release.
+    1. `patch` - no net new functionality to an end-user
+    2. `minor` - some net new functionality to an end-user (new function parameter, new exposed type, etc.)
+    3. `major` - you shouldn’t be committing a major change
diff --git a/packages/docs/v2/best-practices/cost-optimization.mdx b/packages/docs/v2/best-practices/cost-optimization.mdx
new file mode 100644
index 000000000..0602b9db2
--- /dev/null
+++ b/packages/docs/v2/best-practices/cost-optimization.mdx
@@ -0,0 +1,258 @@
+---
+title: Cost Optimization  
+sidebarTitle: Cost Optimization
+description: Minimize costs while maintaining automation performance
+---
+
+Cost optimization in Stagehand involves balancing LLM inference costs and browser infrastructure costs. This guide provides practical strategies to reduce your automation expenses.
+
+## Quick Wins
+
+Start with these simple optimizations that can reduce costs:
+
+### 1. Use the Right Model for the Job
+
+We don't recommend using larger, more premium models for simple tasks. See our [evaluation results](https://stagehand.dev/evals) for model performance and cost comparisons across different task types.
+
+<CardGroup cols={2}>
+<Card title="Model Selection Guide" icon="brain" href="/v2/configuration/models">
+  Choose the right LLM for your budget and accuracy requirements
+</Card>
+<Card title="Evaluation Results" icon="chart-line" href="https://www.stagehand.dev/evals">
+  See how different models perform on different tasks
+</Card>
+</CardGroup>
+
+### 2. Implement Smart Caching
+
+Cache successful actions to avoid repeated LLM calls. Learn the basics in our [Caching Guide](/v2/best-practices/caching):
+
+<CodeGroup>
+```typescript TypeScript
+// Cache successful actions
+const [action] = await page.observe("Click the sign in button");
+await setCache("sign_in_button", action);
+
+// Reuse cached action (no LLM cost)
+const cachedAction = await getCache("sign_in_button");
+if (cachedAction) {
+  await page.act(cachedAction);
+} else {
+  await page.act(action);
+}
+```
+```python Python
+# Cache successful actions
+actions = await page.observe("Click the sign in button")
+action = actions[0]
+await set_cache("sign_in_button", action)
+
+# Reuse cached action (no LLM cost)
+cached_action = await get_cache("sign_in_button")
+if cached_action:
+    await page.act(cached_action)
+else:
+    await page.act(action)
+```
+</CodeGroup>
+
+<CardGroup cols={1}>
+<Card title="Caching Guide" icon="database" href="/v2/best-practices/caching">
+  Reduce costs with smart action caching and observe patterns
+</Card>
+</CardGroup>
+
+### 3. Optimize Browser Sessions
+
+Reuse sessions when possible and set appropriate timeouts. See [Browser Configuration](/v2/configuration/browser) for details:
+
+<CodeGroup>
+```typescript TypeScript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  browserbaseSessionCreateParams: {
+    timeout: 1800, // 30 minutes instead of default 1 hour
+    keepAlive: true, // Keep session alive between tasks
+  }
+});
+```
+```python Python
+stagehand = Stagehand(
+    env="BROWSERBASE",
+    browserbase_session_create_params={
+        "timeout": 1800,  # 30 minutes instead of default 1 hour
+        "keep_alive": True,  # Keep session alive between tasks
+    }
+)
+```
+</CodeGroup>
+
+<CardGroup cols={1}>
+<Card title="Browserbase Cost Optimization" icon="window-maximize" href="https://docs.browserbase.com/guides/cost-optimization">
+  Optimize Browserbase infrastructure costs and session management
+</Card>
+</CardGroup>
+
+## Advanced Strategies
+
+### Intelligent Model Switching
+
+Automatically fall back to cheaper models for simple tasks:
+
+<CodeGroup>
+```typescript TypeScript
+// Use models from least to most expensive based on task complexity
+// See stagehand.dev/evals for performance comparisons
+async function smartAct(page: Page, prompt: string) {
+  const models = ["cheaper-model", "premium-model"];
+  
+  for (const model of models) {
+    try {
+      const stagehand = new Stagehand({ modelName: model });
+      await stagehand.init();
+      const [action] = await stagehand.page.observe(prompt);
+      await stagehand.page.act(action);
+      return;
+    } catch (error) {
+      console.log(`Falling back to ${model}...`);
+    }
+  }
+}
+```
+```python Python
+# Use models from least to most expensive based on task complexity
+# See stagehand.dev/evals for performance comparisons
+async def smart_act(page, prompt: str):
+    models = ["cheaper-model", "premium-model"]
+    
+    for model in models:
+        try:
+            stagehand = Stagehand(model_name=model)
+            await stagehand.init()
+            actions = await stagehand.page.observe(prompt)
+            action = actions[0]
+            await stagehand.page.act(action)
+            return
+        except Exception:
+            print(f"Falling back to {model}...")
+```
+</CodeGroup>
+
+### Session Pooling
+
+Reuse browser sessions across multiple tasks:
+
+<CodeGroup>
+```typescript TypeScript
+class SessionManager {
+  private sessions = new Map<string, Stagehand>();
+  
+  async getSession(taskType: string): Promise<Stagehand> {
+    if (this.sessions.has(taskType)) {
+      return this.sessions.get(taskType)!;
+    }
+    
+    const stagehand = new Stagehand({ env: "BROWSERBASE" });
+    await stagehand.init();
+    this.sessions.set(taskType, stagehand);
+    return stagehand;
+  }
+}
+```
+```python Python
+class SessionManager:
+    def __init__(self):
+        self.sessions = {}
+    
+    async def get_session(self, task_type: str):
+        if task_type in self.sessions:
+            return self.sessions[task_type]
+        
+        stagehand = Stagehand(env="BROWSERBASE")
+        await stagehand.init()
+        self.sessions[task_type] = stagehand
+        return stagehand
+```
+</CodeGroup>
+
+## Cost Monitoring
+
+Track your spending to identify optimization opportunities. See our [Observability Guide](/configuration/observability) for detailed metrics:
+
+<CodeGroup>
+```typescript TypeScript
+// Monitor token usage
+const metrics = stagehand.metrics;
+console.log(`Total tokens: ${metrics.totalPromptTokens + metrics.totalCompletionTokens}`);
+console.log(`Estimated cost: $${(metrics.totalPromptTokens + metrics.totalCompletionTokens) * 0.00001}`);
+```
+```python Python
+# Monitor token usage
+metrics = stagehand.metrics
+total_tokens = metrics['total_prompt_tokens'] + metrics['total_completion_tokens']
+print(f"Total tokens: {total_tokens}")
+print(f"Estimated cost: ${total_tokens * 0.00001:.4f}")
+```
+</CodeGroup>
+
+<CardGroup cols={1}>
+<Card title="Observability & Metrics" icon="chart-line" href="/v2/configuration/observability">
+  Monitor usage patterns and track costs in real-time
+</Card>
+</CardGroup>
+
+## Budget Controls
+
+Set spending limits to prevent unexpected costs:
+
+<CodeGroup>
+```typescript TypeScript
+class BudgetGuard {
+  private dailySpend = 0;
+  private maxDailyBudget: number;
+  
+  constructor(maxDailyBudget: number = 25) {
+    this.maxDailyBudget = maxDailyBudget;
+  }
+  
+  checkBudget(estimatedCost: number): void {
+    if (this.dailySpend + estimatedCost > this.maxDailyBudget) {
+      throw new Error(`Daily budget exceeded: $${this.maxDailyBudget}`);
+    }
+    this.dailySpend += estimatedCost;
+  }
+}
+```
+```python Python
+class BudgetGuard:
+    def __init__(self, max_daily_budget: float = 25.0):
+        self.daily_spend = 0
+        self.max_daily_budget = max_daily_budget
+    
+    def check_budget(self, estimated_cost: float) -> None:
+        if self.daily_spend + estimated_cost > self.max_daily_budget:
+            raise Exception(f"Daily budget exceeded: ${self.max_daily_budget}")
+        self.daily_spend += estimated_cost
+```
+</CodeGroup>
+
+
+## Related Resources
+
+<CardGroup cols={2}>
+<Card title="Model Selection Guide" icon="brain" href="/v2/configuration/models">
+  Choose the right LLM for your budget and accuracy requirements
+</Card>
+
+<Card title="Caching Strategies" icon="database" href="/v2/best-practices/caching">
+  Reduce costs with smart action caching and observe patterns
+</Card>
+
+<Card title="Observability & Metrics" icon="chart-line" href="/v2/configuration/observability">
+  Monitor usage patterns and track costs in real-time
+</Card>
+
+<Card title="Browser Configuration" icon="window-maximize" href="/v2/configuration/browser">
+  Optimize Browserbase infrastructure costs and session management
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/best-practices/deployments.mdx b/packages/docs/v2/best-practices/deployments.mdx
new file mode 100644
index 000000000..0579b7ad7
--- /dev/null
+++ b/packages/docs/v2/best-practices/deployments.mdx
@@ -0,0 +1,238 @@
+---
+title: 'Deploying Stagehand'
+description: 'Deploy your AI agents and automations to the cloud'
+---
+
+<Tip>
+**🌟 Preview: Browser Functions** - Deploy your web automation code directly on Browserbase with browser functions. Scale your `act()` automations in the cloud with zero infrastructure setup. Reach out to hello@browserbase.com to get beta access.
+</Tip>
+
+## Deploy on Vercel
+
+Securely run Stagehand on Browserbase inside a Vercel Function. This guide shows a minimal, production-safe HTTP endpoint you can call directly or on a schedule.
+
+### 1. Install Vercel CLI
+
+To download and install Vercel CLI, run one of the following commands:
+
+<CodeGroup>
+```bash pnpm
+pnpm i -g vercel
+```
+```bash yarn
+yarn global add vercel
+```
+```bash npm
+npm i -g vercel
+```
+```bash bun
+bun add -g vercel
+```
+</CodeGroup>
+
+### 2. Project layout
+
+```text
+your-project/
+  api/
+    run.ts
+  package.json
+  tsconfig.json
+  vercel.json
+```
+
+Create the structure with:
+
+```bash
+mkdir -p api
+touch api/run.ts package.json vercel.json tsconfig.json
+```
+
+### 3. `api/run.ts` (Node.js runtime)
+
+```typescript
+// api/run.ts
+import type { VercelRequest, VercelResponse } from "@vercel/node";
+import { Stagehand } from "@browserbasehq/stagehand";
+import { z } from "zod/v3";
+
+export default async function handler(req: VercelRequest, res: VercelResponse): Promise<void> {
+  try {
+    const stagehand = new Stagehand({
+      env: "BROWSERBASE",
+      apiKey: process.env.BROWSERBASE_API_KEY!,
+      projectId: process.env.BROWSERBASE_PROJECT_ID!,
+      disablePino: true,
+      modelName: "google/gemini-2.5-flash",
+      modelClientOptions: {
+        apiKey: process.env.GOOGLE_API_KEY!,
+      },
+      // optional session params
+      browserbaseSessionCreateParams: {
+        projectId: process.env.BROWSERBASE_PROJECT_ID!,
+        region: "us-west-2",
+        browserSettings: {
+          blockAds: true,
+        },
+      },
+    });
+
+    await stagehand.init();
+    const page = stagehand.page;
+
+    await page.goto("https://www.stagehand.dev/");
+    await page.act("click the evals button");
+
+    const { extraction } = await page.extract("extract the fastest model");
+    const data = { model: extraction ?? "" };
+
+    await stagehand.close();
+
+    res.status(200).json({ ok: true, data: data.model });
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    res.status(500).json({ ok: false, error: msg });
+  }
+}
+```
+
+### 4. `package.json`
+
+```json
+{
+    "name": "bb-stagehand-on-vercel",
+    "private": true,
+    "type": "module",
+    "engines": { "node": ">=18" },
+    "dependencies": {
+      "@browserbasehq/stagehand": "^2.4.3",
+      "zod": "^3.25.0"
+    },
+    "devDependencies": {
+      "typescript": "^5.6.0",
+      "@types/node": "^20.12.12",
+      "@vercel/node": "^3.2.20"
+    }
+}
+```
+
+### 5. `tsconfig.json`
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "outDir": ".vercel/output/functions",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "include": ["api/**/*.ts"]
+}
+```
+
+### 6. `vercel.json`
+
+```json
+{
+  "$schema": "https://openapi.vercel.sh/vercel.json",
+  "functions": {
+    "api/run.ts": {
+      "maxDuration": 60
+    }
+  }
+}
+```
+
+See Vercel's [configuring functions](https://vercel.com/docs/functions/configuring-functions) docs for more details.
+
+### 7. Link your project
+
+Link your local folder to a Vercel project before configuring environment variables:
+
+```bash
+# authenticate if needed
+vercel login
+
+# link the current directory to a Vercel project (interactive)
+vercel link
+```
+
+### 8. Environment variables
+
+Do not commit `.env` in production. Add variables via Vercel CLI:
+
+```bash
+vercel env add BROWSERBASE_API_KEY
+vercel env add BROWSERBASE_PROJECT_ID
+# (and your model key if needed)
+vercel env add GOOGLE_API_KEY
+```
+
+See also: [Browser Environment](/configuration/environment) for details on required variables.
+
+### 9. Test locally
+
+Replicate the Vercel environment locally to exercise your Function before deploying. Run from the project root.
+
+```bash
+# ensure dependencies are installed
+npm install
+
+# start the local Vercel dev server
+vercel dev --listen 5005
+```
+
+### 10. Deploy
+
+```bash
+vercel
+vercel --prod
+```
+
+### Execute the function
+
+#### Configure Protection Bypass for Automation
+
+Before invoking the production URL, create a Protection Bypass for Automation:
+
+1. Generate a 32-character secret (you can use `openssl rand -hex 16`)
+2. Go to your project in Vercel
+3. Navigate to Settings → Deployment Protection
+4. Add the secret to "Protection Bypass for Automation"
+
+Then invoke the function with the bypass header:
+
+```bash
+curl -X POST \
+  -H "x-vercel-protection-bypass: <your-32-character-secret>" \
+  https://<your-deployment>/api/run
+```
+
+### Optional: Cron on Vercel
+
+Hit the same endpoint on a schedule by extending `vercel.json`:
+
+```json
+{
+  "$schema": "https://openapi.vercel.sh/vercel.json",
+  "functions": {
+    "api/run.ts": {
+      "maxDuration": 60
+    }
+  }
+  },
+  "crons": [
+    { "path": "/api/run", "schedule": "0 * * * *" }
+  ]
+}
+```
+
+### Features
+- **No local browsers needed** with `env: "BROWSERBASE"`. [Browserbase](https://www.browserbase.com/) provides the browsers.
+- **Fast functionality**: Offload browser work to Browserbase and return JSON promptly.
+- **Long-running tasks**: Raise `maxDuration` and/or consider Edge runtime limits depending on plan.
+
diff --git a/packages/docs/v2/best-practices/mcp-integrations.mdx b/packages/docs/v2/best-practices/mcp-integrations.mdx
new file mode 100644
index 000000000..b29476941
--- /dev/null
+++ b/packages/docs/v2/best-practices/mcp-integrations.mdx
@@ -0,0 +1,269 @@
+---
+title: "MCP Integrations"
+description: "Using Model Context Protocol (MCP) integrations to enhance agent capabilities"
+---
+
+## What are MCP Integrations?
+
+MCP (Model Context Protocol) integrations allow you to connect your Stagehand agents to external tools, APIs, and services. This enables agents to perform actions beyond browser automation, such as web search, database operations, and API calls.
+
+<Info>
+MCP integrations make your agents more powerful by combining browser automation with external capabilities. The agent can intelligently decide when to use browser actions versus external tools.
+</Info>
+
+## Connection Options
+
+There are two options for connecting to MCP servers:
+
+1. **Pass a URL directly** - The simplest approach for quick setup
+2. **Create a connection first** - Gives you more control over the connection
+
+<Note>
+MCP client support is currently only available in TypeScript.
+</Note>
+
+## Passing a URL
+
+The simplest way to add MCP integrations is by providing server URLs directly in the agent configuration:
+
+```typescript
+const agent = stagehand.agent({
+  provider: "openai",
+  model: "computer-use-preview",
+  integrations: [
+    `https://mcp.exa.ai/mcp?exaApiKey=${process.env.EXA_API_KEY}`,
+  ],
+  instructions: `You have access to web search through Exa. Use it to find current information before browsing.`,
+  options: {
+    apiKey: process.env.OPENAI_API_KEY,
+  },
+});
+
+await agent.execute("Search for the best headphones of 2025 and go through checkout for the top recommendation");
+```
+
+## Creating a Connection First
+
+Alternatively, you can establish MCP connections first and then pass the client objects:
+
+```typescript
+import { connectToMCPServer } from "@browserbasehq/stagehand";
+
+// Connect to MCP server
+const supabaseClient = await connectToMCPServer(
+  `https://server.smithery.ai/@supabase-community/supabase-mcp/mcp?api_key=${process.env.SMITHERY_API_KEY}`
+);
+
+// You can also pass the config to start a local MCP server
+const notionClient = await connectToMCPServer({
+  command: "npx",
+  args: ["-y", "@notionhq/notion-mcp-server"],
+  env: {
+    NOTION_TOKEN: process.env.NOTION_TOKEN,
+  },
+});
+
+// Use the connected client
+const agent = stagehand.agent({
+  provider: "openai", 
+  model: "computer-use-preview",
+  integrations: [supabaseClient, notionClient],
+  instructions: `You can interact with Supabase databases and Notion. Use these tools to store and retrieve data.`,
+  options: {
+    apiKey: process.env.OPENAI_API_KEY,
+  },
+});
+
+await agent.execute("Search for restaurants in New Brunswick, NJ and save the first result to the database");
+```
+
+
+
+## Multiple Integrations
+
+You can combine multiple MCP integrations in a single agent:
+
+```typescript
+const databaseClient = await connectToMCPServer(/* database config */);
+
+const agent = stagehand.agent({
+  integrations: [
+    `https://search-service.example.com/mcp?apiKey=${process.env.SEARCH_API_KEY}`,
+    databaseClient
+  ],
+  instructions: `You have access to external tools for search and data storage. Use these tools strategically to complete tasks efficiently.`
+});
+```
+
+## Best Practices
+
+### Choose the Right Connection Approach
+<Tabs>
+<Tab title="Passing a URL">
+**When to use:**
+- Simple setup requirements
+- Standard API configurations
+- Getting started quickly
+
+**Benefits:**
+- Minimal code required
+- Automatic connection handling
+- Easy to configure
+</Tab>
+
+<Tab title="Creating a Connection First">
+**When to use:**
+- Custom connection options
+- Connection reuse across agents
+- Advanced error handling
+
+**Benefits:**
+- Full control over connections
+- Better error handling
+- Connection pooling capabilities
+</Tab>
+</Tabs>
+
+### Environment Variables
+
+Always use environment variables for API keys and sensitive information:
+
+```bash
+# .env file
+SEARCH_API_KEY=your_search_service_key
+MCP_SERVICE_API_KEY=your_mcp_service_key
+OPENAI_API_KEY=your_openai_key
+DATABASE_URL=your_database_url
+DATABASE_API_KEY=your_database_key
+```
+
+### Instructions Best Practices
+
+Provide clear instructions about available tools:
+
+<Tabs>
+<Tab title="Good Instructions">
+```typescript
+instructions: `You have access to:
+1. Web search tools - Use to find current information
+2. Database tools - Use to store/retrieve data
+3. Browser automation - Use for web interactions
+
+Always search for current information before making decisions.
+Store important data for later reference.`
+```
+</Tab>
+
+<Tab title="Poor Instructions">
+```typescript
+instructions: "You can search and save data."
+```
+</Tab>
+</Tabs>
+
+### Error Handling
+
+Implement proper error handling for MCP connections:
+
+```typescript
+try {
+  const client = await connectToMCPServer(serverUrl);
+  
+  const agent = stagehand.agent({
+    integrations: [client],
+    // ... other config
+  });
+  
+  const result = await agent.execute(instruction);
+} catch (error) {
+  console.error("MCP integration failed:", error);
+  // Handle fallback behavior
+}
+```
+
+## Troubleshooting
+
+<AccordionGroup>
+<Accordion title="Connection timeouts">
+**Problem:** MCP server connections timing out
+
+**Solutions:**
+- Verify server URLs are correct and accessible
+- Check network connectivity
+- Ensure API keys are valid and have proper permissions
+- Try connecting to servers individually to isolate issues
+</Accordion>
+
+<Accordion title="Tool not being used">
+**Problem:** Agent not using available MCP tools
+
+**Solutions:**
+- Make instructions more specific about when to use tools
+- Ensure API keys are properly configured
+- Check that the MCP server supports the expected tools
+- Verify tool descriptions are clear and actionable
+</Accordion>
+
+<Accordion title="Authentication errors">
+**Problem:** API key or authentication failures
+
+**Solutions:**
+- Verify all required environment variables are set
+- Check API key validity and permissions  
+- Ensure URLs include necessary authentication parameters
+- Test MCP connections independently before using in agents
+</Accordion>
+</AccordionGroup>
+
+## Examples
+
+### Web Search + Browser Automation
+```typescript
+const agent = stagehand.agent({
+  integrations: [`https://mcp.exa.ai/mcp?exaApiKey=${process.env.EXA_API_KEY}`],
+  instructions: `First search for current information, then use the browser to complete tasks based on what you find.`
+});
+
+await agent.execute("Find the best laptop deals for 2025 and navigate to purchase the top recommendation");
+```
+
+### Data Extraction + Storage
+```typescript
+const supabaseClient = await connectToMCPServer(/* config */);
+
+const agent = stagehand.agent({
+  integrations: [supabaseClient],
+  instructions: `Extract data from websites and store it using available database tools.`
+});
+
+await agent.execute("Extract all restaurant information from this directory and save it to the database");
+```
+
+### Multi-tool Workflow
+```typescript
+const agent = stagehand.agent({
+  integrations: [
+    `https://mcp.exa.ai/mcp?exaApiKey=${process.env.EXA_API_KEY}`,
+    supabaseClient
+  ],
+  instructions: `Use all available tools strategically: search for current info, browse websites, and store important data.`
+});
+
+await agent.execute("Research competitor pricing, compare with our site, and store the analysis");
+```
+
+## Further Reading
+
+<CardGroup cols={3}>
+<Card title="Agent Basics" icon="robot" href="/v2/basics/agent">
+  Learn the fundamentals of Stagehand agents
+</Card>
+
+<Card title="MCP Server Setup" icon="server" href="/v2/integrations/mcp/setup">  
+  Set up your own MCP server
+</Card>
+
+<Card title="Custom Tools" icon="wrench" href="/v2/integrations/mcp/tools">
+  Create custom MCP tools
+</Card>
+</CardGroup>
diff --git a/packages/docs/v2/best-practices/playwright-interop.mdx b/packages/docs/v2/best-practices/playwright-interop.mdx
new file mode 100644
index 000000000..a9ec4dfc5
--- /dev/null
+++ b/packages/docs/v2/best-practices/playwright-interop.mdx
@@ -0,0 +1,37 @@
+---
+title: 'Playwright Interoperability'
+description: 'How Stagehand interacts with Playwright'
+---
+
+Stagehand is built on top of [Playwright](https://playwright.dev/), so you can use Playwright methods directly through the Stagehand instance.
+
+## `page` and `context`
+
+`stagehand.page` and `stagehand.context` are instances of Playwright's `Page` and `BrowserContext` respectively. Use these methods to interact with the Playwright instance that Stagehand is using.
+
+<CodeGroup>
+```TypeScript TypeScript
+const page = stagehand.page;
+// Base Playwright methods work
+await page.goto("https://github.com/browserbase/stagehand");
+
+// Stagehand overrides Playwright objects
+await page.act("click on the contributors")
+```
+
+```python Python
+page = stagehand.page
+# Base Playwright methods work
+await page.goto("https://github.com/browserbase/stagehand")
+
+# Stagehand overrides Playwright objects
+await page.act("click on the contributors")
+```
+</CodeGroup>
+
+## Stagehand v. Playwright
+Below is an example of how to extract a list of companies from the AI Grant website using both Stagehand and Playwright.
+
+<img src="/images/stagehand-playwright.png" alt="Stagehand v. Playwright" />
+
+The above example with Stagehand can be easily reused to extract data from other websites, whereas the Playwright example would need to be rewritten for each new website.
\ No newline at end of file
diff --git a/packages/docs/v2/best-practices/prompting-best-practices.mdx b/packages/docs/v2/best-practices/prompting-best-practices.mdx
new file mode 100644
index 000000000..9ba3683b9
--- /dev/null
+++ b/packages/docs/v2/best-practices/prompting-best-practices.mdx
@@ -0,0 +1,493 @@
+---
+title: Prompting Best Practices
+description: "Write effective prompts for reliable Stagehand automation"
+---
+
+Good prompts make Stagehand reliable. Bad prompts cause failures. Here's how to write prompts that work consistently.
+
+## Act Method
+
+Use `act()` for single actions on web pages. Each action should be focused and clear.
+
+<CodeGroup>
+```typescript TypeScript
+// Good - Single, specific actions
+await page.act("click the 'Add to Cart' button");
+await page.act("type 'user@example.com' into the email field");
+
+// Bad - Multiple actions combined
+await page.act("fill out the form and submit it");
+await page.act("login with credentials and navigate to dashboard");
+```
+
+```python Python
+# Good - Single, specific actions
+await page.act("click the 'Add to Cart' button")
+await page.act("type 'user@example.com' into the email field")
+
+# Bad - Multiple actions combined
+await page.act("fill out the form and submit it")
+await page.act("login with credentials and navigate to dashboard")
+```
+</CodeGroup>
+
+### Use Element Types, Not Colors
+
+Describe elements by their type and function rather than visual attributes like color.
+
+<CodeGroup>
+```typescript TypeScript
+// Good - Element types and descriptive text
+await page.act("click the 'Sign In' button");
+await page.act("type into the email input field");
+
+// Bad - Color-based descriptions
+await page.act("click the blue button");
+await page.act("type into the white input");
+```
+
+```python Python
+# Good - Element types and descriptive text
+await page.act("click the 'Sign In' button")
+await page.act("type into the email input field")
+
+# Bad - Color-based descriptions
+await page.act("click the blue button")
+await page.act("type into the white input")
+```
+</CodeGroup>
+
+### Use Descriptive Language
+
+<CodeGroup>
+```typescript TypeScript
+// Good - Clear element identification
+await page.act("click the 'Next' button at the bottom of the form");
+await page.act("type into the search bar at the top of the page");
+
+// Bad - Vague descriptions
+await page.act("click next");
+await page.act("type into search");
+```
+
+```python Python
+# Good - Clear element identification
+await page.act("click the 'Next' button at the bottom of the form")
+await page.act("type into the search bar at the top of the page")
+
+# Bad - Vague descriptions
+await page.act("click next")
+await page.act("type into search")
+```
+</CodeGroup>
+
+### Choose the Right Action Verbs
+
+- **Click** for buttons, links, checkboxes
+- **Type** for text inputs
+- **Select** for dropdowns
+- **Check/uncheck** for checkboxes
+- **Upload** for file inputs
+
+<CodeGroup>
+```typescript TypeScript
+// Good
+await page.act("click the submit button");
+await page.act("select 'Option 1' from dropdown");
+
+// Bad
+await page.act("click submit");
+await page.act("choose option 1");
+```
+
+```python Python
+# Good
+await page.act("click the submit button")
+await page.act("select 'Option 1' from dropdown")
+
+# Bad
+await page.act("click submit")
+await page.act("choose option 1")
+```
+</CodeGroup>
+
+### Protect Sensitive Data
+
+Variables keep sensitive information out of prompts and logs.
+
+<CodeGroup>
+```typescript TypeScript
+// Good - Secure approach
+await page.act({
+  action: "enter %username% in the email field",
+  variables: {
+    username: "user@example.com"
+  }
+});
+
+await page.act({
+  action: "enter %password% in the password field", 
+  variables: {
+    password: process.env.USER_PASSWORD
+  }
+});
+
+// Bad - Insecure approach
+await page.act("type 'mySecretPassword123' into the password field");
+```
+
+```python Python
+import os
+
+# Good - Secure approach
+await page.act(
+  "enter %username% in the email field",
+  variables={
+    "username": "user@example.com"
+  }
+)
+
+await page.act(
+  "enter %password% in the password field",
+  variables={
+    "password": os.environ.get("USER_PASSWORD")
+  }
+)
+
+# Bad - Insecure approach
+await page.act("type 'mySecretPassword123' into the password field")
+```
+</CodeGroup>
+
+<Warning>
+Set `verbose: 0` in your Stagehand config to prevent secrets from appearing in logs.
+</Warning>
+
+## Extract Method
+
+Use `extract()` to pull structured data from pages. Define clear schemas and provide context.
+
+### Schema Best Practices
+
+Use descriptive field names, correct types, and detailed descriptions. Field descriptions provide context that helps the agent understand exactly what to extract.
+
+<CodeGroup>
+```typescript TypeScript
+// Good - Descriptive names, correct types, and helpful descriptions
+const productData = await page.extract({
+  instruction: "Extract product information",
+  schema: z.object({
+    productTitle: z.string().describe("The main product name displayed on the page"),
+    priceInDollars: z.number().describe("Current selling price as a number, without currency symbol"),
+    isInStock: z.boolean().describe("Whether the product is available for purchase")
+  })
+});
+
+// Bad - Generic names, wrong types, no descriptions
+const data = await page.extract({
+  instruction: "Get product details", 
+  schema: z.object({
+    name: z.string(), // Too generic, no context
+    price: z.string(), // Should be number
+    stock: z.string() // Should be boolean, no context
+  })
+});
+```
+
+```python Python
+from pydantic import BaseModel, Field
+
+# Good - Descriptive names, correct types, and helpful descriptions
+class ProductData(BaseModel):
+    productTitle: str = Field(description="The main product name displayed on the page")
+    priceInDollars: float = Field(description="Current selling price as a number, without currency symbol")
+    isInStock: bool = Field(description="Whether the product is available for purchase")
+
+productData = await page.extract(
+  "Extract product information",
+  schema=ProductData
+)
+
+# Bad - Generic names, wrong types, no descriptions
+class Data(BaseModel):
+    name: str      # Too generic, no context
+    price: str     # Should be float, no context
+    stock: str     # Should be bool, no context
+
+data = await page.extract(
+  "Get product details",
+  schema=Data
+)
+```
+</CodeGroup>
+
+### Handle Arrays Correctly
+
+Always wrap schemas in objects for reliable extraction.
+
+<CodeGroup>
+```typescript TypeScript
+// Good - Array wrapped in object
+const listings = await page.extract({
+  instruction: "Extract all apartment listings",
+  schema: z.object({
+    apartments: z.array(z.object({
+      address: z.string(),
+      rent: z.number()
+    }))
+  })
+});
+
+// Bad - Bare array
+const listings = await page.extract({
+  instruction: "Extract apartment listings",
+  schema: z.array(z.string()) // Don't do this
+});
+```
+
+```python Python
+from pydantic import BaseModel
+from typing import List
+
+# Good - Array wrapped in object
+class Apartment(BaseModel):
+    address: str
+    rent: float
+
+class Listings(BaseModel):
+    apartments: List[Apartment]
+
+listings = await page.extract(
+  "Extract all apartment listings",
+  schema=Listings
+)
+
+# Bad - Bare array (not supported)
+# Don't do this - arrays must be wrapped in objects
+```
+</CodeGroup>
+
+### Use Proper URL Types
+
+Specify URL types to tell Stagehand to extract URLs. Without proper URL types, Stagehand won't extract URLs.
+
+<CodeGroup>
+```typescript TypeScript
+// Good - Tells Stagehand to extract URLs
+const links = await page.extract({
+  instruction: "Extract navigation links",
+  schema: z.object({
+    links: z.array(z.object({
+      text: z.string(),
+      url: z.string().url() // Required for URL extraction
+    }))
+  })
+});
+```
+
+```python Python
+from pydantic import BaseModel, HttpUrl
+from typing import List
+
+# Good - Tells Stagehand to extract URLs
+class Link(BaseModel):
+    text: str
+    url: HttpUrl  # Required for URL extraction
+
+class Links(BaseModel):
+    links: List[Link]
+
+links = await page.extract(
+  "Extract navigation links",
+  schema=Links
+)
+```
+</CodeGroup>
+
+## Observe Method
+
+Use `observe()` to discover actionable elements before acting on them.
+
+### Check Elements First
+
+Verify elements exist before taking action to avoid errors.
+
+<CodeGroup>
+```typescript TypeScript
+// Check for elements first
+const loginButtons = await page.observe("Find the login button");
+
+if (loginButtons.length > 0) {
+  await page.act(loginButtons[0]);
+} else {
+  console.log("No login button found");
+}
+```
+
+```python Python
+# Check for elements first
+login_buttons = await page.observe("Find the login button")
+
+if len(login_buttons) > 0:
+    await page.act(login_buttons[0])
+else:
+    print("No login button found")
+```
+</CodeGroup>
+
+### Be Specific About Element Types
+
+<CodeGroup>
+```typescript TypeScript
+// Good - Specific element types
+const submitButtons = await page.observe("Find submit button in the form");
+const dropdowns = await page.observe("Find the state dropdown menu");
+
+// Bad - Too vague
+const elements = await page.observe("Find submit stuff");
+const things = await page.observe("Find state selection");
+```
+
+```python Python
+# Good - Specific element types
+submit_buttons = await page.observe("Find submit button in the form")
+dropdowns = await page.observe("Find the state dropdown menu")
+
+# Bad - Too vague
+elements = await page.observe("Find submit")
+things = await page.observe("Find state selection")
+```
+</CodeGroup>
+
+## Agent Method
+
+Use `agent()` for complex, multi-step workflows. Provide detailed instructions and set appropriate limits.
+
+### Navigate First
+
+Don't include navigation in agent tasks. Handle it separately.
+
+<CodeGroup>
+```typescript TypeScript
+// Good - Navigate first
+await page.goto('https://amazon.com');
+await agent.execute('Search for wireless headphones under $100 and add the best rated one to cart');
+
+// Bad - Navigation in task
+await agent.execute('Go to Amazon, search for headphones, and add one to cart');
+```
+
+```python Python
+# Good - Navigate first
+await page.goto('https://amazon.com')
+await agent.execute('Search for wireless headphones under $100 and add the best rated one to cart')
+
+# Bad - Navigation in task
+await agent.execute('Go to Amazon, search for headphones, and add one to cart')
+```
+</CodeGroup>
+
+### Be Highly Specific
+
+Detailed instructions lead to better results.
+
+<CodeGroup>
+```typescript TypeScript
+// Good - Detailed instructions
+await agent.execute({
+  instruction: "Find Italian restaurants in Brooklyn that are open after 10pm, have outdoor seating, and are rated 4+ stars. Save the top 3 results.",
+  maxSteps: 25
+});
+
+// Bad - Vague instructions
+await agent.execute("Find some good restaurants");
+```
+
+```python Python
+# Good - Detailed instructions
+await agent.execute(
+  instruction="Find Italian restaurants in Brooklyn that are open after 10pm, have outdoor seating, and are rated 4+ stars. Save the top 3 results.",
+  max_steps=25
+)
+
+# Bad - Vague instructions
+await agent.execute("Find some good restaurants")
+```
+</CodeGroup>
+
+### Set Appropriate Step Limits
+
+Match step limits to task complexity.
+
+<CodeGroup>
+```typescript TypeScript
+// Simple task - fewer steps
+await agent.execute({
+  instruction: "Subscribe to the newsletter with email 'user@example.com'",
+  maxSteps: 10
+});
+
+// Complex task - more steps  
+await agent.execute({
+  instruction: "Research and compare 5 project management tools with pricing and features",
+  maxSteps: 50
+});
+```
+
+```python Python
+# Simple task - fewer steps
+await agent.execute(
+  instruction="Subscribe to the newsletter with email 'user@example.com'",
+  max_steps=10
+)
+
+# Complex task - more steps
+await agent.execute(
+  instruction="Research and compare 5 project management tools with pricing and features",
+  max_steps=50
+)
+```
+</CodeGroup>
+
+### Include Success Criteria
+
+Tell the agent how to know when it's done.
+
+<CodeGroup>
+```typescript TypeScript
+// Good - Clear success criteria
+await agent.execute({
+  instruction: "Add 3 smartphone cases to cart and confirm the cart shows exactly 3 items with total price",
+  maxSteps: 20
+});
+
+// Bad - No validation
+await agent.execute("Add some items to cart");
+```
+
+```python Python
+# Good - Clear success criteria
+await agent.execute(
+  instruction="Add 3 smartphone cases to cart and confirm the cart shows exactly 3 items with total price",
+  max_steps=20
+)
+
+# Bad - No validation
+await agent.execute("Add some items to cart")
+```
+</CodeGroup>
+
+## Common Mistakes to Avoid
+
+- **Combining multiple actions** - Keep each `act()` call to one action
+- **Using vague descriptions** - Be specific about which elements to interact with  
+- **Exposing sensitive data** - Always use variables for credentials
+- **Skipping validation** - Check results before proceeding
+
+## Testing Your Prompts
+
+1. **Start simple** - Test basic functionality first
+2. **Add complexity gradually** - Build up to complex workflows
+3. **Monitor results** - Use logging to understand what's happening
+4. **Iterate based on failures** - Refine prompts when they don't work
+Remember: Good prompting is iterative. When in doubt, be more specific rather than less.
\ No newline at end of file
diff --git a/packages/docs/v2/best-practices/speed-optimization.mdx b/packages/docs/v2/best-practices/speed-optimization.mdx
new file mode 100644
index 000000000..7bc72a674
--- /dev/null
+++ b/packages/docs/v2/best-practices/speed-optimization.mdx
@@ -0,0 +1,352 @@
+---
+title: Speed Optimization
+sidebarTitle: Speed Optimization
+description: Optimize Stagehand performance for faster automation and reduced latency
+---
+
+Stagehand performance depends on several factors: DOM processing speed, LLM inference time, browser operations, and network latency. This guide provides proven strategies to maximize automation speed.
+
+## Quick Performance Wins
+
+### 1. Plan Ahead with Observe
+
+
+Use a single `observe()` call to plan multiple actions, then execute them efficiently:
+
+<CodeGroup>
+```typescript TypeScript
+// Instead of sequential operations with multiple LLM calls
+await page.act("Fill name field");        // LLM call #1
+await page.act("Fill email field");       // LLM call #2
+await page.act("Select country dropdown"); // LLM call #3
+
+// Use single observe to plan all form fields - one LLM call
+const formFields = await page.observe("Find all form fields to fill");
+
+// Execute all actions without LLM inference
+for (const field of formFields) {
+  await page.act(field); // No LLM calls!
+}
+```
+```python Python
+import asyncio
+
+# Instead of sequential operations with multiple LLM calls
+await page.act("Fill name field")        # LLM call #1
+await page.act("Fill email field")       # LLM call #2  
+await page.act("Select country dropdown") # LLM call #3
+
+# Use single observe to plan all form fields - one LLM call
+form_fields = await page.observe("Find all form fields to fill")
+
+# Execute all actions without LLM inference
+for field in form_fields:
+    await page.act(field) # No LLM calls!
+
+```
+</CodeGroup>
+
+<Note>
+**Performance Tip**: Acting on `observe` results avoids LLM inference entirely. This approach is 2-3x faster than direct `act()` calls and is the recommended pattern for multi-step workflows.
+</Note>
+
+<Card title="Caching Guide" icon="database" href="/v2/best-practices/caching">
+  Learn advanced caching patterns and cache invalidation strategies
+</Card>
+
+### 2. Optimize DOM Processing
+
+Reduce DOM complexity before Stagehand processes the page:
+
+<CodeGroup>
+```typescript TypeScript
+// Remove heavy elements that slow down processing
+await page.evaluate(() => {
+  // Remove video elements
+  document.querySelectorAll('video, iframe').forEach(el => el.remove());
+  
+  // Hide complex animations
+  document.querySelectorAll('[style*="animation"]').forEach(el => {
+    (el as HTMLElement).style.animation = 'none';
+  });
+});
+
+// Then perform Stagehand operations
+await page.act("Click the submit button");
+```
+```python Python
+# Remove heavy elements that slow down processing
+await page.evaluate("""
+() => {
+  // Remove video elements
+  document.querySelectorAll('video, iframe').forEach(el => el.remove());
+  
+  // Hide complex animations
+  document.querySelectorAll('[style*="animation"]').forEach(el => {
+    el.style.animation = 'none';
+  });
+}
+""")
+
+# Then perform Stagehand operations
+await page.act("Click the submit button")
+```
+</CodeGroup>
+
+### 3. Set Appropriate Timeouts
+
+Use shorter timeouts for simple operations and longer ones for complex page loads:
+
+<CodeGroup>
+```typescript TypeScript
+// Simple actions - reduce action timeout
+await page.act({ 
+  instruction: "Click the login button",
+  actTimeout: 5000  // Default is 30000ms, reduce for simple clicks
+});
+
+// Complex page loads - optimize navigation
+await page.goto("https://heavy-spa.com", {
+  waitUntil: "domcontentloaded", // Don't wait for all resources
+  timeout: 15000 // Shorter than default 30s
+});
+```
+```python Python
+# Simple actions - reduce action timeout
+await page.act("Click button", act_timeout=5000)
+
+
+# Complex page loads - optimize navigation
+await page.goto("https://heavy-spa.com", 
+    wait_until="domcontentloaded",
+    timeout=15000
+)
+```
+</CodeGroup>
+
+## Advanced Performance Strategies
+
+
+### Smart Model Selection
+
+Use faster models for simple tasks, premium models only when needed:
+
+<CodeGroup>
+```typescript TypeScript
+class SpeedOptimizedStagehand {
+  private fastModel: Stagehand;
+  private premiumModel: Stagehand;
+
+  async smartAct(page: Page, prompt: string, complexity: 'simple' | 'complex') {
+    const model = complexity === 'simple' ? this.fastModel : this.premiumModel;
+    return await model.page.act(prompt);
+  }
+}
+
+// Use fast model for simple clicks/forms
+await stagehand.smartAct(page, "Click submit", 'simple');
+
+// Use premium model for complex reasoning
+await stagehand.smartAct(page, "Find the cheapest flight option", 'complex');
+```
+```python Python
+class SpeedOptimizedStagehand:
+    def __init__(self):
+        self.fast_model = Stagehand(model_name="fast-model")
+        self.premium_model = Stagehand(model_name="premium-model")
+    
+    async def smart_act(self, page, prompt: str, complexity: str):
+        model = self.fast_model if complexity == 'simple' else self.premium_model
+        return await model.page.act(prompt)
+
+# Use fast model for simple clicks/forms
+await stagehand.smart_act(page, "Click submit", 'simple')
+
+# Use premium model for complex reasoning  
+await stagehand.smart_act(page, "Find the cheapest flight option", 'complex')
+```
+</CodeGroup>
+
+<Card title="Model Configuration" icon="brain" href="/v2/configuration/models">
+  Compare model performance and costs
+</Card>
+
+### Page Load Optimization
+
+Skip unnecessary resources during page loads:
+
+<CodeGroup>
+```typescript TypeScript
+// Block heavy resources globally
+await context.route('**/*', (route) => {
+  const resourceType = route.request().resourceType();
+  if (['image', 'font', 'media'].includes(resourceType)) {
+    route.abort();
+  } else {
+    route.continue();
+  }
+});
+
+// Use faster navigation
+await page.goto(url, { 
+  waitUntil: 'domcontentloaded',  // Don't wait for images/fonts
+  timeout: 10000 
+});
+```
+```python Python
+# Block heavy resources globally
+async def handle_route(route):
+    resource_type = route.request.resource_type
+    if resource_type in ['image', 'font', 'media']:
+        await route.abort()
+    else:
+        await route.continue_()
+
+await context.route('**/*', handle_route)
+
+# Use faster navigation
+await page.goto(url, 
+    wait_until='domcontentloaded',  # Don't wait for images/fonts
+    timeout=10000
+)
+```
+</CodeGroup>
+<Card title="Cost Optimization" icon="dollar-sign" href="/v2/best-practices/cost-optimization">
+  Balance speed with cost considerations
+</Card>
+
+## Performance Monitoring and Benchmarking
+
+Track performance metrics and measure optimization impact:
+
+### Performance Tracking
+
+<CodeGroup>
+```typescript TypeScript
+class PerformanceTracker {
+  private speedMetrics: Map<string, number[]> = new Map();
+
+  async timedAct(page: Page, prompt: string): Promise<ActResult> {
+    const start = Date.now();
+    const result = await page.act(prompt);
+    const duration = Date.now() - start;
+    
+    if (!this.speedMetrics.has(prompt)) {
+      this.speedMetrics.set(prompt, []);
+    }
+    this.speedMetrics.get(prompt)!.push(duration);
+    
+    console.log(`Action "${prompt}" took ${duration}ms`);
+    return result;
+  }
+
+  getAverageTime(prompt: string): number {
+    const times = this.speedMetrics.get(prompt) || [];
+    return times.reduce((a, b) => a + b, 0) / times.length;
+  }
+}
+```
+```python Python
+import time
+from collections import defaultdict
+
+class PerformanceTracker:
+    def __init__(self):
+        self.speed_metrics = defaultdict(list)
+    
+    async def timed_act(self, page, prompt: str):
+        start = time.time()
+        result = await page.act(prompt)
+        duration = (time.time() - start) * 1000  # Convert to ms
+        
+        self.speed_metrics[prompt].append(duration)
+        print(f'Action "{prompt}" took {duration:.0f}ms')
+        return result
+    
+    def get_average_time(self, prompt: str) -> float:
+        times = self.speed_metrics[prompt]
+        return sum(times) / len(times) if times else 0
+```
+</CodeGroup>
+
+Example Output:
+```
+Action "Fill form" took 1000ms
+Action "Click submit" took 2000ms
+Action "Confirm submission" took 5000ms
+```
+
+### Before vs After Benchmarking
+
+<CodeGroup>
+```typescript TypeScript
+// Before optimization
+console.time("workflow");
+await page.act("Fill form");
+await page.act("Click submit");
+await page.act("Confirm submission");
+console.timeEnd("workflow"); // 8000ms
+
+// After optimization with observe planning
+console.time("workflow-optimized");
+const workflowActions = await page.observe("Find form, submit, and confirm elements");
+
+// Execute actions sequentially to avoid conflicts
+for (const action of workflowActions) {
+  await page.act(action);
+}
+console.timeEnd("workflow-optimized"); // 500ms
+```
+```python Python
+import time
+
+# Before optimization  
+start = time.time()
+await page.act("Fill form")
+await page.act("Click submit") 
+await page.act("Confirm submission")
+print(f"Workflow took {(time.time() - start) * 1000:.0f}ms")  # 8000ms
+
+# After optimization with observe planning
+start = time.time()
+workflow_actions = await page.observe("Find form, submit, and confirm elements")
+
+# Execute actions sequentially to avoid conflicts
+for action in workflow_actions:
+    await page.act(action)
+print(f"Optimized workflow took {(time.time() - start) * 1000:.0f}ms")  # 500ms
+```
+</CodeGroup>
+
+Example Output:
+```
+Workflow took 8000ms
+Optimized workflow took 500ms
+```
+
+<CardGroup cols={1}>
+<Card title="Observability & Metrics" icon="chart-line" href="/v2/configuration/observability">
+  Set up comprehensive performance monitoring
+</Card>
+</CardGroup>
+
+
+## Related Resources
+
+<CardGroup cols={2}>
+<Card title="Caching Strategies" icon="database" href="/v2/best-practices/caching">
+  Advanced caching patterns for maximum performance
+</Card>
+
+<Card title="Cost Optimization" icon="dollar-sign" href="/v2/best-practices/cost-optimization">
+  Balance speed improvements with cost considerations
+</Card>
+
+<Card title="Browser Configuration" icon="window-maximize" href="/v2/configuration/browser">
+  Optimize Browserbase settings for speed
+</Card>
+
+<Card title="Model Selection" icon="brain" href="/v2/configuration/models">
+  Choose the right model for speed vs accuracy
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/best-practices/usecase-observe.mdx b/packages/docs/v2/best-practices/usecase-observe.mdx
new file mode 100644
index 000000000..ebe8a1180
--- /dev/null
+++ b/packages/docs/v2/best-practices/usecase-observe.mdx
@@ -0,0 +1,104 @@
+---
+sidebarTitle: Use Cases
+---
+
+## Real-World Use Cases
+
+### E-commerce Product Discovery
+
+```typescript
+// Discover product interaction elements
+const productActions = await page.observe({
+  instruction: "Find add to cart buttons, size selectors, and product images"
+});
+
+// Categorize actions by type
+const cartButtons = productActions.filter(a => 
+  a.description.toLowerCase().includes('cart')
+);
+const sizeOptions = productActions.filter(a => 
+  a.description.toLowerCase().includes('size')
+);
+
+// Execute purchase workflow
+if (sizeOptions.length > 0) {
+  await page.act(sizeOptions[0]); // Select size first
+}
+if (cartButtons.length > 0) {
+  await page.act(cartButtons[0]); // Then add to cart
+}
+```
+
+### Form Handling & Validation
+
+```typescript
+// Analyze form structure before filling
+const formElements = await page.observe({
+  instruction: "Find form fields, validation messages, and submit buttons"
+});
+
+// Check for required fields
+const requiredFields = formElements.filter(e => 
+  e.description.includes('required') || e.description.includes('*')
+);
+
+console.log(`Found ${requiredFields.length} required fields to complete`);
+
+// Fill form systematically
+for (const field of requiredFields) {
+  await page.act(field);
+  // Add appropriate input based on field type
+}
+```
+
+### Dynamic Content & SPA Navigation
+
+```typescript
+// Wait for and discover dynamically loaded content
+await page.waitForLoadState('networkidle');
+
+const dynamicElements = await page.observe({
+  instruction: "Find newly loaded content, infinite scroll triggers, or loading indicators",
+  domSettleTimeoutMs: 15000 // Wait longer for dynamic content
+});
+
+// Handle infinite scroll
+const scrollTriggers = dynamicElements.filter(e => 
+  e.description.toLowerCase().includes('load more') ||
+  e.description.toLowerCase().includes('scroll')
+);
+
+if (scrollTriggers.length > 0) {
+  await page.act(scrollTriggers[0]);
+  // Recursively observe new content
+  const newContent = await page.observe("Find additional items");
+}
+```
+
+### Multi-Step Workflow Planning
+
+```typescript
+// Plan entire checkout flow upfront
+async function planCheckoutWorkflow() {
+  // Step 1: Cart page analysis
+  await page.goto('/cart');
+  const cartActions = await page.observe("Find checkout and cart modification options");
+  
+  // Step 2: Checkout page analysis  
+  const checkoutButton = cartActions.find(a => a.description.includes('checkout'));
+  if (checkoutButton) await page.act(checkoutButton);
+  
+  const checkoutActions = await page.observe("Find payment forms and shipping options");
+  
+  // Step 3: Plan execution order
+  const shippingFields = checkoutActions.filter(a => a.description.includes('shipping'));
+  const paymentFields = checkoutActions.filter(a => a.description.includes('payment'));
+  const submitButton = checkoutActions.find(a => a.description.includes('complete order'));
+  
+  return { shippingFields, paymentFields, submitButton };
+}
+
+// Execute planned workflow
+const workflow = await planCheckoutWorkflow();
+// Fill shipping → payment → submit
+```
diff --git a/packages/docs/v2/best-practices/user-data.mdx b/packages/docs/v2/best-practices/user-data.mdx
new file mode 100644
index 000000000..90e3ac029
--- /dev/null
+++ b/packages/docs/v2/best-practices/user-data.mdx
@@ -0,0 +1,56 @@
+---
+title: User Data Directory
+sidebarTitle: User Data
+description: Persist browser data between sessions
+---
+
+### User Data Directory
+
+Persist browser data between sessions using a custom user data directory:
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+// For Browserbase sessions
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  browserbaseSessionCreateParams: {
+    userDataDir: "/path/to/user/data/directory",
+  },
+});
+
+// For Local sessions
+const localStagehand = new Stagehand({
+  env: "LOCAL",
+  localBrowserLaunchOptions: {
+    userDataDir: "./browser-data",
+  },
+});
+
+await stagehand.init();
+console.log("Session ID:", stagehand.sessionId);
+```
+```python Python
+from stagehand import Stagehand
+
+# For Browserbase sessions
+stagehand = Stagehand(
+    env="BROWSERBASE",
+    browserbase_session_create_params={
+        "user_data_dir": "/path/to/user/data/directory",
+    },
+)
+
+# For Local sessions
+local_stagehand = Stagehand(
+    env="LOCAL",
+    local_browser_launch_options={
+        "user_data_dir": "./browser-data",
+    },
+)
+
+await stagehand.init()
+print(f"Session ID: {stagehand.session_id}")
+```
+</CodeGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/best-practices/using-multiple-tabs.mdx b/packages/docs/v2/best-practices/using-multiple-tabs.mdx
new file mode 100644
index 000000000..9cbda7254
--- /dev/null
+++ b/packages/docs/v2/best-practices/using-multiple-tabs.mdx
@@ -0,0 +1,141 @@
+---
+title: 'Using Multiple Tabs'
+description: 'Act on multiple tabs with Stagehand'
+---
+
+Many modern web applications open new tabs when users click certain buttons or links. Without proper multitab support, automation scripts break when expected content appears in a new tab rather than the current one. Stagehand's multitab capabilities ensure your automations work seamlessly across multitab workflows.
+
+## The Stagehand Page
+
+Stagehand automatically adapts to multitab workflows. The `stagehand.page` object always points to the most recently opened or active tab, ensuring your automations continue working even when new tabs are created.
+
+This means you can continue using familiar patterns:
+
+<CodeGroup>
+```typescript TypeScript
+const page = stagehand.page;
+await page.goto("https://example.com");
+await page.act("click the button that opens a new tab");
+// page now automatically points to the new tab
+await page.extract("get data from new tab");
+```
+
+```python Python
+page = stagehand.page
+await page.goto("https://example.com")
+await page.act("click the button that opens a new tab")
+# page now automatically points to the new tab
+await page.extract("get data from new tab")
+```
+</CodeGroup>
+
+<Warning>
+**Important**: [Stagehand Agent](/v2/basics/agent) will always operate on the `stagehand.page`. If you need an agent to work across specific tabs, you'll need to manage page switching manually.
+</Warning>
+
+## Manual Page Management
+
+For more control or multitab workflows, you can manage multiple tabs explicitly:
+
+<CodeGroup>
+```typescript TypeScript
+// Create a second page
+await stagehand.context.newPage();
+const pages = stagehand.context.pages();
+
+const githubPage = pages[0];
+const pythonPage = pages[1];
+
+// Navigate each page to different repositories
+await githubPage.goto("https://github.com/browserbase/stagehand");
+await pythonPage.goto("https://github.com/browserbase/stagehand-python");
+
+// Extract data from both pages simultaneously
+const [stagehandStars, stagehandPythonStars] = await Promise.all([
+  githubPage.extract("extract the repository stars"),
+  pythonPage.extract("extract the repository stars")
+]);
+
+console.log(`Stagehand stars: ${stagehandStars}`);
+console.log(`Stagehand-Python stars: ${stagehandPythonStars}`);
+```
+
+```python Python
+# Create a second page
+await stagehand.context.new_page()
+pages = stagehand.context.pages()
+
+github_page = pages[0]
+python_page = pages[1]
+
+# Navigate each page to different repositories  
+await github_page.goto("https://github.com/browserbase/stagehand")
+await python_page.goto("https://github.com/browserbase/stagehand-python")
+
+# Extract data from both pages
+stagehand_stars = await github_page.extract("extract the repository stars")
+stagehand_python_stars = await python_page.extract("extract the repository stars")
+
+print(f"Stagehand stars: {stagehand_stars}")
+print(f"Stagehand-Python stars: {stagehand_python_stars}")
+```
+</CodeGroup>
+
+## Handling Tab Events
+
+You can also listen for tab events to control what happens when new tabs are opened:
+
+<CodeGroup>
+```typescript TypeScript
+const page = stagehand.page;
+await page.goto("https://browserbase.github.io/stagehand-eval-sites/sites/five-tab/");
+
+// close the new tab after it's opened
+page.on("popup", async () => {
+  const newPage = stagehand.context.pages()[1];
+  await newPage.close();
+});
+
+await page.act("click the button to open the other page");
+
+const page_number = await page.extract("extract the page number");
+console.log(`You're on page ${page_number}`);
+```
+
+```python Python
+page = stagehand.page
+await page.goto("https://browserbase.github.io/stagehand-eval-sites/sites/five-tab/")
+
+# Close the new tab after it's opened
+async def handle_popup():
+    new_page = stagehand.context.pages()[1]
+    await new_page.close()
+
+page.on("popup", handle_popup)
+
+await page.act("click the button to open the other page")
+
+page_number = await page.extract("extract the page number")
+print(f"You're on page {page_number}")
+```
+</CodeGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Orchestrate complex workflows with Agent" icon="robot" iconType="sharp-solid" href="/v2/basics/agent">
+    Use `Agent` to autonomously execute multi-step tasks and complex workflows.
+  </Card>
+
+  <Card title="Working with iframes" icon="frame" iconType="sharp-solid" href="/v2/best-practices/working-with-iframes">
+    Learn best practices for interacting with elements inside iframes.
+  </Card>
+
+  <Card title="Browser Configuration" icon="browser" iconType="sharp-solid" href="/v2/configuration/browser">
+    Manage browser contexts and sessions for complex automation scenarios.
+  </Card>
+
+  <Card title="Logging & Debugging" icon="bug" iconType="sharp-solid" href="/v2/configuration/logging">
+    Handle errors gracefully and debug automation issues effectively.
+  </Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/best-practices/working-with-iframes.mdx b/packages/docs/v2/best-practices/working-with-iframes.mdx
new file mode 100644
index 000000000..a12d1a99b
--- /dev/null
+++ b/packages/docs/v2/best-practices/working-with-iframes.mdx
@@ -0,0 +1,90 @@
+---
+title: Working with iframes
+---
+
+### What is an iframe?
+
+Iframes embed other pages within your current page. Sites use them for consent banners, payment widgets, chat bubbles, and third-party content.
+Elements inside iframes exist in a separate context than the main page.
+
+### Enable iframe support
+
+Set `iframes: true` in your `act()`, `observe()`, and `extract()` commands.
+
+<CodeGroup>
+```typescript TypeScript
+// Act within iframes
+await page.act({ action: "click the accept cookies button", iframes: true });
+
+// Observe within iframes
+const results = await page.observe({
+  instruction: "Find the primary action button",
+  iframes: true,
+});
+
+// Extract from iframes
+const data = await page.extract({
+  instruction: "Extract the product price from the payment widget",
+  schema: z.object({
+    price: z.string(),
+  }),
+  iframes: true,
+});
+```
+
+```python Python
+# Act within iframes
+await page.act(
+    "click the accept cookies button",
+    iframes=True
+)
+
+# Observe within iframes
+results = await page.observe({
+    "instruction": "Find the primary action button",
+    "iframes": True,
+})
+
+# Extract from iframes
+data = await page.extract({
+    "instruction": "Extract the product price from the payment widget",
+    "schema": {
+        "type": "object",
+        "properties": {
+            "price": {"type": "string"}
+        }
+    },
+    "iframes": True,
+})
+```
+</CodeGroup>
+
+### Tips
+
+- Iframes can increase processing time. For best performance, use the iframe option only when necessary.
+- When you are unsure whether an element will be in an iframe, you can verify the presence of iframes in Stagehand logs.
+- If an element intermittently fails to be found, it may be inside a lazy‑loaded iframe. Add small waits between steps or re‑run your action.
+
+<Note>
+You can enable experimental features (like Shadow DOM support) via your Stagehand configuration. See the [configuration guide](/v2/configuration/browser).
+</Note>
+
+## Next steps
+
+<CardGroup cols={2}>
+  <Card title="Analyze pages with observe()" icon="magnifying-glass" iconType="sharp-solid" href="/v2/basics/observe">
+    Use `observe()` to plan precise, single-step actions before executing them.
+  </Card>
+
+  <Card title="Extract data with extract()" icon="table" iconType="sharp-solid" href="/v2/basics/extract">
+    Use `extract()` with a data schema to pull clean, typed data from any page.
+  </Card>
+
+  <Card title="Caching actions" icon="bolt" iconType="sharp-solid" href="/v2/best-practices/caching">
+    Speed up repeated automations by caching actions.
+  </Card>
+
+  <Card title="Act fundamentals" icon="arrow-pointer" iconType="sharp-solid" href="/v2/basics/act">
+    Learn how to perform single-step actions reliably with `act()`.
+  </Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/configuration/browser.mdx b/packages/docs/v2/configuration/browser.mdx
new file mode 100644
index 000000000..18316f0e0
--- /dev/null
+++ b/packages/docs/v2/configuration/browser.mdx
@@ -0,0 +1,433 @@
+---
+title: Browser
+sidebarTitle: Browser
+description: Configure Stagehand on Browserbase or locally
+---
+
+Stagehand supports two primary environments:
+
+- **Browserbase** - Cloud-managed browser infrastructure optimized for production web automation at scale
+- **Local** - Run browsers directly on your machine for development and debugging
+
+## Browserbase Environment
+
+Browserbase provides managed cloud browser infrastructure optimized for web automation at scale. It offers advanced features like stealth mode, proxy support, and persistent contexts.
+
+<Card icon="cloud" title="Browserbase" href="https://docs.browserbase.com" description="Explore the features and benefits of using Browserbase for scalable web automation.">
+  Discover the power of cloud-managed browser infrastructure with Browserbase.
+</Card>
+
+### Environment Variables
+
+Before getting started, set up the required environment variables:
+
+<CodeGroup>
+```bash .env
+BROWSERBASE_API_KEY=your_api_key_here
+BROWSERBASE_PROJECT_ID=your_project_id_here
+```
+</CodeGroup>
+
+<Tip>
+Get your API key and Project ID from the [Browserbase Dashboard](https://browserbase.com/overview)
+</Tip>
+
+### Using Stagehand with Browserbase
+
+#### Basic Setup
+
+The simplest way to get started is with default settings:
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+});
+
+await stagehand.init();
+```
+```python Python
+import os
+from stagehand import Stagehand
+
+stagehand = Stagehand(
+    env="BROWSERBASE",
+)
+
+await stagehand.init()
+```
+</CodeGroup>
+
+#### Advanced Configuration
+
+Configure browser settings, proxy support, and other session parameters:
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  // Optional: API Key and Project ID will be pulled directly from your environment
+  apiKey: process.env.BROWSERBASE_API_KEY,
+  projectId: process.env.BROWSERBASE_PROJECT_ID,
+  browserbaseSessionCreateParams: {
+    proxies: true,
+    region: "us-west-2",
+    browserSettings: {
+      viewport: { width: 1920, height: 1080 },
+      blockAds: true,
+    },
+  },
+});
+
+await stagehand.init();
+console.log("Session ID:", stagehand.sessionId);
+```
+```python Python
+import os
+from stagehand import Stagehand
+
+stagehand = Stagehand(
+    env="BROWSERBASE",
+    # Optional: API Key and Project ID will be pulled directly from your environment
+    api_key=os.getenv("BROWSERBASE_API_KEY"),
+    project_id=os.getenv("BROWSERBASE_PROJECT_ID"),
+    browserbase_session_create_params={
+        "proxies": True,
+        "region": "us-west-2",
+        "browser_settings": {
+            "viewport": {"width": 1920, "height": 1080},
+            "block_ads": True,
+        },
+    },
+)
+```
+</CodeGroup>
+
+<Accordion title="Advanced Browserbase Configuration Example">
+    <CodeGroup>
+    ```typescript TypeScript
+    const stagehand = new Stagehand({
+      env: "BROWSERBASE",
+      apiKey: process.env.BROWSERBASE_API_KEY,
+      projectId: process.env.BROWSERBASE_PROJECT_ID,
+      browserbaseSessionCreateParams: {
+        projectId: process.env.BROWSERBASE_PROJECT_ID!,
+        proxies: true,
+        region: "us-west-2",
+        timeout: 3600, // 1 hour session timeout
+        keepAlive: true, // Available on Startup plan
+        browserSettings: {
+          advancedStealth: false, // this is a Scale Plan feature - reach out to support@browserbase.com to enable
+          blockAds: true,
+          solveCaptchas: true,
+          recordSession: false,
+          viewport: {
+            width: 1920,
+            height: 1080,
+          },
+          fingerprint: {
+            browsers: ["chrome", "edge"],
+            devices: ["desktop"],
+            operatingSystems: ["windows", "macos"],
+            locales: ["en-US", "en-GB"],
+            httpVersion: 2,
+          },
+        },
+        userMetadata: {
+          userId: "automation-user-123",
+          environment: "production",
+        },
+      },
+    });
+    ```
+    ```python Python
+    stagehand = Stagehand(
+        env="BROWSERBASE",
+        api_key=os.getenv("BROWSERBASE_API_KEY"),
+        project_id=os.getenv("BROWSERBASE_PROJECT_ID"),
+        browserbase_session_create_params={
+            "project_id": os.getenv("BROWSERBASE_PROJECT_ID"),
+            "proxies": True,
+            "region": "us-west-2",
+            "timeout": 3600,  # 1 hour session timeout
+            "keep_alive": True,  # Available on Startup plan
+            "browser_settings": {
+                "advanced_stealth": False,  # this is a Scale Plan feature - reach out to support@browserbase.com to enable
+                "block_ads": True,
+                "solve_captchas": True,
+                "record_session": False,
+                "viewport": {
+                    "width": 1920,
+                    "height": 1080,
+                },
+                "fingerprint": {
+                    "browsers": ["chrome", "edge"],
+                    "devices": ["desktop"],
+                    "operating_systems": ["windows", "macos"],
+                    "locales": ["en-US", "en-GB"],
+                    "http_version": 2,
+                },
+            },
+            "user_metadata": {
+                "user_id": "automation-user-123",
+                "environment": "production",
+            },
+        },
+    )
+    ```
+</CodeGroup>
+</Accordion>
+
+#### Initialization Result
+After calling `stagehand.init()`, the method returns configuration information about the initialized session:
+
+<CodeGroup>
+```typescript TypeScript
+const result = await stagehand.init();
+console.log(result);
+```
+```python Python
+result = await stagehand.init()
+print(result)
+```
+</CodeGroup>
+
+The returned object contains:
+```Example
+{
+  debugUrl: 'https://www.browserbase.com/devtools/inspector.html?wss=connect.browserbase.com/debug/f8a21b4a-6fa1-4ab9-9007-fbfe61dc14f0/devtools/page/5474B0E0510C5B6E629BEB06E799CD70?debug=true',
+  sessionUrl: 'https://www.browserbase.com/sessions/f8a21b4a-6fa1-4ab9-9007-fbfe61dc14f0',
+  sessionId: 'f8a21b4a-6fa1-4ab9-9007-fbfe61dc14f0'
+}
+```
+
+<AccordionGroup>
+<Accordion title="debugUrl">
+**Open the Browserbase [session live view](https://docs.browserbase.com/features/session-live-view)** to include a human-in-the-loop.
+</Accordion>
+
+<Accordion title="sessionUrl">
+**Open the [session replay](https://docs.browserbase.com/features/session-replay)** to see the full session recording. 
+</Accordion>
+
+<Accordion title="sessionId">
+**Unique identifier** for the [Browserbase session](https://docs.browserbase.com/introduction/what-is-browserbase). This is used to identify the session in the Browserbase dashboard and to connect to the session.
+</Accordion>
+</AccordionGroup>
+
+### Alternative: Browserbase SDK
+
+If you prefer to manage sessions directly, you can use the Browserbase SDK:
+
+<CodeGroup>
+```typescript TypeScript
+import { Browserbase } from "@browserbasehq/sdk";
+
+const bb = new Browserbase({ 
+  apiKey: process.env.BROWSERBASE_API_KEY! 
+});
+
+const session = await bb.sessions.create({
+  projectId: process.env.BROWSERBASE_PROJECT_ID!,
+  // Add configuration options here
+});
+```
+```python Python
+from browserbase import Browserbase
+
+bb = Browserbase(api_key=os.environ["BROWSERBASE_API_KEY"])
+
+session = bb.sessions.create(
+    project_id=os.environ["BROWSERBASE_PROJECT_ID"],
+    # Add configuration options here
+)
+```
+</CodeGroup>
+
+#### Connecting to an Existing Session
+
+Connect to a previously created Browserbase session using its session ID:
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  browserbaseSessionID: "existing-session-uuid-here",
+});
+
+await stagehand.init();
+console.log("Resumed Session ID:", stagehand.sessionId);
+```
+```python Python
+import os
+from stagehand import Stagehand
+
+stagehand = Stagehand(
+    env="BROWSERBASE",
+    browserbase_session_id="existing-session-uuid-here",
+)
+
+await stagehand.init()
+print(f"Resumed Session ID: {stagehand.session_id}")
+```
+</CodeGroup>
+
+## Local Environment
+
+The local environment runs browsers directly on your machine, providing full control over browser instances and configurations. Ideal for development, debugging, and scenarios requiring custom browser setups.
+
+### Environment Comparison
+
+| Feature | Browserbase | Local |
+| --- | --- | --- |
+| **Scalability** | High (cloud-managed) | Limited (local resources) |
+| **Stealth Features** | Advanced fingerprinting | Basic stealth |
+| **Proxy Support** | Built-in residential proxies | Manual configuration |
+| **Session Persistence** | Cloud context storage | File-based user data |
+| **Geographic Distribution** | Multi-region deployment | Single machine |
+| **Debugging** | Session recordings & logs | Direct DevTools access |
+| **Setup Complexity** | Environment variables only | Browser installation required |
+| **Cost** | Usage-based pricing | Infrastructure & maintenance |
+| **Best For** | Production, scale, compliance | Development, debugging |
+
+### Basic Local Setup
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL"
+});
+  
+await stagehand.init();
+console.log("Session ID:", stagehand.sessionId);
+```
+```python Python
+from stagehand import Stagehand
+
+stagehand = Stagehand(
+    env="LOCAL"
+)
+
+await stagehand.init()
+print(f"Session ID: {stagehand.session_id}")
+```
+</CodeGroup>
+
+### Advanced Local Configuration
+
+Customize browser launch options for local development:
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  localBrowserLaunchOptions: {
+    headless: false, // Show browser window
+    devtools: true, // Open developer tools
+    viewport: { width: 1280, height: 720 },
+    executablePath: '/opt/google/chrome/chrome', // Custom Chrome path
+    args: [
+      '--no-sandbox',
+      '--disable-setuid-sandbox',
+      '--disable-web-security',
+      '--allow-running-insecure-content',
+    ],
+    env: {
+      NODE_ENV: "development",
+      DEBUG: "true",
+    },
+  },
+});
+
+await stagehand.init();
+```
+```python Python
+from stagehand import Stagehand
+
+stagehand = Stagehand(
+    env="LOCAL",
+    headless=False,  # Show browser window
+    local_browser_launch_options={
+        "devtools": True,  # Open developer tools
+        "viewport": {"width": 1280, "height": 720},
+        "executable_path": "/opt/google/chrome/chrome",  # Custom Chrome path
+        "args": [
+            "--no-sandbox",
+            "--disable-setuid-sandbox",
+            "--disable-web-security",
+            "--allow-running-insecure-content",
+        ],
+        "env": {
+            "NODE_ENV": "development",
+            "DEBUG": "true",
+        },
+    },
+)
+
+await stagehand.init()
+```
+</CodeGroup>
+
+### Connecting to your local browser
+
+Connect to your existing local Chrome/Chromium browser instead of launching a new one. This lets you automate your normal browser with all your existing tabs, extensions and settings.
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+	env: "LOCAL",
+	localBrowserLaunchOptions: {
+		cdpUrl: 'http://localhost:9222'
+	}
+});
+
+await stagehand.init();
+```
+```python Python
+from stagehand import Stagehand
+
+stagehand = Stagehand(
+    env="LOCAL",
+    local_browser_launch_options={
+      "cdp_url": "http://localhost:9222"
+    }
+)
+
+await stagehand.init()
+```
+</CodeGroup>
+
+## Troubleshooting
+
+### Common Issues
+
+<AccordionGroup>
+<Accordion title="Browserbase Authentication Errors">
+- Verify your `BROWSERBASE_API_KEY` and `BROWSERBASE_PROJECT_ID` are set correctly
+- Check that your API key has the necessary permissions
+- Ensure your Browserbase account has sufficient credits
+</Accordion>
+
+<Accordion title="Local Browser Launch Failures">
+- Install Chrome or Chromium on your system
+- Set the correct `executablePath` for your Chrome installation
+- Check that required dependencies are installed (Linux: `libnss3-dev libatk-bridge2.0-dev libgtk-3-dev libxss1 libasound2`)
+</Accordion>
+
+<Accordion title="Session Timeout Issues">
+- Increase session timeout in `browserbaseSessionCreateParams.timeout`
+- Use `keepAlive: true` for long-running sessions
+- Monitor session usage to avoid unexpected terminations
+</Accordion>
+</AccordionGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/configuration/evals.mdx b/packages/docs/v2/configuration/evals.mdx
new file mode 100644
index 000000000..71199218d
--- /dev/null
+++ b/packages/docs/v2/configuration/evals.mdx
@@ -0,0 +1,301 @@
+---
+title: Evaluations & Metrics
+sidebarTitle: Evaluations
+description: Monitor performance, optimize costs, and evaluate LLM effectiveness
+---
+
+Evaluations help you understand how well your automation performs, which models work best for your use cases, and how to optimize for cost and reliability. This guide covers both monitoring your own workflows and running comprehensive evaluations.
+
+## Why Evaluations Matter
+
+- **Performance Optimization**: Identify which models and settings work best for your specific automation tasks
+- **Cost Control**: Track token usage and inference time to optimize spending
+- **Reliability**: Measure success rates and identify failure patterns
+- **Model Selection**: Compare different LLMs on real-world tasks to make informed decisions
+
+<Card
+  title="Live Model Comparisons"
+  icon="scale-balanced"
+  href="https://www.stagehand.dev/evals"
+>
+  View real-time performance comparisons across different LLMs on the [Stagehand Evals Dashboard](https://www.stagehand.dev/evals)
+</Card>
+
+## Comprehensive Evaluations
+
+Evaluations help you systematically test and improve your automation workflows. Stagehand provides both built-in evaluations and tools to create your own.
+
+We have 2 types of evals:
+1. **Deterministic Evals** - These include unit tests, integration tests, and E2E tests that can be run without any LLM inference.
+2. **LLM-based Evals** - These are evals that test the underlying functionality of Stagehand's AI primitives.
+
+
+### Evals CLI
+![Evals CLI](/media/evals-cli.png)
+
+<Tip>
+To run evals, you'll need to clone the [Stagehand repo](https://github.com/browserbase/stagehand) and set up the CLI.
+
+We recommend using [Braintrust](https://www.braintrust.dev/docs/) to help visualize evals results and metrics.
+</Tip>
+
+The Stagehand CLI provides a powerful interface for running evaluations. You can run specific evals, categories, or external benchmarks with customizable settings.
+
+Evals are grouped into:
+1. **Act Evals** - These are evals that test the functionality of the `act` method.
+2. **Extract Evals** - These are evals that test the functionality of the `extract` method.
+3. **Observe Evals** - These are evals that test the functionality of the `observe` method.
+4. **Combination Evals** - These are evals that test the functionality of the `act`, `extract`, and `observe` methods together.
+5. **Experimental Evals** - These are experimental custom evals that test the functionality of the stagehand primitives.
+6. **Agent Evals** - These are evals that test the functionality of `agent`.
+7. **(NEW) External Benchmarks** - Run external benchmarks like WebBench, GAIA, WebVoyager, OnlineMind2Web, and OSWorld.
+
+#### Installation
+
+<Steps> 
+<Step title="Install Dependencies">
+```bash
+# From the stagehand root directory
+pnpm install
+```
+</Step>
+
+<Step title="Build the CLI">
+```bash
+pnpm run build:cli
+```
+</Step>
+
+<Step title="Verify Installation">
+```bash
+evals help
+```
+</Step>
+</Steps>
+
+#### CLI Commands and Options
+
+##### Basic Commands
+
+```bash
+# Run all evals
+evals run all
+
+# Run specific category
+evals run act
+evals run extract
+evals run observe
+evals run agent
+
+# Run specific eval
+evals run extract/extract_text
+
+# List available evals
+evals list
+evals list --detailed
+
+# Configure defaults
+evals config
+evals config set env browserbase
+evals config set trials 5
+```
+
+##### Command Options
+
+- **`-e, --env`**: Environment (`local` or `browserbase`)
+- **`-t, --trials`**: Number of trials per eval (default: 3)
+- **`-c, --concurrency`**: Max parallel sessions (default: 10)
+- **`-m, --model`**: Model override
+- **`-p, --provider`**: Provider override
+- **`--api`**: Use Stagehand API instead of SDK
+
+##### Running External Benchmarks
+
+The CLI supports several industry-standard benchmarks:
+
+```bash
+# WebBench with filters
+evals run benchmark:webbench -l 10 -f difficulty=easy -f category=READ
+
+# GAIA benchmark
+evals run b:gaia -s 100 -l 25 -f level=1
+
+# WebVoyager
+evals run b:webvoyager -l 50
+
+# OnlineMind2Web
+evals run b:onlineMind2Web
+
+# OSWorld
+evals run b:osworld -f source=Mind2Web
+```
+
+#### Configuration Files
+
+You can view the specific evals in [`evals/tasks`](https://github.com/browserbase/stagehand/tree/v2/evals/tasks). Each eval is grouped into eval categories based on [`evals/evals.config.json`](https://github.com/browserbase/stagehand/blob/main/evals/evals.config.json).
+
+
+#### Viewing eval results
+![Eval results](/images/evals.png)
+
+Eval results are viewable on Braintrust. You can view the results of a specific eval by going to the Braintrust URL specified in the terminal when you run `npm run evals`.
+
+By default, each eval will run five times per model. The "Exact Match" column shows the percentage of times the eval was correct. The "Error Rate" column shows the percentage of times the eval errored out.
+
+You can use the Braintrust UI to filter by model/eval and aggregate results across all evals.
+
+### Deterministic Evals
+
+To run deterministic evals, you can run `npm run e2e` from within the Stagehand repo. This will test the functionality of Playwright within Stagehand to make sure it's working as expected.
+
+These tests are in [`evals/deterministic`](https://github.com/browserbase/stagehand/tree/v2/evals/deterministic) and test on both Browserbase browsers and local headless Chromium browsers.
+
+## Creating Custom Evaluations
+
+### Step-by-Step Guide
+
+<Steps>
+<Step title="Create Evaluation File">
+Create a new file in `evals/tasks/your-eval.ts`:
+
+```typescript
+import { EvalTask } from '../types';
+
+export const customEvalTask: EvalTask = {
+  name: 'custom_task_name',
+  description: 'Test specific automation workflow',
+  
+  // Test setup
+  setup: async ({ page }) => {
+    await page.goto('https://example.com');
+  },
+  
+  // The actual test
+  task: async ({ stagehand, page }) => {
+    // Your automation logic
+    await page.act({ action: 'click the login button' });
+    const result = await page.extract({ 
+      instruction: 'Get the user name',
+      schema: { username: 'string' }
+    });
+    return result;
+  },
+  
+  // Validation
+  validate: (result, expected) => {
+    return result.username === expected.username;
+  },
+  
+  // Test cases
+  testCases: [
+    {
+      input: { /* test input */ },
+      expected: { username: 'john_doe' }
+    }
+  ],
+  
+  // Evaluation criteria
+  scoring: {
+    exactMatch: true,
+    timeout: 30000,
+    retries: 2
+  }
+};
+```
+</Step>
+
+<Step title="Add to Configuration">
+Update `evals/evals.config.json`:
+
+```json
+{
+  "categories": {
+    "custom": ["custom_task_name"],
+    "existing_category": ["custom_task_name"]
+  }
+}
+```
+</Step>
+
+<Step title="Run Your Evaluation">
+```bash
+# Test your custom evaluation
+evals run custom_task_name
+
+# Run the entire custom category
+evals run custom
+
+# Run with specific settings
+evals run custom_task_name -e browserbase -t 5 -m gpt-4o
+```
+</Step>
+</Steps>
+
+
+## Best Practices for Custom Evals
+
+<AccordionGroup>
+<Accordion title="Test Design Principles">
+- **Atomic**: Each test should validate one specific capability
+- **Deterministic**: Tests should produce consistent results
+- **Realistic**: Use real-world scenarios and websites
+- **Measurable**: Define clear success/failure criteria
+</Accordion>
+
+<Accordion title="Performance Optimization">
+- **Parallel Execution**: Design tests to run independently
+- **Resource Management**: Clean up after each test
+- **Timeout Handling**: Set appropriate timeouts for operations
+- **Error Recovery**: Handle failures gracefully
+</Accordion>
+
+<Accordion title="Data Quality">
+- **Ground Truth**: Establish reliable expected outcomes
+- **Edge Cases**: Test boundary conditions and error scenarios
+- **Statistical Significance**: Run multiple iterations for reliability
+- **Version Control**: Track changes to test cases over time
+</Accordion>
+</AccordionGroup>
+
+### Troubleshooting Evaluations
+<AccordionGroup>
+<Accordion title="Evaluation Timeouts">
+**Symptoms**: Tests fail with timeout errors
+
+**Solutions**:
+- Increase timeout in `taskConfig.ts`
+- Use faster models (Gemini 2.5 Flash, GPT-4o Mini)
+- Optimize test scenarios to be less complex
+- Check network connectivity to LLM providers
+</Accordion>
+
+<Accordion title="Inconsistent Results">
+**Symptoms**: Same test passes/fails randomly
+
+**Solutions**:
+- Set temperature to 0 for deterministic outputs
+- Increase repetitions for statistical significance
+- Use more capable models for complex tasks
+- Check for dynamic website content affecting tests
+</Accordion>
+
+<Accordion title="High Evaluation Costs">
+**Symptoms**: Token usage exceeding budget
+
+**Solutions**:
+- Use cost-effective models (Gemini 2.0 Flash, GPT-4o Mini)
+- Reduce repetitions for initial testing
+- Focus on specific evaluation categories
+- Use local browser environment to reduce Browserbase costs
+</Accordion>
+
+<Accordion title="Braintrust Integration Issues">
+**Symptoms**: Results not uploading to dashboard
+
+**Solutions**:
+- Check Braintrust API key configuration
+- Verify internet connectivity
+- Update Braintrust SDK to latest version
+- Check project permissions in Braintrust dashboard
+</Accordion>
+</AccordionGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/configuration/logging.mdx b/packages/docs/v2/configuration/logging.mdx
new file mode 100644
index 000000000..978541ae6
--- /dev/null
+++ b/packages/docs/v2/configuration/logging.mdx
@@ -0,0 +1,299 @@
+---
+title: Logging & Debugging
+sidebarTitle: Logging
+description: Set up logging, debugging, and error tracking for Stagehand workflows
+---
+
+Stagehand provides comprehensive logging capabilities to help you debug automation workflows, track execution, and diagnose issues. Configure logging levels, structured output, and debugging tools for both development and production environments.
+
+## Logging Configuration
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE", // or "LOCAL"
+  verbose: 1, // 0 = errors only, 1 = info, 2 = debug
+});
+```
+
+```python Python
+from stagehand import Stagehand
+
+stagehand = Stagehand(
+    env="BROWSERBASE",  # or "LOCAL"
+    verbose=1,  # 0 = errors only, 1 = info, 2 = debug
+)
+```
+</CodeGroup>
+
+### Verbose Levels
+
+- **Level 0**: Errors only - minimal output for production
+- **Level 1**: Info - includes successful operations and important events
+- **Level 2**: Debug - comprehensive logging including internal operations
+
+## Structured Logging
+
+### Log Line Format
+
+Each log entry contains structured information:
+
+<CodeGroup>
+```typescript TypeScript
+interface LogLine {
+  category: 'browser' | 'action' | 'llm' | 'error' | 'stagehand' | 'cache';
+  message: string;
+  level: 0 | 1 | 2; // error | info | debug
+  timestamp: string;
+  auxiliary?: {
+    executionTime?: { value: string; unit: string };
+    sessionId?: string;
+    url?: string;
+    [key: string]: any;
+  };
+}
+```
+
+```python Python
+# Log line structure in Python
+{
+  "category": "browser" | "action" | "llm" | "error" | "stagehand" | "cache",
+  "message": str,
+  "level": 0 | 1 | 2,  # error | info | debug
+  "timestamp": str,
+  "auxiliary": {
+    "execution_time": {"value": str, "unit": str},
+    "session_id": str,
+    "url": str,
+    # ... other context data
+  }
+}
+```
+</CodeGroup>
+
+### Custom Logger
+
+<CodeGroup>
+```typescript TypeScript
+class AdvancedLogger {
+  private logFile?: string;
+  
+  constructor(logFile?: string) {
+    this.logFile = logFile;
+  }
+  
+  log = (logLine: any) => {
+    const timestamp = new Date().toISOString();
+    const colors = {
+      browser: '\x1b[34m', // blue
+      action: '\x1b[32m',  // green
+      llm: '\x1b[35m',     // magenta
+      error: '\x1b[31m',   // red
+      stagehand: '\x1b[36m', // cyan
+      cache: '\x1b[33m',   // yellow
+    };
+    
+    const color = colors[logLine.category] || '\x1b[0m';
+    const reset = '\x1b[0m';
+    
+    // Console output with colors
+    console.log(`${color}[${logLine.category}]${reset} ${logLine.message}`);
+    
+    // Log execution time if available
+    if (logLine.auxiliary?.executionTime) {
+      console.log(` ${logLine.auxiliary.executionTime.value}${logLine.auxiliary.executionTime.unit}`);
+    }
+    
+    // Log additional context
+    if (logLine.auxiliary && Object.keys(logLine.auxiliary).length > 0) {
+      console.log('  Context:', JSON.stringify(logLine.auxiliary, null, 2));
+    }
+    
+    // File logging (optional)
+    if (this.logFile) {
+      const logEntry = {
+        timestamp,
+        ...logLine
+      };
+      require('fs').appendFileSync(this.logFile, JSON.stringify(logEntry) + '\n');
+    }
+  }
+}
+
+// Usage
+const logger = new AdvancedLogger('./automation.log');
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  verbose: 2,
+  logger: logger.log
+});
+```
+
+```python Python
+import json
+import os
+from datetime import datetime
+from typing import Dict, Any, Optional
+
+class AdvancedLogger:
+    def __init__(self, log_file: Optional[str] = None):
+        self.log_file = log_file
+    
+    def log(self, log_line: Dict[str, Any]):
+        timestamp = datetime.now().isoformat()
+        colors = {
+            'browser': '\033[34m',   # blue
+            'action': '\033[32m',    # green
+            'llm': '\033[35m',       # magenta
+            'error': '\033[31m',     # red
+            'stagehand': '\033[36m', # cyan
+            'cache': '\033[33m',     # yellow
+        }
+        
+        color = colors.get(log_line.get('category', ''), '\033[0m')
+        reset = '\033[0m'
+        
+        # Console output with colors
+        print(f"{color}[{log_line.get('category')}]{reset} {log_line.get('message')}")
+        
+        # Log execution time if available
+        if log_line.get('auxiliary', {}).get('execution_time'):
+            exec_time = log_line['auxiliary']['execution_time']
+            print(f"{exec_time['value']}{exec_time['unit']}")
+        
+        # Log additional context
+        auxiliary = log_line.get('auxiliary', {})
+        if auxiliary and len(auxiliary) > 0:
+            print('  Context:', json.dumps(auxiliary, indent=2))
+        
+        # File logging (optional)
+        if self.log_file:
+            log_entry = {
+                'timestamp': timestamp,
+                **log_line
+            }
+            with open(self.log_file, 'a') as f:
+                f.write(json.dumps(log_entry) + '\n')
+
+# Usage
+logger = AdvancedLogger('./automation.log')
+stagehand = Stagehand(
+    env="BROWSERBASE",
+    verbose=2,
+    logger=logger.log
+)
+```
+</CodeGroup>
+
+## Detailed Logging Features
+
+### LLM Inference Logging
+
+Enable detailed logging of all LLM interactions:
+
+<CodeGroup>
+```typescript TypeScript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  logInferenceToFile: true,  // Creates inference_summary/ directory
+  verbose: 2
+});
+```
+
+```python Python
+stagehand = Stagehand(
+    env="BROWSERBASE",
+    log_inference_to_file=True,  # Creates inference_summary/ directory
+    verbose=2
+)
+```
+</CodeGroup>
+
+The `inference_summary/` directory structure:
+```
+inference_summary/                   
+├── act_summary/            
+│   ├── 20240329_080446068.json    
+│   ├── 20240329_080447019.json   
+│   └── act_summary.json          
+├── extract_summary/               
+│   ├── 20240329_081205123.json    
+│   └── extract_summary.json       
+└── observe_summary/                
+    ├── 20240329_081634891.json    
+    └── observe_summary.json       
+```
+
+## Log Analysis & Debugging
+
+### Common Log Patterns
+<Tabs>
+  <Tab title="Successful Action">
+    ```json
+    {
+      "category": "action", 
+      "message": "act completed successfully",
+      "level": 1,
+      "auxiliary": {
+        "executionTime": {"value": "1250", "unit": "ms"},
+        "url": "https://example.com",
+        "sessionId": "session-123"
+      }
+    }
+    ```
+  </Tab>
+  <Tab title="LLM Inference">
+    ```json
+    {
+      "category": "llm",
+      "message": "inference completed", 
+      "level": 1,
+      "auxiliary": {
+        "model": "gpt-4o",
+        "tokens": {"prompt": 3451, "completion": 45},
+        "executionTime": {"value": "951", "unit": "ms"}
+      }
+    }
+    ```
+  </Tab>
+  <Tab title="Error Example">
+    ```json
+    {
+      "category": "action",
+      "message": "action failed: element not found",
+      "level": 0, 
+      "auxiliary": {
+        "selector": "button[data-testid='submit']",
+        "url": "https://example.com/form",
+        "sessionId": "session-123"
+      }
+    }
+    ```
+  </Tab>
+</Tabs>
+
+## Best Practices
+
+<AccordionGroup>
+<Accordion title="Development Environment">
+- Use `verbose: 2` with visual debugging
+- Enable browser DevTools for element inspection
+- Use `logInferenceToFile: true` to capture LLM decisions
+- Implement structured logging early
+</Accordion>
+
+<Accordion title="Production Environment">
+- Use `verbose: 1` to balance visibility with performance
+- Implement error tracking and alerting
+- Use structured JSON logging
+- Monitor session success rates and execution times
+</Accordion>
+
+<Accordion title="Security & Compliance">
+- Never log credentials or sensitive data
+- Implement log retention policies
+- Secure log files and dashboards
+</Accordion>
+</AccordionGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/configuration/models.mdx b/packages/docs/v2/configuration/models.mdx
new file mode 100644
index 000000000..277a81b26
--- /dev/null
+++ b/packages/docs/v2/configuration/models.mdx
@@ -0,0 +1,305 @@
+---
+title: Models
+sidebarTitle: Models
+description: Enhance Stagehand with LLMs for optimal performance, cost, and reliability
+---
+
+Stagehand uses Large Language Models (LLMs) to understand web pages, plan actions, and interact with complex interfaces. The choice of LLM significantly impacts your automation's accuracy, speed, and cost.
+
+<Card title="Model Evaluation" href="https://www.stagehand.dev/evals" icon="paper-plane">
+Find more details about how to choose the right model on our Model Evaluation page.
+</Card>
+
+## Why LLM Choice Matters
+
+- **Accuracy**: Better models provide more reliable element detection and action planning
+- **Speed**: Faster models reduce automation latency
+- **Cost**: Different providers offer varying pricing structures
+- **Reliability**: Structured output support ensures consistent automation behavior
+
+<Tip>
+Find more details about how to choose the right model on our [Model Evaluation](https://www.stagehand.dev/evals) page.
+</Tip>
+
+<Warning>
+Small models on **Ollama** struggle with consistent structured outputs. While technically supported, we don't recommend them for production Stagehand workflows.
+</Warning>
+
+## Environment Variables Setup
+
+Set up your API keys before configuring Stagehand:
+
+<CodeGroup>
+```bash .env
+# Choose one or more providers
+OPENAI_API_KEY=your_openai_key_here
+ANTHROPIC_API_KEY=your_anthropic_key_here
+GOOGLE_API_KEY=your_google_key_here
+GROQ_API_KEY=your_groq_key_here
+```
+</CodeGroup>
+
+## Supported Providers
+
+Stagehand supports major LLM providers with structured output capabilities:
+
+### Production-Ready Providers
+
+| Provider | Best Models | Strengths | Use Case |
+|----------|-------------|-----------|----------|
+| **OpenAI** | `gpt-4.1`, `gpt-4.1-mini` | High accuracy, reliable | Production, complex sites |
+| **Anthropic** | `claude-sonnet-4-6` | Excellent reasoning | Complex automation tasks |
+| **Google** | `gemini-2.5-flash`, `gemini-2.5-pro` | Fast, cost-effective | High-volume automation |
+
+### Additional Providers
+
+<Expandable title="More Providers">
+- **Groq** - `llama-3.3-70b-versatile` (Good for speed critical applications)
+- **xAI** - `grok-beta` (Good for complex reasoning)
+- **Azure** - Enterprise OpenAI deployment
+- **Cerebras** - High-speed inference
+- **TogetherAI** - Open-source models
+- **Mistral** - `mixtral-8x7b-32768` (European option)
+- **DeepSeek** - Cost-effective alternative
+- **Perplexity** - Real-time web data
+- **Ollama** - Local deployment (limited accuracy)
+- **Run any model included in AI SDK** - Find supported models in the [Vercel AI SDK](https://sdk.vercel.ai/providers/ai-sdk-providers) (Follow the guide 
+     [here](#vercel-ai-sdk) to get started.)
+</Expandable>
+
+## Basic Configuration
+
+### Model Name Format
+
+Stagehand uses the format `provider/model-name` for model specification.
+
+**Examples:**
+- OpenAI: `openai/gpt-4.1`
+- Anthropic: `anthropic/claude-sonnet-4-6`
+- Google: `google/gemini-2.5-flash` (Recommended)
+
+### Quick Start Examples
+
+<Tabs>
+<Tab title="Google (Recommended)">
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  modelName: "google/gemini-2.5-flash",
+  modelClientOptions: {
+    apiKey: process.env.GOOGLE_API_KEY,
+  },
+});
+```
+```python Python
+import os
+from stagehand import Stagehand
+
+stagehand = Stagehand(
+    model_name="google/gemini-2.5-flash",
+    model_api_key=os.getenv("GOOGLE_API_KEY")
+)
+```
+</CodeGroup>
+</Tab>
+<Tab title="OpenAI">
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  modelName: "openai/gpt-4.1",
+  modelClientOptions: {
+    apiKey: process.env.OPENAI_API_KEY,
+  },
+});
+```
+```python Python
+import os
+from stagehand import Stagehand
+
+stagehand = Stagehand(
+    model_name="openai/gpt-4.1",
+    model_api_key=os.getenv("OPENAI_API_KEY")
+)
+```
+</CodeGroup>
+</Tab>
+
+<Tab title="Anthropic">
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  modelName: "anthropic/claude-sonnet-4-6",
+  modelClientOptions: {
+    apiKey: process.env.ANTHROPIC_API_KEY,
+  },
+});
+```
+```python Python
+import os
+from stagehand import Stagehand
+
+stagehand = Stagehand(
+    model_name="anthropic/claude-sonnet-4-6",
+    model_api_key=os.getenv("ANTHROPIC_API_KEY")
+)
+```
+</CodeGroup>
+</Tab>
+</Tabs>
+
+## Custom LLM Integration
+
+<Note>
+Custom LLMs are currently only supported in TypeScript.
+</Note>
+
+Integrate any LLM with Stagehand using custom clients. The only requirement is **structured output support** for consistent automation behavior.
+
+### Vercel AI SDK
+The [Vercel AI SDK](https://sdk.vercel.ai/providers/ai-sdk-providers) is a popular library for interacting with LLMs. You can use any of the providers supported by the Vercel AI SDK to create a client for your model, **as long as they support structured outputs**.
+
+Vercel AI SDK supports providers for OpenAI, Anthropic, and Google, along with support for **Amazon Bedrock** and **Azure OpenAI**.
+
+To get started, you'll need to install the `ai` package and the provider you want to use. For example, to use Amazon Bedrock, you'll need to install the `@ai-sdk/amazon-bedrock` package.
+
+You'll also need to use the [Vercel AI SDK external client](https://github.com/browserbase/stagehand/blob/v2/examples/external_clients/aisdk.ts) as a template to create a client for your model.
+
+<Tabs>
+	<Tab title="npm">
+	```bash
+	npm install ai @ai-sdk/amazon-bedrock
+	```
+	</Tab>
+
+	<Tab title="pnpm">
+	```bash
+	pnpm install ai @ai-sdk/amazon-bedrock
+	```
+	</Tab>
+
+	<Tab title="yarn">
+	```bash
+	yarn add ai @ai-sdk/amazon-bedrock
+	```
+	</Tab>
+</Tabs>
+
+To get started, you can use the [Vercel AI SDK external client](https://github.com/browserbase/stagehand/blob/84f810b4631291307a32a47addad7e26e9c1deb3/examples/external_clients/aisdk.ts) as a template to create a client for your model.
+
+```ts
+// Install/import the provider you want to use.
+// For example, to use OpenAI, import `openai` from @ai-sdk/openai
+import { bedrock } from "@ai-sdk/amazon-bedrock";
+import { AISdkClient } from "./external_clients/aisdk";
+
+const stagehand = new Stagehand({
+  llmClient: new AISdkClient({
+	model: bedrock("anthropic.claude-sonnet-4-6-v1:0"),
+  }),
+});
+```
+
+## Troubleshooting
+
+### Common Issues
+
+<AccordionGroup>
+<Accordion title="Model doesn't support structured outputs">
+**Error**: `Model does not support structured outputs`
+
+**Solution**:
+Use models that support function calling/structured outputs. The minimum requirements are:
+
+- Model must support JSON/structured outputs
+- Model must have strong reasoning capabilities
+- Model must be able to handle complex instructions
+
+For each provider, use their latest models that meet these requirements. Some examples:
+
+- **OpenAI**: GPT-4 series or newer
+- **Anthropic**: Claude 3 series or newer 
+- **Google**: Gemini 2 series or newer
+- **Other providers**: Latest models with structured output support
+
+**Note**: Avoid base language models without structured output capabilities or fine-tuning for instruction following. When in doubt, check our [Model Evaluation](https://www.stagehand.dev/evals) page for up-to-date recommendations.
+</Accordion>
+
+<Accordion title="Authentication errors">
+**Error**: `Invalid API key` or `Unauthorized`
+
+**Solution**:
+- Verify your environment variables are set correctly
+- Check API key permissions and quotas
+- Ensure you're using the correct API key for the provider
+- For Anthropic, make sure you have access to the Claude API
+</Accordion>
+
+<Accordion title="Inconsistent automation results">
+**Symptoms**: Actions work sometimes but fail other times
+
+**Causes & Solutions**:
+- **Weak models**: Use more capable models - check our [Model Evaluation](https://www.stagehand.dev/evals) page for current recommendations
+- **High temperature**: Set temperature to 0 for deterministic outputs
+- **Complex pages**: Switch to models with higher accuracy scores on our [Model Evaluation](https://www.stagehand.dev/evals) page
+- **Rate limits**: Implement retry logic with exponential backoff
+- **Context limits**: Reduce page complexity or use models with larger context windows
+- **Prompt clarity**: Ensure your automation instructions are clear and specific
+</Accordion>
+
+<Accordion title="Slow performance">
+**Issue**: Automation takes too long to respond
+
+**Solutions**:
+- **Use fast models**: Choose models optimized for speed
+  - Any model with < 1s response time
+  - Models with "fast" or "flash" variants
+- **Optimize settings**: 
+  - Use `verbose: 0` to minimize token usage
+  - Set temperature to 0 for fastest processing
+  - Keep max tokens as low as possible
+- **Consider local deployment**: Local models can provide lowest latency
+- **Batch operations**: Group multiple actions when possible
+</Accordion>
+
+<Accordion title="High costs">
+**Issue**: LLM usage costs are too high
+
+**Cost Optimization Strategies**:
+1. **Switch to cost-effective models**: 
+   - Check our [Model Evaluation](https://www.stagehand.dev/evals) page for current cost-performance benchmarks
+   - Choose models with lower cost per token that still meet accuracy requirements
+   - Consider models optimized for speed to reduce total runtime costs
+2. **Optimize token usage**: 
+   - Set `verbose: 0` to reduce logging overhead
+   - Use concise prompts and limit response length
+3. **Smart model selection**: Start with cheaper models, fallback to premium ones only when needed
+4. **Cache responses**: Implement LLM response caching for repeated automation patterns
+5. **Monitor usage**: Set up billing alerts and track costs per automation run
+6. **Batch processing**: Process multiple similar tasks together
+</Accordion>
+</AccordionGroup>
+
+### Next Steps
+<CardGroup cols={2}>
+<Card title="Choose Models" href="https://www.stagehand.dev/evals" icon="robot">
+  See our Model Evaluation page
+</Card>
+
+<Card title="Test Models" href="/v2/configuration/evals" icon="flask-vial">
+  Evaluate performance on your specific use cases in our Model Evaluation guide
+</Card>
+
+<Card title="Track Costs" href="/v2/configuration/observability" icon="chart-line">
+  Monitor token usage and set alerts using our Observability tools
+</Card>
+
+<Card title="Cache Results" href="/v2/best-practices/caching" icon="database">
+  Store successful patterns using our Caching Guide
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/configuration/observability.mdx b/packages/docs/v2/configuration/observability.mdx
new file mode 100644
index 000000000..085506d98
--- /dev/null
+++ b/packages/docs/v2/configuration/observability.mdx
@@ -0,0 +1,532 @@
+---
+title: Observability
+sidebarTitle: Observability
+description: Track Stagehand automation with session visibility and analytics
+---
+
+Stagehand provides powerful observability features to help you monitor, track performance, and analyze your browser automation workflows. Focus on session monitoring, resource usage, and operational insights for both Browserbase and local environments.
+
+## Browserbase Session Monitoring
+
+When running on Browserbase, you gain access to comprehensive cloud-based monitoring and session management through the Browserbase API and dashboard.
+
+<div style={{ textAlign: "center" }}>
+  <img src="/media/observability.gif" alt="Browserbase Session Observability" width="400" />
+</div>
+
+### Live Session Visibility
+
+Browserbase provides real-time visibility into your automation sessions:
+
+**Session Dashboard Features**
+- Real-time browser screen recording and replay
+- Network request monitoring with detailed timing
+- JavaScript console logs and error tracking
+- CPU and memory usage metrics
+- Session status and duration tracking
+
+**Session Management & API Access**
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+import { Browserbase } from "@browserbasehq/sdk";
+
+const browserbase = new Browserbase({
+  apiKey: process.env.BROWSERBASE_API_KEY,
+});
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE"
+});
+
+await stagehand.init();
+
+const sessionInfo = await browserbase.sessions.retrieve(stagehand.sessionId);
+
+console.log("Session status:", sessionInfo.status);
+console.log("Session region:", sessionInfo.region);
+console.log("CPU usage:", sessionInfo.avgCpuUsage);
+console.log("Memory usage:", sessionInfo.memoryUsage);
+console.log("Proxy bytes:", sessionInfo.proxyBytes);
+```
+
+```python Python
+import os
+from stagehand import Stagehand
+from browserbase import Browserbase
+
+browserbase = Browserbase(
+  api_key=os.getenv("BROWSERBASE_API_KEY"),
+)
+
+stagehand = Stagehand(
+    env="BROWSERBASE",
+)
+
+await stagehand.init()
+
+session_info = browserbase.sessions.retrieve(stagehand.session_id)
+
+print(f"Session status: {session_info['status']}")
+print(f"Session region: {session_info['region']}")
+print(f"CPU usage: {session_info['avgCpuUsage']}")
+print(f"Memory usage: {session_info['memoryUsage']}")
+print(f"Proxy bytes: {session_info['proxyBytes']}")
+```
+</CodeGroup>
+
+### Session Analytics & Insights
+
+<CardGroup>
+  <Card title="Real-Time Monitoring" icon="chart-line">
+    Monitor live session status, resource usage, and geographic distribution. Scale and manage concurrent sessions with real-time insights.
+  </Card>
+
+  <Card title="Session Recordings" icon="video">
+    Review complete session recordings with frame-by-frame playback. Analyze network requests and debug browser interactions visually.
+  </Card>
+
+  <Card title="API Management" icon="code">
+    Programmatically access session data, automate lifecycle management, and integrate with monitoring systems through our API.
+  </Card>
+
+  <Card title="Usage Monitoring" icon="chart-bar">
+    Track resource consumption, session duration, and API usage. Get detailed breakdowns of costs and utilization across your automation.
+  </Card>
+</CardGroup>
+
+### Session Monitoring & Filtering
+
+Query and monitor sessions by status and metadata:
+
+<CodeGroup>
+```typescript TypeScript
+import { Browserbase } from "@browserbasehq/sdk";
+
+const browserbase = new Browserbase({
+  apiKey: process.env.BROWSERBASE_API_KEY,
+});
+
+// List sessions with filtering
+async function getFilteredSessions() {
+  const sessions = await browserbase.sessions.list({
+    status: 'RUNNING'
+  });
+  
+  return sessions.map(session => ({
+    id: session.id,
+    status: session.status, // RUNNING, COMPLETED, ERROR, TIMED_OUT
+    startedAt: session.startedAt,
+    endedAt: session.endedAt,
+    region: session.region,
+    avgCpuUsage: session.avgCpuUsage,
+    memoryUsage: session.memoryUsage,
+    proxyBytes: session.proxyBytes,
+    userMetadata: session.userMetadata
+  }));
+}
+
+// Query sessions by metadata
+async function querySessionsByMetadata(query: string) {
+  const sessions = await browserbase.sessions.list({
+    q: query
+  });
+  
+  return sessions;
+}
+```
+
+```python Python
+import os
+from browserbase import Browserbase
+
+browserbase = Browserbase(
+    api_key=os.getenv("BROWSERBASE_API_KEY"),
+)
+
+def get_filtered_sessions():
+    sessions = browserbase.sessions.list(status="RUNNING")
+    
+    return [{
+        'id': session['id'],
+        'status': session['status'],  # RUNNING, COMPLETED, ERROR, TIMED_OUT
+        'started_at': session['startedAt'],
+        'ended_at': session['endedAt'],
+        'region': session['region'],
+        'avg_cpu_usage': session['avgCpuUsage'],
+        'memory_usage': session['memoryUsage'],
+        'proxy_bytes': session['proxyBytes'],
+        'user_metadata': session['userMetadata']
+    } for session in sessions]
+
+def query_sessions_by_metadata(query):
+    sessions = browserbase.sessions.list(q=query)
+    
+    return sessions
+```
+</CodeGroup>
+
+## Local Environment Monitoring
+
+For local development, Stagehand provides performance monitoring and resource tracking capabilities directly on your machine.
+
+### Performance Tracking
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  verbose: 1, // Monitor performance without debug noise
+});
+
+// Track local automation metrics
+const startTime = Date.now();
+const initialMetrics = stagehand.metrics;
+
+// ... perform automation tasks
+
+const finalMetrics = stagehand.metrics;
+const executionTime = Date.now() - startTime;
+
+console.log('Local Performance Summary:', {
+  executionTime: `${executionTime}ms`,
+  totalTokens: finalMetrics.totalPromptTokens + finalMetrics.totalCompletionTokens,
+  averageResponseTime: finalMetrics.totalInferenceTimeMs / 3, // Assuming 3 operations
+  tokensPerSecond: (finalMetrics.totalPromptTokens + finalMetrics.totalCompletionTokens) / (executionTime / 1000)
+});
+```
+
+```python Python
+from stagehand import Stagehand
+import time
+
+stagehand = Stagehand(
+    env="LOCAL",
+    verbose=1,  # Monitor performance without debug noise
+)
+
+# Track local automation metrics
+start_time = time.time()
+initial_metrics = stagehand.metrics
+
+# ... perform automation tasks
+
+final_metrics = stagehand.metrics
+execution_time = (time.time() - start_time) * 1000  # Convert to ms
+
+print('Local Performance Summary:', {
+    'execution_time': f"{execution_time:.0f}ms",
+    'total_tokens': final_metrics['total_prompt_tokens'] + final_metrics['total_completion_tokens'],
+    'average_response_time': final_metrics['total_inference_time_ms'] / 3,  # Assuming 3 operations
+    'tokens_per_second': (final_metrics['total_prompt_tokens'] + final_metrics['total_completion_tokens']) / (execution_time / 1000)
+})
+```
+</CodeGroup>
+
+## Resource Usage Monitoring
+
+When running locally, monitor system resource usage and browser performance:
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+import * as os from 'os';
+import { performance } from 'perf_hooks';
+
+class LocalResourceMonitor {
+  private cpuUsage: number[] = [];
+  private memoryUsage: number[] = [];
+  
+  startMonitoring() {
+    const interval = setInterval(() => {
+      // Track system resources
+      const memUsage = process.memoryUsage();
+      this.memoryUsage.push(memUsage.heapUsed / 1024 / 1024); // MB
+      
+      // Track CPU (simplified)
+      const loadAvg = os.loadavg()[0];
+      this.cpuUsage.push(loadAvg);
+    }, 1000);
+    
+    return interval;
+  }
+  
+  getResourceSummary() {
+    return {
+      avgMemoryUsage: this.memoryUsage.reduce((a, b) => a + b, 0) / this.memoryUsage.length,
+      peakMemoryUsage: Math.max(...this.memoryUsage),
+      avgCpuLoad: this.cpuUsage.reduce((a, b) => a + b, 0) / this.cpuUsage.length,
+      totalDataPoints: this.cpuUsage.length
+    };
+  }
+}
+
+const monitor = new LocalResourceMonitor();
+const interval = monitor.startMonitoring();
+
+const stagehand = new Stagehand({ env: "LOCAL" });
+
+// ... run automation
+
+clearInterval(interval);
+console.log('Resource Usage:', monitor.getResourceSummary());
+```
+
+```python Python
+import psutil
+import time
+from typing import List
+from stagehand import Stagehand
+
+class LocalResourceMonitor:
+    def __init__(self):
+        self.cpu_usage: List[float] = []
+        self.memory_usage: List[float] = []
+        self.monitoring = False
+    
+    def start_monitoring(self):
+        self.monitoring = True
+        import threading
+        
+        def monitor_resources():
+            while self.monitoring:
+                # Track CPU and memory usage
+                cpu_percent = psutil.cpu_percent(interval=1)
+                memory_info = psutil.virtual_memory()
+                
+                self.cpu_usage.append(cpu_percent)
+                self.memory_usage.append(memory_info.percent)
+                
+                time.sleep(1)
+        
+        thread = threading.Thread(target=monitor_resources)
+        thread.daemon = True
+        thread.start()
+        return thread
+    
+    def stop_monitoring(self):
+        self.monitoring = False
+    
+    def get_resource_summary(self):
+        if not self.cpu_usage or not self.memory_usage:
+            return {'error': 'No monitoring data collected'}
+        
+        return {
+            'avg_cpu_usage': sum(self.cpu_usage) / len(self.cpu_usage),
+            'peak_cpu_usage': max(self.cpu_usage),
+            'avg_memory_usage': sum(self.memory_usage) / len(self.memory_usage),
+            'peak_memory_usage': max(self.memory_usage),
+            'total_data_points': len(self.cpu_usage)
+        }
+
+monitor = LocalResourceMonitor()
+monitor.start_monitoring()
+
+stagehand = Stagehand(env="LOCAL")
+
+# ... run automation
+
+monitor.stop_monitoring()
+print('Resource Usage:', monitor.get_resource_summary())
+```
+</CodeGroup>
+
+
+  <Card title="LLM Usage" icon="chart-line" href="/v2/configuration/evals">
+    Monitor token usage, costs, and speed. Set up automated alerting for critical failures. Implement cost tracking across different environments. Use session analytics to optimize automation workflows.
+  </Card>
+
+
+## Real-Time Metrics & Monitoring
+
+### Basic Usage Tracking
+
+Monitor your automation's resource usage in real-time with `stagehand.metrics`:
+
+<CodeGroup>
+```typescript TypeScript
+// Get current metrics
+console.log(stagehand.metrics);
+
+// Monitor during automation
+const startTime = Date.now();
+const initialMetrics = stagehand.metrics;
+
+// ... perform automation tasks
+
+const finalMetrics = stagehand.metrics;
+const executionTime = Date.now() - startTime;
+
+console.log('Automation Summary:', {
+  totalTokens: finalMetrics.totalPromptTokens + finalMetrics.totalCompletionTokens,
+  totalCost: calculateCost(finalMetrics),
+  executionTime,
+  efficiency: (finalMetrics.totalPromptTokens + finalMetrics.totalCompletionTokens) / executionTime
+});
+```
+
+```python Python
+# Get current metrics
+print(stagehand.metrics)
+
+# Monitor during automation
+import time
+start_time = time.time()
+initial_metrics = stagehand.metrics
+
+# ... perform automation tasks
+
+final_metrics = stagehand.metrics
+execution_time = (time.time() - start_time) * 1000  # Convert to ms
+
+print('Automation Summary:', {
+    'total_tokens': final_metrics['total_prompt_tokens'] + final_metrics['total_completion_tokens'],
+    'total_cost': calculate_cost(final_metrics),
+    'execution_time': execution_time,
+    'efficiency': (final_metrics['total_prompt_tokens'] + final_metrics['total_completion_tokens']) / execution_time
+})
+```
+</CodeGroup>
+
+### Understanding Metrics Data
+
+The metrics object provides detailed breakdown by Stagehand operation:
+
+<CodeGroup>
+```typescript TypeScript
+{
+  actPromptTokens: 4011,
+  actCompletionTokens: 51,
+  actInferenceTimeMs: 1688,
+
+  extractPromptTokens: 4200,
+  extractCompletionTokens: 243,
+  extractInferenceTimeMs: 4297,
+
+  observePromptTokens: 347,
+  observeCompletionTokens: 43,
+  observeInferenceTimeMs: 903,
+
+  totalPromptTokens: 8558,
+  totalCompletionTokens: 337,
+  totalInferenceTimeMs: 6888
+}
+```
+
+```python Python
+{
+  "act_prompt_tokens": 4011,
+  "act_completion_tokens": 51,
+  "act_inference_time_ms": 1688,
+
+  "extract_prompt_tokens": 4200,
+  "extract_completion_tokens": 243,
+  "extract_inference_time_ms": 4297,
+
+  "observe_prompt_tokens": 347,
+  "observe_completion_tokens": 43,
+  "observe_inference_time_ms": 903,
+
+  "total_prompt_tokens": 8558,
+  "total_completion_tokens": 337,
+  "total_inference_time_ms": 6888
+}
+```
+</CodeGroup>
+
+### Log Inference to File
+
+You can also log inference to a file by setting `logInferenceToFile` to `true`. This will create a directory called `inference_summary` in your project's root directory.
+<CodeGroup>
+```typescript TypeScript
+const stagehand = new Stagehand({
+  logInferenceToFile: true,    
+});
+```
+
+```python Python
+stagehand = Stagehand(
+    log_inference_to_file=True,             
+)
+```
+</CodeGroup>
+The `inference_summary` directory provides granular analysis data:
+```
+inference_summary/
+├── act_summary/
+│   ├── {timestamp}.json
+│   ├── {timestamp}.json
+│   └── ...
+│   └── act_summary.json
+├── extract_summary/
+│   ├── {timestamp}.json
+│   ├── {timestamp}.json
+│   └── ...
+│   └── extract_summary.json
+├── observe_summary/
+│   ├── {timestamp}.json
+│   ├── {timestamp}.json
+│   └── ...
+│   └── observe_summary.json
+```
+
+### Log File Structure
+
+Each operation creates detailed logs for analysis:
+```typescript
+{
+  "act_summary": [
+    {
+      "act_inference_type": "act",
+      "timestamp": "20250329_080446068",
+      "LLM_input_file": "20250329_080446068_act_call.txt",
+      "LLM_output_file": "20250329_080447019_act_response.txt",
+      "prompt_tokens": 3451,
+      "completion_tokens": 45,
+      "inference_time_ms": 951
+    },
+    ...
+  ],
+}
+```
+
+
+## Best Practices
+
+<AccordionGroup>
+<Accordion title="Production Monitoring">
+- Track session success rates and failure patterns
+- Monitor resource usage and scaling requirements
+- Set up automated alerting for critical failures
+- Implement cost tracking across different environments
+- Use session analytics to optimize automation workflows
+</Accordion>
+
+<Accordion title="Performance Optimization">
+- Compare Browserbase vs local execution times
+- Monitor token usage and inference costs across models
+- Track geographic performance differences
+- Identify bottlenecks in automation workflows
+- Optimize for cost-effectiveness and speed
+</Accordion>
+
+<Accordion title="Operational Insights">
+- Track session distribution across regions
+- Monitor concurrent session limits and scaling
+- Analyze failure patterns and common error scenarios
+- Use session recordings for root cause analysis
+- Implement custom metadata for workflow categorization
+</Accordion>
+
+<Accordion title="Integration & Alerting">
+- Integrate session APIs with monitoring dashboards
+- Set up automated notifications for session failures  
+- Track SLA compliance and performance benchmarks
+- Monitor resource costs and usage patterns
+- Use analytics data for capacity planning and optimization
+</Accordion>
+</AccordionGroup>
+
+For detailed logging and debugging capabilities, see [Logging](/v2/configuration/logging).
\ No newline at end of file
diff --git a/packages/docs/v2/first-steps/ai-rules.mdx b/packages/docs/v2/first-steps/ai-rules.mdx
new file mode 100644
index 000000000..fd2b33785
--- /dev/null
+++ b/packages/docs/v2/first-steps/ai-rules.mdx
@@ -0,0 +1,616 @@
+---
+title: AI Rules
+description: Using AI to write Stagehand code faster, and better.
+---
+
+You're likely using AI to write code, and there's a **right and wrong way to do it.** This page is a collection of rules, configs, and copy‑paste snippets to allow your AI agents/assistants to write performant, Stagehand code as fast as possible. 
+
+## Quickstart
+
+<CardGroup cols={2}>
+  <Card title="Add MCP servers" icon="screwdriver-wrench">
+    Configure Browserbase (Stagehand), Context7, DeepWiki, and Stagehand Docs in your MCP client. 
+  </Card>
+  <Card title="Pin editor rules" icon="memo">
+    Drop in `cursorrules` and `claude.md` so AI agents/assistants always emit Stagehand patterns. 
+  </Card>
+</CardGroup>
+
+## Using MCP Servers
+
+MCP (Model Context Protocol) servers act as intermediaries that connect AI systems to external data sources and tools. These servers enable your coding assistant to access real-time information, execute tasks, and retrieve structured data to enhance code generation accuracy.
+
+The following **MCP servers** provide specialized access to Stagehand documentation and related resources:
+
+<Accordion title="Context7 by Upstash" icon="database">
+Provides semantic search across documentation and codebase context. Context7 enables AI assistants to find relevant code patterns, examples, and implementation details from your project history. It maintains contextual understanding of your development workflow and can surface related solutions from previous work.
+
+**Installation:**
+```json
+{
+  "mcpServers": {
+    "context7": {
+      "command": "npx",
+      "args": ["-y", "@upstash/context7-mcp"]
+    }
+  }
+}
+```
+</Accordion>
+
+<Accordion title="DeepWiki by Cognition" icon="book-open">
+Offers deep indexing of GitHub repositories and documentation. DeepWiki allows AI agents to understand project architecture, API references, and best practices from the entire Stagehand ecosystem. It provides comprehensive knowledge about repository structure, code relationships, and development patterns.
+
+**Installation:**
+```json
+{
+  "mcpServers": {
+    "deepwiki": {
+      "url": "https://mcp.deepwiki.com/mcp"
+    }
+  }
+}
+```
+</Accordion>
+
+<Accordion title="Stagehand Docs by Mintlify" icon="mintbit">
+Direct access to official Stagehand documentation. This MCP server provides AI assistants with up-to-date API references, configuration options, and usage examples for accurate code generation. Mintlify auto-generates this server from the official docs, ensuring your AI assistant always has the latest information.
+
+**Usage:**
+```json
+{
+  "mcpServers": {
+    "stagehand-docs": {
+      "url": "https://docs.stagehand.dev/mcp"
+    }
+  }
+}
+```
+</Accordion>
+
+**How MCP Servers Enhance Your Development:**
+- **Real-time Documentation Access**: AI assistants can query the latest Stagehand docs, examples, and best practices
+- **Context-Aware Code Generation**: Servers provide relevant code patterns and configurations based on your specific use case
+- **Reduced Integration Overhead**: Standardized protocol eliminates the need for custom integrations with each documentation source
+- **Enhanced Accuracy**: AI agents receive structured, up-to-date information rather than relying on potentially outdated training data
+
+
+<Tip>
+**Prompting tip:** 
+Explicitly ask your coding agent/assistant to use these MCP servers to fetch relevant information from the docs so they have better context and know how to write proper Stagehand code. 
+
+ie. **"Use the stagehand-docs MCP to fetch the act/observe guidelines, then generate code that follows them. Prefer cached observe results."**
+</Tip>
+
+
+## Editor rule files (copy‑paste)
+
+Drop these in `.cursorrules`, `windsurfrules`, `claude.md`, or any agent rule framework:
+
+<Accordion title="TypeScript">
+
+``````md
+# Stagehand Project
+
+This is a project that uses [Stagehand](https://github.com/browserbase/stagehand), which amplifies Playwright with AI-powered `act`, `extract`, and `observe` methods added to the Page class.
+
+`Stagehand` is a class that provides configuration and browser automation capabilities with:
+- `stagehand.page`: A StagehandPage object (extends Playwright Page)
+- `stagehand.context`: A StagehandContext object (extends Playwright BrowserContext)
+- `stagehand.agent()`: Create AI-powered agents for autonomous multi-step workflows
+- `stagehand.init()`: Initialize the browser session
+- `stagehand.close()`: Clean up resources
+
+`Page` extends Playwright's Page class with AI-powered methods:
+- `act()`: Perform actions on web elements using natural language
+- `extract()`: Extract structured data from pages using schemas
+- `observe()`: Plan actions and get selectors before executing
+
+`Agent` provides autonomous Computer Use Agent capabilities:
+- `execute()`: Perform complex multi-step tasks using natural language instructions
+
+`Context` extends Playwright's BrowserContext class for browser session management.
+
+Use the following rules to write code for this project.
+
+- To plan an instruction like "click the sign in button", use Stagehand `observe` to get the action to execute.
+
+```typescript
+const results = await page.observe("Click the sign in button");
+```
+
+You can also pass in the following params:
+
+```typescript
+await page.observe({
+  instruction: "the instruction to execute",
+  returnAction: true 
+});
+```
+
+- The result of `observe` is an array of `ObserveResult` objects that can directly be used as params for `act` like this:
+  ```typescript
+  const results = await page.observe({
+    instruction: "the instruction to execute",
+    returnAction: true, // return the action to execute
+  });
+
+  await page.act(results[0]);
+  ```
+  
+- When writing code that needs to extract data from the page, use Stagehand `extract`. Explicitly pass the following params by default:
+
+```typescript
+const { someValue } = await page.extract({
+  instruction: "the instruction to execute",
+  schema: z.object({
+    someValue: z.string(),
+  }), // The schema to extract
+});
+```
+
+## Initialize
+
+```typescript
+import { Stagehand, Page, BrowserContext } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE"
+});
+
+await stagehand.init();
+
+const page = stagehand.page; // Playwright Page with act, extract, and observe methods
+
+const context = stagehand.context; // Playwright BrowserContext
+```
+### Configuration Options
+```typescript
+const StagehandConfig = {
+  env: "BROWSERBASE" | "LOCAL", // Environment to run in
+  apiKey: process.env.BROWSERBASE_API_KEY, // Browserbase API key
+  projectId: process.env.BROWSERBASE_PROJECT_ID, // Browserbase project ID
+  debugDom: true, // Enable DOM debugging features
+  headless: false, // Run browser in headless mode
+  domSettleTimeoutMs: 30_000, // Timeout for DOM to settle
+  enableCaching: true, // Enable action caching
+  modelName: "gpt-4o", // AI model to use
+  modelClientOptions: {
+    apiKey: process.env.OPENAI_API_KEY, // OpenAI API key
+  },
+};
+```
+## Act
+
+You can act directly with string instructions:
+
+```typescript
+await page.act("Click the sign in button");
+```
+
+Use variables for dynamic form filling:
+
+```typescript
+await page.act({
+  action: `Enter the following information:
+    Name: %name%
+    Email: %email%
+    Phone: %phone%`,
+  variables: {
+    name: "John Doe",
+    email: "john@example.com", 
+    phone: "+1-555-0123"
+  }
+});
+```
+
+**Best Practices:**
+- Cache the results of `observe` to avoid unexpected DOM changes
+- Keep actions atomic and specific (e.g., "Click the sign in button" not "Sign in to the website")
+- Use variable substitution for dynamic data entry
+
+Act `action` should be as atomic and specific as possible, i.e. "Click the sign in button" or "Type 'hello' into the search input".
+AVOID actions that are more than one step, i.e. "Order me pizza" or "Send an email to Paul asking him to call me".
+
+## Extract
+
+### Simple String Extraction
+
+```typescript
+const signInButtonText = await page.extract("extract the sign in button text");
+```
+
+### Structured Extraction with Schema (Recommended)
+
+Always use Zod schemas for structured data extraction:
+
+```typescript
+import { z } from "zod/v3";
+
+const data = await page.extract({
+  instruction: "extract the sign in button text",
+  schema: z.object({
+    text: z.string(),
+  }),
+});
+```
+
+### Array Extraction
+
+To extract multiple items, wrap the array in a single object:
+
+```typescript
+const data = await page.extract({
+  instruction: "extract the text inside all buttons",
+  schema: z.object({
+    buttons: z.array(z.string()),
+  })
+});
+```
+
+### Complex Object Extraction
+
+For more complex data structures:
+
+```typescript
+const productData = await page.extract({
+  instruction: "extract product information from this page",
+  schema: z.object({
+    title: z.string(),
+    price: z.number(),
+    description: z.string(),
+    features: z.array(z.string()),
+    availability: z.boolean(),
+  }),
+});
+```
+
+### Schema Validation
+
+```typescript
+import { validateZodSchema } from "./utils.js";
+import { z } from "zod/v3";
+
+const schema = z.object({ name: z.string() });
+const isValid = validateZodSchema(schema, { name: "John" }); // true
+```
+
+## Agent System
+
+Stagehand provides an Agent System for autonomous web browsing using Computer Use Agents (CUA). Agents execute multi-step workflows using natural language instructions.
+
+### Creating Agents
+
+```typescript
+// Basic agent (default)
+const agent = stagehand.agent();
+
+// OpenAI agent
+const agent = stagehand.agent({
+  provider: "openai",
+  model: "computer-use-preview",
+  instructions: "You are a helpful assistant that can use a web browser.",
+  options: { 
+    apiKey: process.env.OPENAI_API_KEY 
+  }
+});
+
+// Anthropic agent
+const agent = stagehand.agent({
+  provider: "anthropic", 
+  model: "claude-sonnet-4-20250514",
+  instructions: "You are a helpful assistant that can use a web browser.",
+  options: { 
+    apiKey: process.env.ANTHROPIC_API_KEY 
+  }
+});
+```
+### Agent Execution
+```typescript
+// Simple task
+const result = await agent.execute("Extract the title from this webpage");
+
+// Complex multi-step task
+const result = await agent.execute({
+  instruction: "Apply for the first engineer position with mock data",
+  maxSteps: 20,
+  autoScreenshot: true
+});
+```
+
+### Best Practices
+- Be specific with instructions: `"Fill out the contact form with name 'John Doe' and submit it"`
+- Break down complex tasks into smaller steps
+- Use error handling with try/catch blocks
+- Combine agents for navigation with traditional methods for precise data extraction
+
+```typescript
+// Good: Specific instructions
+await agent.execute("Navigate to products page and filter by 'Electronics'");
+
+// Avoid: Vague instructions  
+await agent.execute("Do some stuff on this page");
+```
+
+## Project Structure Best Practices
+
+- Store configurations in `stagehand.config.ts`
+- Use environment variables for API keys (see `.env.example`)
+- Implement main automation logic in functions that accept `{ page, context, stagehand }`
+- Use TypeScript with proper imports from `@browserbasehq/stagehand`
+``````
+
+</Accordion>
+
+<Accordion title="Python">
+
+``````md
+# Stagehand Python Project
+
+This is a project that uses [Stagehand Python](https://github.com/browserbase/stagehand-python), which provides AI-powered browser automation with `act`, `extract`, and `observe` methods.
+
+`Stagehand` is a class that provides configuration and browser automation capabilities with:
+- `stagehand.page`: A StagehandPage object (extends Playwright Page)
+- `stagehand.context`: A StagehandContext object (extends Playwright BrowserContext)
+- `stagehand.agent()`: Create AI-powered agents for autonomous multi-step workflows
+- `stagehand.init()`: Initialize the browser session
+- `stagehand.close()`: Clean up resources
+
+`Page` extends Playwright's Page class with AI-powered methods:
+- `act()`: Perform actions on web elements using natural language
+- `extract()`: Extract structured data from pages using schemas
+- `observe()`: Plan actions and get selectors before executing
+
+`Agent` provides autonomous Computer Use Agent capabilities:
+- `execute()`: Perform complex multi-step tasks using natural language instructions
+
+Use the following rules to write code for this project.
+
+- To plan an instruction like "click the sign in button", use Stagehand `observe` to get the action to execute.
+
+```python
+results = await page.observe("Click the sign in button")
+```
+
+You can also pass in the following params:
+
+```python
+await page.observe(
+    instruction="the instruction to execute",
+    draw_overlay=True  # Show visual overlay on observed elements
+)
+```
+
+- The result of `observe` is a list of `ObserveResult` objects that can directly be used as params for `act` like this:
+  ```python
+  results = await page.observe("Click the sign in button")
+  await page.act(results[0])
+  ```
+- When writing code that needs to extract data from the page, use Stagehand `extract`. Use Pydantic models for schemas:
+
+```python
+from pydantic import BaseModel
+
+class ExtractedData(BaseModel):
+    some_value: str
+
+result = await page.extract(
+    instruction="the instruction to execute",
+    schema=ExtractedData
+)
+```
+
+## Initialize
+
+```python
+from stagehand import Stagehand, StagehandConfig
+import asyncio
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+async def main():
+    config = StagehandConfig(
+        env="BROWSERBASE",  # or "LOCAL"
+        api_key=os.getenv("BROWSERBASE_API_KEY"),
+        project_id=os.getenv("BROWSERBASE_PROJECT_ID"),
+        model_name="google/gemini-2.5-flash-preview-05-20",
+        model_api_key=os.getenv("MODEL_API_KEY"),
+    )
+    
+    # Recommended: Use as async context manager
+    async with Stagehand(config) as stagehand:
+        page = stagehand.page
+        # Your automation code here
+        
+    # Alternative: Manual initialization
+    stagehand = Stagehand(config)
+    await stagehand.init()
+    page = stagehand.page
+    # Your automation code here
+    await stagehand.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Configuration Options
+
+Key configuration options in `StagehandConfig`:
+
+```python
+config = StagehandConfig(
+    env="BROWSERBASE",  # or "LOCAL"
+    api_key=os.getenv("BROWSERBASE_API_KEY"),
+    project_id=os.getenv("BROWSERBASE_PROJECT_ID"),
+    model_name="google/gemini-2.5-flash-preview-05-20",
+    model_api_key=os.getenv("MODEL_API_KEY"),
+    verbose=1,  # 0=minimal, 1=medium, 2=detailed
+    dom_settle_timeout_ms=30000,
+    self_heal=True,  # Enable self-healing functionality
+)
+```
+
+## Act
+
+You can act directly with string instructions:
+
+```python
+await page.act("Click the sign in button")
+```
+
+Use variables for dynamic form filling:
+
+```python
+await page.act(
+    "Enter the following information: Name: John Doe, Email: john@example.com"
+)
+```
+
+**Best Practices:**
+- Cache the results of `observe` to avoid unexpected DOM changes
+- Keep actions atomic and specific (e.g., "Click the sign in button" not "Sign in to the website")
+- Use specific, descriptive instructions
+
+Act `action` should be as atomic and specific as possible, i.e. "Click the sign in button" or "Type 'hello' into the search input".
+AVOID actions that are more than one step, i.e. "Order me pizza" or "Send an email to Paul asking him to call me".
+
+## Extract
+
+### Simple String Extraction
+```python
+sign_in_button_text = await page.extract("extract the sign in button text")
+```
+
+### Structured Extraction with Schema (Recommended)
+Always use Pydantic models for structured data extraction:
+
+```python
+from pydantic import BaseModel, Field
+from typing import List
+
+class ButtonData(BaseModel):
+    text: str = Field(..., description="Button text content")
+
+data = await page.extract(
+    instruction="extract the sign in button text",
+    schema=ButtonData
+)
+```
+
+### Array Extraction
+For arrays, use List types:
+
+```python
+from pydantic import BaseModel, Field
+from typing import List
+
+class ButtonsData(BaseModel):
+    buttons: List[str] = Field(..., description="List of button texts")
+
+data = await page.extract(
+    instruction="extract the text inside all buttons",
+    schema=ButtonsData
+)
+```
+
+### Complex Object Extraction
+For more complex data structures:
+
+```python
+from pydantic import BaseModel, Field
+from typing import List
+
+class Company(BaseModel):
+    name: str = Field(..., description="Company name")
+    description: str = Field(..., description="Brief company description")
+
+class Companies(BaseModel):
+    companies: List[Company] = Field(..., description="List of companies")
+
+companies_data = await page.extract(
+    "Extract names and descriptions of 5 companies",
+    schema=Companies
+)
+```
+
+## Agent System
+
+Stagehand provides an Agent System for autonomous web browsing using Computer Use Agents (CUA).
+
+### Creating Agents
+
+```python
+# Basic agent (uses default model)
+agent = stagehand.agent()
+
+# OpenAI agent
+agent = stagehand.agent(
+    model="computer-use-preview",
+    instructions="You are a helpful web navigation assistant.",
+    options={"apiKey": os.getenv("OPENAI_API_KEY")}
+)
+
+# Anthropic agent
+agent = stagehand.agent(
+    model="claude-sonnet-4-20250514",
+    instructions="You are a helpful web navigation assistant.",
+    options={"apiKey": os.getenv("ANTHROPIC_API_KEY")}
+)
+```
+
+### Agent Execution
+
+```python
+# Simple task
+result = await agent.execute("Play a game of 2048")
+
+# Complex multi-step task with options
+result = await agent.execute(
+    instruction="Apply for the first engineer position with mock data",
+    max_steps=20,
+    auto_screenshot=True,
+    wait_between_actions=1000  # milliseconds
+)
+```
+
+**Best Practices:**
+- Be specific with instructions: `"Fill out the contact form with name 'John Doe' and submit it"`
+- Break down complex tasks into smaller steps
+- Use error handling with try/except blocks
+- Combine agents for navigation with traditional methods for precise data extraction
+
+```python
+# Good: Specific instructions
+await agent.execute("Navigate to products page and filter by 'Electronics'")
+
+# Avoid: Vague instructions
+await agent.execute("Do some stuff on this page")
+```
+
+## Project Structure Best Practices
+
+- Store configurations in environment variables or config files
+- Use async/await patterns consistently
+- Implement main automation logic in async functions
+- Use async context managers for resource management
+- Use type hints and Pydantic models for data validation
+- Handle exceptions appropriately with try/except blocks
+``````
+
+</Accordion>
+
+## Security notes
+
+- Do not embed secrets in docs or rule files; use env vars in MCP configs.
+- Avoid broad actions that may trigger unintended navigation; prefer `observe` first.
+
+## Resources/references
+
+- Context7 MCP (Upstash)
+  - https://github.com/upstash/context7
+- DeepWiki MCP
+  - https://mcp.deepwiki.com/
+- Stagehand Docs MCP (Mintlify)
+  - https://docs.stagehand.dev/mcp
diff --git a/packages/docs/v2/first-steps/installation.mdx b/packages/docs/v2/first-steps/installation.mdx
new file mode 100644
index 000000000..eb5efe29b
--- /dev/null
+++ b/packages/docs/v2/first-steps/installation.mdx
@@ -0,0 +1,198 @@
+---
+title: Installation
+description: Integrate Stagehand into an existing project.
+---
+
+Install Stagehand in your current app with the TypeScript or Python SDK.
+
+<Tip>
+For TypeScript/Node.js: We highly recommend using the Node.js runtime environment to run Stagehand scripts, as opposed to newer alternatives like Deno or Bun. 
+
+**Bun does not support Stagehand** since it doesn't support [Playwright](https://github.com/search?q=repo:oven-sh/bun+playwright&type=issues).
+
+For Python: We require Python 3.9+ and recommend using [uv](https://docs.astral.sh/uv/) to manage your virtual environment.
+</Tip>
+
+<Tabs>
+<Tab title="TypeScript">
+
+### Install dependencies
+
+<CodeGroup>
+```bash npm
+npm install @browserbasehq/stagehand playwright zod
+```
+
+```bash pnpm
+pnpm add @browserbasehq/stagehand playwright zod
+```
+
+```bash yarn
+yarn add @browserbasehq/stagehand playwright zod
+```
+</CodeGroup>
+
+<Tip>
+If you plan to run locally, install browsers once: `npx playwright install`.
+For cloud browser sessions, skip this.
+</Tip>
+
+### Configure environment
+
+Set environment variables (or a `.env` via your framework):
+
+<CodeGroup>
+```bash Bash
+OPENAI_API_KEY=your_api_key
+BROWSERBASE_API_KEY=your_api_key
+BROWSERBASE_PROJECT_ID=your_project_id
+```
+</CodeGroup>
+
+### Use in your codebase
+
+Add Stagehand where you need browser automation.
+
+<CodeGroup>
+```typescript TypeScript
+import "dotenv/config";
+import { Stagehand } from "@browserbasehq/stagehand";
+import { z } from "zod/v3";
+
+async function main() {
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE"
+  });
+
+  await stagehand.init();
+  const page = stagehand.page;
+
+  await page.goto("https://example.com");
+  
+  // Act on the page
+  await page.act("Click the sign in button");
+  
+  // Extract structured data
+  const { title } = await page.extract({
+    instruction: "extract the page title",
+    schema: z.object({
+      title: z.string(),
+    }),
+  });
+
+  console.log(title);
+  await stagehand.close();
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+```
+</CodeGroup>
+
+</Tab>
+
+<Tab title="Python">
+
+### Add dependencies
+
+<CodeGroup>
+
+```bash uv
+uv add stagehand
+```
+
+```bash pip
+pip install stagehand
+```
+
+</CodeGroup>
+
+### Configure environment
+
+Set environment variables (or a `.env` via your framework):
+
+<CodeGroup>
+```bash Bash
+MODEL_API_KEY=your_api_key
+BROWSERBASE_API_KEY=your_api_key
+BROWSERBASE_PROJECT_ID=your_project_id
+```
+</CodeGroup>
+
+### Use in your codebase
+
+<CodeGroup>
+```python Python
+import os
+import asyncio
+from stagehand import Stagehand
+
+async def main():
+    stagehand = Stagehand(
+        env="BROWSERBASE",
+        model_api_key=os.getenv("MODEL_API_KEY")
+    )
+    await stagehand.init()
+    page = stagehand.page
+    
+    await page.goto("https://example.com")
+    
+    # Act on the page
+    await page.act("Click the sign in button")
+    
+    # Extract structured data
+    result = await page.extract({
+        "instruction": "extract the page title",
+        "schema": {
+            "title": {
+                "type": "string"
+            }
+        }
+    })
+    
+    print(result["title"])
+    await stagehand.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+</CodeGroup>
+
+</Tab>
+
+</Tabs>
+
+## Next steps
+
+<CardGroup cols={2}>
+  <Card 
+    title="Configuration"
+    icon="gear"
+    href="/v2/configuration/browser"
+  >
+    Environment, Browserbase vs Local, logging, timeouts, LLM customization
+  </Card>
+  <Card 
+    title="Act"
+    icon="arrow-pointer"
+    href="/v2/basics/act"
+  >
+    Perform precise actions with natural language
+  </Card>
+  <Card 
+    title="Extract"
+    icon="download"
+    href="/v2/basics/extract"
+  >
+    Typed data extraction with Zod schemas
+  </Card>
+  <Card 
+    title="Observe"
+    icon="eye"
+    href="/v2/basics/observe"
+  >
+    Discover elements and suggested actions
+  </Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/first-steps/introduction.mdx b/packages/docs/v2/first-steps/introduction.mdx
new file mode 100644
index 000000000..1615eb9a0
--- /dev/null
+++ b/packages/docs/v2/first-steps/introduction.mdx
@@ -0,0 +1,138 @@
+---
+title: Introducing Stagehand
+sidebarTitle: Introduction
+description: Developers use Stagehand to reliably automate the web.
+---
+
+Stagehand is a browser automation framework used to control web browsers with natural language and code. By combining the power of AI with the precision of code, Stagehand makes web automation flexible, maintainable, and actually reliable.
+
+## The Problem with Browser Automation
+
+Traditional frameworks like Playwright and Puppeteer force you to write brittle scripts that break with every UI change. Web agents promise to solve this with AI, but leave you at the mercy of unpredictable behavior.
+
+**You're stuck between two bad options:**
+- **Too brittle**: Traditional selectors break when websites change
+- **Too agentic**: AI agents are unpredictable and impossible to debug
+
+## Enter Stagehand
+
+Stagehand gives you the best of both worlds through four powerful primitives that let you choose exactly how much AI to use:
+
+<CardGroup cols={2}>
+  <Card title="Act" icon="play" href="/v2/basics/act">
+    Execute actions using natural language
+  </Card>
+  <Card title="Extract" icon="database" href="/v2/basics/extract">
+    Pull structured data with schemas
+  </Card>
+  <Card title="Observe" icon="eye" href="/v2/basics/observe">
+    Discover available actions on any page
+  </Card>
+  <Card title="Agent" icon="robot" href="/v2/basics/agent">
+    Automate entire workflows autonomously
+  </Card>
+</CardGroup>
+
+<CodeGroup>
+```typescript TypeScript
+// Act - Execute natural language actions
+await page.act("click the login button");
+
+// Extract - Pull structured data
+const { price } = await page.extract({
+  schema: z.object({ price: z.number() })
+});
+
+// Observe - Discover available actions
+const actions = await page.observe("find submit buttons");
+
+// Agent - Automate entire workflows
+const agent = stagehand.agent({
+    provider: "anthropic",
+    model: "claude-sonnet-4-20250514",
+    options: {
+      apiKey: process.env.ANTHROPIC_API_KEY,
+    },
+})
+await agent.execute("apply for this job");
+```
+```python Python
+# Act - Execute natural language actions
+await page.act("click the login button")
+
+# Extract - Pull structured data
+result = await page.extract(
+  schema={"price": float}
+)
+
+# Observe - Discover available actions
+actions = await page.observe("find submit buttons")
+
+# Agent - Automate entire workflows
+await agent.execute("apply for this job")
+```
+</CodeGroup>
+
+
+## Why Developers Choose Stagehand
+
+- **Precise Control**: Mix AI-powered actions with deterministic code. You decide exactly how much AI to use.
+
+- **Actually Repeatable**: Save and replay actions exactly. No more "it worked on my machine" with browser automations.
+
+- **Maintainable at Scale**: One script can automate multiple websites. When sites change, your automations adapt.
+
+- **Composable Tools**: Choose your level of automation with Act, Extract, Observe, and Agent.
+
+## Built for Modern Development
+Stagehand is designed for developers building production browser automations and AI agents that need reliable web access.
+
+<AccordionGroup>
+  <Accordion title="Full Playwright Compatibility">
+    Use any Playwright API alongside Stagehand. You're never locked into our abstractions.
+  </Accordion>
+  <Accordion title="TypeScript & Python SDKs">
+    First-class support for both ecosystems with type safety and IDE autocomplete.
+  </Accordion>
+  <Accordion title="Works Everywhere">
+    Compatible with all Chromium-based browsers: Chrome, Edge, Arc, Brave, and more.
+  </Accordion>
+  <Accordion title="Built by Browserbase">
+    Created and maintained by the team behind enterprise browser infrastructure.
+  </Accordion>
+</AccordionGroup>
+
+## Get Started in 60 Seconds
+<Info>
+  **Pro tip**: For best results, we recommend using Stagehand with [Browserbase](https://www.browserbase.com) for reliable cloud browser infrastructure.
+</Info>
+<CardGroup cols={2}>
+  <Card
+    title="Quickstart"
+    icon="rocket"
+    href="/v2/first-steps/quickstart"
+  >
+    Build your first automation in under a minute
+  </Card>
+  <Card
+    title="Try Director"
+    icon="wand-magic-sparkles"
+    href="https://www.director.ai"
+  >
+    Generate Stagehand scripts with AI
+  </Card>
+  <Card
+    title="View Templates"
+    icon="code"
+    href="https://www.browserbase.com/templates"
+  >
+    See real-world automation examples
+  </Card>
+  <Card
+    title="Join Discord"
+    icon="discord"
+    href="https://stagehand.dev/discord"
+  >
+    Get help from the community
+  </Card>
+</CardGroup>
diff --git a/packages/docs/v2/first-steps/quickstart.mdx b/packages/docs/v2/first-steps/quickstart.mdx
new file mode 100644
index 000000000..ff32a2ea6
--- /dev/null
+++ b/packages/docs/v2/first-steps/quickstart.mdx
@@ -0,0 +1,125 @@
+---
+title: Quickstart
+description: 'Stagehand allows you to build web automations with natural language and code.'
+---
+
+If this is your **first time using Stagehand**, you should try [Director](https://director.ai) first. It's an agent that allows you to build Stagehand workflows using natural language. You can also try Stagehand using our [MCP server](/integrations/mcp/introduction) .   
+
+Otherwise, the quickest way to start with Stagehand is with our CLI. It scaffolds a ready‑to‑run Stagehand app with sensible defaults, and an example script.
+
+<Note>
+This quickstart is for **TypeScript**. For **Python**, see the [installation guide](/v2/first-steps/installation).
+</Note>
+
+## 1) Create a sample project
+
+<CodeGroup>
+```bash Bash
+npx create-browser-app
+```
+</CodeGroup>
+
+## 2) Run it
+
+Follow the CLI prompts to enter the project directory and add your API keys. Then run the example script.
+
+<CodeGroup>
+```bash Bash
+cd my-stagehand-app # Enter the project directory
+cp .env.example .env  # Add your API keys
+npm start # Run the example script
+```
+</CodeGroup>
+
+## 3) Use Stagehand (act, extract, observe)
+
+The scaffold includes an index.ts file that contains the example script. Here's what it looks like:
+
+<CodeGroup>
+```typescript TypeScript
+import "dotenv/config";
+import { Stagehand } from "@browserbasehq/stagehand";
+
+async function main() {
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE"
+  });
+
+  await stagehand.init();
+
+  console.log(`Stagehand Session Started`);
+  console.log(`Watch live: https://browserbase.com/sessions/${stagehand.browserbaseSessionID}`);
+
+  const page = stagehand.page;
+
+  await page.goto("https://stagehand.dev");
+
+  const extractResult = await page.extract("Extract the value proposition from the page.");
+  console.log(`Extract result:\n`, extractResult);
+
+  const actResult = await page.act("Click the 'Evals' button.");
+  console.log(`Act result:\n`, actResult);
+
+  const observeResult = await page.observe("What can I click on this page?");
+  console.log(`Observe result:\n`, observeResult);
+
+  const agent = await stagehand.agent({
+    instructions: "You're a helpful assistant that can control a web browser.",
+  });
+
+  const agentResult = await agent.execute("What is the most accurate model to use in Stagehand?");
+  console.log(`Agent result:\n`, agentResult);
+
+  await stagehand.close();
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+
+```
+</CodeGroup>
+
+<Tip>
+To use, set provider keys in `.env` (e.g., `OPENAI_API_KEY`). For cloud browsers, add `BROWSERBASE_API_KEY` and `BROWSERBASE_PROJECT_ID`.
+</Tip>
+
+## Next steps
+
+Learn about the Stagehand primitives: act, extract, observe, and agent.
+
+<CardGroup cols={2}>
+  <Card 
+    title="Act" 
+    icon="arrow-pointer" 
+    href="/v2/basics/act"
+  >
+    Perform actions on web pages with natural language
+  </Card>
+  
+  <Card 
+    title="Extract" 
+    icon="download" 
+    href="/v2/basics/extract"
+  >
+    Get structured data with Zod schemas
+  </Card>
+  
+  <Card 
+    title="Observe" 
+    icon="eye" 
+    href="/v2/basics/observe"
+  >
+    Discover available elements and actions
+  </Card>
+  
+  <Card 
+    title="Agent" 
+    icon="robot" 
+    href="/v2/basics/agent"
+  >
+    Autonomous multi-step browser workflows
+  </Card>
+</CardGroup>
+
diff --git a/packages/docs/v2/integrations/crew-ai/configuration.mdx b/packages/docs/v2/integrations/crew-ai/configuration.mdx
new file mode 100644
index 000000000..7b8e7cc20
--- /dev/null
+++ b/packages/docs/v2/integrations/crew-ai/configuration.mdx
@@ -0,0 +1,170 @@
+---
+title: "Use CrewAI to Automate Browser Tasks"
+sidebarTitle: Configuration
+description: "Create intelligent agents that can interact with websites and automate browser tasks using natural language instructions"
+---
+
+This guide walks you through setting up CrewAI with Browserbase to create agents that can perform web automation tasks using natural language instructions.
+
+## Step 1: Install Dependencies
+
+Install the required packages for CrewAI and Stagehand integration:
+
+```bash
+pip install stagehand-py crewai crewai-tools
+```
+
+## Step 2: Configure Environment Variables
+
+You'll need API keys from three services:
+
+1. **Browserbase API Key and Project ID**: Get these from your [Browserbase dashboard](https://www.browserbase.com/)
+2. **LLM API Key**: Get an API key from [OpenAI](https://platform.openai.com/api-keys) or [Anthropic](https://console.anthropic.com/)
+
+Store your API keys securely as environment variables:
+
+```bash
+BROWSERBASE_API_KEY="your-browserbase-api-key"
+BROWSERBASE_PROJECT_ID="your-browserbase-project-id"
+OPENAI_API_KEY="your-openai-api-key"
+ANTHROPIC_API_KEY="your-anthropic-api-key"
+```
+
+## Step 3: Create Your First Agent
+
+Create a Python script with a basic CrewAI agent:
+
+```python
+import os
+from crewai import Agent, Task, Crew
+from crewai_tools import StagehandTool
+from stagehand.schemas import AvailableModel
+
+# Get API keys from environment
+browserbase_api_key = os.environ.get("BROWSERBASE_API_KEY")
+browserbase_project_id = os.environ.get("BROWSERBASE_PROJECT_ID")
+model_api_key = os.environ.get("OPENAI_API_KEY")  # or ANTHROPIC_API_KEY
+
+# Initialize the StagehandTool
+stagehand_tool = StagehandTool(
+    api_key=browserbase_api_key,
+    project_id=browserbase_project_id,
+    model_api_key=model_api_key,
+    model_name=AvailableModel.GPT_4O,  # or AvailableModel.CLAUDE_3_7_SONNET_LATEST
+)
+
+# Create an agent with the tool
+researcher = Agent(
+    role="Web Researcher",
+    goal="Find and summarize information from websites",
+    backstory="I'm an expert at finding information online.",
+    verbose=True,
+    tools=[stagehand_tool],
+)
+```
+
+## Step 4: Create and Run a Task
+
+Define a task for your agent and execute it:
+
+```python
+# Create a task that uses the tool
+research_task = Task(
+    description="Go to https://www.example.com and tell me what you see on the homepage.",
+    agent=researcher,
+)
+
+# Run the crew
+crew = Crew(
+    agents=[researcher],
+    tasks=[research_task],
+    verbose=True,
+)
+
+try:
+    result = crew.kickoff()
+    print(result)
+finally:
+    # Clean up resources
+    stagehand_tool.close()
+```
+
+## Step 5: Run Your Script
+
+Execute your Python script:
+
+```bash
+python your_crew_script.py
+```
+
+## Advanced Configuration
+
+Customize the StagehandTool behavior with additional parameters:
+
+```python
+stagehand_tool = StagehandTool(
+    api_key=browserbase_api_key,
+    project_id=browserbase_project_id, 
+    model_api_key=model_api_key,
+    model_name=AvailableModel.CLAUDE_3_7_SONNET_LATEST,
+    dom_settle_timeout_ms=5000,  # Wait longer for DOM to settle
+    headless=True,  # Run browser in headless mode
+    self_heal=True,  # Attempt to recover from errors
+    wait_for_captcha_solves=True,  # Wait for CAPTCHA solving
+    verbose=1,  # Control logging verbosity (0-3)
+)
+```
+
+## Example Tasks
+
+<Tabs>
+  <Tab title="Form Submission" value="form-submission" label="Python">
+    ```python
+    form_task = Task(
+        description="""
+        Submit a contact form:
+        1. Go to https://example.com/contact
+        2. Fill out the form with name 'John Doe', email 'john@example.com'
+        3. Submit and confirm success
+        """,
+        agent=researcher,
+    )
+    ```
+  </Tab>
+  <Tab title="Data Extraction" value="data-extraction" label="Python">
+    ```python
+    extraction_task = Task(
+        description="""
+        Extract product information:
+        1. Go to the products page
+        2. Extract all product names, prices, and descriptions
+        3. Format as structured data
+        """,
+        agent=researcher,
+    )
+    ```
+  </Tab>
+  <Tab title="Multi-step Navigation" value="multi-step-navigation" label="Python">
+    ```python
+    navigation_task = Task(
+        description="""
+        Navigate and analyze:
+        1. Start at homepage
+        2. Navigate to products section  
+        3. Filter by 'Electronics' category
+        4. Find and extract details of highest-rated product
+        """,
+        agent=researcher,
+    )
+    ```
+  </Tab>
+</Tabs>
+
+<CardGroup cols={2}>
+  <Card title="CrewAI Documentation" icon="book" href="https://docs.crewai.com/">
+    Dive into the CrewAI documentation to learn more about its capabilities and integrations.
+  </Card>
+  <Card title="Browserbase Documentation" icon="book" href="https://docs.browserbase.com/">
+    Access the Browserbase documentation for comprehensive guides and resources.
+  </Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/integrations/crew-ai/introduction.mdx b/packages/docs/v2/integrations/crew-ai/introduction.mdx
new file mode 100644
index 000000000..a8c5bfd8d
--- /dev/null
+++ b/packages/docs/v2/integrations/crew-ai/introduction.mdx
@@ -0,0 +1,35 @@
+---
+title: "CrewAI Introduction"
+sidebarTitle: Introduction
+description: "Automate browser tasks using natural language instructions with CrewAI"
+---
+
+## Overview
+
+This guide shows you how to use CrewAI with Browserbase to create intelligent agents that can automate web interactions. By the end of this guide, you'll know how to:
+
+- Set up CrewAI with the StagehandTool
+- Create agents that can interact with websites
+- Automate browser tasks using natural language instructions
+- Extract structured data from web pages
+
+## When You'd Use This
+
+The CrewAI integration is perfect for scenarios where you need intelligent web automation:
+
+- **Research automation**: Have agents research information across multiple websites
+- **Data collection**: Extract structured data from e-commerce sites, job boards, or news sites
+- **Form automation**: Automatically fill out and submit forms based on specific criteria
+- **Multi-step workflows**: Execute complex browser workflows that require decision-making
+
+The StagehandTool wraps the Stagehand Python SDK to provide CrewAI agents with the ability to control a real web browser and interact with websites using three core primitives:
+
+1. **Act**: Perform actions like clicking, typing, or navigating
+2. **Extract**: Extract structured data from web pages
+3. **Observe**: Identify and analyze elements on the page
+
+<CardGroup cols={1}>
+<Card title="CrewAI Configuration" icon="gear" href="/integrations/crew-ai/configuration">
+  Learn how to configure and use the StagehandTool with CrewAI agents for web automation tasks
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/integrations/langchain/configuration.mdx b/packages/docs/v2/integrations/langchain/configuration.mdx
new file mode 100644
index 000000000..6c3dd4b61
--- /dev/null
+++ b/packages/docs/v2/integrations/langchain/configuration.mdx
@@ -0,0 +1,242 @@
+---
+title: "LangChain JS Configuration"
+sidebarTitle: Configuration
+description: "Set up Stagehand with LangChain JS to create intelligent web automation agents"
+---
+
+This guide walks you through integrating Stagehand with LangChain JS to build powerful web automation workflows using natural language instructions.
+
+## Step 1: Install Dependencies
+
+Install the required packages for LangChain JS and Stagehand integration:
+
+```bash
+npm install @langchain/langgraph @langchain/community @langchain/core @browserbasehq/stagehand
+```
+
+## Step 2: Configure Environment Variables
+
+For remote browser automation, set up your Browserbase credentials:
+
+```bash
+BROWSERBASE_API_KEY="your-browserbase-api-key"
+BROWSERBASE_PROJECT_ID="your-browserbase-project-id"
+```
+
+## Step 3: Create a Stagehand Instance
+
+Initialize Stagehand with your preferred configuration:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+// For local development
+const stagehand = new Stagehand({
+    env: "LOCAL",
+    verbose: 2,
+    enableCaching: false,
+});
+
+// For production with Browserbase
+const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    verbose: 1,
+    enableCaching: true,
+});
+```
+
+## Step 4: Generate the StagehandToolkit
+
+Create the toolkit that provides LangChain-compatible tools:
+
+```typescript
+import { StagehandToolkit } from '@langchain/community/agents/toolkits/stagehand';
+
+const stagehandToolkit = await StagehandToolkit.fromStagehand(stagehand);
+```
+
+## Step 5: Use Individual Tools
+
+The toolkit provides four specialized tools for web automation:
+
+### Available Tools
+
+- **stagehand_navigate**: Navigate to specific URLs
+- **stagehand_act**: Perform browser actions (clicking, typing, etc.)
+- **stagehand_extract**: Extract structured data using schemas  
+- **stagehand_observe**: Analyze page elements and possible actions
+
+### Basic Tool Usage
+
+```typescript
+import { z } from "zod";
+
+// Navigate to a website
+const navigateTool = stagehandToolkit.tools.find(
+    (t) => t.name === "stagehand_navigate"
+);
+await navigateTool.invoke("https://www.google.com");
+
+// Perform an action
+const actionTool = stagehandToolkit.tools.find(
+    (t) => t.name === "stagehand_act"
+);
+await actionTool.invoke('Search for "OpenAI"');
+
+// Observe the page
+const observeTool = stagehandToolkit.tools.find(
+    (t) => t.name === "stagehand_observe"
+);
+const result = await observeTool.invoke(
+    "What actions can be performed on the current page?"
+);
+console.log(JSON.parse(result));
+
+// Extract structured data
+const extractTool = stagehandToolkit.tools.find(
+    (t) => t.name === "stagehand_extract"
+);
+const extractResult = await extractTool.invoke({
+    instruction: "Extract the main heading and description",
+    schema: z.object({
+        heading: z.string(),
+        description: z.string(),
+    }),
+});
+console.log(extractResult);
+```
+
+## Step 6: Build LangGraph Agents
+
+Integrate with LangGraph for complex automation workflows:
+
+```typescript
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+
+// Create an LLM
+const llm = new ChatOpenAI({
+    model: "gpt-4",
+    temperature: 0,
+});
+
+// Create an agent with Stagehand tools
+const agent = createReactAgent({
+    llm,
+    tools: stagehandToolkit.tools,
+});
+
+// Execute a complex workflow
+const result = await agent.invoke({
+    messages: [
+        {
+            role: "user", 
+            content: "Go to example.com, find the contact form, and extract all the form fields"
+        }
+    ]
+});
+```
+
+## Advanced Configuration
+
+### Custom Stagehand Configuration
+
+```typescript
+const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    verbose: 2,
+    enableCaching: true,
+    headless: true,
+    domSettleTimeoutMs: 5000,
+});
+```
+
+### Error Handling
+
+```typescript
+try {
+    const result = await agent.invoke({
+        messages: [{ role: "user", content: "Navigate to invalid-url.com" }]
+    });
+} catch (error) {
+    console.error("Automation failed:", error);
+} finally {
+    // Clean up resources
+    await stagehand.close();
+}
+```
+
+## Example Workflows
+
+<Tabs>
+  <Tab title="Data Extraction" value="data-extraction" label="TypeScript">
+    ```typescript
+    const extractionAgent = createReactAgent({
+        llm,
+        tools: stagehandToolkit.tools,
+    });
+
+    const result = await extractionAgent.invoke({
+        messages: [{
+            role: "user",
+            content: `
+                Go to news-website.com and extract:
+                1. All article headlines
+                2. Publication dates  
+                3. Author names
+                Format as structured JSON
+            `
+        }]
+    });
+    ```
+  </Tab>
+  <Tab title="Form Automation" value="form-automation" label="TypeScript">
+    ```typescript
+    const formAgent = createReactAgent({
+        llm,
+        tools: stagehandToolkit.tools,
+    });
+
+    const result = await formAgent.invoke({
+        messages: [{
+            role: "user", 
+            content: `
+                Navigate to contact-form.com and:
+                1. Fill out the contact form with:
+                   - Name: John Doe
+                   - Email: john@example.com
+                   - Message: Inquiry about services
+                2. Submit the form
+                3. Confirm submission success
+            `
+        }]
+    });
+    ```
+  </Tab>
+  <Tab title="Multi-site Research" value="multi-site-research" label="TypeScript">
+    ```typescript
+    const researchAgent = createReactAgent({
+        llm,
+        tools: stagehandToolkit.tools,
+    });
+
+    const result = await researchAgent.invoke({
+        messages: [{
+            role: "user",
+            content: `
+                Research product pricing by:
+                1. Visit competitor1.com and extract pricing info
+                2. Visit competitor2.com and extract pricing info  
+                3. Compare features and prices
+                4. Provide summary analysis
+            `
+        }]
+    });
+    ```
+  </Tab>
+</Tabs>
+
+<CardGroup cols={1}>
+  <Card title="LangChain JS Documentation" icon="book" href="https://js.langchain.com/docs/integrations/tools/stagehand/">
+    Official LangChain JS documentation for the Stagehand integration
+  </Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/integrations/langchain/introduction.mdx b/packages/docs/v2/integrations/langchain/introduction.mdx
new file mode 100644
index 000000000..b0d7b9341
--- /dev/null
+++ b/packages/docs/v2/integrations/langchain/introduction.mdx
@@ -0,0 +1,29 @@
+---
+title: "Langchain JS Introduction"
+sidebarTitle: Introduction
+description: "Integrate Stagehand with Langchain JS for intelligent web automation"
+---
+
+## Overview
+
+This guide shows you how to use Stagehand with Langchain JS to create intelligent agents that can automate web interactions. By the end of this guide, you'll know how to:
+
+- Set up the StagehandToolkit with Langchain JS
+- Create agents that can navigate and interact with websites
+- Extract structured data using natural language instructions
+- Build complex automation workflows with LangGraph
+
+## When You'd Use This
+
+The Langchain JS integration is perfect for scenarios where you need intelligent web automation with advanced reasoning:
+
+- **AI-driven research**: Create agents that can research information across multiple websites and synthesize findings
+- **Dynamic form filling**: Automatically fill out complex forms based on contextual requirements
+- **Data extraction workflows**: Extract and transform data from multiple sources with intelligent navigation
+- **Multi-step web processes**: Execute complex browser workflows that require decision-making and adaptation
+
+<CardGroup cols={1}>
+<Card title="Langchain JS Configuration" icon="gear" href="/integrations/langchain/configuration">
+  Learn how to set up and configure the StagehandToolkit with Langchain JS agents
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/integrations/mcp/configuration.mdx b/packages/docs/v2/integrations/mcp/configuration.mdx
new file mode 100644
index 000000000..1f5c3dba6
--- /dev/null
+++ b/packages/docs/v2/integrations/mcp/configuration.mdx
@@ -0,0 +1,436 @@
+---
+title: "Browserbase MCP Server Configuration"
+sidebarTitle: "Configuration"
+description: "Configure your browser automation with command-line flags, environment variables, and advanced options"
+---
+
+## Configuration Overview
+
+The Browserbase MCP server supports extensive configuration options through command-line flags and environment variables. Configure browser behavior, proxy settings, stealth modes, model selection, and more to customize your browser automation workflows.
+
+<Note>
+Command-line flags are only available when running the server locally (`npx @browserbasehq/mcp-server-browserbase` with flags or local development setup).
+</Note>
+
+## Environment Variables
+
+Configure the essential Browserbase credentials and optional debugging settings:
+
+<CardGroup cols={2}>
+<Card title="BROWSERBASE_API_KEY" icon="key">
+Your Browserbase API key for authentication
+</Card>
+
+<Card title="BROWSERBASE_PROJECT_ID" icon="key">
+Your Browserbase project ID
+</Card>
+
+</CardGroup>
+
+## Command-Line Flags
+
+### Available Flags
+
+| Flag | Description |
+|------|-------------|
+| `--proxies` | Enable Browserbase proxies for the session |
+| `--advancedStealth` | Enable Browserbase Advanced Stealth (Scale Plan only) |
+| `--keepAlive` | Enable Browserbase Keep Alive Session |
+| `--contextId <contextId>` | Specify a Browserbase Context ID to use |
+| `--persist [boolean]` | Whether to persist the Browserbase context (default: true) |
+| `--port <port>` | Port to listen on for HTTP/SHTTP transport |
+| `--host <host>` | Host to bind server to (default: localhost, use 0.0.0.0 for all interfaces) |
+| `--cookies [json]` | JSON array of cookies to inject into the browser |
+| `--browserWidth <width>` | Browser viewport width (default: 1024) |
+| `--browserHeight <height>` | Browser viewport height (default: 768) |
+| `--modelName <model>` | The model to use for Stagehand (default: gemini-2.0-flash) |
+| `--modelApiKey <key>` | API key for the custom model provider (required when using custom models) |
+| `--experimental` | Enable experimental features (default: false) |
+
+## Configuration Examples
+
+### Basic Configuration
+
+<Tabs>
+<Tab title="Remote URL (SHTTP)">
+
+
+<CodeGroup>
+```json Direct SHTTP
+{
+  "mcpServers": {
+    "browserbase": {
+      "url": "your-smithery-url.com"
+    }
+  }
+}
+```
+</CodeGroup>
+
+When using our remote hosted server, we provide the LLM costs for Gemini, the [best performing model](https://www.stagehand.dev/evals) in [Stagehand](https://www.stagehand.dev).
+</Tab>
+
+<Tab title="NPM Package">
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": ["@browserbasehq/mcp-server-browserbase"],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</Tab>
+
+<Tab title="Local STDIO">
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "node",
+      "args": ["/path/to/mcp-server-browserbase/cli.js"],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</Tab>
+
+<Tab title="Local SHTTP">
+```bash
+# Start server
+node cli.js --port 8931
+```
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "url": "http://localhost:8931/mcp",
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</Tab>
+</Tabs>
+
+### Advanced Features
+
+<Tabs>
+<Tab title="Proxies">
+Enable Browserbase proxies for IP rotation and geo-location testing.
+
+<Panel>
+[Learn more about Browserbase Proxies](https://docs.browserbase.com/features/proxies)
+</Panel>
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": ["@browserbasehq/mcp-server-browserbase", "--proxies"],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</Tab>
+
+<Tab title="Advanced Stealth">
+Enable advanced anti-detection features for enhanced stealth browsing.
+
+<Panel>
+[Learn more about Advanced Stealth](https://docs.browserbase.com/features/stealth-mode#advanced-stealth-mode)
+
+**Note:** Advanced Stealth is only available for Scale Plan users.
+</Panel>
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": ["@browserbasehq/mcp-server-browserbase", "--advancedStealth"],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</Tab>
+
+<Tab title="Contexts">
+Use persistent browser contexts to maintain authentication and state across sessions.
+
+<Panel>
+[Learn more about Browserbase Contexts](https://docs.browserbase.com/features/contexts)
+</Panel>
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": ["@browserbasehq/mcp-server-browserbase", "--contextId", "your_context_id"],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id"
+      }
+    }
+  }
+}
+```
+</Tab>
+</Tabs>
+
+### Browser Customization
+
+<Tabs>
+<Tab title="Viewport Sizing">
+Customize browser window dimensions. Default is 1024x768. Recommended aspect ratios: 16:9.
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": [
+        "@browserbasehq/mcp-server-browserbase",
+        "--browserWidth", "1920",
+        "--browserHeight", "1080"
+      ],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+
+**Common Resolutions:**
+- Desktop: 1920x1080, 1280x720, 1024x768
+- Mobile: 375x667 (iPhone), 360x640 (Android)
+- Tablet: 768x1024 (iPad)
+</Tab>
+
+<Tab title="Cookie Injection">
+Inject session cookies for authentication. Useful when persistent contexts don't handle session cookies.
+
+<Panel>
+Cookies must be in [Playwright Cookie format](https://playwright.dev/docs/api/class-browsercontext#browser-context-cookies).
+</Panel>
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": [
+        "@browserbasehq/mcp-server-browserbase",
+        "--cookies",
+        "[{\"name\": \"session\", \"value\": \"abc123\", \"domain\": \".example.com\", \"path\": \"/\", \"httpOnly\": true, \"secure\": true}]"
+      ],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</Tab>
+</Tabs>
+
+## Model Configuration
+
+Configure AI models for enhanced browser automation. Stagehand defaults to Google's Gemini 2.0 Flash but supports multiple providers.
+
+<Warning>
+When using any custom model (non-default), you must provide your own API key for that model provider using the `--modelApiKey` flag.
+</Warning>
+
+<Tabs>
+<Tab title="Available Models">
+**Google Gemini** (Default)
+- `google/gemini-2.0-flash` (default)
+- `google/gemini-1.5-pro`
+- `google/gemini-1.5-flash`
+
+**OpenAI**
+- `openai/gpt-4o`
+- `openai/gpt-4o-mini`
+- `openai/o1-mini`
+- `openai/o1-preview`
+- `openai/o3-mini`
+
+**Anthropic Claude**
+- `anthropic/claude-sonnet-4-6`
+- `anthropic/claude-sonnet-4-5-20250929`
+
+[View full list of supported models](https://docs.stagehand.dev/examples/custom_llms#supported-llms)
+</Tab>
+
+<Tab title="Configuration Examples">
+<CodeGroup>
+```json OpenAI GPT-4o
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": [
+        "@browserbasehq/mcp-server-browserbase",
+        "--modelName", "openai/gpt-4o",
+        "--modelApiKey", "your_openai_api_key"
+      ],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id"
+      }
+    }
+  }
+}
+```
+
+```json Claude Sonnet
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": [
+        "@browserbasehq/mcp-server-browserbase",
+        "--modelName", "anthropic/claude-sonnet-4-6",
+        "--modelApiKey", "your_anthropic_api_key"
+      ],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id"
+      }
+    }
+  }
+}
+```
+</CodeGroup>
+</Tab>
+</Tabs>
+
+## Development Configuration
+
+<Tabs>
+<Tab title="Debug Mode">
+Enable detailed logging for troubleshooting and development.
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": ["@browserbasehq/mcp-server-browserbase"],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key",
+        "DEBUG": "true"
+      }
+    }
+  }
+}
+```
+</Tab>
+
+<Tab title="Custom Host/Port">
+Configure custom host and port for SHTTP transport.
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": [
+        "@browserbasehq/mcp-server-browserbase",
+        "--host", "0.0.0.0",
+        "--port", "8080"
+      ],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</Tab>
+</Tabs>
+
+## Best Practices
+
+<Accordion title="Performance - How can I optimize browser automation performance?">
+- Use appropriate viewport sizes for your use case
+- Enable proxies only when needed for geo-location
+- Choose efficient models (Gemini Flash for speed, GPT-4o for accuracy)
+- Reuse contexts for authentication persistence
+</Accordion>
+
+<Accordion title="Security - What security measures should I implement?">
+- Store API keys securely in environment variables
+- Use Advanced Stealth for sensitive operations
+- Implement proper session management
+- Rotate cookies and contexts regularly
+</Accordion>
+
+<Accordion title="Development - What are the recommended development practices?">
+- Enable debug mode during development
+- Use context persistence for faster iteration
+- Test with different viewport sizes
+- Monitor session usage and quotas
+</Accordion>
+
+<Accordion title="Production - How should I configure for production environments?">
+- Use NPM installation for reliability
+- Configure appropriate timeouts
+- Implement error handling and retries
+- Monitor performance and resource usage
+</Accordion>
+
+## Further Reading
+
+<CardGroup cols={3}>
+<Card title="Browserbase Documentation" icon="globe" href="https://docs.browserbase.com">
+Complete platform documentation
+</Card>
+
+<Card title="Stagehand Docs" icon="robot" href="https://docs.stagehand.dev/">
+AI-powered browser automation
+</Card>
+
+<Card title="Support" icon="headset" href="mailto:support@browserbase.com">
+Get help from our team
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/integrations/mcp/introduction.mdx b/packages/docs/v2/integrations/mcp/introduction.mdx
new file mode 100644
index 000000000..9938fb982
--- /dev/null
+++ b/packages/docs/v2/integrations/mcp/introduction.mdx
@@ -0,0 +1,235 @@
+---
+title: "Browserbase MCP Server"
+sidebarTitle: "Introduction"
+description: "AI-powered browser automation through Model Context Protocol integration with Stagehand"
+---
+
+## Overview
+
+The Browserbase MCP Server brings powerful browser automation capabilities to Claude through the Model Context Protocol (MCP). Built on top of [Stagehand](https://docs.stagehand.dev/), this integration provides AI-powered web automation using natural language commands.
+
+<Info>
+This server enables Claude to control browsers, navigate websites, interact with web elements, and extract data—all through simple conversational commands.
+</Info>
+
+<Note>
+**Two Ways to Use MCP:**
+1. **Browserbase MCP Server**: Provides browser automation tools to Claude Desktop and other MCP clients
+2. **MCP Integrations in Stagehand**: Add external tools (like Exa search, Supabase) to Stagehand agents
+
+This documentation covers the Browserbase MCP Server. For using MCP integrations within Stagehand agents, see [MCP Integrations](/best-practices/mcp-integrations).
+</Note>
+
+## Key Features
+
+<CardGroup cols={2}>
+<Card title="Natural Language Automation" icon="wand-magic-sparkles">
+Control browsers using plain English commands like "click the login button" or "fill out the contact form"
+</Card>
+
+<Card title="Web Interaction" icon="browser">
+Navigate, click, and fill forms with ease
+</Card>
+
+<Card title="Data Extraction" icon="download">
+Extract structured data from any website automatically
+
+</Card>
+
+<Card title="Multi-Session Management" icon="window-restore">
+Run multiple browser sessions simultaneously for complex workflows
+</Card>
+
+<Card title="Screenshot Capture" icon="camera">
+Capture and analyze webpage screenshots programmatically
+</Card>
+
+<Card title="Cookie Management" icon="cookie-bite">
+Handle authentication and session persistence across interactions
+</Card>
+</CardGroup>
+
+## Core Benefits
+
+<Tabs>
+<Tab title="Ease of Use">
+<CardGroup cols={2}>
+<Card title="Intuitive Commands" icon="wand-magic-sparkles">
+No need to learn complex selectors or automation syntax. Simply describe what you want to do in natural language.
+</Card>
+
+<Card title="Quick Setup" icon="rocket">
+Get started in minutes with our NPM package or our remote hosted URL.
+</Card>
+
+<Card title="Smart Automation" icon="brain">
+Stagehand's AI understands web page context and can adapt to different layouts and designs.
+</Card>
+</CardGroup>
+</Tab>
+
+<Tab title="Powerful Capabilities">
+<CardGroup cols={2}>
+<Card title="Full Browser Control" icon="browser">
+Navigate, click, type, scroll, and interact with any web element.
+</Card>
+
+<Card title="Data Intelligence" icon="chart-line">
+Extract structured information from complex web pages automatically.
+</Card>
+
+<Card title="Session Persistence" icon="cookie-bite">
+Maintain authentication states and cookies across multiple interactions.
+</Card>
+
+<Card title="Multi-Session Support" icon="window-restore">
+Run parallel browser instances for complex workflows.
+</Card>
+</CardGroup>
+</Tab>
+
+<Tab title="Enterprise Ready">
+<CardGroup cols={2}>
+<Card title="Reliable Infrastructure" icon="server">
+Built on Browserbase's cloud browser platform for consistent performance.
+</Card>
+
+<Card title="Scalable Architecture" icon="arrows-up-to-line">
+Handle multiple concurrent sessions and high-volume automation tasks.
+</Card>
+
+<Card title="Security Features" icon="shield-check">
+Stealth mode, proxy support, and advanced anti-detection capabilities.
+</Card>
+
+<Card title="Comprehensive Logging" icon="file-lines">
+Detailed session recordings and debugging information.
+</Card>
+</CardGroup>
+</Tab>
+</Tabs>
+
+## Use Cases
+
+<Tabs>
+<Tab title="Web Scraping & Data Collection">
+<CardGroup cols={2}>
+<Card title="E-commerce Monitoring" icon="store">
+Track product prices, availability, and competitor information
+</Card>
+
+<Card title="Market Research" icon="chart-bar">
+Gather data from multiple sources for analysis and reporting
+</Card>
+
+<Card title="Content Aggregation" icon="newspaper">
+Collect articles, posts, and media from various websites
+</Card>
+
+<Card title="Lead Generation" icon="users">
+Extract contact information and business data from directories
+</Card>
+</CardGroup>
+</Tab>
+
+<Tab title="Testing">
+<CardGroup cols={2}>
+<Card title="Automated Testing" icon="flask">
+Create comprehensive test suites for web applications
+</Card>
+
+<Card title="Cross-Browser Validation" icon="browsers">
+Test functionality across different browser environments
+</Card>
+
+<Card title="User Journey Testing" icon="route">
+Simulate real user interactions and workflows
+</Card>
+
+<Card title="Performance Monitoring" icon="gauge">
+Track page load times and user experience metrics
+</Card>
+</CardGroup>
+</Tab>
+
+<Tab title="Workflow Automation">
+<CardGroup cols={2}>
+<Card title="Form Automation" icon="file-contract">
+Automatically fill and submit complex web forms
+</Card>
+
+<Card title="Report Generation" icon="chart-line">
+Extract data and generate automated reports
+</Card>
+
+<Card title="Social Media Management" icon="share-nodes">
+Schedule posts and monitor engagement across platforms
+</Card>
+
+<Card title="Administrative Tasks" icon="clipboard-check">
+Automate repetitive web-based business processes
+</Card>
+</CardGroup>
+</Tab>
+</Tabs>
+
+## Session Management
+
+<Info>
+The Browserbase MCP Server supports both single and multi-session architectures to accommodate different automation needs.
+</Info>
+
+<Tabs>
+<Tab title="Single Session Mode">
+**Traditional Approach**
+- One active browser session at a time
+- Simpler for basic automation tasks  
+- Automatic session lifecycle management
+- Ideal for sequential workflows
+</Tab>
+
+<Tab title="Multi-Session Mode">
+**Advanced Parallel Processing**
+- Multiple independent browser sessions
+- Each session maintains separate state
+- Parallel execution capabilities
+- Perfect for complex workflows
+</Tab>
+</Tabs>
+
+## Getting Started
+
+<Steps>
+<Step title="Install the MCP Server">
+Choose from NPM installation, remote hosted URL, or local development based on your needs.
+</Step>
+
+<Step title="Configure Authentication">
+Set up your Browserbase API credentials in the MCP configuration. 
+Get your API keys from the [Browserbase Dashboard](https://www.browserbase.com/overview).
+</Step>
+
+<Step title="Start Automating">
+Begin using natural language commands to control browsers through Claude.
+</Step>
+</Steps>
+
+<Tip>
+Ready to get started? Check out our [Setup Guide](/integrations/mcp/setup) for detailed installation instructions.
+</Tip>
+
+## Further Reading
+
+<CardGroup cols={3}>
+<Card title="Setup Guide" icon="rocket" href="/integrations/mcp/setup">
+Get started with installation and configuration
+</Card>
+
+<Card title="Available Tools" icon="wrench" href="/integrations/mcp/tools">
+Explore all available automation tools
+</Card>
+
+<Card title="Configuration Options" icon="gear" href="/integrations/mcp/configuration">
+Customize your browser automation setup
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/integrations/mcp/setup.mdx b/packages/docs/v2/integrations/mcp/setup.mdx
new file mode 100644
index 000000000..8219e74a6
--- /dev/null
+++ b/packages/docs/v2/integrations/mcp/setup.mdx
@@ -0,0 +1,197 @@
+---
+title: "Browserbase MCP Server Setup"
+sidebarTitle: "Setup"
+description: "Add the Browserbase MCP Server to Claude"
+---
+
+## Quick Installation
+
+<Card title="Install with Cursor" icon="arrow-pointer" href="cursor://anysphere.cursor-deeplink/mcp/install?name=browserbase&config=eyJjb21tYW5kIjoibnB4IEBicm93c2VyYmFzZWhxL21jcCIsImVudiI6eyJCUk9XU0VSQkFTRV9BUElfS0VZIjoiIiwiQlJPV1NFUkJBU0VfUFJPSkVDVF9JRCI6IiIsIkdFTUlOSV9BUElfS0VZIjoiIn19">
+One-click installation directly in Cursor with pre-configured settings
+</Card>
+
+We support multiple transport methods for our MCP server: STDIO and SHTTP. We recommend using SHTTP with our remote hosted URL to take advantage of the server at full capacity.
+
+## Prerequisites
+
+<Steps>
+<Step title="Get your Browserbase credentials">
+Get your Browserbase API key and project ID from the [Browserbase Dashboard](https://www.browserbase.com/overview).
+
+<Frame>
+<img src="/images/quickstart/api-key.png" alt="Browserbase API Key and Project ID settings" />
+</Frame>
+
+Then copy your API Key and Project ID directly from the input.
+</Step>
+</Steps>
+
+## Installation Methods
+
+<Tabs>
+<Tab title="Remote URL (SHTTP)">
+
+Go to [smithery.ai](https://smithery.ai/server/@browserbasehq/mcp-browserbase) and enter your API keys and configuration to get a remote hosted URL.
+
+![Smithery](../../images/mcp/smithery.jpg)
+
+<CodeGroup>
+```json Smithery
+{
+  "mcpServers": {
+    "browserbase": {
+      "url": "your-smithery-url.com"
+    }
+  }
+}
+```
+</CodeGroup>
+
+When using our remote hosted server, we provide the LLM costs for Gemini, the [best performing model](https://www.stagehand.dev/evals) in [Stagehand](https://www.stagehand.dev).
+
+</Tab>
+
+<Tab title="NPM Package (STDIO)">
+The easiest way to get started locally is using our NPM package.
+
+<Note>
+If you would like to use a different model, you have to pass the model name and keys in the args. More info [here](https://docs.browserbase.com/integrations/mcp/configuration).
+</Note>
+
+<Steps>
+<Step title="Add to MCP Config">
+Go into your MCP Config JSON and add the Browserbase Server:
+
+<CodeGroup>
+```json Claude Desktop
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": ["@browserbasehq/mcp-server-browserbase"],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</CodeGroup>
+</Step>
+
+<Step title="Restart your MCP client">
+<Check>
+That's it! Reload your MCP client and Claude will be able to use Browserbase.
+</Check>
+</Step>
+</Steps>
+</Tab>
+
+<Tab title="Local Development">
+For local development or customization, you can run the server locally.
+
+<Steps>
+<Step title="Clone and build">
+```bash
+# Clone the Repo
+git clone https://github.com/browserbase/mcp-server-browserbase.git
+cd mcp-server-browserbase
+
+# Install the dependencies and build the project
+npm install && npm run build
+```
+</Step>
+
+<Step title="Choose your transport method">
+You can run locally using either STDIO or Streamable HTTP (SHTTP).
+
+<Tabs>
+<Tab title="STDIO">
+Add the following to your MCP Config JSON file:
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "node",
+      "args": ["/path/to/mcp-server-browserbase/cli.js"],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</Tab>
+
+<Tab title="SHTTP (Self-hosted)">
+First, run the server:
+
+```bash
+node cli.js --port 8931
+```
+
+Then add this to your MCP Config JSON file:
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "url": "http://localhost:8931/mcp",
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</Tab>
+</Tabs>
+</Step>
+
+<Step title="Restart your client">
+<Check>
+Reload your MCP client and you should be good to go!
+</Check>
+</Step>
+</Steps>
+</Tab>
+</Tabs>
+
+## Verify Installation
+
+<Steps>
+<Step title="Restart your Claude Client">
+Restart/refresh your Claude Client app and you should see the tools available by clicking the 🔨 icon.
+</Step>
+
+<Step title="Test the integration">
+Get started using our MCP Server by asking Claude to navigate to any page and see your Browserbase Browser in action on the [dashboard](https://www.browserbase.com/sessions).
+
+<Tip>
+Try asking Claude: "Navigate to google.com and take a screenshot"
+</Tip>
+</Step>
+</Steps>
+
+## Further Reading
+
+<CardGroup cols={3}>
+<Card title="Model Context Protocol (MCP) Docs" icon="book" href="https://modelcontextprotocol.io/introduction">
+Learn more about the MCP protocol
+</Card>
+
+<Card title="Browserbase Documentation" icon="globe" href="https://docs.browserbase.com">
+Explore Browserbase features and capabilities
+</Card>
+
+<Card title="Support" icon="headset" href="mailto:support@browserbase.com">
+Get help from our support team
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/integrations/mcp/tools.mdx b/packages/docs/v2/integrations/mcp/tools.mdx
new file mode 100644
index 000000000..953518f43
--- /dev/null
+++ b/packages/docs/v2/integrations/mcp/tools.mdx
@@ -0,0 +1,241 @@
+---
+title: "Browserbase MCP Server Tools"
+sidebarTitle: "Tools"
+description: "This guide covers the specialized tools available in the Browserbase MCP server for browser automation and interaction."
+---
+
+## Overview
+
+The Browserbase MCP server provides comprehensive tools for browser automation and session management. These tools allow you to perform actions like navigating pages, capturing screenshots, manipulating cookies, and managing multiple browser sessions simultaneously.
+
+## Core Browser Automation Tools
+
+These are the primary tools for modern web automation using natural language commands.
+
+<Accordion title="browserbase_stagehand_navigate">
+Navigate to any URL in the browser
+
+<ParamField path="url" type="string" required>
+  The URL to navigate to
+</ParamField>
+</Accordion>
+
+<Accordion title="browserbase_stagehand_act">
+Perform an action on the web page using natural language
+
+<ParamField path="action" type="string" required>
+  The action to perform (e.g., "click the login button", "fill form field")
+</ParamField>
+
+</Accordion>
+
+<Accordion title="browserbase_stagehand_extract">
+Extract all text content from the current page (filters out CSS and JavaScript)
+
+<Info>No input parameters required</Info>
+</Accordion>
+
+<Accordion title="browserbase_stagehand_observe">
+Observe and find actionable elements on the web page
+
+<ParamField path="instruction" type="string" required>
+  Specific instruction for observation (e.g., "find the login button", "locate search form")
+</ParamField>
+
+</Accordion>
+
+<Accordion title="browserbase_screenshot">
+Capture a PNG screenshot of the current page
+
+<Info>No input parameters required</Info>
+
+<ResponseField name="image" type="string">
+  Base-64 encoded PNG data
+</ResponseField>
+</Accordion>
+
+<Accordion title="browserbase_stagehand_get_url">
+Get the current URL of the browser page
+
+<Info>No input parameters required</Info>
+
+<ResponseField name="url" type="string">
+  Complete URL including protocol, domain, path, and any query parameters or fragments
+</ResponseField>
+</Accordion>
+
+<Accordion title="browserbase_stagehand_get_all_urls">
+Get current URLs of all active browser sessions
+
+<Info>No input parameters required</Info>
+
+<ResponseField name="sessionUrls" type="object">
+  Mapping of session IDs to their current URLs in JSON format
+</ResponseField>
+</Accordion>
+
+## Single Session Management
+
+Traditional approach with one active browser session. Simpler for basic automation tasks and automatically manages the active session.
+
+<Accordion title="browserbase_session_create">
+Create or reuse a cloud browser session using Browserbase with fully initialized Stagehand
+
+<ParamField path="sessionId" type="string">
+  Optional session ID to use/reuse. If not provided, creates new session
+</ParamField>
+
+</Accordion>
+
+<Accordion title="browserbase_session_close">
+Close the current Browserbase session, disconnect the browser, and cleanup Stagehand instance
+
+<Info>No input parameters required</Info>
+
+</Accordion>
+
+## Multi-Session Management
+
+Advanced approach with multiple parallel browser sessions for complex automation workflows. Each session maintains independent state, cookies, and browser context.
+
+### Session Lifecycle Management
+
+<Accordion title="multi_browserbase_stagehand_session_create">
+Create a new independent Stagehand browser session with full web automation capabilities
+
+<ParamField path="name" type="string">
+  Human-readable name for tracking (e.g., 'login-flow', 'data-scraping')
+</ParamField>
+</Accordion>
+
+<Accordion title="multi_browserbase_stagehand_session_list">
+List all currently active Stagehand browser sessions with detailed metadata
+
+<Info>No input parameters required</Info>
+
+</Accordion>
+
+<Accordion title="multi_browserbase_stagehand_session_close">
+Close and clean up a specific Stagehand browser session
+
+<ParamField path="sessionId" type="string" required>
+  Exact session ID to close (cannot be undone)
+</ParamField>
+</Accordion>
+
+### Session-Specific Automation Tools
+
+All core browser automation tools are available with session-specific variants:
+
+<Accordion title="multi_browserbase_stagehand_navigate_session">
+Navigate to a URL in a specific browser session
+
+<ParamField path="sessionId" type="string" required>
+  The session ID to use
+</ParamField>
+
+<ParamField path="url" type="string" required>
+  The URL to navigate to
+</ParamField>
+</Accordion>
+
+<Accordion title="multi_browserbase_stagehand_act_session">
+Perform an action in a specific browser session using natural language
+
+<ParamField path="sessionId" type="string" required>
+  The session ID to use
+</ParamField>
+
+<ParamField path="action" type="string" required>
+  The action to perform
+</ParamField>
+
+</Accordion>
+
+<Accordion title="multi_browserbase_stagehand_extract_session">
+Extract structured information from a specific browser session
+
+<ParamField path="sessionId" type="string" required>
+  The session ID to use
+</ParamField>
+
+<ParamField path="instruction" type="string" required>
+  What to extract from the page
+</ParamField>
+</Accordion>
+
+<Accordion title="multi_browserbase_stagehand_observe_session">
+Observe and find actionable elements in a specific browser session
+
+<ParamField path="sessionId" type="string" required>
+  The session ID to use
+</ParamField>
+
+<ParamField path="instruction" type="string" required>
+  What to observe (e.g., "find the login button")
+</ParamField>
+
+<ParamField path="returnAction" type="boolean">
+  Whether to return the action to perform
+</ParamField>
+</Accordion>
+
+<Accordion title="multi_browserbase_stagehand_get_url_session">
+Get the current URL of a specific browser session
+
+<ParamField path="sessionId" type="string" required>
+  The session ID to use
+</ParamField>
+
+<ResponseField name="url" type="string">
+  Complete URL including protocol, domain, path, and any query parameters or fragments
+</ResponseField>
+</Accordion>
+
+### Multi-Session Use Cases
+
+<CardGroup cols={2}>
+  <Card title="Parallel Data Collection" icon="globe">
+    Run multiple scraping sessions simultaneously across different websites
+  </Card>
+  
+  <Card title="A/B Testing" icon="flask">
+    Compare user flows across different browser sessions with varying configurations
+  </Card>
+  
+  <Card title="Cross-Site Operations" icon="link">
+    Perform coordinated actions across multiple websites or applications
+  </Card>
+  
+  <Card title="Backup Sessions" icon="shield">
+    Keep fallback sessions ready in case primary sessions encounter issues
+  </Card>
+</CardGroup>
+
+## Resources
+
+<Card title="Screenshot Resources" icon="camera">
+  The server provides access to screenshot resources with URI-based access. 
+
+  example: 
+  ```
+  screenshot://screenshot-name-of-the-screenshot
+  ```
+
+</Card>
+
+## Further Reading
+
+<CardGroup cols={3}>
+<Card title="Model Context Protocol (MCP) Docs" icon="book" href="https://modelcontextprotocol.io/introduction">
+Learn more about the MCP protocol
+</Card>
+
+<Card title="Stagehand Documentation" icon="robot" href="https://docs.stagehand.dev/">
+Explore Stagehand's AI-powered browser automation
+</Card>
+
+<Card title="Support" icon="headset" href="mailto:support@browserbase.com">
+Get help from our support team
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/integrations/vercel/configuration.mdx b/packages/docs/v2/integrations/vercel/configuration.mdx
new file mode 100644
index 000000000..83e2318ce
--- /dev/null
+++ b/packages/docs/v2/integrations/vercel/configuration.mdx
@@ -0,0 +1,165 @@
+---
+title: Use Stagehand in Next.js
+sidebarTitle: Configuration
+description: Next.js is a popular framework for developing web-based applications in production. It powers Stagehand apps like [Director](https://director.ai), [Brainrot](https://brainrot.run) and [Open Operator](https://operator.browserbase.com).
+---
+
+<Card
+  title="Check out the Stagehand Next.js Quickstart"
+  icon="github"
+  href="https://github.com/browserbase/stagehand-nextjs-quickstart"
+>
+  Clone our [GitHub repo](https://github.com/browserbase/stagehand-nextjs-quickstart) to get started with Stagehand in Next.js.
+</Card>
+
+## Add Stagehand to an existing Next.js project
+If you'd like to add Stagehand to an existing Next.js project, you can do so by installing the dependencies:
+<Tabs>
+	<Tab title="npm">
+	```bash
+	npm install @browserbasehq/stagehand @browserbasehq/sdk playwright zod
+	```
+	</Tab>
+
+	<Tab title="pnpm">
+	```bash
+	pnpm add @browserbasehq/stagehand @browserbasehq/sdk playwright zod
+	```
+	</Tab>
+
+	<Tab title="yarn">
+	```bash
+	yarn add @browserbasehq/stagehand @browserbasehq/sdk playwright zod
+	```
+	</Tab>
+</Tabs>
+
+### Write a server action
+Next, let's define our `main` function as a server action in `app/stagehand/main.ts`. This file will have the following three functions:
+
+1. **`main`: Run the main Stagehand script**
+2. **`runStagehand`: Initialize and run the `main` function**
+3. **`startBBSSession`: Start a Browserbase session**
+
+```ts app/stagehand/main.ts
+// 🤘 Welcome to Stagehand!
+// This file is from the [Stagehand docs](https://docs.stagehand.dev/sections/examples/nextjs).
+
+"use server";
+
+import { Stagehand } from "@browserbasehq/stagehand";
+import { z } from "zod/v3";
+import { Browserbase } from "@browserbasehq/sdk";
+
+/**
+ * Run the main Stagehand script
+ */
+async function main(stagehand: Stagehand) {
+  // You can use the `page` instance to write any Playwright code
+  // For more info: https://playwright.dev/docs/pom
+  const page = stagehand.page;
+
+  // In this example, we'll get the title of the Stagehand quickstart page
+  await page.goto("https://docs.stagehand.dev/");
+  await page.act("click the quickstart link");
+  const { title } = await page.extract({
+    instruction: "extract the main heading of the page",
+    schema: z.object({
+      title: z.string(),
+    }),
+  });
+
+  return title;
+}
+
+/**
+ * Initialize and run the main() function
+ */
+export async function runStagehand(sessionId?: string) {
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    apiKey: process.env.BROWSERBASE_API_KEY,
+    projectId: process.env.BROWSERBASE_PROJECT_ID,
+    verbose: 1,
+    logger: console.log,
+    browserbaseSessionID: sessionId,
+    disablePino: true,
+  });
+  await stagehand.init();
+  await main(stagehand);
+  await stagehand.close();
+}
+
+/**
+ * Start a Browserbase session
+ */
+export async function startBBSSession() {
+  const browserbase = new Browserbase();
+  const session = await browserbase.sessions.create({
+    projectId: process.env.BROWSERBASE_PROJECT_ID!,
+  });
+  const debugUrl = await browserbase.sessions.debug(session.id);
+  return {
+    sessionId: session.id,
+    debugUrl: debugUrl.debuggerFullscreenUrl,
+  };
+}
+```
+
+### Create a client component
+Next, let's create a client component that will start a Browserbase session and run the `main` function with the server actions we just defined. We'll first create a Browserbase session and embed the session in an iframe before running the `main` function.
+
+```tsx app/components/stagehandEmbed.tsx
+"use client";
+
+import { useCallback, useState } from "react";
+import { runStagehand, startBBSSession } from "@/app/stagehand/main";
+
+export function StagehandEmbed() {
+  const [sessionId, setSessionId] = useState<string | null>(null);
+  const [debugUrl, setDebugUrl] = useState<string | null>(null);
+
+  const startSession = useCallback(async () => {
+    const { sessionId, debugUrl } = await startBBSSession();
+    setSessionId(sessionId);
+    setDebugUrl(debugUrl);
+    await runStagehand(sessionId);
+  }, []);
+
+  return (
+    <div>
+      {!sessionId && <button onClick={startSession}>Start Session</button>}
+      {sessionId && debugUrl && (
+        <iframe src={debugUrl} className="w-full h-full" />
+      )}
+    </div>
+  );
+}
+```
+
+### Use the `StagehandEmbed` component
+Now, we can use the `StagehandEmbed` component in our app.
+
+```tsx app/page.tsx
+import { StagehandEmbed } from "@/app/components/stagehandEmbed";
+
+export default function Home() {
+	return (
+		<main>
+			<StagehandEmbed />
+		</main>
+	)
+}
+```
+
+## References
+
+<CardGroup cols={2}>
+  <Card title="Deploy Template" icon="rocket" href="https://vercel.com/templates/ai/stagehand-next-js-quickstart">
+    One‑click deploy the Stagehand Next.js template on Vercel
+  </Card>
+  
+  <Card title="Source Code" icon="github" href="https://github.com/browserbase/stagehand-nextjs-quickstart">
+    Browse the complete template repository on GitHub
+  </Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/integrations/vercel/introduction.mdx b/packages/docs/v2/integrations/vercel/introduction.mdx
new file mode 100644
index 000000000..22434e258
--- /dev/null
+++ b/packages/docs/v2/integrations/vercel/introduction.mdx
@@ -0,0 +1,62 @@
+---
+title: "Next.js + Vercel"
+sidebarTitle: "Introduction"
+description: "Build and deploy a Stagehand‑powered Next.js app to Vercel"
+---
+
+## Overview
+
+The Stagehand + Next.js Quickstart is a production‑ready template that pairs Stagehand's AI browser automation with a modern Next.js app, deployable in one click on Vercel.
+
+<CardGroup cols={3}>
+  <Card title="Deploy Template" icon="rocket" href="https://vercel.com/templates/ai/stagehand-next-js-quickstart">
+    One‑click deploy to Vercel with environment setup
+  </Card>
+
+  <Card title="Live Demo" icon="globe" href="https://stagehand-nextjs-quickstart.vercel.app">
+    See the deployed template in action
+  </Card>
+
+  <Card title="Source Code" icon="github" href="https://github.com/browserbase/stagehand-nextjs-quickstart">
+    Browse the repository on GitHub
+  </Card>
+</CardGroup>
+
+## What you get
+
+<CardGroup cols={2}>
+  <Card title="App Router project" icon="browser">
+    Next.js App Router scaffold with Tailwind styling
+  </Card>
+  <Card title="Server‑safe automation" icon="shield-check">
+    Uses Browserbase for cloud browsers (works on Vercel functions)
+  </Card>
+  <Card title="Prewired config" icon="gear">
+    `stagehand.config.ts` with model + provider switching
+  </Card>
+  <Card title="Automation ready" icon="robot">
+    Example usage of Stagehand primitives
+  </Card>
+</CardGroup>
+
+## Requirements
+
+- **Node 18+** locally
+- **Model key**: OpenAI or Anthropic (or plug a custom client)
+- **Browserbase keys**: `BROWSERBASE_API_KEY` and `BROWSERBASE_PROJECT_ID` for cloud browsers
+
+<Tip>
+Local Playwright browsers are not available on Vercel. Set Stagehand to Browserbase when deploying.
+</Tip>
+
+## Links
+
+<CardGroup cols={2}>
+  <Card title="Quickstart" icon="rocket" href="/integrations/vercel/quickstart">
+    Run locally and deploy to Vercel in minutes
+  </Card>
+  <Card title="TypeScript Quickstart" icon="code" href="/first-steps/quickstart">
+    More templates, including Vercel deployment examples
+  </Card>
+</CardGroup>
+
diff --git a/packages/docs/v2/references/act.mdx b/packages/docs/v2/references/act.mdx
new file mode 100644
index 000000000..ff5f70b82
--- /dev/null
+++ b/packages/docs/v2/references/act.mdx
@@ -0,0 +1,134 @@
+---
+title: act()
+description: 'Complete API reference for the act() method'
+icon: 'arrow-pointer'
+---
+
+<CardGroup cols={1}>
+<Card title="Act" icon="arrow-pointer" href="/v2/basics/act">
+  See how to use act() to perform browser actions
+</Card>
+</CardGroup>
+
+### Method Signatures
+
+<Tabs>
+<Tab title="TypeScript">
+
+```typescript
+// String instruction
+await page.act(instruction: string): Promise<ActResult>
+
+// With ActOptions
+await page.act(options: ActOptions): Promise<ActResult>
+
+// Execute observed action
+await page.act(observeResult: ObserveResult): Promise<ActResult>
+```
+
+**ActOptions Interface:**
+```typescript
+interface ActOptions {
+  action: string;
+  modelName?: AvailableModel;
+  modelClientOptions?: ClientOptions;
+  variables?: Record<string, string>;
+  domSettleTimeoutMs?: number;
+  timeoutMs?: number;
+  iframes?: boolean;
+}
+```
+
+</Tab>
+<Tab title="Python">
+
+```python
+# String instruction
+await page.act(instruction: str) -> ActResult
+
+# With parameters
+await page.act(
+    instruction: str,
+    variables: Dict[str, str] = None,
+    dom_settle_timeout_ms: int = None,
+    timeout_ms: int = None,
+    model_name: AvailableModel = None,
+    model_client_options: Dict = None,
+    iframes: bool = None,
+) -> ActResult
+
+# Execute observed action
+await page.act(observe_result: ObserveResult) -> ActResult
+```
+
+</Tab>
+</Tabs>
+
+### Parameters
+
+<ParamField path="action" type="string" required>
+  Natural language description of the action to perform.
+</ParamField>
+
+<ParamField path="variables" type="Record<string, string>" optional>
+  Key-value pairs for variable substitution using `%variable%` syntax. Prevents sensitive data from appearing in logs.
+</ParamField>
+
+<ParamField path="modelName" type="AvailableModel" optional>
+  Override the default LLM model for this action.
+</ParamField>
+
+<ParamField path="modelClientOptions" type="ClientOptions" optional>
+  Model-specific configuration options.
+  
+  **Options:** `temperature`, `maxTokens`, `apiKey`
+</ParamField>
+
+<ParamField path="domSettleTimeoutMs" type="number" optional>
+  Maximum time to wait for DOM to stabilize before attempting action.
+  
+  **Default:** `30000`
+</ParamField>
+
+<ParamField path="timeoutMs" type="number" optional>
+  Maximum time to wait for the action to complete.
+</ParamField>
+
+<ParamField path="iframes" type="boolean" optional>
+  Set to `true` if target element is within an iframe.
+  
+  **Default:** `false`
+</ParamField>
+
+<ParamField path="observeResult" type="ObserveResult" optional>
+  Previously observed action to execute directly (enables self-healing).
+</ParamField>
+
+### Returns `Promise<ActResult>`
+
+<ParamField path="success" type="boolean" required>
+  Whether the action was completed successfully.
+</ParamField>
+
+<ParamField path="message" type="string" required>
+  Details about the action's execution.
+</ParamField>
+
+<ParamField path="action" type="string" required>
+  The action that was performed.
+</ParamField>
+
+```Example Response
+{
+  success: true,
+  message: 'Action [scrollTo] performed successfully on selector: /html[1]',
+  action: 'Scrollable area of the page where user can navigate to the pricing section or other parts of the page'
+}
+```
+
+### Error Types
+
+- **TimeoutError** - Action exceeded timeout limits
+- **ElementNotFoundError** - Target element could not be located  
+- **ActionFailedError** - Action could not be completed
+- **StagehandError** - General Stagehand-specific errors
\ No newline at end of file
diff --git a/packages/docs/v2/references/agent.mdx b/packages/docs/v2/references/agent.mdx
new file mode 100644
index 000000000..795c6ece7
--- /dev/null
+++ b/packages/docs/v2/references/agent.mdx
@@ -0,0 +1,262 @@
+---
+title: agent()
+description: 'Complete API reference for the agent() method'
+icon: 'robot'
+---
+
+<CardGroup cols={1}>
+<Card title="Agent" icon="robot" href="/v2/basics/agent">
+  See how to use agent() to create autonomous AI agents for multi-step browser workflows
+</Card>
+</CardGroup>
+
+### Agent Creation
+
+<Tabs>
+<Tab title="TypeScript">
+
+```typescript
+// Create agent instance
+const agent = stagehand.agent(config: AgentConfig): AgentInstance
+```
+
+**AgentConfig Interface:**
+```typescript
+interface AgentConfig {
+  provider?: AgentProviderType;  // "openai" | "anthropic"
+  model?: string;
+  instructions?: string;
+  options?: Record<string, unknown>;
+  integrations?: (Client | string)[];
+  tools?: ToolSet;
+}
+```
+
+**AgentInstance Interface:**
+```typescript
+interface AgentInstance {
+  execute: (instructionOrOptions: string | AgentExecuteOptions) => Promise<AgentResult>;
+}
+```
+
+</Tab>
+<Tab title="Python">
+
+```python
+# Create agent instance
+agent = stagehand.agent(
+    model: str,
+    instructions: str = None,
+    options: Dict[str, Any] = None
+)
+```
+
+</Tab>
+</Tabs>
+
+### Agent Configuration
+
+<ParamField path="provider" type="AgentProviderType" optional>
+  AI provider for agent functionality.
+  
+  **Options:** `"anthropic"`, `"openai"`
+</ParamField>
+
+<ParamField path="model" type="string" optional>
+  Specific model for agent execution.
+  
+  **Anthropic:** `"claude-sonnet-4-6"`, `"claude-sonnet-4-5-20250929"`
+  
+  **OpenAI:** `"computer-use-preview"`, `"gpt-4o"`
+</ParamField>
+
+<ParamField path="instructions" type="string" optional>
+  System instructions defining agent behavior.
+</ParamField>
+
+<ParamField path="options" type="Record<string, unknown>" optional>
+  Provider-specific configuration.
+  
+  **Common:** `apiKey`, `baseURL`, `organization`
+</ParamField>
+
+<ParamField path="integrations" type="(Client | string)[]" optional>
+  MCP (Model Context Protocol) integrations for external tools and services.
+  
+  **Array of:** MCP server URLs (strings) or connected Client objects
+</ParamField>
+
+<ParamField path="tools" type="ToolSet" optional>
+  Custom tool definitions to extend agent capabilities.
+  
+  **Format:** Object with tool name keys and tool definition values
+</ParamField>
+
+### Execute Method
+
+<Tabs>
+<Tab title="TypeScript">
+
+```typescript
+// String instruction
+await agent.execute(instruction: string): Promise<AgentResult>
+
+// With options
+await agent.execute(options: AgentExecuteOptions): Promise<AgentResult>
+```
+
+**AgentExecuteOptions Interface:**
+```typescript
+interface AgentExecuteOptions {
+  instruction: string;
+  maxSteps?: number;
+  autoScreenshot?: boolean;
+  waitBetweenActions?: number;
+  context?: string;
+}
+```
+
+</Tab>
+<Tab title="Python">
+
+```python
+# String instruction
+await agent.execute(instruction: str) -> AgentResult
+
+# With options dictionary
+await agent.execute({
+    "instruction": str,
+    "max_steps": int = 20,
+    "auto_screenshot": bool = True,
+    "wait_between_actions": int = 0,
+    "context": str = None
+}) -> AgentResult
+```
+
+</Tab>
+</Tabs>
+
+### Execute Parameters
+
+<ParamField path="instruction" type="string" required>
+  High-level task description in natural language.
+</ParamField>
+
+<ParamField path="maxSteps" type="number" optional>
+  Maximum number of actions the agent can take.
+  
+  **Default:** `20`
+</ParamField>
+
+<ParamField path="autoScreenshot" type="boolean" optional>
+  Whether to take screenshots before each action.
+  
+  **Default:** `true`
+</ParamField>
+
+<ParamField path="waitBetweenActions" type="number" optional>
+  Delay in milliseconds between actions.
+  
+  **Default:** `0`
+</ParamField>
+
+<ParamField path="context" type="string" optional>
+  Additional context or constraints for the agent.
+</ParamField>
+
+### Response
+
+**Returns:** `Promise<AgentResult>`
+
+**AgentResult Interface:**
+```typescript
+interface AgentResult {
+  success: boolean;
+  message: string;
+  actions: AgentAction[];
+  completed: boolean;
+  metadata?: Record<string, unknown>;
+  usage?: {
+    input_tokens: number;
+    output_tokens: number;
+    reasoning_tokens?: number;
+    cached_input_tokens?: number;
+    inference_time_ms: number;
+  };
+}
+```
+
+<Tabs>
+<Tab title="TypeScript">
+
+<ParamField path="success" type="boolean">
+  Whether the task was completed successfully.
+</ParamField>
+
+<ParamField path="message" type="string">
+  Description of the execution result and status.
+</ParamField>
+
+<ParamField path="actions" type="AgentAction[]">
+  Array of individual actions taken during execution.
+</ParamField>
+
+<ParamField path="completed" type="boolean">
+  Whether the agent believes the task is fully complete.
+</ParamField>
+
+<ParamField path="metadata" type="Record<string, unknown>" optional>
+  Additional execution metadata and debugging information.
+</ParamField>
+
+<ParamField path="usage" type="object" optional>
+  Token usage and performance metrics.
+</ParamField>
+
+</Tab>
+<Tab title="Python">
+
+<ParamField path="success" type="boolean">
+  Whether the task was completed successfully.
+</ParamField>
+
+<ParamField path="message" type="string">
+  Description of the execution result and status.
+</ParamField>
+
+<ParamField path="actions" type="AgentAction[]">
+  Array of individual actions taken during execution.
+</ParamField>
+
+<ParamField path="completed" type="boolean">
+  Whether the agent believes the task is fully complete.
+</ParamField>
+
+</Tab>
+</Tabs>
+
+### Example Response
+```json
+{
+  "success": true,
+  "message": "Task completed successfully",
+  "actions": [
+    {
+      "action": "click",
+      "selector": "button.primary",
+      "text": "Submit"
+    }
+  ],
+  "completed": true,
+  "metadata": {
+    "execution_time": 1000
+  },
+  "usage": {
+    "input_tokens": 100,
+    "output_tokens": 50,
+    "reasoning_tokens": 12,
+    "cached_input_tokens": 0,
+    "inference_time_ms": 100
+  }
+}
+```
\ No newline at end of file
diff --git a/packages/docs/v2/references/extract.mdx b/packages/docs/v2/references/extract.mdx
new file mode 100644
index 000000000..3169179ac
--- /dev/null
+++ b/packages/docs/v2/references/extract.mdx
@@ -0,0 +1,450 @@
+---
+title: extract()
+description: 'Complete API reference for the extract() method'
+icon: 'ufo-beam'
+---
+
+<CardGroup cols={1}>
+<Card title="Extract" icon="ufo-beam" href="/v2/basics/extract">
+  See how to use extract() to extract structured data from web pages
+</Card>
+</CardGroup>
+
+### Method Signatures
+
+<Tabs>
+<Tab title="TypeScript">
+
+```typescript
+// With schema and options
+await page.extract<T extends z.AnyZodObject>(options: ExtractOptions<T>): Promise<ExtractResult<T>>
+
+// String instruction only
+await page.extract(instruction: string): Promise<{ extraction: string }>
+
+// No parameters (raw page content)
+await page.extract(): Promise<{ pageText: string }>
+```
+
+**ExtractOptions Interface:**
+```typescript
+interface ExtractOptions<T extends z.AnyZodObject> {
+  instruction?: string;
+  schema?: T;
+  modelName?: AvailableModel;
+  modelClientOptions?: ClientOptions;
+  domSettleTimeoutMs?: number;
+  selector?: string;
+  iframes?: boolean;
+}
+
+type ExtractResult<T> = z.infer<T>;
+```
+
+</Tab>
+<Tab title="Python">
+
+```python
+# With schema and parameters
+await page.extract(
+    instruction: str = None,
+    schema: BaseModel = None,
+    selector: str = None,
+    iframes: bool = None,
+    model_name: AvailableModel = None,
+    model_client_options: Dict = None,
+    dom_settle_timeout_ms: int = None
+) -> ExtractResult
+
+# String instruction only
+await page.extract(instruction: str) -> Dict[str, str]
+
+# No parameters (raw page content)
+await page.extract() -> Dict[str, str]
+```
+
+</Tab>
+</Tabs>
+
+### Parameters
+
+<ParamField path="instruction" type="string" optional>
+  Natural language description of what data to extract.
+</ParamField>
+
+<ParamField path="schema" type="z.ZodSchema | BaseModel" optional>
+  Type schema defining the structure of data to extract. Ensures type safety and validation.
+</ParamField>
+
+<ParamField path="selector" type="string" optional>
+  XPath selector to limit extraction scope. Reduces token usage and improves accuracy.
+</ParamField>
+
+<ParamField path="iframes" type="boolean" optional>
+  Set to `true` if content exists within iframes.
+  
+  **Default:** `false`
+</ParamField>
+
+<ParamField path="modelName" type="AvailableModel" optional>
+  Override the default LLM model for this extraction.
+</ParamField>
+
+<ParamField path="modelClientOptions" type="ClientOptions" optional>
+  Model-specific configuration options.
+</ParamField>
+
+<ParamField path="domSettleTimeoutMs" type="number" optional>
+  Maximum time to wait for DOM to stabilize.
+  
+  **Default:** `30000`
+</ParamField>
+
+### Response Types
+
+<Tabs>
+<Tab title="With Schema">
+**Returns:** `Promise<ExtractResult<T>>` where T matches your schema
+
+The returned object will be strictly typed according to your schema definition.
+</Tab>
+
+<Tab title="String Only">
+**Returns:** `Promise<{ extraction: string }>`
+
+Simple string extraction without schema validation.
+</Tab>
+
+<Tab title="No Parameters">
+**Returns:** `Promise<{ pageText: string }>`
+
+Raw accessibility tree representation of page content.
+</Tab>
+</Tabs>
+
+### Code Examples
+
+<Tabs>
+<Tab title="Single Object">
+
+<CodeGroup>
+```typescript TypeScript
+import { z } from 'zod';
+
+// Schema definition
+const ProductSchema = z.object({
+  name: z.string(),
+  price: z.number(),
+  inStock: z.boolean()
+});
+
+// Extraction
+const product = await page.extract({
+  instruction: "extract product details",
+  schema: ProductSchema
+});
+```
+
+```python Python
+from pydantic import BaseModel
+
+# Schema definition
+class Product(BaseModel):
+    name: str
+    price: float
+    in_stock: bool
+
+# Extraction
+product = await page.extract(
+    instruction="extract product details",
+    schema=Product
+)
+```
+</CodeGroup>
+
+#### Example Response
+```json
+{
+  "name": "Product Name",
+  "price": 100,
+  "inStock": true
+}
+```
+
+</Tab>
+<Tab title="Arrays">
+
+<CodeGroup>
+```typescript TypeScript
+import { z } from 'zod';
+
+// Schema definition
+const ApartmentListingsSchema = z.object({
+  apartments: z.array(z.object({
+    address: z.string(),
+    price: z.string(),
+    bedrooms: z.number()
+  }))
+});
+
+// Extraction
+const listings = await page.extract({
+  instruction: "extract all apartment listings", 
+  schema: ApartmentListingsSchema
+});
+```
+
+```python Python
+from pydantic import BaseModel
+from typing import List
+
+# Schema definition
+class Apartment(BaseModel):
+    address: str
+    price: str
+    bedrooms: int
+
+class ApartmentListings(BaseModel):
+    apartments: List[Apartment]
+
+# Extraction
+listings = await page.extract(
+    instruction="extract all apartment listings",
+    schema=ApartmentListings
+)
+```
+</CodeGroup>
+
+#### Example Response
+```json
+{
+  "apartments": [
+    {
+      "address": "123 Main St",
+      "price": "$100,000",
+      "bedrooms": 3
+    },
+    {
+      "address": "456 Elm St",
+      "price": "$150,000",
+      "bedrooms": 2
+    }
+  ]
+}
+```
+
+</Tab>
+<Tab title="URLs">
+
+<CodeGroup>
+```typescript TypeScript
+import { z } from 'zod';
+
+// Schema definition
+const NavigationSchema = z.object({
+  links: z.array(z.object({
+    text: z.string(),
+    url: z.string().url()  // URL validation
+  }))
+});
+
+// Extraction
+const links = await page.extract({
+  instruction: "extract navigation links",
+  schema: NavigationSchema
+});
+```
+
+```python Python
+from pydantic import BaseModel, HttpUrl
+from typing import List
+
+# Schema definition
+class NavLink(BaseModel):
+    text: str
+    url: HttpUrl  # URL validation
+
+class Navigation(BaseModel):
+    links: List[NavLink]
+
+# Extraction
+links = await page.extract(
+    instruction="extract navigation links", 
+    schema=Navigation
+)
+```
+</CodeGroup>
+
+#### Example Response
+```json
+{
+  "links": [
+    {
+      "text": "Home",
+      "url": "https://example.com"
+    }
+  ]
+}
+```
+
+</Tab>
+<Tab title="Scoped">
+
+<CodeGroup>
+```typescript TypeScript
+import { z } from 'zod';
+
+const ProductSchema = z.object({
+  name: z.string(),
+  price: z.number(),
+  description: z.string()
+});
+
+// Extract from specific page section
+const data = await page.extract({
+  instruction: "extract product info from this section",
+  selector: "xpath=/html/body/div/div",
+  schema: ProductSchema
+});
+```
+
+```python Python
+from pydantic import BaseModel
+
+class Product(BaseModel):
+    name: str
+    price: float
+    description: str
+
+# Extract from specific page section
+data = await page.extract(
+    instruction="extract product info from this section",
+    selector="xpath=/html/body/div/div",
+    schema=Product
+)
+```
+</CodeGroup>
+
+#### Example Response
+```json
+{
+  "name": "Product Name",
+  "price": 100,
+  "description": "Product description"
+}
+```
+
+</Tab>
+<Tab title="Schema-less">
+
+<CodeGroup>
+```typescript TypeScript
+// String only extraction
+const title = await page.extract("get the page title");
+// Returns: { extraction: "Page Title" }
+
+// Raw page content
+const content = await page.extract();
+// Returns: { pageText: "Accessibility Tree: ..." }
+```
+
+```python Python
+# String only extraction
+title = await page.extract("get the page title")
+# Returns: {"extraction": "Page Title"}
+
+# Raw page content
+content = await page.extract()
+# Returns: {"pageText": "Accessibility Tree: ..."}
+```
+</CodeGroup>
+
+#### Example Response
+```json
+{
+  "extraction": "Page Title"
+}
+```
+
+</Tab>
+<Tab title="Advanced">
+
+<CodeGroup>
+```typescript TypeScript
+import { z } from 'zod';
+
+// Schema with descriptions and validation
+const ProductSchema = z.object({
+  price: z.number().describe("Product price in USD"),
+  rating: z.number().min(0).max(5).describe("Customer rating out of 5"),
+  available: z.boolean().describe("Whether product is in stock"),
+  tags: z.array(z.string()).optional()
+});
+
+// Nested schema
+const EcommerceSchema = z.object({
+  product: z.object({
+    name: z.string(),
+    price: z.object({
+      current: z.number(),
+      original: z.number().optional()
+    })
+  }),
+  reviews: z.array(z.object({
+    rating: z.number(),
+    comment: z.string()
+  }))
+});
+```
+
+```python Python
+from pydantic import BaseModel, Field
+from typing import Optional, List
+
+# Schema with descriptions and validation
+class Product(BaseModel):
+    price: float = Field(description="Product price in USD")
+    rating: float = Field(ge=0, le=5, description="Customer rating out of 5")
+    available: bool = Field(description="Whether product is in stock")
+    tags: Optional[List[str]] = None
+
+# Nested schema
+class Price(BaseModel):
+    current: float
+    original: Optional[float] = None
+
+class Review(BaseModel):
+    rating: int
+    comment: str
+
+class ProductDetails(BaseModel):
+    name: str
+    price: Price
+
+class EcommerceData(BaseModel):
+    product: ProductDetails
+    reviews: List[Review]
+```
+</CodeGroup>
+
+#### Example Response
+```json
+{
+  "product": {
+    "name": "Product Name",
+    "price": {
+      "current": 100,
+      "original": 120
+    }
+  },
+  "reviews": [
+    {
+      "rating": 4,
+      "comment": "Great product!"
+    }
+  ]
+}
+```
+
+</Tab>
+</Tabs>
\ No newline at end of file
diff --git a/packages/docs/v2/references/observe.mdx b/packages/docs/v2/references/observe.mdx
new file mode 100644
index 000000000..7e9a53604
--- /dev/null
+++ b/packages/docs/v2/references/observe.mdx
@@ -0,0 +1,241 @@
+---
+title: observe()
+description: 'Complete API reference for the observe() method'
+icon: 'magnifying-glass'
+---
+
+<CardGroup cols={1}>
+<Card title="Observe" icon="magnifying-glass" href="/v2/basics/observe">
+  See how to use observe() to discover actionable elements and analyze web page structure
+</Card>
+</CardGroup>
+
+### Method Signatures
+
+<Tabs>
+<Tab title="TypeScript">
+
+```typescript
+// With ObserveOptions
+await page.observe(options: ObserveOptions): Promise<ObserveResult[]>
+
+// String instruction shorthand
+await page.observe(instruction: string): Promise<ObserveResult[]>
+```
+
+**ObserveOptions Interface:**
+```typescript
+interface ObserveOptions {
+  instruction?: string;
+  modelName?: AvailableModel;
+  modelClientOptions?: ClientOptions;
+  domSettleTimeoutMs?: number;
+  drawOverlay?: boolean;
+  iframes?: boolean;
+}
+```
+
+</Tab>
+<Tab title="Python">
+
+```python
+# With parameters
+await page.observe(
+    instruction: str,
+    dom_settle_timeout_ms: int = None,
+    iframes: bool = None,
+    model_name: AvailableModel = None,
+    model_client_options: Dict = None
+) -> List[ObserveResult]
+```
+
+</Tab>
+</Tabs>
+
+### Parameters
+
+<ParamField path="instruction" type="string" optional>
+  Natural language description of elements or actions to discover.
+</ParamField>
+
+<ParamField path="modelName" type="AvailableModel" optional>
+  Override the default LLM model for this observation.
+</ParamField>
+
+<ParamField path="modelClientOptions" type="ClientOptions" optional>
+  Model-specific configuration options.
+</ParamField>
+
+<ParamField path="domSettleTimeoutMs" type="number" optional>
+  Maximum time to wait for DOM to stabilize before analysis.
+  
+  **Default:** `30000`
+</ParamField>
+
+<ParamField path="drawOverlay" type="boolean" optional>
+  Whether to draw visual overlays on discovered elements (debugging).
+  
+  **Default:** `false`
+</ParamField>
+
+<ParamField path="iframes" type="boolean" optional>
+  Set to `true` to search within iframes.
+  
+  **Default:** `false`
+</ParamField>
+
+### Response
+
+**Returns:** `Promise<ObserveResult[]>`
+
+Array of discovered actionable elements, ordered by relevance.
+
+**ObserveResult Interface:**
+```typescript
+interface ObserveResult {
+  selector: string;        // XPath selector to locate element
+  description: string;     // Human-readable description
+  method?: string;         // Suggested action method
+  arguments?: string[];    // Additional action parameters
+}
+```
+
+<ParamField path="selector" type="string">
+  XPath selector that precisely locates the element.
+</ParamField>
+
+<ParamField path="description" type="string">
+  Human-readable description of the element and its purpose.
+</ParamField>
+
+<ParamField path="method" type="string" optional>
+  Suggested interaction method: `"click"`, `"fill"`, `"selectOptionFromDropdown"`, `"nextChunk"`, `"scrollTo"`, `"prevChunk"`.
+</ParamField>
+
+<ParamField path="arguments" type="string[]" optional>
+  Additional parameters for the suggested action.
+</ParamField>
+
+
+### Code Examples
+
+<CodeGroup>
+```typescript TypeScript
+// Basic element discovery
+const buttons = await page.observe("find all clickable buttons");
+const formFields = await page.observe("locate form input fields");
+
+// Advanced configuration
+const elements = await page.observe({
+  instruction: "find important call-to-action buttons",
+  modelName: "gpt-4.1-mini",
+  domSettleTimeoutMs: 45000,
+  drawOverlay: true
+});
+
+// Working with results
+const [loginButton] = await page.observe("find the login button");
+if (loginButton) {
+  console.log("Found:", loginButton.description);
+  console.log("Selector:", loginButton.selector);
+  await page.act(loginButton); // Execute the action
+}
+
+// Filter results
+const submitButtons = await page.observe("find all submit buttons");
+const primarySubmit = submitButtons.find(btn => 
+  btn.description.toLowerCase().includes('primary')
+);
+
+// Iframe search
+const iframeElements = await page.observe({
+  instruction: "find form fields inside the iframe",
+  iframes: true
+});
+```
+
+```python Python
+# Basic element discovery
+buttons = await page.observe("find all clickable buttons")
+form_fields = await page.observe("locate the form fields")
+
+# Advanced configuration  
+elements = await page.observe(
+    instruction="find important call-to-action buttons",
+    model_name="gpt-4.1-mini",
+    dom_settle_timeout_ms=45000
+)
+
+# Working with results
+login_buttons = await page.observe("find the login button")
+if login_buttons:
+    button = login_buttons[0]
+    print("Found:", button.description)
+    print("Selector:", button.selector)
+    await page.act(button)  # Execute the action
+
+# Filter results
+submit_buttons = await page.observe("find all submit buttons")
+primary_submit = next((
+    btn for btn in submit_buttons 
+    if 'primary' in btn.description.lower()
+), None)
+
+# Iframe search
+iframe_elements = await page.observe(
+    instruction="find the form fields inside the iframe",
+    iframes=True
+)
+```
+</CodeGroup>
+
+### Integration Patterns
+
+<CodeGroup>
+```typescript TypeScript
+// Observe → Act workflow
+const actions = await page.observe("find checkout elements");
+for (const action of actions) {
+  await page.act(action);
+  await page.waitForTimeout(1000);
+}
+
+// Observe → Extract workflow
+const tables = await page.observe("find data tables");
+if (tables.length > 0) {
+  const data = await page.extract({
+    instruction: "extract the table data",
+    selector: tables[0].selector,
+    schema: DataSchema
+  });
+}
+
+// Element validation
+const requiredElements = await page.observe("find the login form");
+if (requiredElements.length === 0) {
+  throw new Error("Login form not found");
+}
+```
+
+```python Python
+# Observe → Act workflow  
+actions = await page.observe("find checkout elements")
+for action in actions:
+    await page.act(action)
+    await page.wait_for_timeout(1000)
+
+# Observe → Extract workflow
+tables = await page.observe("find data tables")
+if tables:
+    data = await page.extract(
+        instruction="extract the table data",
+        selector=tables[0].selector,
+        schema=DataSchema
+    )
+
+# Element validation
+required_elements = await page.observe("find login form")
+if not required_elements:
+    raise Exception("Login form not found")
+```
+</CodeGroup>
\ No newline at end of file
diff --git a/packages/docs/v2/references/stagehand.mdx b/packages/docs/v2/references/stagehand.mdx
new file mode 100644
index 000000000..0fb6c0fc2
--- /dev/null
+++ b/packages/docs/v2/references/stagehand.mdx
@@ -0,0 +1,260 @@
+---
+title: 'Stagehand'
+description: 'Complete API reference for initializing Stagehand'
+icon: 'wand-magic-sparkles'
+---
+
+### Constructor Signature
+
+<Tabs>
+<Tab title="TypeScript">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  // ... other options
+});
+await stagehand.init();
+```
+
+**ConstructorParams Interface:**
+```typescript
+interface ConstructorParams {
+  env: "BROWSERBASE" | "LOCAL";
+  apiKey?: string;
+  projectId?: string;
+  verbose?: 0 | 1 | 2;
+  llmProvider?: LLMProvider;
+  logger?: (message: LogLine) => void | Promise<void>;
+  domSettleTimeoutMs?: number;
+  browserbaseSessionCreateParams?: Omit<Browserbase.Sessions.SessionCreateParams, "projectId"> & { projectId?: string };
+  enableCaching?: boolean;
+  browserbaseSessionID?: string;
+  modelName?: AvailableModel;
+  llmClient?: LLMClient;
+  modelClientOptions?: ClientOptions;
+  systemPrompt?: string;
+  useAPI?: boolean;
+  waitForCaptchaSolves?: boolean;
+  localBrowserLaunchOptions?: LocalBrowserLaunchOptions;
+  logInferenceToFile?: boolean;
+  selfHeal?: boolean;
+  disablePino?: boolean;
+  experimental?: boolean;
+}
+```
+
+</Tab>
+<Tab title="Python">
+
+```python
+from stagehand import Stagehand
+
+stagehand = Stagehand(
+    env: Literal["BROWSERBASE", "LOCAL"] = "BROWSERBASE",
+    api_key: str = None,
+    project_id: str = None,
+    api_url: str = None,
+    model_name: str = None,
+    model_api_key: str = None,
+    model_client_options: Dict[str, Any] = None,
+    verbose: int = 1,
+    logger: Callable = None,
+    use_rich_logging: bool = True,
+    dom_settle_timeout_ms: int = 3000,
+    browserbase_session_create_params: Dict = None,
+    browserbase_session_id: str = None,
+    enable_caching: bool = False,
+    self_heal: bool = True,
+    wait_for_captcha_solves: bool = False,
+    system_prompt: str = None,
+    local_browser_launch_options: Dict[str, Any] = None,
+    use_api: bool = True,
+    experimental: bool = False,
+)
+await stagehand.init()
+```
+
+</Tab>
+</Tabs>
+
+<CardGroup cols={1}>
+<Card title="Model Configuration" icon="brain" href="/configuration/models">
+  Learn how to configure different LLM models for Stagehand
+</Card>
+</CardGroup>
+
+### Parameters
+
+#### Required Parameters
+
+<ParamField path="env" type="'BROWSERBASE' | 'LOCAL'" required>
+  The environment to use for Stagehand.
+
+  - `BROWSERBASE` - Run browser on Browserbase cloud infrastructure
+  - `LOCAL` - Run browser locally on your machine
+
+  **Default:** `"BROWSERBASE"` (Python only)
+</ParamField>
+
+#### Browserbase Configuration
+
+<ParamField path="apiKey" type="string" optional>
+  Your Browserbase API key. Required when `env` is `BROWSERBASE`.
+</ParamField>
+
+<ParamField path="projectId" type="string" optional>
+  Your Browserbase project ID. Required when `env` is `BROWSERBASE`.
+</ParamField>
+
+<ParamField path="browserbaseSessionID" type="string" optional>
+  The ID of an existing Browserbase session to resume. Useful for continuing previous browser sessions.
+</ParamField>
+
+<ParamField path="browserbaseSessionCreateParams" type="object" optional>
+  Parameters to use when creating a Browserbase session. See [Browserbase API documentation](https://docs.browserbase.com/reference/api/create-a-session) for available options.
+</ParamField>
+
+<ParamField path="waitForCaptchaSolves" type="boolean" optional>
+  Wait for captchas to be solved after navigation when using Browserbase environment.
+
+  **Default:** `false`
+</ParamField>
+
+#### Local Browser Configuration
+
+<ParamField path="localBrowserLaunchOptions" type="LocalBrowserLaunchOptions" optional>
+  Configuration options for launching a local browser. Only used when `env` is `LOCAL`.
+
+  See the [full interface definition](https://github.com/browserbase/stagehand/blob/v2/types/stagehand.ts#L174) for all available options.
+</ParamField>
+
+#### LLM Configuration
+
+<CardGroup cols={1}>
+<Card title="Model Configuration" icon="brain" href="/configuration/models">
+  Learn how to configure different LLM models for Stagehand
+</Card>
+</CardGroup>
+
+<ParamField path="modelName" type="AvailableModel" optional>
+  The LLM model to use for Stagehand operations.
+
+  **Examples:** `gpt-4o`, `gpt-4o-mini`, `claude-sonnet-4-6`
+
+  **Python Default:** `"gpt-4o"`
+</ParamField>
+
+<ParamField path="modelApiKey" type="string" optional>
+  API key for the LLM model provider. **Python only.**
+
+  In TypeScript, use `modelClientOptions.apiKey` instead.
+</ParamField>
+
+<ParamField path="llmProvider" type="LLMProvider" optional>
+  The LLM provider to use for Stagehand. Custom provider implementation. **TypeScript only.**
+</ParamField>
+
+<ParamField path="llmClient" type="LLMClient" optional>
+  Custom LLM client instance to use for Stagehand operations. **TypeScript only.**
+</ParamField>
+
+<ParamField path="modelClientOptions" type="ClientOptions" optional>
+  LLM client configuration options. Useful for parameterizing LLM API keys and other settings.
+
+  **Common options:** `apiKey` (TypeScript), `api_base`, `temperature`, `maxTokens`
+</ParamField>
+
+<ParamField path="enableCaching" type="boolean" optional>
+  Enable caching of LLM responses to reduce API calls and costs.
+
+  **TypeScript Default:** `true`
+  **Python Default:** `false`
+</ParamField>
+
+#### Logging and Debugging
+
+<Note>
+**Security tip:** Use `verbose: 0` when your automation handles secrets to prevent sensitive data from appearing in logs.
+</Note>
+
+<ParamField path="verbose" type="0 | 1 | 2" optional>
+  The verbosity level of the Stagehand logger.
+
+  - `0` - Minimal (ERROR only)
+  - `1` - Medium (INFO level)
+  - `2` - Detailed (DEBUG level)
+
+  **Default:** `1`
+</ParamField>
+
+<ParamField path="logger" type="(message: LogLine) => void | Promise<void>" optional>
+  Custom logger function to handle log messages from Stagehand.
+</ParamField>
+
+<ParamField path="useRichLogging" type="boolean" optional>
+  Whether to use Rich for colorized logging output. **Python only.**
+
+  **Default:** `true`
+</ParamField>
+
+<ParamField path="disablePino" type="boolean" optional>
+  Disable Pino logger. Helpful for Next.js or test environments where Pino causes issues. **TypeScript only.**
+
+  **Default:** `false`
+</ParamField>
+
+<ParamField path="logInferenceToFile" type="boolean" optional>
+  Log LLM inference details to a file for debugging purposes. **TypeScript only.**
+
+  **Default:** `false`
+</ParamField>
+
+#### Performance and Behavior
+
+<ParamField path="domSettleTimeoutMs" type="number" optional>
+  Default timeout to wait for the DOM to settle before performing operations.
+
+  **TypeScript Default:** `10000` (10 seconds)
+  **Python Default:** `3000` (3 seconds)
+</ParamField>
+
+<ParamField path="selfHeal" type="boolean" optional>
+  Enable self-healing capabilities to automatically recover from failures.
+
+  **Python Default:** `true`
+</ParamField>
+
+<ParamField path="systemPrompt" type="string" optional>
+  Customize the Stagehand system prompt used for LLM interactions.
+</ParamField>
+
+<ParamField path="useAPI" type="boolean" optional>
+  Offload Stagehand method calls to the Stagehand API.
+
+  **Default:** `true`
+</ParamField>
+
+<ParamField path="experimental" type="boolean" optional>
+  Enable the latest experimental features. Use with caution in production.
+
+  **Default:** `false`
+</ParamField>
+
+### Returns `InitResult`
+
+After calling `stagehand.init()`, you receive an `InitResult` object:
+
+<ParamField path="debugUrl" type="string" required>
+  URL for debugging the browser session (e.g., Chrome DevTools).
+</ParamField>
+
+<ParamField path="sessionUrl" type="string" required>
+  URL of the browser session (especially useful with Browserbase).
+</ParamField>
+
+<ParamField path="sessionId" type="string" required>
+  Unique identifier for the browser session.
+</ParamField>
\ No newline at end of file
diff --git a/packages/docs/v3/basics/act.mdx b/packages/docs/v3/basics/act.mdx
new file mode 100644
index 000000000..b6378e575
--- /dev/null
+++ b/packages/docs/v3/basics/act.mdx
@@ -0,0 +1,407 @@
+---
+title: Act
+description: 'Interact with a web page'
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## What is `act()`?
+``` typescript
+await stagehand.act("click on add to cart")
+```
+`act` enables Stagehand to perform **individual** actions on a web page. Use it to build self-healing and deterministic automations that adapt to website changes. 
+
+## Why use `act()`?
+
+<CardGroup cols={2}>
+  <Card title="Natural Language Instructions" icon="wand-magic-sparkles" href="#using-act">
+    Write automation in plain English. No selectors or complex syntax.
+  </Card>
+  <Card title="Precise Control" icon="crosshairs" href="#best-practices">
+    Build automations step by step. Define exactly what happens at every moment.
+  </Card>
+  <Card title="Self-Healing" icon="bandage" href="#ensure-reliable-actions">
+    Actions automatically adapt when websites change.
+  </Card>
+  <Card title="Caching" icon="repeat" href="#reduce-model-costs">
+    Cache actions to avoid LLM calls and ensure consistent execution across runs.
+  </Card>
+</CardGroup>
+
+
+## Using `act()`
+
+Use `act` to perform single actions in your automation. Here's how to click a button:
+
+```typescript
+await page.goto("https://example-store.com");
+await stagehand.act("click the add to cart button");
+```
+
+<Note>
+**iFrame and Shadow DOM Support** Stagehand automatically handles iFrame traversal and shadow DOM elements without requiring additional configuration.
+</Note>
+
+With `act`, breaking complex actions into small, single-step actions works best. If you need to orchestrate multi-step flows, use multiple `act` commands or `agent`.
+
+<Accordion title="Suggested actions">
+
+| Action | Example instruction |
+|--------|---------------------|
+| Click | `click the button` |
+| Fill | `fill the field with <value>` |
+| Type | `type <text> into the search box` |
+| Press | `press <key> in the search field` |
+| Scroll | `scroll to <position>` |
+| Select from dropdown | `select <value> from the dropdown` |
+</Accordion>
+
+### Return value of `act()`?
+When you use `act()`, Stagehand will return a `Promise<ActResult>` with the following structure:
+``` typescript
+{
+  success: true,
+  message: 'Action [click] performed successfully on selector: xpath=/html[1]/body[1]/div[1]/span[1] → Action [click] performed successfully on selector: xpath=/html[1]/body[1]/div[2]/div[1]/section[1]/div[1]/div[1]/div[25]',
+  actionDescription: 'Favorite Colour',
+  actions: [
+    {
+      selector: 'xpath=/html[1]/body[1]/div[1]/span[1]',
+      description: 'Favorite Colour',
+      method: 'click',
+      arguments: []
+    },
+    {
+      selector: 'xpath=/html[1]/body[1]/div[2]/div[1]/section[1]/div[1]/div[1]/div[25]',
+      description: 'Peach',
+      method: 'click',
+      arguments: []
+    }
+  ]
+}
+```
+
+
+<Tabs>
+<Tab title="Do this" icon="check">
+Break your task into single-step actions.
+
+```typescript
+// Break it into single-step actions
+await stagehand.act("open the filters panel");
+await stagehand.act("choose 4-star rating");
+await stagehand.act("click the apply button");
+```
+</Tab>
+
+<Tab title="Don't do this" icon="xmark">
+For multi-step tasks, use [`agent()`](/basics/agent) instead.
+
+```typescript
+// Too complex - trying to do multiple things at once
+await stagehand.act("open the filters panel, choose 4-star rating, and click apply");
+```
+</Tab>
+</Tabs>
+
+## Advanced Configuration
+
+You can pass additional options to configure the model, timeout, variables, and target page:
+
+```typescript
+// Custom model configuration
+await stagehand.act("choose 'Peach' from the favorite color dropdown", {
+  model: {
+    modelName: "google/gemini-2.5-flash",
+    apiKey: process.env.GEMINI_API_KEY
+  },
+  timeout: 10000
+});
+```
+
+### Server-side Caching
+
+<Note>
+`serverCache` only works when running with `env: "BROWSERBASE"`. It has no effect in local environments.
+</Note>
+
+When running on Browserbase, Stagehand automatically caches `act()` results server-side. Repeated calls with the same inputs return instantly without consuming LLM tokens. Caching is enabled by default and can be controlled globally on the constructor or overridden per call:
+
+```typescript
+// Disable server-side caching for the entire instance
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  serverCache: false,
+});
+
+// Or disable it for a single call
+await stagehand.act("click the login button", { serverCache: false });
+
+// Check whether a result was served from cache
+const result = await stagehand.act("click the login button");
+console.log(result.cacheStatus); // "HIT", "MISS", or undefined
+```
+
+### Using with Custom Pages
+
+You can use `act()` with pages from other browser automation libraries like Puppeteer, Playwright, or Patchright by passing the `page` option:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+import puppeteer from "puppeteer-core";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+});
+await stagehand.init();
+
+// Connect with Puppeteer
+const browser = await puppeteer.connect({
+  browserWSEndpoint: stagehand.connectURL(),
+  defaultViewport: null,
+});
+
+const pages = await browser.pages();
+const customPage = pages[0];
+
+await customPage.goto("https://www.example.com/blog");
+
+// Use act with the custom Puppeteer page
+await stagehand.act("click the next page button", {
+  page: customPage
+});
+```
+
+This works with:
+- **Puppeteer**: Pass Puppeteer Page objects
+- **Playwright**: Pass Playwright Page objects
+- **Patchright**: Pass Patchright Page objects
+- **Stagehand Page**: Use `stagehand.context.pages()[0]` or `context.activePage()` (default)
+
+<Card title="Complete API Reference" icon="book" href="/v3/references/act">
+  See the full `act()` reference for detailed parameter documentation, return values, and advanced examples.
+</Card>
+
+
+
+
+
+## Best practices
+
+### Ensure reliable actions
+
+Use `observe()` to discover candidate actions on the current page and plan reliably. It returns a list of suggested actions (with selector, description, method, and arguments). You can pass an observed action directly to `act` to execute it.
+
+```typescript
+const [action] = await stagehand.observe("click the login button");
+
+if (action) {
+  await stagehand.act(action);
+}
+```
+
+<Card title="Analyze pages with observe()" icon="magnifying-glass" iconType="sharp-solid" href="/v3/basics/observe">
+  Plan actions with `observe()` before executing with `act`.
+</Card>
+
+### Reduce model costs
+
+Enable automatic action caching by specifying a `cacheDir` when initializing Stagehand. The first time an action runs, it's cached. Subsequent runs reuse the cached action without LLM calls.
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+// Enable caching by specifying a cache directory
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "act-cache" // Actions are automatically cached here
+});
+
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+// First run - makes LLM call and caches the action
+await stagehand.act("click the login button");
+```
+
+<Note>
+Caching persists across script executions. The first time you run your script, actions are cached to your local filesystem. On subsequent runs, cached actions are reused automatically, significantly reducing costs and improving performance.
+</Note>
+
+<Card title="Complete caching guide" icon="database" iconType="sharp-solid" href="/v3/best-practices/caching">
+  Learn advanced caching techniques and patterns for optimal performance.
+</Card>
+
+### Secure your automations
+
+Variables are **not shared with LLM providers**. Use them for passwords, API keys, and other sensitive data.
+
+<Note>
+Load sensitive data from environment variables using `.env` files. Never hardcode API keys, passwords, or other secrets directly in your code.
+</Note>
+
+```typescript
+// Variables use %variableName% syntax in the instruction
+await stagehand.act("type %username% into the email field", {
+  variables: { username: "user@example.com" }
+});
+
+await stagehand.act("type %password% into the password field", {
+  variables: { password: process.env.USER_PASSWORD }
+});
+
+await stagehand.act("click the login button");
+```
+
+<Warning>
+When handling sensitive data, set `verbose: 0` in your Stagehand configuration to prevent secrets from appearing in logs. See the [configuration guide](/configuration/browser) for more details.
+</Warning>
+
+<Card title="User Data Best Practices" icon="shield-check" iconType="sharp-solid" href="/v3/best-practices/user-data">
+  Complete guide to securing your browser automations with best practices and configurations.
+</Card>
+
+## Troubleshooting
+
+<AccordionGroup>
+
+
+<Accordion title="Method not supported">
+**Problem**: `act` fails with "method not supported" error
+
+**Solutions**:
+- Use clear and detailed instructions for what you want to accomplish
+- Review our [evals](https://stagehand.dev/evals) to find the best models for your use case
+- Use [`observe()`](/basics/observe) and verify the resulting action is within a list of expected actions
+
+**Solution 1: Validate with observe**
+
+```typescript
+const prompt = "click the submit button";
+const expectedMethod = "click";
+
+try {
+  await stagehand.act(prompt);
+} catch (error) {
+  if (error.message.includes("method not supported")) {
+    // Observe the same prompt to get the planned action
+    const [action] = await stagehand.observe(prompt);
+
+    if (action && action.method === expectedMethod) {
+      await stagehand.act(action);
+    } else {
+      throw new Error(`Unsupported method: expected "${expectedMethod}", got "${action?.method}"`);
+    }
+  } else {
+    throw error;
+  }
+}
+```
+
+**Solution 2: Retry with exponential backoff**
+
+```typescript
+// Retry with exponential backoff for intermittent issues
+const prompt = "click the submit button";
+const maxRetries = 3;
+
+for (let attempt = 0; attempt <= maxRetries; attempt++) {
+  try {
+    await stagehand.act(prompt, { timeout: 10000 + (attempt * 5000) });
+    break; // Success, exit retry loop
+  } catch (error) {
+    if (error.message.includes("method not supported") && attempt < maxRetries) {
+      // Exponential backoff: wait 2^attempt seconds
+      const delay = Math.pow(2, attempt) * 1000;
+      console.log(`Retry ${attempt + 1}/${maxRetries} after ${delay}ms`);
+      await new Promise(resolve => setTimeout(resolve, delay));
+    } else {
+      throw error;
+    }
+  }
+}
+```
+
+</Accordion>
+
+<Accordion title="Action failed or timed out">
+**Problem**: `act` times out or fails to complete action (often due to element not found)
+
+**Solutions**:
+- Ensure page has fully loaded
+- Check if content is in iframes: [Learn more about working with iframes](/best-practices/working-with-iframes)
+- Increase action timeout
+- Use `observe()` first to verify element exists
+
+```typescript
+// Handle timeout and element not found issues
+try {
+  await stagehand.act("click the submit button", { timeout: 30000 });
+} catch (error) {
+  // Check if page is fully loaded
+  await page.waitForLoadState('domcontentloaded');
+
+  // Use observe to check element state
+  const [element] = await stagehand.observe("find the submit button");
+
+  if (element) {
+    console.log("Element found, trying more specific instruction");
+    await stagehand.act("click the submit button at the bottom of the form");
+  } else {
+    console.log("Element not found, trying alternative selector");
+    await stagehand.act("click the button with text 'Submit'");
+  }
+}
+```
+</Accordion>
+
+<Accordion title="Incorrect element selected">
+**Problem**: `act` performs action on wrong element
+
+**Solutions**:
+- Be more specific in instructions: include visual cues, position, or context
+- Use `observe()` to preview which element will be selected
+- Add contextual information: "the search button in the header"
+- Use unique identifiers when available
+
+```typescript
+// More precise element targeting
+// Instead of:
+await stagehand.act("click the button");
+
+// Use specific context:
+await stagehand.act("click the red 'Delete' button next to the user John Smith");
+
+// Or preview with observe first:
+const [action] = await stagehand.observe("click the submit button in the checkout form");
+if (action.description.includes("checkout")) {
+  await stagehand.act(action);
+}
+```
+</Accordion>
+
+
+
+</AccordionGroup>
+
+## Next steps
+
+<CardGroup cols={2}>
+
+  <Card title="Orchestrate complex workflows with Agent" icon="robot" iconType="sharp-solid" href="/v3/basics/agent">
+    Use `Agent` to autonomously execute multi-step tasks and complex workflows.
+  </Card>
+
+   <Card title="Caching actions" icon="bolt" iconType="sharp-solid" href="/v3/best-practices/caching">
+    Speed up repeated automations by caching actions.
+  </Card>
+
+  <Card title="Extract data with extract()" icon="table" iconType="sharp-solid" href="/v3/basics/extract">
+    Use `extract` with a data schema to pull clean, typed data from any page.
+  </Card>
+
+  <Card title="Preview actions with observe()" icon="magnifying-glass" iconType="sharp-solid" href="/v3/basics/observe">
+    Preview actions with `observe()` before executing them.
+  </Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v3/basics/agent.mdx b/packages/docs/v3/basics/agent.mdx
new file mode 100644
index 000000000..9eb92363a
--- /dev/null
+++ b/packages/docs/v3/basics/agent.mdx
@@ -0,0 +1,1169 @@
+---
+title: Agent
+description: 'Automate complex workflows with AI powered browser agents'
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## What is `agent()?`
+
+``` typescript
+await agent.execute("apply for a job at browserbase")
+```
+`agent` turns high level tasks into **fully autonomous** browser workflows. You can customize the agent by specifying the LLM provider and model, setting custom instructions for behavior, and configuring max steps.
+
+<img src="/images/agent.gif" alt="Agent" />
+
+## Why use `agent()`?
+
+<CardGroup cols={2}>
+  <Card title="Multi-Step Workflows" icon="route" href="#agent-execution-configuration">
+    Execute complex sequences automatically.
+  </Card>
+  <Card title="Visual Understanding" icon="eye" href="/v3/best-practices/computer-use">
+    Sees and understands web interfaces like humans do using computer vision.
+  </Card>
+</CardGroup>
+
+## Using `agent()`
+
+There are three ways to create agents in Stagehand:
+1. Use a Computer Use Agent (CUA mode)
+2. Use Agent with any LLM (DOM mode)
+3. Use Agent with vision and DOM (Hybrid mode)
+
+### Feature Availability
+
+Some advanced features are only available with certain agent modes:
+
+| Feature                  | CUA | DOM | Hybrid |
+|:-------------------------|:---:|:---:|:------:|
+| Basic execution          | ✅  | ✅  | ✅     |
+| Custom tools             | ✅  | ✅  | ✅     |
+| MCP integrations         | ✅  | ✅  | ✅     |
+| System prompt            | ✅  | ✅  | ✅     |
+| Variables                | ❌  | ✅  | ✅     |
+| Streaming                | ❌  | ✅  | ✅     |
+| Callbacks                | ❌  | ✅  | ✅     |
+| Abort signal             | ❌  | ✅  | ✅     |
+| Message continuation     | ❌  | ✅  | ✅     |
+| Exclude tools            | ❌  | ✅  | ✅     |
+| Structured output        | ❌  | ✅  | ✅     |
+| DOM-based actions        | ❌  | ✅  | ✅     |
+| Coordinate-based actions | ✅  | ❌  | ✅     |
+| Visual cursor highlight  | ✅  | ❌  | ✅     |
+
+### Computer Use Agents
+
+You can use specialized computer use models from Google, OpenAI, Anthropic, or Microsoft as shown below, with `mode` set to `"cua"`. To compare the performance of different computer use models, you can visit our [evals page](https://www.stagehand.dev/agent-evals).
+
+<Warning>
+**Deprecation Notice:** The `cua: true` option is deprecated and will be removed in a future version. Use `mode: "cua"` instead.
+</Warning>
+
+<CodeGroup>
+```typescript Google
+const agent = stagehand.agent({
+    mode: "cua",
+    model: {
+        modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+        apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY
+    },
+    systemPrompt: "You are a helpful assistant...",
+});
+
+await agent.execute({
+    instruction: "Go to Hacker News and find the most controversial post from today, then read the top 3 comments and summarize the debate.",
+    maxSteps: 20,
+    highlightCursor: true
+})
+```
+
+```typescript OpenAI
+const agent = stagehand.agent({
+    mode: "cua",
+    model: {
+        modelName: "openai/computer-use-preview",
+        apiKey: process.env.OPENAI_API_KEY
+    },
+    systemPrompt: "You are a helpful assistant...",
+});
+
+await agent.execute({
+    instruction: "Go to Hacker News and find the most controversial post from today, then read the top 3 comments and summarize the debate.",
+    maxSteps: 20,
+    highlightCursor: true
+})
+```
+```typescript Anthropic
+const agent = stagehand.agent({
+    mode: "cua",
+    model: {
+        modelName: "anthropic/claude-sonnet-4-20250514",
+        apiKey: process.env.ANTHROPIC_API_KEY
+    },
+    systemPrompt: "You are a helpful assistant...",
+});
+
+await agent.execute({
+    instruction: "Go to Hacker News and find the most controversial post from today, then read the top 3 comments and summarize the debate.",
+    maxSteps: 20,
+    highlightCursor: true
+})
+```
+</CodeGroup>
+
+<Callout icon="code" color="#6ec202" iconType="regular">View or run the example template [here](https://www.browserbase.com/templates/gemini-cua)</Callout>
+
+### Use Stagehand Agent with Any LLM
+
+Use the agent without specifying a provider to utilize any model or LLM provider:
+
+<Note>Non CUA agents are currently only supported in TypeScript</Note>
+
+```typescript TypeScript
+const agent = stagehand.agent();
+await agent.execute("apply for a job at Browserbase")
+```
+<Card title="Available Agent Models" icon="robot" href="/v3/configuration/models#agent-models-with-cua-support">
+  Check out the guide on how to use different models with Stagehand Agent.
+</Card>
+
+### Hybrid Mode
+
+Both DOM and CUA modes have their strengths and weaknesses. Hybrid mode combines them, giving the agent access to both coordinate-based and DOM-based tools to better account for where each may fall short.
+
+<Warning>
+**Model Requirements:** Hybrid mode requires models that can reliably perform coordinate-based actions from screenshots. The following models are recommended:
+- **Google:** `google/gemini-3-flash-preview`
+- **Anthropic:** `anthropic/claude-sonnet-4-20250514`, `anthropic/claude-sonnet-4-5-20250929`, `anthropic/claude-haiku-4-5-20251001`
+
+Other models may not reliably produce accurate coordinates for clicking and typing.
+
+</Warning>
+
+<Note>Hybrid mode requires `experimental: true` in your Stagehand constructor.</Note>
+
+<CodeGroup>
+```typescript Hybrid Mode with Google
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  experimental: true, // Required for hybrid mode
+});
+await stagehand.init();
+
+const agent = stagehand.agent({
+  mode: "hybrid",
+  model: "google/gemini-3-flash-preview",
+});
+
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com");
+
+await agent.execute({
+  instruction: "Click the sign up button and fill out the registration form",
+  maxSteps: 20,
+});
+```
+
+```typescript Hybrid Mode with Anthropic
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  experimental: true, // Required for hybrid mode
+});
+await stagehand.init();
+
+const agent = stagehand.agent({
+  mode: "hybrid",
+  model: "anthropic/claude-haiku-4-5-20251001",
+  systemPrompt: "You are a helpful assistant that interacts with web pages visually.",
+});
+
+await agent.execute({
+  instruction: "Navigate the page and interact with the form elements",
+  maxSteps: 15,
+  highlightCursor: true, // Enabled by default in hybrid mode
+});
+```
+</CodeGroup>
+
+### Return value of `agent()`?
+
+When you use `agent()`, Stagehand will return a `Promise<AgentResult>` with the following structure:
+
+```typescript
+{
+  success: true,
+  message: "The first name and email fields have been filled successfully with 'John' and 'john@example.com'.",
+  actions: [
+    {
+      type: 'ariaTree',
+      reasoning: undefined,
+      taskCompleted: true,
+      pageUrl: 'https://example.com',
+      timestamp: 1761598722055
+    },
+    {
+      type: 'act',
+      reasoning: undefined,
+      taskCompleted: true,
+      action: 'type "John" into the First Name textbox',
+      playwrightArguments: {...},
+      pageUrl: 'https://example.com',
+      timestamp: 1761598731643
+    },
+    {
+      type: 'close',
+      reasoning: "The first name and email fields have been filled successfully.",
+      taskCompleted: true,
+      taskComplete: true,
+      pageUrl: 'https://example.com',
+      timestamp: 1761598732861
+    }
+  ],
+  completed: true,
+  // Only populated when `output` schema is provided (DOM/Hybrid modes only)
+  output: {
+    price: "$199",
+    airline: "Delta"
+  },
+  usage: {
+    input_tokens: 2040,
+    output_tokens: 28,
+    reasoning_tokens: 12,
+    cached_input_tokens: 0,
+    inference_time_ms: 14079
+  }
+}
+```
+
+## Customizing Agent Tools
+
+Stagehand agents come with built-in tools for browser automation, but you can customize the toolset by adding your own custom tools or excluding built-in ones.
+
+### Adding Custom Tools
+
+Custom tools enhance agents with additional capabilities for more granular control and better performance. Unlike MCP integrations, custom tools are defined inline and execute directly within your application.
+
+<Note>Custom tools provide a cleaner, more performant alternative to MCP integrations when you need specific functionality.</Note>
+
+#### Defining Custom Tools
+
+Use the `tool` helper exported from `@browserbasehq/stagehand` to define custom tools:
+
+<CodeGroup>
+```typescript Basic Tool
+import { tool } from "@browserbasehq/stagehand";
+import { z } from "zod";
+
+const agent = stagehand.agent({
+  model: "openai/gpt-5",
+  tools: {
+    getWeather: tool({
+      description: 'Get the current weather in a location',
+      inputSchema: z.object({
+        location: z.string().describe('The location to get weather for'),
+      }),
+      execute: async ({ location }) => {
+        // Your custom logic here
+        const weather = await fetchWeatherAPI(location);
+        return {
+          location,
+          temperature: weather.temp,
+          conditions: weather.conditions,
+        };
+      },
+    }),
+  },
+  systemPrompt: 'You are a helpful assistant with access to weather data.',
+});
+
+await agent.execute("What's the weather in San Francisco and should I bring an umbrella?");
+```
+
+```typescript Multiple Tools
+import { tool } from "@browserbasehq/stagehand";
+import { z } from "zod";
+
+const agent = stagehand.agent({
+  mode: "cua",
+  model: "anthropic/claude-sonnet-4-20250514",
+  tools: {
+    searchDatabase: tool({
+      description: 'Search for records in the database',
+      inputSchema: z.object({
+        query: z.string().describe('The search query'),
+        limit: z.number().optional().describe('Max results to return'),
+      }),
+      execute: async ({ query, limit = 10 }) => {
+        const results = await db.search(query, limit);
+        return { results };
+      },
+    }),
+
+    calculatePrice: tool({
+      description: 'Calculate the total price with tax',
+      inputSchema: z.object({
+        amount: z.number().describe('The base amount'),
+        taxRate: z.number().describe('Tax rate as decimal (e.g., 0.08 for 8%)'),
+      }),
+      execute: async ({ amount, taxRate }) => {
+        const total = amount * (1 + taxRate);
+        return { total: total.toFixed(2) };
+      },
+    }),
+  },
+});
+
+await agent.execute("Find products under $50 and calculate the total with 8% tax");
+```
+
+```typescript Tool with API Integration
+import { tool } from "@browserbasehq/stagehand";
+import { z } from "zod";
+
+const agent = stagehand.agent({
+  model: "google/gemini-2.0-flash",
+  tools: {
+    sendEmail: tool({
+      description: 'Send an email via SendGrid',
+      inputSchema: z.object({
+        to: z.string().email().describe('Recipient email address'),
+        subject: z.string().describe('Email subject'),
+        body: z.string().describe('Email body content'),
+      }),
+      execute: async ({ to, subject, body }) => {
+        const response = await fetch('https://api.sendgrid.com/v3/mail/send', {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${process.env.SENDGRID_API_KEY}`,
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            personalizations: [{ to: [{ email: to }] }],
+            from: { email: 'noreply@example.com' },
+            subject,
+            content: [{ type: 'text/plain', value: body }],
+          }),
+        });
+
+        return {
+          sent: response.ok,
+          messageId: response.headers.get('X-Message-Id'),
+        };
+      },
+    }),
+  },
+});
+
+await agent.execute("Fill out the contact form and send me a confirmation email at user@example.com");
+```
+</CodeGroup>
+
+#### Custom Tools vs MCP Integrations
+
+| Custom Tools                           | MCP Integrations                        |
+|----------------------------------------|-----------------------------------------|
+| Defined inline with your code          | Connect to external services            |
+| Direct function execution              | Standard protocol                       |
+| Better performance & optimized context | Reusable across applications            |
+| Type-safe with TypeScript              | Access to pre-built integrations        |
+| Granular control                       | Network-based communication             |
+
+<Tip>
+Use custom tools when you need specific functionality within your application. Use MCP integrations when connecting to external services or when you need standardized cross-application tools.
+</Tip>
+
+### Excluding Built-in Tools
+
+Prevent the agent from using specific built-in tools during execution. This is useful when you want to restrict the agent's capabilities or avoid certain behaviors.
+
+<Note>**Non-CUA agents only.** Requires `experimental: true`. Not available when `cua: true`.</Note>
+
+#### Basic Usage
+
+```typescript
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  experimental: true, // Required for excludeTools
+});
+await stagehand.init();
+
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5-20250929",
+});
+
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com");
+
+// Exclude screenshot and extract tools
+const result = await agent.execute({
+  instruction: "Navigate through the website and click the submit button",
+  maxSteps: 15,
+  excludeTools: ["screenshot", "extract"],
+});
+```
+
+#### Available Tools by Mode
+
+The tools you can exclude depend on the agent mode:
+
+<Tabs>
+<Tab title="DOM Mode (default)">
+
+| Tool | Description |
+|------|-------------|
+| `act` | Perform semantic actions (click, type, etc.) |
+| `fillForm` | Fill form fields using DOM selectors |
+| `ariaTree` | Get accessibility tree of the page |
+| `extract` | Extract structured data from page |
+| `goto` | Navigate to a URL |
+| `scroll` | Scroll using semantic directions (up/down/left/right) |
+| `keys` | Press keyboard keys |
+| `navback` | Navigate back in history |
+| `screenshot` | Take a screenshot |
+| `think` | Agent reasoning/planning step |
+| `wait` | Wait for time or condition |
+| `search` | Web search (requires `BRAVE_API_KEY`) |
+
+</Tab>
+
+<Tab title="Hybrid Mode">
+
+| Tool | Description |
+|------|-------------|
+| `click` | Click at specific coordinates |
+| `type` | Type text at coordinates |
+| `dragAndDrop` | Drag from one point to another |
+| `clickAndHold` | Click and hold at coordinates |
+| `fillFormVision` | Fill forms using vision/coordinates |
+| `act` | Perform semantic actions |
+| `ariaTree` | Get accessibility tree |
+| `extract` | Extract data from page |
+| `goto` | Navigate to URL |
+| `scroll` | Scroll using coordinates |
+| `keys` | Press keyboard keys |
+| `navback` | Navigate back |
+| `screenshot` | Take screenshot |
+| `think` | Agent reasoning step |
+| `wait` | Wait for time/condition |
+| `search` | Web search (requires `BRAVE_API_KEY`) |
+
+</Tab>
+</Tabs>
+
+#### Use Cases
+
+```typescript
+// Prevent the agent from taking screenshots during execution
+const result = await agent.execute({
+  instruction: "Fill out the contact form",
+  excludeTools: ["screenshot"],
+});
+
+// Prevent the agent from extracting data
+const result = await agent.execute({
+  instruction: "Click through the signup flow",
+  excludeTools: ["extract"],
+});
+
+// Disable web search capability
+const result = await agent.execute({
+  instruction: "Find information on the current page",
+  excludeTools: ["search"],
+});
+```
+
+## Variables
+
+Use variables to pass sensitive data (like passwords, API keys, or personal information) to the agent without exposing the actual values to the LLM. The agent sees only variable names and descriptions, while the actual values are substituted at runtime.
+
+<Note>**Non-CUA agents only.** Variables require `experimental: true` and are not available with Computer Use Agents.</Note>
+
+### Basic Usage
+
+```typescript
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  experimental: true, // Required for variables
+});
+await stagehand.init();
+
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5-20250929",
+});
+
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com/login");
+
+const result = await agent.execute({
+  instruction: "Log into the website using my credentials",
+  maxSteps: 10,
+  variables: {
+    username: {
+      value: "john@example.com",
+      description: "The user's email address for login"
+    },
+    password: {
+      value: process.env.USER_PASSWORD,
+      description: "The user's password for login"
+    }
+  }
+});
+```
+
+Variables use the same type as `act()`. You can pass simple values or rich objects with descriptions:
+
+```typescript
+// Simple values (same format as act)
+variables: {
+  username: "john@example.com",
+  password: "secret123",
+}
+
+// Rich values with descriptions (helps the agent understand context)
+variables: {
+  username: { value: "john@example.com", description: "The login email" },
+  password: { value: "secret123", description: "The login password" },
+}
+```
+
+### How Variables Work
+
+1. **LLM receives descriptions only**: The agent sees variable names and descriptions in its system prompt, but never the actual values
+2. **Placeholder syntax**: The LLM uses `%variableName%` syntax when it needs to use a variable (e.g., "type %password% into the password field")
+3. **Runtime substitution**: Actual values are substituted just before the action executes
+4. **Secure logging**: Variable values are never logged or returned in tool outputs
+
+### Supported Tools
+
+Variables work with the following agent tools:
+
+<Tabs>
+<Tab title="DOM Mode">
+
+| Tool | Usage |
+|------|-------|
+| `act` | Use `%variableName%` in the action description |
+| `fillForm` | Use `%variableName%` in field values |
+
+</Tab>
+
+<Tab title="Hybrid Mode">
+
+| Tool | Usage |
+|------|-------|
+| `type` | Use `%variableName%` in the text to type |
+| `fillFormVision` | Use `%variableName%` in field values |
+| `act` | Use `%variableName%` in the action description |
+
+</Tab>
+</Tabs>
+
+### Cache Optimization
+
+Variables are cache-friendly by design:
+- Cache keys use only variable names, not values
+- Changing variable values (e.g., different passwords) won't invalidate cached executions
+- This enables efficient replay of the same workflow with different credentials
+
+### Best Practices
+
+<Tabs>
+<Tab title="Do this">
+```typescript
+// Use variables for sensitive data
+variables: {
+  apiKey: {
+    value: process.env.API_KEY,
+    description: "API key for authentication"
+  }
+}
+```
+</Tab>
+
+<Tab title="Don't do this">
+```typescript
+// Don't hardcode sensitive values in instructions
+instruction: "Log in with password 'secret123'"
+```
+</Tab>
+</Tabs>
+
+<Tip>
+Use descriptive names and descriptions for variables. The LLM relies on the description to understand when and how to use each variable.
+</Tip>
+
+## MCP Integrations
+
+Agents can be enhanced with external tools and services through MCP (Model Context Protocol) integrations. This allows your agent to access external APIs and data sources beyond just browser interactions.
+
+<CodeGroup>
+```typescript Pass URL
+const agent = stagehand.agent({
+    mode: "cua",
+    model: {
+        modelName: "openai/computer-use-preview",
+        apiKey: process.env.OPENAI_API_KEY
+    },
+    integrations: [
+      `https://mcp.exa.ai/mcp?exaApiKey=${process.env.EXA_API_KEY}`,
+    ],
+    systemPrompt: `You have access to web search through Exa. Use it to find current information before browsing.`
+});
+
+await agent.execute("Search for the best headphones of 2025 and go through checkout for the top recommendation");
+```
+
+```typescript Create Connection
+import { connectToMCPServer } from "@browserbasehq/stagehand";
+
+const supabaseClient = await connectToMCPServer(
+  `https://server.smithery.ai/@supabase-community/supabase-mcp/mcp?api_key=${process.env.SMITHERY_API_KEY}`
+);
+
+const agent = stagehand.agent({
+    mode: "cua",
+    model: {
+        modelName: "openai/computer-use-preview",
+        apiKey: process.env.OPENAI_API_KEY
+    },
+    integrations: [supabaseClient],
+    systemPrompt: `You can interact with Supabase databases. Use these tools to store and retrieve data.`
+});
+
+await agent.execute("Search for restaurants and save the first result to the database");
+```
+</CodeGroup>
+
+<Tip>
+MCP integrations enable agents to be more powerful by combining browser automation with external APIs, databases, and services. The agent can intelligently decide when to use browser actions versus external tools.
+</Tip>
+
+## Streaming
+
+Enable streaming mode to receive incremental responses from the agent. This is useful for building real-time UIs that show the agent's reasoning as it progresses.
+
+<Warning>
+**Non-CUA agents only.** Streaming, callbacks, abort signals, and message continuation are only available when using the standard agent (without `mode: "cua"`). These features are not supported with Computer Use Agents.
+</Warning>
+
+<Note>These are experimental features. Set `experimental: true` in your Stagehand constructor to enable them.</Note>
+
+### Enabling Streaming Mode
+
+Set `stream: true` in the agent configuration to enable streaming:
+
+```typescript
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  experimental: true, // Required for streaming
+});
+await stagehand.init();
+
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5-20250929",
+  stream: true, // Enable streaming mode
+});
+
+const streamResult = await agent.execute({
+  instruction: "Search for headphones on Amazon",
+  maxSteps: 20,
+});
+
+// Stream the text output incrementally
+for await (const delta of streamResult.textStream) {
+  process.stdout.write(delta);
+}
+
+// Get the final result after streaming completes
+const finalResult = await streamResult.result;
+console.log("Completed:", finalResult.completed);
+```
+
+### Stream Properties
+
+When streaming is enabled, `execute()` returns an `AgentStreamResult` with:
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `textStream` | `AsyncIterable<string>` | Incremental text output from the agent |
+| `fullStream` | `AsyncIterable<StreamPart>` | All stream events including tool calls and messages |
+| `result` | `Promise<AgentResult>` | Final result after streaming completes |
+
+```typescript
+// Stream everything (tool calls, messages, etc.)
+for await (const event of streamResult.fullStream) {
+  console.log(event);
+}
+```
+
+## Callbacks
+
+Callbacks let you hook into the agent's execution lifecycle to monitor progress, log events, or modify behavior.
+
+<Note>**Non-CUA agents only.** Callbacks require `experimental: true` and are not available with Computer Use Agents.</Note>
+
+### Available Callbacks
+
+<Tabs>
+<Tab title="Non-Streaming">
+
+When `stream: false` (default), these callbacks are available:
+
+| Callback | Description |
+|----------|-------------|
+| `prepareStep` | Called before each LLM step to modify settings |
+| `onStepFinish` | Called when each step completes |
+
+```typescript
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5-20250929",
+});
+
+await agent.execute({
+  instruction: "Fill out the contact form",
+  maxSteps: 10,
+  callbacks: {
+    prepareStep: async (stepContext) => {
+      console.log(`Starting step ${stepContext.stepNumber}`);
+      return stepContext; // Return modified or original context
+    },
+    onStepFinish: async (event) => {
+      console.log(`Step finished: ${event.finishReason}`);
+      if (event.toolCalls) {
+        for (const tc of event.toolCalls) {
+          console.log(`Tool called: ${tc.toolName}`);
+        }
+      }
+    },
+  },
+});
+```
+
+</Tab>
+
+<Tab title="Streaming">
+
+When `stream: true`, additional callbacks are available:
+
+| Callback | Description |
+|----------|-------------|
+| `prepareStep` | Called before each LLM step to modify settings |
+| `onStepFinish` | Called when each step completes |
+| `onChunk` | Called for each stream chunk |
+| `onFinish` | Called when streaming completes |
+| `onError` | Called when an error occurs |
+| `onAbort` | Called when the stream is aborted |
+
+```typescript
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5-20250929",
+  stream: true,
+});
+
+const streamResult = await agent.execute({
+  instruction: "Search for products",
+  maxSteps: 15,
+  callbacks: {
+    onChunk: async (chunk) => {
+      // Called for each incremental chunk
+      console.log("Chunk received:", chunk);
+    },
+    onStepFinish: async (event) => {
+      console.log(`Step completed: ${event.finishReason}`);
+    },
+    onFinish: (event) => {
+      console.log("Stream finished!");
+      console.log("Total steps:", event.steps.length);
+    },
+    onError: ({ error }) => {
+      console.error("Stream error:", error);
+    },
+    onAbort: (event) => {
+      console.log("Stream aborted after", event.steps.length, "steps");
+    },
+  },
+});
+
+// Don't forget to consume the stream
+for await (const delta of streamResult.textStream) {
+  process.stdout.write(delta);
+}
+
+await streamResult.result;
+```
+
+</Tab>
+</Tabs>
+
+<Warning>
+Streaming-only callbacks (`onChunk`, `onFinish`, `onError`, `onAbort`) will throw an error if used without `stream: true`. If you need these callbacks, enable streaming in your agent configuration.
+</Warning>
+
+## Abort Signal
+
+Cancel agent execution at any time using an `AbortSignal`. This is useful for implementing timeouts or allowing users to stop long-running tasks.
+
+<Note>**Non-CUA agents only.** Abort signals require `experimental: true` and are not available with Computer Use Agents.</Note>
+
+### Basic Usage
+
+```typescript
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  experimental: true, // Required for abort signal
+});
+await stagehand.init();
+
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5-20250929",
+});
+
+const controller = new AbortController();
+
+// Set a 30 second timeout
+setTimeout(() => controller.abort(), 30000);
+
+try {
+  const result = await agent.execute({
+    instruction: "Complete a complex multi-step task",
+    maxSteps: 50,
+    signal: controller.signal,
+  });
+} catch (error) {
+  if (error.name === "AgentAbortError") {
+    console.log("Task was cancelled");
+  }
+}
+```
+
+### Abort with Streaming
+
+Abort signals also work with streaming mode:
+
+```typescript
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5-20250929",
+  stream: true,
+});
+
+const controller = new AbortController();
+
+const streamResult = await agent.execute({
+  instruction: "Describe every element on the page",
+  maxSteps: 50,
+  signal: controller.signal,
+  callbacks: {
+    onAbort: (event) => {
+      console.log(`Aborted after ${event.steps.length} steps`);
+    },
+  },
+});
+
+// Abort after receiving 10 chunks
+let chunkCount = 0;
+for await (const delta of streamResult.textStream) {
+  process.stdout.write(delta);
+  chunkCount++;
+  if (chunkCount >= 10) {
+    controller.abort();
+    break;
+  }
+}
+
+// The result promise will reject with AgentAbortError
+try {
+  await streamResult.result;
+} catch (error) {
+  console.log("Stream was aborted:", error.message);
+}
+```
+
+### Custom Abort Reasons
+
+You can pass a reason when aborting:
+
+```typescript
+controller.abort("User cancelled the operation");
+
+// The error message will include your reason
+// Error: "User cancelled the operation"
+```
+
+## Message Continuation
+
+Continue a conversation across multiple agent executions by passing the `messages` from a previous result. This is useful for multi-turn interactions or breaking complex tasks into steps while maintaining context.
+
+<Note>**Non-CUA agents only.** Message continuation requires `experimental: true` and is not available with Computer Use Agents.</Note>
+
+### Basic Continuation
+
+```typescript
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  experimental: true, // Required for message continuation
+});
+await stagehand.init();
+
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5-20250929",
+});
+
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com/products");
+
+// First execution: search for products
+const firstResult = await agent.execute({
+  instruction: "Search for wireless headphones and note the top 3 results",
+  maxSteps: 10,
+});
+
+console.log("First task:", firstResult.message);
+
+// Continue with the same context: ask follow-up
+const secondResult = await agent.execute({
+  instruction: "Now filter by price under $100 and tell me which of those 3 are still available",
+  maxSteps: 10,
+  messages: firstResult.messages, // Pass previous conversation
+});
+
+console.log("Follow-up:", secondResult.message);
+
+// Continue further: take action based on conversation history
+const thirdResult = await agent.execute({
+  instruction: "Add the cheapest one to the cart",
+  maxSteps: 10,
+  messages: secondResult.messages, // Chain the conversation
+});
+
+console.log("Final action:", thirdResult.message);
+```
+
+## Structured Output
+
+Define a Zod schema to receive structured data when the agent completes its task. This is useful when you need specific information extracted from the agent's execution, such as prices, dates, or other structured data.
+
+<Note>**Non-CUA agents only.** Structured output requires `experimental: true` and is not available with Computer Use Agents.</Note>
+
+<Tip>Use `.describe()` on schema fields to help the agent understand what data to extract.</Tip>
+
+<CodeGroup>
+```typescript Basic Usage
+import { z } from "zod";
+
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  experimental: true, // Required for structured output
+});
+await stagehand.init();
+
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5-20250929",
+});
+
+const page = stagehand.context.pages()[0];
+await page.goto("https://www.google.com/flights");
+
+const result = await agent.execute({
+  instruction: "Find the cheapest flight from NYC to LA for next week",
+  maxSteps: 20,
+  output: z.object({
+    price: z.string().describe("The price of the flight"),
+    airline: z.string().describe("The airline name"),
+    departureTime: z.string().describe("Departure time"),
+    arrivalTime: z.string().describe("Arrival time"),
+  }),
+});
+
+// Access the structured output
+console.log(result.output);
+// { price: "$199", airline: "Delta", departureTime: "8:00 AM", arrivalTime: "11:30 AM" }
+```
+
+```typescript Complex Schema
+const result = await agent.execute({
+  instruction: "Extract all items from the shopping cart",
+  output: z.object({
+    items: z.array(z.object({
+      name: z.string().describe("Product name"),
+      quantity: z.number().describe("Quantity in cart"),
+      unitPrice: z.string().describe("Price per item"),
+      totalPrice: z.string().describe("Total price for this item"),
+    })).describe("List of items in the cart"),
+    subtotal: z.string().describe("Cart subtotal before tax"),
+    tax: z.string().optional().describe("Tax amount if shown"),
+    total: z.string().describe("Final total"),
+  }),
+});
+
+console.log(`Found ${result.output?.items.length} items in cart`);
+console.log(`Total: ${result.output?.total}`);
+```
+
+```typescript With Streaming
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5-20250929",
+  stream: true,
+});
+
+const streamResult = await agent.execute({
+  instruction: "Find the top 3 search results",
+  output: z.object({
+    results: z.array(z.object({
+      title: z.string().describe("The title of the search result"),
+      url: z.string().url().describe("The URL of the search result"),
+      snippet: z.string().describe("A brief description or snippet"),
+    })).max(3).describe("Top 3 search results"),
+  }),
+});
+
+// Stream the text output
+for await (const delta of streamResult.textStream) {
+  process.stdout.write(delta);
+}
+
+// Get the structured output from the final result
+const finalResult = await streamResult.result;
+console.log(finalResult.output?.results);
+```
+</CodeGroup>
+
+## Agent Execution Configuration
+
+<Warning>
+Stagehand uses a 1288x711 viewport by default. Other viewport sizes may reduce performance. If you need to modify the viewport, you can edit in the [Browser Configuration](/v3/configuration/browser).
+</Warning>
+
+Control the maximum number of steps the agent can take to complete the task using the `maxSteps` parameter.
+
+<CodeGroup>
+```typescript TypeScript
+// Set maxSteps to control how many actions the agent can take
+await agent.execute({
+  instruction: "Sign me up for a library card",
+  maxSteps: 15 // Agent will stop after 15 steps if task isn't complete
+});
+```
+
+For complex tasks, increase the `maxSteps` limit and check task success.
+
+```typescript
+// Complex multi-step task requiring more actions
+const result = await agent.execute({
+  instruction: "Find and apply for software engineering jobs, filtering by remote work and saving 3 applications",
+  maxSteps: 30, // Higher limit for complex workflows
+});
+
+// Check if the task completed successfully
+if (result.success === true) {
+  console.log("Task completed successfully!");
+} else {
+  console.log("Task failed or was incomplete");
+}
+```
+</CodeGroup>
+
+## Best Practices
+
+Following these best practices will improve your agent's success rate, reduce execution time, and minimize unexpected errors during task completion.
+
+### Start on the Right Page
+Navigate to your target page before executing tasks:
+
+<Tabs>
+<Tab title="Do this">
+```typescript
+await page.goto('https://github.com/browserbase/stagehand');
+await agent.execute('Get me the latest PR on the stagehand repo');
+```
+</Tab>
+
+<Tab title="Don't do this">
+```typescript
+await agent.execute('Go to GitHub and find the latest PR on browserbase/stagehand');
+```
+</Tab>
+</Tabs>
+
+
+### Be Specific
+Provide detailed instructions for better results:
+
+<Tabs>
+<Tab title="Do this">
+```typescript
+await agent.execute("Find Italian restaurants in Brooklyn that are open after 10pm and have outdoor seating");
+```
+</Tab>
+
+<Tab title="Don't do this">
+```typescript
+await agent.execute("Find a restaurant");
+```
+</Tab>
+</Tabs>
+
+## Troubleshooting
+
+<AccordionGroup>
+
+
+<Accordion title="Agent is stopping before completing the task">
+**Problem**: Agent stops before finishing the requested task
+
+**Solutions**:
+- Check if the agent is hitting the maxSteps limit (default is 20)
+- Increase maxSteps for complex tasks: `maxSteps: 30` or higher
+- Break very complex tasks into smaller sequential executions
+
+```typescript
+// Increase maxSteps for complex tasks
+await agent.execute({
+  instruction: "Complete the multi-page registration form with all required information",
+  maxSteps: 40 // Increased limit for complex task
+});
+
+// Or break into smaller tasks with success checking
+const firstResult = await agent.execute({
+  instruction: "Fill out page 1 of the registration form", 
+  maxSteps: 15
+});
+
+// Only proceed if the first task was successful
+if (firstResult.success === true) {
+  await agent.execute({
+    instruction: "Navigate to page 2 and complete remaining fields",
+    maxSteps: 15
+  });
+} else {
+  console.log("First task failed, stopping execution");
+}
+```
+</Accordion>
+
+<Accordion title="Agent is failing to click the proper elements">
+**Problem**: Agent clicks on wrong elements or fails to interact with the correct UI components
+
+**Solutions**:
+- Ensure proper viewport size: Stagehand uses `1288x711` by default (optimal for Computer Use models)
+- Avoid changing viewport dimensions as other sizes may reduce performance
+</Accordion>
+
+
+</AccordionGroup>
+
+
+## Next steps
+
+<CardGroup cols={2}>
+<Card title="Act" icon="play" href="/v3/basics/act">
+  Execute actions efficiently using observe results
+</Card>
+
+<Card title="Extract" icon="download" href="/v3/basics/extract">
+  Extract structured data from observed elements
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v3/basics/evals.mdx b/packages/docs/v3/basics/evals.mdx
new file mode 100644
index 000000000..b670b9e5c
--- /dev/null
+++ b/packages/docs/v3/basics/evals.mdx
@@ -0,0 +1,294 @@
+---
+title: Evaluations & Metrics
+sidebarTitle: Evals
+description: Monitor performance, optimize costs, and evaluate LLM effectiveness
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+Evaluations help you understand how well your automation performs, which models work best for your use cases, and how to optimize for cost and reliability. This guide covers both monitoring your own workflows and running comprehensive evaluations.
+
+## Why Evaluations Matter
+
+- **Performance Optimization**: Identify which models and settings work best for your specific automation tasks
+- **Cost Control**: Track token usage and inference time to optimize spending
+- **Reliability**: Measure success rates and identify failure patterns
+- **Model Selection**: Compare different LLMs on real-world tasks to make informed decisions
+
+<Card
+  title="Live Model Comparisons"
+  icon="scale-balanced"
+  href="https://www.stagehand.dev/evals"
+>
+  View real-time performance comparisons across different LLMs on the [Stagehand Evals Dashboard](https://www.stagehand.dev/evals)
+</Card>
+
+## Comprehensive Evaluations
+
+Evaluations help you systematically test and improve your automation workflows. Stagehand provides both built-in evaluations and tools to create your own.
+
+### Evals CLI
+![Evals CLI](/media/evals-cli.png)
+
+<Tip>
+To run evals, you'll need to clone the [Stagehand repo](https://github.com/browserbase/stagehand) and set up the CLI.
+
+We recommend using [Braintrust](https://www.braintrust.dev/docs/) to help visualize evals results and metrics.
+</Tip>
+
+The Stagehand CLI provides a powerful interface for running evaluations. You can run specific evals, categories, or external benchmarks with customizable settings.
+
+Evals are grouped into:
+1. **Act Evals** - These are evals that test the functionality of the `act` method.
+2. **Extract Evals** - These are evals that test the functionality of the `extract` method.
+3. **Observe Evals** - These are evals that test the functionality of the `observe` method.
+4. **Combination Evals** - These are evals that test the functionality of the `act`, `extract`, and `observe` methods together.
+5. **Experimental Evals** - These are experimental custom evals that test the functionality of the stagehand primitives.
+6. **Agent Evals** - These are evals that test the functionality of `agent`.
+7. **(NEW) External Benchmarks** - Run external benchmarks like WebBench, GAIA, WebVoyager, OnlineMind2Web, and OSWorld.
+
+#### Installation
+
+<Steps> 
+<Step title="Install Dependencies">
+```bash
+# From the stagehand root directory
+pnpm install
+```
+</Step>
+
+<Step title="Build the CLI">
+```bash
+pnpm run build:cli
+```
+</Step>
+
+<Step title="Verify Installation">
+```bash
+evals help
+```
+</Step>
+</Steps>
+
+#### CLI Commands and Options
+
+##### Basic Commands
+
+```bash
+# Run all evals
+evals run all
+
+# Run specific category
+evals run act
+evals run extract
+evals run observe
+evals run agent
+
+# Run specific eval
+evals run extract/extract_text
+
+# List available evals
+evals list
+evals list --detailed
+
+# Configure defaults
+evals config
+evals config set env browserbase
+evals config set trials 5
+```
+
+##### Command Options
+
+- **`-e, --env`**: Environment (`local` or `browserbase`)
+- **`-t, --trials`**: Number of trials per eval (default: 3)
+- **`-c, --concurrency`**: Max parallel sessions (default: 10)
+- **`-m, --model`**: Model override
+- **`-p, --provider`**: Provider override
+- **`--api`**: Use Stagehand API instead of SDK
+
+##### Running External Benchmarks
+
+The CLI supports several industry-standard benchmarks:
+
+```bash
+# WebBench with filters
+evals run benchmark:webbench -l 10 -f difficulty=easy -f category=READ
+
+# GAIA benchmark
+evals run b:gaia -s 100 -l 25 -f level=1
+
+# WebVoyager
+evals run b:webvoyager -l 50
+
+# OnlineMind2Web
+evals run b:onlineMind2Web
+
+# OSWorld
+evals run b:osworld -f source=Mind2Web
+```
+
+#### Configuration Files
+
+You can view the specific evals in [`evals/tasks`](https://github.com/browserbase/stagehand/tree/main/packages/evals/tasks). Each eval is grouped into eval categories based on [`evals/evals.config.json`](https://github.com/browserbase/stagehand/blob/main/evals/evals.config.json).
+
+
+#### Viewing eval results
+![Eval results](/images/evals.png)
+
+Eval results are viewable on Braintrust. You can view the results of a specific eval by going to the Braintrust URL specified in the terminal when you run `npm run evals`.
+
+By default, each eval will run five times per model. The "Exact Match" column shows the percentage of times the eval was correct. The "Error Rate" column shows the percentage of times the eval errored out.
+
+You can use the Braintrust UI to filter by model/eval and aggregate results across all evals.
+
+## Creating Custom Evaluations
+
+### Step-by-Step Guide
+
+<Steps>
+<Step title="Create Evaluation File">
+Create a new file in `evals/tasks/your-eval.ts`:
+
+```typescript
+import { EvalTask } from '../types';
+
+export const customEvalTask: EvalTask = {
+  name: 'custom_task_name',
+  description: 'Test specific automation workflow',
+  
+  // Test setup
+  setup: async ({ page }) => {
+    await page.goto('https://example.com');
+  },
+  
+  // The actual test
+  task: async ({ stagehand, page }) => {
+    // Your automation logic
+    await stagehand.act({ action: 'click the login button' });
+    const result = await stagehand.extract({ 
+      instruction: 'Get the user name',
+      schema: { username: 'string' }
+    });
+    return result;
+  },
+  
+  // Validation
+  validate: (result, expected) => {
+    return result.username === expected.username;
+  },
+  
+  // Test cases
+  testCases: [
+    {
+      input: { /* test input */ },
+      expected: { username: 'john_doe' }
+    }
+  ],
+  
+  // Evaluation criteria
+  scoring: {
+    exactMatch: true,
+    timeout: 30000,
+    retries: 2
+  }
+};
+```
+</Step>
+
+<Step title="Add to Configuration">
+Update `evals/evals.config.json`:
+
+```json
+{
+  "categories": {
+    "custom": ["custom_task_name"],
+    "existing_category": ["custom_task_name"]
+  }
+}
+```
+</Step>
+
+<Step title="Run Your Evaluation">
+```bash
+# Test your custom evaluation
+evals run custom_task_name
+
+# Run the entire custom category
+evals run custom
+
+# Run with specific settings
+evals run custom_task_name -e browserbase -t 5 -m gpt-4o
+```
+</Step>
+</Steps>
+
+
+## Best Practices for Custom Evals
+
+<AccordionGroup>
+<Accordion title="Test Design Principles">
+- **Atomic**: Each test should validate one specific capability
+- **Deterministic**: Tests should produce consistent, measurable results
+- **Realistic**: Use real-world scenarios and websites
+- **Measurable**: Define clear success/failure criteria
+</Accordion>
+
+<Accordion title="Performance Optimization">
+- **Parallel Execution**: Design tests to run independently
+- **Resource Management**: Clean up after each test
+- **Timeout Handling**: Set appropriate timeouts for operations
+- **Error Recovery**: Handle failures gracefully
+</Accordion>
+
+<Accordion title="Data Quality">
+- **Ground Truth**: Establish reliable expected outcomes
+- **Edge Cases**: Test boundary conditions and error scenarios
+- **Statistical Significance**: Run multiple iterations for reliability
+- **Version Control**: Track changes to test cases over time
+</Accordion>
+</AccordionGroup>
+
+### Troubleshooting Evaluations
+<AccordionGroup>
+<Accordion title="Evaluation Timeouts">
+**Symptoms**: Tests fail with timeout errors
+
+**Solutions**:
+- Increase timeout in `taskConfig.ts`
+- Use faster models (Gemini 2.5 Flash, Claude Haiku 4.5)
+- Optimize test scenarios to be less complex
+- Check network connectivity to LLM providers
+</Accordion>
+
+<Accordion title="Inconsistent Results">
+**Symptoms**: Same test passes/fails randomly
+
+**Solutions**:
+- Set temperature to 0 for deterministic outputs
+- Increase repetitions for statistical significance
+- Use more capable models for complex tasks
+- Check for dynamic website content affecting tests
+</Accordion>
+
+<Accordion title="High Evaluation Costs">
+**Symptoms**: Token usage exceeding budget
+
+**Solutions**:
+- Use cost-effective models (Gemini 2.5 Flash, Claude Haiku 4.5)
+- Reduce repetitions for initial testing
+- Focus on specific evaluation categories
+- Use local browser environment to reduce Browserbase costs
+</Accordion>
+
+<Accordion title="Braintrust Integration Issues">
+**Symptoms**: Results not uploading to dashboard
+
+**Solutions**:
+- Check Braintrust API key configuration
+- Verify internet connectivity
+- Update Braintrust SDK to latest version
+- Check project permissions in Braintrust dashboard
+</Accordion>
+</AccordionGroup>
\ No newline at end of file
diff --git a/packages/docs/v3/basics/extract.mdx b/packages/docs/v3/basics/extract.mdx
new file mode 100644
index 000000000..e51ff0b3f
--- /dev/null
+++ b/packages/docs/v3/basics/extract.mdx
@@ -0,0 +1,360 @@
+---
+title: Extract
+description: Extract structured data from a webpage
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## What is `extract()`?
+
+```typescript
+await stagehand.extract("extract the name of the repository");
+```
+
+`extract()` grabs structured data from a webpage. You can define your schema with [Zod](https://github.com/colinhacks/zod) (TypeScript) or JSON. If you don't want to define a schema, you can also call `extract` with just a [natural language prompt](#instruction-only), or call `extract` [with no parameters](#no-parameters).
+
+## Why use `extract()`?
+
+<CardGroup cols={2}>
+  <Card title="Structured" icon="brackets-curly" href="#basic-schema">
+    Turn messy webpage data into clean objects that follow a schema.
+  </Card>
+  <Card title="Resilient" icon="dumbbell" href="#extract-with-context">
+    Build resilient extractions that don't break when the website changes
+  </Card>
+</CardGroup>
+
+## Return value
+
+When you use `extract()`, Stagehand will return a `Promise<ExtractResult>` with the following structure:
+<Tabs>
+<Tab title="Basic Schema">
+
+When extracting with a schema, the return type is inferred from your Zod schema:
+
+```typescript
+const result = await stagehand.extract(
+  "extract product details",
+  z.object({
+    name: z.string(),
+    price: z.number(),
+    inStock: z.boolean()
+  })
+);
+```
+
+**Example result:**
+```typescript
+{
+  name: "Wireless Mouse",
+  price: 29.99,
+  inStock: true
+}
+```
+
+</Tab>
+<Tab title="Array">
+
+When extracting an array, you get an array of objects:
+
+```typescript
+const apartments = await stagehand.extract(
+  "extract all apartment listings",
+  z.array(
+    z.object({
+      address: z.string(),
+      price: z.string(),
+      sqft: z.number()
+    })
+  )
+);
+```
+
+**Example result:**
+```typescript
+[
+  {
+    address: "123 Main St",
+    price: "$1,200/mo",
+    sqft: 750
+  },
+  {
+    address: "456 Oak Ave",
+    price: "$1,500/mo",
+    sqft: 900
+  }
+]
+```
+
+</Tab>
+<Tab title="Primitive">
+
+When extracting a single primitive value:
+
+```typescript
+const price = await stagehand.extract(
+  "extract the price",
+  z.number()
+);
+```
+
+**Example result:**
+```typescript
+19.99
+```
+
+You can also extract strings, booleans, etc.:
+
+```typescript
+const url = await stagehand.extract(
+  "extract the contact page link",
+  z.string().url()
+);
+```
+
+</Tab>
+<Tab title="Instruction Only">
+
+When calling with just an instruction (no schema):
+
+```typescript
+const result = await stagehand.extract("extract the repository name");
+```
+
+**Example result:**
+```typescript
+{
+  extraction: "stagehand"
+}
+```
+
+</Tab>
+<Tab title="No Parameters">
+
+When calling with no parameters:
+
+```typescript
+const result = await stagehand.extract();
+```
+
+**Example result:**
+```typescript
+{
+  pageText: "Accessibility Tree:\n[0-2] RootWebArea: Page Title\n  [0-37] scrollable\n    [0-118] body\n      ..."
+}
+```
+
+This returns the accessibility tree representation of the page without LLM processing.
+
+</Tab>
+</Tabs>
+
+## Advanced Configuration
+
+You can pass additional options to configure the model, timeout, and selector scope:
+```typescript
+const result = await stagehand.extract("extract the repository name", {
+  model: "anthropic/claude-sonnet-4-5",
+  timeout: 30000,
+  selector: "//header" // Focus on specific area
+});
+```
+
+### Server-side Caching
+
+<Note>
+`serverCache` only works when running with `env: "BROWSERBASE"`. It has no effect in local environments.
+</Note>
+
+When running on Browserbase, Stagehand automatically caches `extract()` results server-side. Repeated calls with the same inputs return instantly without consuming LLM tokens. Caching is enabled by default and can be controlled globally on the constructor or overridden per call:
+
+```typescript
+// Disable server-side caching for the entire instance
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  serverCache: false,
+});
+
+// Or disable it for a single call
+const data = await stagehand.extract("extract the repository name", { serverCache: false });
+
+// Check whether a result was served from cache
+const result = await stagehand.extract("extract the page title");
+console.log(result.cacheStatus); // "HIT" or "MISS"
+```
+
+### Targeted Extract
+
+Pass a selector to `extract` to target a specific element on the page.
+<Tip>
+This helps reduce the context passed to the LLM, optimizing token usage/speed and improving accuracy.
+</Tip>
+```typescript
+const tableData = await stagehand.extract(
+  "Extract the values of the third row",
+  z.object({
+    values: z.array(z.string())
+  }),
+  {
+    // xPath or CSS selector
+    selector: "xpath=/html/body/div/table/" 
+  }
+);
+```
+
+
+## Best practices
+
+
+### Extract with Context
+
+You can provide additional context to your schema to help the model extract the data more accurately.
+
+```typescript
+const apartments = await stagehand.extract(
+  "Extract ALL the apartment listings and their details, including address, price, and square feet.",
+  z.array(
+    z.object({
+      address: z.string().describe("the address of the apartment"),
+      price: z.string().describe("the price of the apartment"),
+      square_feet: z.string().describe("the square footage of the apartment"),
+    })
+  )
+);
+```
+
+### Link Extraction
+<Note>
+To extract links or URLs, define the relevant field as `z.string().url()`.
+</Note>
+
+Here is how an `extract` call might look for extracting a link or URL. This also works for image links.
+
+```typescript
+const contactLink = await stagehand.extract(
+  "extract the link to the 'contact us' page",
+  z.string().url() // note the usage of z.string().url() for URL validation
+);
+
+console.log("the link to the contact us page is: ", contactLink);
+```
+
+<Tip>
+Inside Stagehand, extracting links works by asking the LLM to select an ID. Stagehand looks up that ID in a mapping of IDs -> URLs. When logging the LLM trace, you should expect to see IDs. The actual URLs will be included in the final `ExtractResult`.
+</Tip>
+
+## Troubleshooting
+
+<AccordionGroup>
+<Accordion title="Empty or partial results">
+**Problem**: `extract()` returns empty or incomplete data
+
+**Solutions**:
+- **Check your instruction clarity**: Make sure your instruction is specific and describes exactly what data you want to extract
+- **Verify the data exists**: Use `stagehand.observe()` first to confirm the data is present on the page
+- **Wait for dynamic content**: If the page loads content dynamically, use `stagehand.act("wait for the content to load")` before extracting
+
+**Solution: Wait for content before extracting**
+```typescript
+// Wait for content before extracting
+await stagehand.act("wait for the product listings to load");
+const products = await stagehand.extract(
+  "extract all product names and prices",
+  z.array(z.object({
+    name: z.string(),
+    price: z.string()
+  }))
+);
+```
+</Accordion>
+
+<Accordion title="Schema validation errors">
+**Problem**: Getting schema validation errors or type mismatches
+
+**Solutions**:
+- **Use optional fields**: Make fields optional with `z.optional()` if the data might not always be present
+- **Use flexible types**: Consider using `z.string()` instead of `z.number()` for prices that might include currency symbols
+- **Add descriptions**: Use `.describe()` to help the model understand field requirements
+
+**Solution: More flexible schema**
+```typescript
+const schema = z.object({
+  price: z.string().describe("price including currency symbol, e.g., '$19.99'"),
+  availability: z.string().optional().describe("stock status if available"),
+  rating: z.number().optional()
+});
+```
+</Accordion>
+
+<Accordion title="Inconsistent results">
+**Problem**: Extraction results vary between runs
+
+**Solutions**:
+- **Be more specific in instructions**: Instead of "extract prices", use "extract the numerical price value for each item"
+- **Use context in schema descriptions**: Add field descriptions to guide the model
+- **Combine with observe**: Use `stagehand.observe()` to understand the page structure first
+
+**Solution: Validate with observe first**
+```typescript
+// First observe to understand the page structure
+const elements = await stagehand.observe("find all product listings");
+console.log("Found elements:", elements.map(e => e.description));
+
+// Then extract with specific targeting
+const products = await stagehand.extract(
+  "extract name and price from each product listing shown on the page",
+  z.array(z.object({
+    name: z.string().describe("the product title or name"),
+    price: z.string().describe("the price as displayed, including currency")
+  }))
+);
+```
+</Accordion>
+
+<Accordion title="Performance issues">
+**Problem**: Extraction is slow or timing out
+
+**Solutions**:
+- **Reduce scope**: Extract smaller chunks of data in multiple calls rather than everything at once
+- **Use targeted instructions**: Be specific about which part of the page to focus on
+- **Consider pagination**: For large datasets, extract one page at a time
+- **Increase timeout**: Use `timeoutMs` parameter for complex extractions
+
+**Solution: Break down large extractions**
+```typescript
+// Instead of extracting everything at once
+const allData = [];
+const pageNumbers = [1, 2, 3, 4, 5];
+
+for (const pageNum of pageNumbers) {
+  await stagehand.act(`navigate to page ${pageNum}`);
+
+  const pageData = await stagehand.extract(
+    "extract product data from the current page only",
+    z.array(z.object({
+      name: z.string(),
+      price: z.number()
+    })),
+    { timeout: 60000 } // 60 second timeout
+  );
+
+  allData.push(...pageData);
+}
+```
+</Accordion>
+</AccordionGroup>
+
+## Next steps
+
+<CardGroup cols={2}>
+
+  <Card title="Act" icon="play" href="/v3/basics/act">
+    Execute actions efficiently
+  </Card>
+
+  <Card title="Observe" icon="magnifying-glass" href="/v3/basics/observe">
+    Analyze pages and preview actions
+  </Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v3/basics/observe.mdx b/packages/docs/v3/basics/observe.mdx
new file mode 100644
index 000000000..21cdd8640
--- /dev/null
+++ b/packages/docs/v3/basics/observe.mdx
@@ -0,0 +1,340 @@
+---
+title: Observe
+sidebarTitle: Observe
+description: 'Discover and plan executable actions on any web page'
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## What is `observe()`?
+
+```typescript
+await stagehand.observe("find the login button");
+```
+
+`observe()` discovers actionable elements on a page and returns structured actions you can execute or validate before acting. Use it to explore pages, plan multi-step workflows, cache actions, and validate elements before acting.
+
+## Why use `observe()`?
+
+<CardGroup cols={2}>
+  <Card title="Explore" icon="compass" href="#using-observe">
+    Discover what's possible on a page—find buttons, forms, links, and interactive elements
+  </Card>
+  <Card title="Plan" icon="map" href="#plan-then-execute">
+    Map out multi-step workflows by discovering all required actions upfront
+  </Card>
+  <Card title="Cache" icon="database" href="/v3/best-practices/caching">
+    Store discovered actions to skip LLM calls and speed up repeated workflows
+  </Card>
+  <Card title="Validate" icon="check" href="#validate-before-acting">
+    Verify elements exist and check their properties before performing critical actions
+  </Card>
+</CardGroup>
+
+## Using `observe()`
+
+Use `observe()` to discover actionable elements on a page. Here's how to find a button:
+
+```typescript
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com");
+const actions = await stagehand.observe("find the learn more button");
+```
+
+<Note>
+**iFrame and Shadow DOM Support** Stagehand automatically handles iFrame traversal and shadow DOM elements without requiring additional configuration.
+</Note>
+
+<Accordion title="Common use cases">
+
+| Use Case | Example instruction |
+|----------|---------------------|
+| Find buttons | `find the submit button` |
+| Locate forms | `find all input fields in the form` |
+| Discover links | `find navigation links` |
+| Identify tables | `find the pricing table` |
+| Map workflows | `find all checkout steps` |
+| Validate elements | `find the delete account button` |
+
+</Accordion>
+
+
+### Return value of `observe()`?
+When you use `observe()`, Stagehand will return a `Promise<Action[]>` with the following structure:
+``` typescript
+[
+  {
+    description: 'Learn more button',
+    method: 'click',
+    arguments: [],
+    selector: 'xpath=/html[1]/body[1]/shadow-demo[1]//div[1]/button[1]'
+  }
+]
+```
+
+<Tabs>
+<Tab title="Do this">
+Use specific, descriptive instructions.
+
+```typescript
+// Clear and specific
+await stagehand.observe("find the primary call-to-action button in the hero section");
+await stagehand.observe("find all input fields in the checkout form");
+await stagehand.observe("find the delete account button in settings");
+```
+</Tab>
+
+<Tab title="Don't do this">
+Avoid vague or data-oriented queries.
+
+```typescript
+// Too vague
+await stagehand.observe("find buttons");
+
+// Use extract() for data instead
+await stagehand.observe("what is the page title?");
+```
+</Tab>
+</Tabs>
+
+## Advanced Configuration
+
+You can pass additional options to configure the model, timeout, and selector scope:
+
+```typescript
+// Custom model configuration
+const actions = await stagehand.observe("find navigation links", {
+  model: "openai/gpt-4o",
+  timeout: 30000,
+  selector: "//header" // Focus on specific area
+});
+```
+
+### Server-side Caching
+
+<Note>
+`serverCache` only works when running with `env: "BROWSERBASE"`. It has no effect in local environments.
+</Note>
+
+When running on Browserbase, Stagehand automatically caches `observe()` results server-side. Repeated calls with the same inputs return instantly without consuming LLM tokens. Caching is enabled by default and can be controlled globally on the constructor or overridden per call:
+
+```typescript
+// Disable server-side caching for the entire instance
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  serverCache: false,
+});
+
+// Or disable it for a single call
+const actions = await stagehand.observe("find the login button", { serverCache: false });
+```
+
+<Note>
+  `observe()` does not currently expose a `cacheStatus` field. To check whether an `observe()` call was served from cache, use the [Browserbase session replay dashboard](https://docs.browserbase.com/features/observability#stagehand) or inspect the session logs.
+</Note>
+
+### Using with Custom Pages
+
+You can use `observe()` with pages from other browser automation libraries like Puppeteer, Playwright, or Patchright by passing the `page` option:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+import puppeteer from "puppeteer-core";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+});
+await stagehand.init();
+
+// Connect with Puppeteer
+const browser = await puppeteer.connect({
+  browserWSEndpoint: stagehand.connectURL(),
+  defaultViewport: null,
+});
+
+const pages = await browser.pages();
+const customPage = pages[0];
+
+await customPage.goto("https://www.example.com/products");
+
+// Use observe with the custom Puppeteer page
+const actions = await stagehand.observe("find all product cards", {
+  page: customPage
+});
+```
+
+This works with:
+- **Puppeteer**: Pass Puppeteer Page objects
+- **Playwright**: Pass Playwright Page objects
+- **Patchright**: Pass Patchright Page objects
+- **Stagehand Context Pages**: Access pages via `stagehand.context.pages()` (default)
+
+<Card title="Complete API Reference" icon="book" href="/v3/references/observe">
+  See the full `observe()` reference for detailed parameter documentation, return values, and advanced examples.
+</Card>
+
+## Best practices
+
+### Plan then execute
+
+Discover all actions once, then execute without additional LLM calls. This approach is 2-3x faster than separate `act()` calls.
+
+```typescript
+const formFields = await stagehand.observe("find all form input fields");
+
+for (const field of formFields) {
+  await stagehand.act(field); // No LLM call
+}
+```
+
+<Card title="Analyze pages with observe()" icon="magnifying-glass" href="/v3/references/observe">
+  Complete guide to planning actions with `observe()`.
+</Card>
+
+### Scope extractions
+
+Use `observe()` to narrow extraction scope and reduce token usage by up to 10x.
+
+```typescript
+const [table] = await stagehand.observe("find the pricing table");
+
+const pricing = await stagehand.extract({
+  instruction: "extract all pricing tiers",
+  schema: PricingSchema,
+  selector: table.selector
+});
+```
+
+<Card title="Extract structured data" icon="table" href="/v3/basics/extract">
+  Learn how to use `observe()` with `extract()` for precise data extraction.
+</Card>
+
+### Validate before acting
+
+Check elements exist and verify their properties before performing critical operations.
+
+```typescript
+const [deleteButton] = await stagehand.observe("find the delete account button");
+
+if (deleteButton?.method === "click") {
+  await stagehand.act(deleteButton);
+} else {
+  throw new Error("Delete button not found");
+}
+```
+
+<Card title="Execute actions with act()" icon="play" href="/v3/basics/act">
+  Learn how to execute observed actions reliably.
+</Card>
+
+### Cache observed actions
+
+Store and reuse observed actions to eliminate redundant LLM calls. Build a simple cache:
+
+```typescript
+const actionCache = new Map<string, Action[]>();
+
+async function cachedObserve(instruction: string) {
+  if (actionCache.has(instruction)) {
+    return actionCache.get(instruction)!;
+  }
+
+  const actions = await stagehand.observe(instruction);
+  actionCache.set(instruction, actions);
+  return actions;
+}
+```
+
+<Card title="Complete caching guide" icon="database" href="/v3/best-practices/caching">
+  Learn advanced caching techniques and patterns for optimal performance.
+</Card>
+
+## Troubleshooting
+
+<AccordionGroup>
+
+<Accordion title="No elements found">
+**Problem**: `observe()` returns empty array
+
+**Solutions**:
+- Verify the element exists on the page
+- Use more specific instructions (e.g., "find the blue submit button" instead of "find button")
+- Ensure page has fully loaded before calling `observe()`
+- Enable verbose logging in Stagehand configuration to inspect detection behavior
+
+```typescript
+// Check page state before observing
+const page = stagehand.context.pages()[0];
+await page.waitForLoadState('domcontentloaded');
+
+const actions = await stagehand.observe("find the submit button");
+
+if (actions.length === 0) {
+  console.log("No elements found, trying alternative instruction");
+  const altActions = await stagehand.observe("find the button at the bottom of the form");
+}
+```
+</Accordion>
+
+<Accordion title="Inaccurate results">
+**Problem**: Descriptions or selectors don't match actual elements
+
+**Solutions**:
+- Use more capable models—check [model evals](https://stagehand.dev/evals) for recommendations
+- Provide more context in your instruction (e.g., "find the submit button in the checkout form")
+- Enable verbose logging and `logInferenceToFile` in Stagehand configuration to inspect LLM reasoning
+
+```typescript
+// More specific instructions improve accuracy
+// Instead of:
+await stagehand.observe("find the button");
+
+// Use context:
+await stagehand.observe("find the red 'Delete' button in the user settings panel");
+```
+</Accordion>
+
+<Accordion title="Wrong method suggested">
+**Problem**: The `method` field has an unexpected value
+
+**Solutions**:
+- Validate the method before using it: `if (action.method === "click") { ... }`
+- Check [supported actions](/v3/basics/act) for valid method names
+- Override with a specific method when needed: `await stagehand.act({ ...action, method: "click" })`
+
+```typescript
+const [action] = await stagehand.observe("find the submit button");
+
+// Validate method before acting
+const validMethods = ["click", "fill", "type", "press"];
+if (action && validMethods.includes(action.method || "")) {
+  await stagehand.act(action);
+} else {
+  console.warn(`Unexpected method: ${action?.method}`);
+}
+```
+</Accordion>
+
+</AccordionGroup>
+
+## Next steps
+
+<CardGroup cols={2}>
+  <Card title="Execute actions with act()" icon="play" href="/v3/basics/act">
+    Use `act()` to execute discovered actions reliably.
+  </Card>
+
+  <Card title="Extract structured data" icon="table" href="/v3/basics/extract">
+    Combine `observe()` with `extract()` for precise data extraction.
+  </Card>
+
+  <Card title="Caching actions" icon="bolt" href="/v3/best-practices/caching">
+    Build action caches to eliminate redundant LLM calls.
+  </Card>
+
+  <Card title="Complete API Reference" icon="book" href="/v3/references/observe">
+    Full `observe()` reference with detailed parameter documentation.
+  </Card>
+</CardGroup>
diff --git a/packages/docs/v3/best-practices/agent-fallbacks.mdx b/packages/docs/v3/best-practices/agent-fallbacks.mdx
new file mode 100644
index 000000000..ae03a08ca
--- /dev/null
+++ b/packages/docs/v3/best-practices/agent-fallbacks.mdx
@@ -0,0 +1,51 @@
+---
+title: Agent Fallbacks
+description: "A failsafe when unexpected page changes add extra steps"
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## When to use
+
+Use an agent fallback as a failsafe when a one step action unexpectedly becomes a multi-step flow.
+
+## How it works
+
+1. [`act()`](/v3/basics/act) is attempted for the direct action
+2. If it fails, [`agent()`](/v3/basics/agent) figures out the new path
+3. Agent completes all needed steps (open menu → click button)
+
+### Example scenario
+
+**Before**: Sign in button was in the header  
+**After**: Sign in now requires: Click account menu → Click "Sign in" option
+
+A single `act("click sign in")` can't handle this change. The agent fallback can discover and execute both steps.
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+try {
+  await stagehand.act("click the 'Sign In' button");
+} catch (err) {
+  console.log("Agent fallback triggered");
+
+  const agent = stagehand.agent({
+    model: "anthropic/claude-sonnet-4-20250514",
+    systemPrompt: "You are a helpful assistant that can use a web browser.",
+  });
+
+  const result = await agent.execute({
+    instruction: "Find and click Sign In button",
+    maxSteps: 10,
+  });
+
+  console.log(result.success ? "Agent fallback success" : "Agent fallback failed");
+
+  if (!result.success) throw err;
+}
+```
+
+See all available agent models on the [models page](/v3/configuration/models#agent-models-with-cua-support).
diff --git a/packages/docs/v3/best-practices/caching.mdx b/packages/docs/v3/best-practices/caching.mdx
new file mode 100644
index 000000000..e6f86b94b
--- /dev/null
+++ b/packages/docs/v3/best-practices/caching.mdx
@@ -0,0 +1,231 @@
+---
+title: Caching Actions
+description: Cache actions automatically to reduce costs and improve performance
+---
+
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+Stagehand supports two caching strategies to reduce LLM costs and speed up your automations: **Browserbase Cache** and **Local Cache**. They serve different use cases and can be used independently or together.
+
+---
+
+## Browserbase Cache
+
+Browserbase Cache is a managed, server-side caching layer built into the Stagehand API. When you run Stagehand with `env: "BROWSERBASE"`, every `act()` call is automatically cached on Browserbase's servers. Repeated calls with the same inputs return instantly without consuming any LLM tokens. You don't need to configure anything to start benefiting.
+
+The cache key is generated from the instruction, page content, and options you pass. On a cache hit, the response is returned directly from the server with no LLM inference and no token cost. You can inspect cache behavior via the `cacheStatus` field returned by `act()`. Check out the [Browserbase blog](https://www.browserbase.com/blog/stagehand-caching) for more details on how it works under the hood.
+
+### Disabling on the Constructor
+
+Pass `serverCache: false` to disable caching for all requests made by that instance:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  serverCache: false,
+});
+
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+await page.goto("https://example.com");
+
+// Cache is disabled, always hits the LLM
+await stagehand.act("click the login button");
+```
+
+### Disabling per Call
+
+Override the instance setting for a single call by passing `serverCache: false` in the options:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({ env: "BROWSERBASE" }); // caching on by default
+
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com");
+
+// This call skips the cache
+await stagehand.act("click the login button", { serverCache: false });
+
+// This call uses the cache as normal
+await stagehand.act("submit the form");
+```
+
+### Inspecting Cache Status
+
+`act()` returns a `cacheStatus` field you can use to verify whether a result was served from cache:
+
+```typescript
+const actResult = await stagehand.act("click the login button");
+console.log(actResult.cacheStatus); // "HIT" or "MISS"
+```
+
+### Limitations
+
+- The page URL factors in to the cache key. If the action is being made on a page with a dynamic URL, caching may not work as expected. We do filter out certain query parameters like referral trackers and analytics, but we don't catch everything just yet.
+- If the page content or structure changes, the action won't get a cache `HIT` and the LLM will be called. The subsequent actions will attempt to hit the resulting cache entry.
+
+---
+
+## Local Cache
+
+Local Cache writes action results to your filesystem so they persist across script runs. It works in both `LOCAL` and `BROWSERBASE` environments. When you specify a `cacheDir`, Stagehand saves every action and agent step to a local file on first run, then replays those cached actions on subsequent runs with no LLM calls, no token cost, and no network round-trip to Browserbase.
+
+This is especially useful for:
+
+- **CI/CD pipelines** - commit your cache directory to version control for consistent, deterministic runs across environments
+- **Local development** - iterate on automations without burning tokens on repeated runs
+- **Cross-machine sharing** - cache files are portable and can be shared across machines
+
+### Caching with `act()`
+
+Cache actions from `act()` by specifying a cache directory in your Stagehand constructor.
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "act-cache", // Specify a cache directory
+});
+
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+await page.goto("https://browserbase.github.io/stagehand-eval-sites/sites/iframe-same-proc-scroll/");
+
+// First run: uses LLM inference and caches
+// Subsequent runs: reuses cached action
+await stagehand.act("scroll to the bottom of the iframe");
+
+// Variables work with caching too
+await stagehand.act("fill the username field with %username%", {
+  variables: {
+    username: "fakeUsername",
+  },
+});
+```
+
+### Caching with `agent()`
+
+Cache agent actions (including Computer Use Agent actions) the same way. Just specify a `cacheDir`. The cache key is automatically generated based on the instruction, start URL, agent execution options, and agent configuration. Subsequent runs with the same parameters will reuse cached actions.
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "agent-cache", // Specify a cache directory
+});
+
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+await page.goto("https://browserbase.github.io/stagehand-eval-sites/sites/drag-drop/");
+
+const agent = stagehand.agent({
+  mode: "cua",
+  model: {
+    modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+    apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY
+  },
+  systemPrompt: "You are a helpful assistant that can use a web browser.",
+});
+
+await page.goto("https://play2048.co/");
+
+// First run: uses LLM inference and caches
+// Subsequent runs: reuses cached actions
+const result = await agent.execute({
+  instruction: "play a game of 2048",
+  maxSteps: 20,
+});
+
+console.log(JSON.stringify(result, null, 2));
+```
+
+### Cache Directory Organization
+
+You can organize your caches by using different directory names for different workflows:
+
+```typescript
+// Separate caches for different parts of your automation
+const loginStagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "cache/login-flow"
+});
+
+const checkoutStagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "cache/checkout-flow"
+});
+
+const dataExtractionStagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "cache/data-extraction"
+});
+```
+
+### Best Practices
+
+<AccordionGroup>
+
+<Accordion title="Use descriptive cache directories">
+Organize caches by workflow or feature for easier management:
+
+```typescript
+// Good: descriptive cache names
+cacheDir: "cache/login-actions"
+cacheDir: "cache/search-actions"
+cacheDir: "cache/form-submissions"
+
+// Avoid: generic cache names
+cacheDir: "cache"
+cacheDir: "my-cache"
+```
+</Accordion>
+
+<Accordion title="Clear cache when DOM changes">
+If the website structure changes significantly, clear your cache directory to force fresh inference:
+
+```bash
+rm -rf cache/login-actions
+```
+
+Or programmatically:
+
+```typescript
+import { rmSync } from 'fs';
+
+// Clear cache before running if needed
+if (shouldClearCache) {
+  rmSync('cache/login-actions', { recursive: true, force: true });
+}
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "cache/login-actions"
+});
+```
+</Accordion>
+
+<Accordion title="Commit cache for CI/CD">
+Consider committing your cache directory to version control for consistent behavior across environments:
+
+```gitignore
+# .gitignore
+# Don't ignore cache directories
+!cache/
+```
+
+This ensures your CI/CD pipelines use the same cached actions without needing to run inference on first execution.
+</Accordion>
+
+</AccordionGroup>
diff --git a/packages/docs/v3/best-practices/computer-use.mdx b/packages/docs/v3/best-practices/computer-use.mdx
new file mode 100644
index 000000000..b4a4d038d
--- /dev/null
+++ b/packages/docs/v3/best-practices/computer-use.mdx
@@ -0,0 +1,194 @@
+---
+title: Computer Use Agents
+description: Incorporate Computer Use APIs from Google, Anthropic, OpenAI, and Microsoft with one line of code in Stagehand.
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## What is a Computer Use Agent?
+
+<iframe
+  width="100%"
+  height="400"
+  src="https://www.youtube.com/embed/ODaHJzOyVCQ"
+  title="YouTube video player"
+  frameborder="0"
+  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+  allowfullscreen
+></iframe>
+You might've heard of [Gemini Computer Use](https://blog.google/technology/google-deepmind/gemini-computer-use-model/), [Claude Computer Use](https://www.anthropic.com/news/3-5-models-and-computer-use), or [OpenAI's Computer Using Agent](https://openai.com/index/computer-using-agent/).
+
+These are powerful tools that can convert natural language into actions on the computer. However, you'd otherwise need to write your own code to convert these actions into Playwright commands.
+
+Stagehand not only handles the execution of Computer Use outputs, but also lets you hot-swap between Google, OpenAI, Anthropic, and Microsoft models with one line of code. You can find more information on the performance of different computer use models by visiting our [evals page](https://www.stagehand.dev/agent-evals).
+
+## How to use a Computer Use Agent in Stagehand
+
+Stagehand lets you use Computer Use Agents with one line of code:
+
+<Warning>
+**Deprecation Notice:** The `cua: true` option is deprecated and will be removed in a future version. Use `mode: "cua"` instead.
+</Warning>
+
+<Note>
+**IMPORTANT! Configure your browser dimensions**
+
+Computer Use Agents will often return XY-coordinates to click on the screen, so you'll need to configure your browser dimensions.
+
+If not specified, the default browser dimensions are 1288 x 711. You can also configure the browser dimensions in the `browserbaseSessionCreateParams` or `localBrowserLaunchOptions` options.
+</Note>
+
+
+### Configuring browser dimensions
+
+Browser configuration differs by environment:
+
+<Tabs>
+<Tab title="BROWSERBASE">
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+	env: "BROWSERBASE",
+    model: "google/gemini-2.5-flash",
+  
+    browserbaseSessionCreateParams: {
+      projectId: process.env.BROWSERBASE_PROJECT_ID!,
+      browserSettings: {
+		blockAds: true,
+        viewport: {
+          width: 1288,
+          height: 711,
+        },
+      },
+  	},
+});
+
+await stagehand.init();
+```
+</Tab>
+<Tab title="LOCAL">
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  localBrowserLaunchOptions: {
+    headless: false,
+    viewport: {
+      width: 1288,
+      height: 711,
+    },
+  }
+});
+
+await stagehand.init();
+```
+</Tab>
+</Tabs>
+
+### Direct your Computer Use Agent
+
+Call `execute` on the agent to assign a task to the agent.
+
+<CodeGroup>
+```typescript Google
+await page.goto("https://www.google.com/");
+const agent = stagehand.agent({
+    mode: "cua",
+    model: {
+        modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+        apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY
+    },
+    systemPrompt: "You are a helpful assistant...",
+});
+
+await agent.execute({
+    instruction: "Go to Hacker News and find the most controversial post from today, then read the top 3 comments and summarize the debate.",
+    maxSteps: 20,
+    highlightCursor: true
+})
+```
+
+```typescript OpenAI
+await page.goto("https://www.google.com/");
+const agent = stagehand.agent({
+    mode: "cua",
+    model: {
+        modelName: "openai/computer-use-preview",
+        apiKey: process.env.OPENAI_API_KEY
+    },
+    systemPrompt: "You are a helpful assistant...",
+});
+
+await agent.execute({
+    instruction: "Go to Hacker News and find the most controversial post from today, then read the top 3 comments and summarize the debate.",
+    maxSteps: 20,
+    highlightCursor: true
+})
+```
+```typescript Anthropic
+await page.goto("https://www.google.com/");
+const agent = stagehand.agent({
+    mode: "cua",
+    model: {
+        modelName: "anthropic/claude-sonnet-4-20250514",
+        apiKey: process.env.ANTHROPIC_API_KEY
+    },
+    systemPrompt: "You are a helpful assistant...",
+});
+
+await agent.execute({
+    instruction: "Go to Hacker News and find the most controversial post from today, then read the top 3 comments and summarize the debate.",
+    maxSteps: 20,
+    highlightCursor: true
+})
+```
+</CodeGroup>
+
+You can define the maximum number of steps the agent can take with `maxSteps`:
+
+```typescript
+await agent.execute({
+	instructions: "Apply for a library card at the San Francisco Public Library",
+	maxSteps: 10,
+});
+``` 
+
+### Select Your Computer Use Model
+
+Stagehand supports computer use models from Google, Anthropic, OpenAI, and Microsoft. You can find all supported models on the [models page](/v3/configuration/models#agent-models-with-cua-support).
+
+<Tabs>
+<Tab title="Google">
+```typescript
+const agent = stagehand.agent({
+    mode: "cua",
+    model: "google/gemini-2.5-computer-use-preview-10-2025",
+    // GOOGLE_GENERATIVE_AI_API_KEY is auto-loaded - set in your .env
+});
+```
+</Tab>
+<Tab title="Anthropic">
+```typescript
+const agent = stagehand.agent({
+    mode: "cua",
+    model: "anthropic/claude-sonnet-4-20250514",
+    // ANTHROPIC_API_KEY is auto-loaded - set in your .env
+});
+```
+</Tab>
+<Tab title="OpenAI">
+```typescript
+const agent = stagehand.agent({
+    mode: "cua",
+    model: "openai/computer-use-preview",
+    // OPENAI_API_KEY is auto-loaded - set in your .env
+});
+```
+</Tab>
+</Tabs>
+
+<Callout icon="code" color="#6ec202" iconType="regular">View or run the example templates [here](https://www.browserbase.com/templates?category=Computer+Use+Agents)</Callout>
diff --git a/packages/docs/v3/best-practices/cost-optimization.mdx b/packages/docs/v3/best-practices/cost-optimization.mdx
new file mode 100644
index 000000000..cc373447f
--- /dev/null
+++ b/packages/docs/v3/best-practices/cost-optimization.mdx
@@ -0,0 +1,183 @@
+---
+title: Cost Optimization  
+sidebarTitle: Cost Optimization
+description: Minimize costs while maintaining automation performance
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+Cost optimization in Stagehand involves balancing LLM inference costs and browser infrastructure costs. This guide provides practical strategies to reduce your automation expenses.
+
+## Quick Wins
+
+Start with these simple optimizations that can reduce costs:
+
+### 1. Use the Right Model for the Job
+
+We don't recommend using larger, more premium models for simple tasks. See our [evaluation results](https://stagehand.dev/evals) for model performance and cost comparisons across different task types.
+
+<CardGroup cols={2}>
+<Card title="Model Selection Guide" icon="brain" href="/configuration/models">
+  Choose the right LLM for your budget and accuracy requirements
+</Card>
+<Card title="Evaluation Results" icon="chart-line" href="https://www.stagehand.dev/evals">
+  See how different models perform on different tasks
+</Card>
+</CardGroup>
+
+### 2. Implement Caching
+
+Enable automatic action caching to eliminate redundant LLM calls. Simply specify a `cacheDir` when initializing Stagehand:
+
+```typescript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "action-cache", // Enable automatic caching
+});
+
+await stagehand.init();
+
+// First run: uses LLM inference and caches
+// Subsequent runs: reuses cached action (no LLM cost)
+await stagehand.act("Click the sign in button");
+```
+
+<CardGroup cols={1}>
+<Card title="Caching Guide" icon="database" href="/best-practices/caching">
+  Learn how to organize caches and manage cache directories
+</Card>
+</CardGroup>
+
+### 3. Optimize Browser Sessions
+
+Reuse sessions when possible and set appropriate timeouts. See [Browser Configuration](/configuration/browser) for details:
+
+```typescript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  browserbaseSessionCreateParams: {
+    timeout: 1800, // 30 minutes instead of default 1 hour
+    keepAlive: true, // Keep session alive between tasks
+  }
+});
+```
+
+<CardGroup cols={1}>
+<Card title="Browserbase Cost Optimization" icon="window-maximize" href="https://docs.browserbase.com/guides/cost-optimization">
+  Optimize Browserbase infrastructure costs and session management
+</Card>
+</CardGroup>
+
+## Advanced Strategies
+
+### Intelligent Model Switching
+
+Automatically fall back to cheaper models for simple tasks:
+
+```typescript
+// Use models from least to most expensive based on task complexity
+// See stagehand.dev/evals for performance comparisons
+async function smartAct(prompt: string) {
+  const models = ["google/gemini-2.5-flash", "openai/gpt-4o"];
+
+  for (const model of models) {
+    try {
+      const stagehand = new Stagehand({
+        env: "LOCAL",
+        model: model
+      });
+      await stagehand.init();
+      const [action] = await stagehand.observe(prompt);
+      await stagehand.act(action);
+      await stagehand.close();
+      return;
+    } catch (error) {
+      console.log(`Falling back to ${model}...`);
+      await stagehand.close();
+    }
+  }
+}
+```
+
+### Session Pooling
+
+Reuse browser sessions across multiple tasks:
+
+```typescript
+class SessionManager {
+  private sessions = new Map<string, Stagehand>();
+  
+  async getSession(taskType: string): Promise<Stagehand> {
+    if (this.sessions.has(taskType)) {
+      return this.sessions.get(taskType)!;
+    }
+    
+    const stagehand = new Stagehand({ env: "BROWSERBASE" });
+    await stagehand.init();
+    this.sessions.set(taskType, stagehand);
+    return stagehand;
+  }
+}
+```
+
+## Cost Monitoring
+
+Track your spending to identify optimization opportunities. See our [Observability Guide](/configuration/observability) for detailed metrics:
+
+```typescript
+// Monitor token usage
+const metrics = await stagehand.metrics;
+console.log(`Total tokens: ${metrics.totalPromptTokens + metrics.totalCompletionTokens}`);
+console.log(`Estimated cost: $${(metrics.totalPromptTokens + metrics.totalCompletionTokens) * 0.00001}`);
+```
+
+<CardGroup cols={1}>
+<Card title="Observability & Metrics" icon="chart-line" href="/configuration/observability">
+  Monitor usage patterns and track costs in real-time
+</Card>
+</CardGroup>
+
+## Budget Controls
+
+Set spending limits to prevent unexpected costs:
+
+```typescript
+class BudgetGuard {
+  private dailySpend = 0;
+  private maxDailyBudget: number;
+  
+  constructor(maxDailyBudget: number = 25) {
+    this.maxDailyBudget = maxDailyBudget;
+  }
+  
+  checkBudget(estimatedCost: number): void {
+    if (this.dailySpend + estimatedCost > this.maxDailyBudget) {
+      throw new Error(`Daily budget exceeded: $${this.maxDailyBudget}`);
+    }
+    this.dailySpend += estimatedCost;
+  }
+}
+```
+
+
+## Related Resources
+
+<CardGroup cols={2}>
+<Card title="Model Selection Guide" icon="brain" href="/configuration/models">
+  Choose the right LLM for your budget and accuracy requirements
+</Card>
+
+<Card title="Caching Strategies" icon="database" href="/best-practices/caching">
+  Reduce costs with smart action caching and observe patterns
+</Card>
+
+<Card title="Observability & Metrics" icon="chart-line" href="/configuration/observability">
+  Monitor usage patterns and track costs in real-time
+</Card>
+
+<Card title="Browser Configuration" icon="window-maximize" href="/configuration/browser">
+  Optimize Browserbase infrastructure costs and session management
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v3/best-practices/deployments.mdx b/packages/docs/v3/best-practices/deployments.mdx
new file mode 100644
index 000000000..346a1b080
--- /dev/null
+++ b/packages/docs/v3/best-practices/deployments.mdx
@@ -0,0 +1,240 @@
+---
+title: 'Deploying Stagehand'
+description: 'Deploy your AI agents and automations to the cloud'
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+<Tip>
+**🌟 Preview: Browser Functions** - Deploy your web automation code directly on Browserbase with browser functions. Scale your `act()` automations in the cloud with zero infrastructure setup. Reach out to hello@browserbase.com to get beta access.
+</Tip>
+
+## Deploy on Vercel
+
+Securely run Stagehand on Browserbase inside a Vercel Function. This guide shows a minimal, production-safe HTTP endpoint you can call directly or on a schedule.
+
+### 1. Install Vercel CLI
+
+To download and install Vercel CLI, run one of the following commands:
+
+<CodeGroup>
+```bash pnpm
+pnpm i -g vercel
+```
+```bash yarn
+yarn global add vercel
+```
+```bash npm
+npm i -g vercel
+```
+```bash bun
+bun add -g vercel
+```
+</CodeGroup>
+
+### 2. Project layout
+
+```text
+your-project/
+  api/
+    run.ts
+  package.json
+  tsconfig.json
+  vercel.json
+```
+
+Create the structure with:
+
+```bash
+mkdir -p api
+touch api/run.ts package.json vercel.json tsconfig.json
+```
+
+### 3. `api/run.ts` (Node.js runtime)
+
+```typescript
+// api/run.ts
+import type { VercelRequest, VercelResponse } from "@vercel/node";
+import { Stagehand } from "@browserbasehq/stagehand";
+import { z } from "zod";
+
+export default async function handler(req: VercelRequest, res: VercelResponse): Promise<void> {
+  try {
+    const stagehand = new Stagehand({
+      env: "BROWSERBASE",
+      apiKey: process.env.BROWSERBASE_API_KEY!,
+      projectId: process.env.BROWSERBASE_PROJECT_ID!,
+      disablePino: true,
+      model: {
+        modelName: "google/gemini-2.5-flash",
+        apiKey: process.env.GOOGLE_API_KEY!,
+      },
+      // optional session params
+      browserbaseSessionCreateParams: {
+        projectId: process.env.BROWSERBASE_PROJECT_ID!,
+        region: "us-west-2",
+        browserSettings: {
+          blockAds: true,
+        },
+      },
+    });
+
+    await stagehand.init();
+    const page = stagehand.context.pages()[0];
+
+    await page.goto("https://www.stagehand.dev/");
+    await stagehand.act("click the evals button");
+
+    const fastestModel = await stagehand.extract("extract the fastest model", z.string());
+
+    await stagehand.close();
+
+    res.status(200).json({ ok: true, data: fastestModel });
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    res.status(500).json({ ok: false, error: msg });
+  }
+}
+```
+
+### 4. `package.json`
+
+```json
+{
+    "name": "bb-stagehand-on-vercel",
+    "private": true,
+    "type": "module",
+    "engines": { "node": ">=18" },
+    "dependencies": {
+      "@browserbasehq/stagehand": "^3.0.0"
+    },
+    "devDependencies": {
+      "@types/node": "^20.12.12",
+      "@vercel/node": "^3.2.20",
+      "typescript": "^5.2.2"
+    }
+}
+```
+
+### 5. `tsconfig.json`
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "outDir": ".vercel/output/functions",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "include": ["api/**/*.ts"]
+}
+```
+
+### 6. `vercel.json`
+
+```json
+{
+  "$schema": "https://openapi.vercel.sh/vercel.json",
+  "functions": {
+    "api/run.ts": {
+      "maxDuration": 60
+    }
+  }
+}
+```
+
+See Vercel's [configuring functions](https://vercel.com/docs/functions/configuring-functions) docs for more details.
+
+### 7. Link your project
+
+Link your local folder to a Vercel project before configuring environment variables:
+
+```bash
+# authenticate if needed
+vercel login
+
+# link the current directory to a Vercel project (interactive)
+vercel link
+```
+
+### 8. Environment variables
+
+Do not commit `.env` in production. Add variables via Vercel CLI:
+
+```bash
+vercel env add BROWSERBASE_API_KEY
+vercel env add BROWSERBASE_PROJECT_ID
+# (and your model key if needed)
+vercel env add GOOGLE_API_KEY
+```
+
+See also: [Browser Environment](/configuration/environment) for details on required variables.
+
+### 9. Test locally
+
+Replicate the Vercel environment locally to exercise your Function before deploying. Run from the project root.
+
+```bash
+# ensure dependencies are installed
+npm install
+
+# start the local Vercel dev server
+vercel dev --listen 5005
+```
+
+### 10. Deploy
+
+```bash
+vercel
+vercel --prod
+```
+
+### Execute the function
+
+#### Configure Protection Bypass for Automation
+
+Before invoking the production URL, create a Protection Bypass for Automation:
+
+1. Generate a 32-character secret (you can use `openssl rand -hex 16`)
+2. Go to your project in Vercel
+3. Navigate to Settings → Deployment Protection
+4. Add the secret to "Protection Bypass for Automation"
+
+Then invoke the function with the bypass header:
+
+```bash
+curl -X POST \
+  -H "x-vercel-protection-bypass: <your-32-character-secret>" \
+  https://<your-deployment>/api/run
+```
+
+### Optional: Cron on Vercel
+
+Hit the same endpoint on a schedule by extending `vercel.json`:
+
+```json
+{
+  "$schema": "https://openapi.vercel.sh/vercel.json",
+  "functions": {
+    "api/run.ts": {
+      "maxDuration": 60
+    }
+  }
+  },
+  "crons": [
+    { "path": "/api/run", "schedule": "0 * * * *" }
+  ]
+}
+```
+
+### Features
+- **No local browsers needed** with `env: "BROWSERBASE"`. [Browserbase](https://www.browserbase.com/) provides the browsers.
+- **Fast functionality**: Offload browser work to Browserbase and return JSON promptly.
+- **Long-running tasks**: Raise `maxDuration` and/or consider Edge runtime limits depending on plan.
+
diff --git a/packages/docs/v3/best-practices/deterministic-agent.mdx b/packages/docs/v3/best-practices/deterministic-agent.mdx
new file mode 100644
index 000000000..8f0a05b43
--- /dev/null
+++ b/packages/docs/v3/best-practices/deterministic-agent.mdx
@@ -0,0 +1,573 @@
+---
+title: Deterministic Agent Scripts
+sidebarTitle: Deterministic Agent
+description: Use auto-caching to convert agent workflows into fast, deterministic scripts
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+Agent workflows are powerful for exploring and automating complex tasks, but they can be slow and non-deterministic. This guide shows you how to use Stagehand's built-in auto-caching to convert agent-discovered workflows into fast, deterministic scripts that run 10-100x faster.
+
+## Why Use Auto-Caching with Agent?
+
+<CardGroup cols={2}>
+  <Card title="Speed" icon="bolt">
+    Cached agent workflows run 10-100x faster by skipping LLM inference on subsequent runs
+  </Card>
+  <Card title="Cost" icon="dollar-sign">
+    Eliminate repeated LLM calls—first run uses inference, subsequent runs use cache
+  </Card>
+  <Card title="Reliability" icon="shield-check">
+    Cached actions are deterministic and more predictable than fresh agent exploration
+  </Card>
+  <Card title="Simplicity" icon="wand-magic-sparkles">
+    Works automatically—just specify `cacheDir` and Stagehand handles everything
+  </Card>
+</CardGroup>
+
+## How Auto-Caching Works
+
+When you specify a `cacheDir`:
+
+1. **First run**: Agent explores and executes workflow using LLM inference
+2. **Actions cached**: All actions are automatically saved to local cache
+3. **Subsequent runs**: Same workflow reuses cached actions (no LLM calls)
+4. **Performance**: 10-100x faster execution, zero LLM tokens
+
+The cache key is automatically generated based on:
+- Agent instruction
+- Start URL
+- Agent execution options
+- Agent configuration
+
+## Basic Auto-Caching with Agent
+
+Simply add `cacheDir` when initializing Stagehand:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+// Enable auto-caching
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "agent-cache" // Automatic caching enabled
+});
+
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+await page.goto("https://example.com");
+
+const agent = stagehand.agent({
+  mode: "cua",
+  model: {
+    modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+    apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY
+  },
+  systemPrompt: "You are a helpful assistant that can use a web browser.",
+});
+
+// First run: Uses LLM inference (~20-30 seconds, ~50,000 tokens)
+// Subsequent runs: Uses cached actions (~2-3 seconds, 0 tokens)
+const result = await agent.execute({
+  instruction: "Find the login form, fill in username 'demo' and password 'test123', then click submit",
+  maxSteps: 10
+});
+
+console.log("Completed:", result.success);
+console.log("Actions taken:", result.actions.length);
+
+await stagehand.close();
+```
+
+That's it! The second time you run this script, it will reuse the cached agent actions automatically.
+
+## Organizing Caches by Workflow
+
+Use descriptive cache directories for different workflows:
+
+```typescript
+// Login workflow
+const loginStagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "cache/login-workflow"
+});
+
+// Checkout workflow
+const checkoutStagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "cache/checkout-workflow"
+});
+
+// Data extraction workflow
+const extractStagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "cache/extraction-workflow"
+});
+```
+
+## Complete Example: First vs Subsequent Runs
+
+### First Run (Exploration Mode)
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "cache/github-search" // Enable caching
+});
+
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+await page.goto("https://github.com");
+
+const agent = stagehand.agent({
+  mode: "cua",
+  model: {
+    modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+    apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY
+  },
+  systemPrompt: "You are a helpful assistant that can use a web browser.",
+});
+
+console.log("First run: Exploring with agent...");
+const startTime = Date.now();
+
+const result = await agent.execute({
+  instruction: "Search for 'stagehand' and click the first repository result",
+  maxSteps: 10
+});
+
+const duration = Date.now() - startTime;
+console.log(`First run completed in ${duration}ms`);
+console.log(`Actions: ${result.actions.length}`);
+console.log(`Status: ${result.success}`);
+
+await stagehand.close();
+
+// Output (example):
+// First run completed in 25000ms
+// Actions: 8
+// Status: true
+```
+
+### Subsequent Runs (Cached Mode)
+
+Run the **exact same script** again:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "cache/github-search" // Same cache directory
+});
+
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+await page.goto("https://github.com");
+
+const agent = stagehand.agent({
+  mode: "cua",
+  model: {
+    modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+    apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY
+  },
+  systemPrompt: "You are a helpful assistant that can use a web browser.",
+});
+
+console.log("Subsequent run: Using cached actions...");
+const startTime = Date.now();
+
+const result = await agent.execute({
+  instruction: "Search for 'stagehand' and click the first repository result",
+  maxSteps: 10
+});
+
+const duration = Date.now() - startTime;
+console.log(`Subsequent run completed in ${duration}ms`);
+console.log(`Actions: ${result.actions.length}`);
+console.log(`Status: ${result.success}`);
+
+await stagehand.close();
+
+// Output (example):
+// Subsequent run completed in 2500ms  ← 10x faster!
+// Actions: 8
+// Status: true
+```
+
+## Using History for Analysis
+
+While caching handles execution automatically, you can still use `stagehand.history` to analyze what happened:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+import fs from "fs/promises";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "cache/workflow"
+});
+
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+await page.goto("https://example.com");
+
+const agent = stagehand.agent({
+  mode: "cua",
+  model: {
+    modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+    apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY
+  },
+  systemPrompt: "You are a helpful assistant that can use a web browser.",
+});
+
+await agent.execute({
+  instruction: "Complete the login process",
+  maxSteps: 10
+});
+
+// Analyze what the agent did
+const history = await stagehand.history;
+
+console.log(`\nWorkflow Analysis:`);
+console.log(`Total operations: ${history.length}`);
+
+const agentOps = history.filter(e => e.method === 'agent');
+const actOps = history.filter(e => e.method === 'act');
+const navOps = history.filter(e => e.method === 'navigate');
+
+console.log(`- Agent executions: ${agentOps.length}`);
+console.log(`- Act operations: ${actOps.length}`);
+console.log(`- Navigate operations: ${navOps.length}`);
+
+// Save for documentation
+await fs.writeFile(
+  'workflow-analysis.json',
+  JSON.stringify(history, null, 2)
+);
+
+await stagehand.close();
+```
+
+## Cache Management
+
+### Clear Cache When Site Changes
+
+If the website structure changes, clear the cache to force fresh exploration:
+
+```typescript
+import { rmSync } from 'fs';
+
+// Clear specific workflow cache
+rmSync('cache/login-workflow', { recursive: true, force: true });
+
+// Then run with fresh exploration
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "cache/login-workflow" // Will rebuild cache
+});
+```
+
+### Programmatic Cache Control
+
+```typescript
+import { rmSync, existsSync } from 'fs';
+
+function clearCacheIfNeeded(cacheDir: string, maxAge: number = 7 * 24 * 60 * 60 * 1000) {
+  if (!existsSync(cacheDir)) {
+    return; // No cache to clear
+  }
+
+  const stats = statSync(cacheDir);
+  const age = Date.now() - stats.mtimeMs;
+
+  if (age > maxAge) {
+    console.log(`Cache older than ${maxAge}ms, clearing...`);
+    rmSync(cacheDir, { recursive: true, force: true });
+  }
+}
+
+// Clear cache if older than 7 days
+clearCacheIfNeeded('cache/workflow');
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "cache/workflow"
+});
+```
+
+## Advanced Patterns
+ 
+### Fallback to Fresh Exploration
+
+Combine caching with fallback for resilience:
+
+```typescript
+async function executeWithFallback() {
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    cacheDir: "cache/workflow",
+    selfHeal: true // Enable self-healing
+  });
+
+  await stagehand.init();
+  const page = stagehand.context.pages()[0];
+
+  await page.goto("https://example.com");
+
+  const agent = stagehand.agent({
+    model: "anthropic/claude-sonnet-4-20250514"
+  });
+
+  try {
+    // Try with cache
+    const result = await agent.execute({
+      instruction: "Complete the checkout process",
+      maxSteps: 15
+    });
+
+    console.log("Execution successful:", result.success);
+  } catch (error) {
+    console.error("Cached workflow failed:", error);
+
+    // Clear cache and retry with fresh exploration
+    rmSync('cache/workflow', { recursive: true, force: true });
+
+    console.log("Retrying with fresh exploration...");
+    const retryResult = await agent.execute({
+      instruction: "Complete the checkout process",
+      maxSteps: 15
+    });
+
+    console.log("Retry successful:", retryResult.success);
+  }
+
+  await stagehand.close();
+}
+```
+
+### Version Control for Caches
+
+Commit cache directories to ensure consistent behavior across environments:
+
+```gitignore
+# .gitignore
+
+# Commit cache directories for deterministic CI/CD
+!cache/
+!cache/**/*.json
+```
+
+```typescript
+// CI/CD pipeline will use pre-generated cache
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "cache/production-workflow" // Committed to repo
+});
+```
+
+## Best Practices
+
+<AccordionGroup>
+
+<Accordion title="Use Descriptive Cache Names">
+Organize caches by workflow or feature:
+
+```typescript
+// Good: descriptive cache names
+cacheDir: "cache/user-registration"
+cacheDir: "cache/product-search"
+cacheDir: "cache/checkout-flow"
+
+// Avoid: generic names
+cacheDir: "cache"
+cacheDir: "my-cache"
+```
+</Accordion>
+
+<Accordion title="Cache Invalidation Strategy">
+Implement a strategy for refreshing caches:
+
+```typescript
+// Option 1: Time-based invalidation
+if (isCacheOlderThan('cache/workflow', 7)) {
+  clearCache('cache/workflow');
+}
+
+// Option 2: Version-based invalidation
+const CACHE_VERSION = 'v2';
+const cacheDir = `cache/workflow-${CACHE_VERSION}`;
+
+// Option 3: Manual invalidation flag
+if (process.env.CLEAR_CACHE === 'true') {
+  clearCache('cache/workflow');
+}
+```
+</Accordion>
+
+<Accordion title="Test in Staging First">
+Always test cached workflows in staging before production:
+
+```typescript
+const env = process.env.NODE_ENV === 'production' ? 'production' : 'staging';
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: `cache/${env}-workflow`
+});
+```
+</Accordion>
+
+<Accordion title="Monitor Cache Hit Rates">
+Track cache usage for optimization:
+
+```typescript
+const cacheHit = existsSync('cache/workflow') &&
+                statSync('cache/workflow').mtimeMs < Date.now();
+
+if (cacheHit) {
+  console.log("Cache hit - using cached workflow");
+} else {
+  console.log("Cache miss - exploring with agent");
+}
+
+// Log metrics
+metrics.recordCacheHit(cacheHit);
+```
+</Accordion>
+
+</AccordionGroup>
+
+## Performance Comparison
+
+**Without Caching (Every Run):**
+```typescript
+const stagehand = new Stagehand({ env: "BROWSERBASE" });
+// No cacheDir specified
+
+const result = await agent.execute({
+  instruction: "Complete workflow",
+  maxSteps: 10
+});
+
+// Every run: ~20-30 seconds, ~50,000 tokens
+```
+
+**With Auto-Caching (First Run):**
+```typescript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "cache/workflow"
+});
+
+const result = await agent.execute({
+  instruction: "Complete workflow",
+  maxSteps: 10
+});
+
+// First run: ~20-30 seconds, ~50,000 tokens (cached for next time)
+```
+
+**With Auto-Caching (Subsequent Runs):**
+```typescript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "cache/workflow" // Reuses cache
+});
+
+const result = await agent.execute({
+  instruction: "Complete workflow",
+  maxSteps: 10
+});
+
+// Subsequent runs: ~2-3 seconds, 0 tokens ← 10-100x faster!
+```
+
+<Note>
+Cached agent workflows run **10-100x faster** and consume **zero LLM tokens** on subsequent runs. The first run pays the exploration cost, every run after is nearly instant.
+</Note>
+
+## Troubleshooting
+
+<AccordionGroup>
+<Accordion title="Cache not being used">
+**Problem**: Workflow still slow on subsequent runs
+
+**Solutions**:
+- Verify `cacheDir` path is correct and consistent across runs
+- Ensure instruction, URL, and agent config are identical
+- Check file permissions on cache directory
+- Look for cache hit/miss logs in verbose mode
+
+```typescript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "cache/workflow",
+  verbose: 2 // Enable debug logs
+});
+```
+</Accordion>
+
+<Accordion title="Cached workflow fails">
+**Problem**: Cached actions fail on subsequent runs
+
+**Solutions**:
+- Website may have changed—clear cache to re-explore
+- Enable self-healing to adapt to minor changes
+- Implement fallback logic to retry with fresh exploration
+
+```typescript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  cacheDir: "cache/workflow",
+  selfHeal: true // Adapt to changes
+});
+```
+</Accordion>
+
+<Accordion title="Too many cache directories">
+**Problem**: Cache directories growing uncontrolled
+
+**Solutions**:
+- Use version prefixes for cache directories
+- Implement automatic cleanup of old caches
+- Share cache directories for similar workflows
+
+```typescript
+// Versioned caches
+const CACHE_VERSION = '2024-01';
+const cacheDir = `cache/workflow-${CACHE_VERSION}`;
+
+// Cleanup old versions
+rmSync('cache/workflow-2023-12', { recursive: true, force: true });
+```
+</Accordion>
+</AccordionGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Agent Guide" icon="robot" href="/v3/basics/agent">
+    Learn more about agent capabilities and configuration
+  </Card>
+
+  <Card title="Caching Guide" icon="database" href="/v3/best-practices/caching">
+    Complete guide to auto-caching with act() and agent()
+  </Card>
+
+  <Card title="Observability" icon="chart-line" href="/v3/configuration/observability">
+    Monitor and track history and metrics
+  </Card>
+
+  <Card title="Speed Optimization" icon="bolt" href="/v3/best-practices/speed-optimization">
+    Additional techniques for faster automation
+  </Card>
+</CardGroup>
diff --git a/packages/docs/v3/best-practices/history.mdx b/packages/docs/v3/best-practices/history.mdx
new file mode 100644
index 000000000..f174ae37a
--- /dev/null
+++ b/packages/docs/v3/best-practices/history.mdx
@@ -0,0 +1,189 @@
+---
+title: History Tracking
+sidebarTitle: History Tracking
+description: Track and analyze Stagehand operations with the history API
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+The history API captures every Stagehand operation for debugging, auditing, and workflow analysis.
+
+## Basic Usage
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({ env: "BROWSERBASE" });
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+await page.goto("https://example.com");
+await stagehand.act("click login button");
+
+// Get complete history
+const history = await stagehand.history;
+
+console.log(`Total operations: ${history.length}`);
+history.forEach((entry, i) => {
+  console.log(`${i + 1}. ${entry.method} at ${entry.timestamp}`);
+});
+
+await stagehand.close();
+```
+
+## History Entry Structure
+
+```typescript
+interface HistoryEntry {
+  method: "act" | "extract" | "observe" | "navigate" | "agent";
+  parameters: unknown;  // Input parameters
+  result: unknown;      // Output/result
+  timestamp: string;    // ISO 8601 timestamp
+}
+```
+
+## Common Use Cases
+
+### Debugging Failures
+
+```typescript
+try {
+  await stagehand.act("click login button");
+} catch (error) {
+  const history = await stagehand.history;
+
+  history.forEach((entry, i) => {
+    const status = entry.result && 'error' in entry.result ? "FAILED" : "SUCCESS";
+    console.log(`${i + 1}. ${status} - ${entry.method}`);
+  });
+}
+```
+
+### Analyzing Timing
+
+```typescript
+const history = await stagehand.history;
+
+const timings = history.map((entry, i) => {
+  if (i === 0) return null;
+  const duration = new Date(entry.timestamp).getTime() -
+                   new Date(history[i - 1].timestamp).getTime();
+  return { operation: entry.method, duration };
+}).filter(Boolean);
+
+console.log("Slowest operations:",
+  timings.sort((a, b) => b.duration - a.duration).slice(0, 3)
+);
+```
+
+### Operation Statistics
+
+```typescript
+const history = await stagehand.history;
+
+const stats = history.reduce((acc, entry) => {
+  acc[entry.method] = (acc[entry.method] || 0) + 1;
+  return acc;
+}, {} as Record<string, number>);
+
+console.log("Operations:", stats);
+// { act: 5, extract: 2, observe: 3, navigate: 1 }
+```
+
+### Saving History
+
+```typescript
+import fs from "fs/promises";
+
+const history = await stagehand.history;
+const metrics = await stagehand.metrics;
+
+await fs.writeFile(
+  `workflow-report.json`,
+  JSON.stringify({
+    history,
+    totalOps: history.length,
+    totalTokens: metrics.totalPromptTokens + metrics.totalCompletionTokens
+  }, null, 2)
+);
+```
+
+## Filtering by Operation Type
+
+```typescript
+const history = await stagehand.history;
+
+const actions = history.filter(e => e.method === 'act');
+const extractions = history.filter(e => e.method === 'extract');
+const agentOps = history.filter(e => e.method === 'agent');
+
+console.log(`Actions: ${actions.length}`);
+console.log(`Extractions: ${extractions.length}`);
+console.log(`Agent executions: ${agentOps.length}`);
+```
+
+## Combining with Metrics
+
+```typescript
+const history = await stagehand.history;
+const metrics = await stagehand.metrics;
+
+const report = {
+  totalOps: history.length,
+  successful: history.filter(e => !e.result || !('error' in e.result)).length,
+  failed: history.filter(e => e.result && 'error' in e.result).length,
+  totalTokens: metrics.totalPromptTokens + metrics.totalCompletionTokens,
+  avgTimePerOp: `${(metrics.totalInferenceTimeMs / history.length).toFixed(0)}ms`
+};
+
+console.log(report);
+```
+
+<Card title="Observability Guide" icon="chart-line" href="/configuration/observability">
+  Learn more about metrics, logging, and monitoring
+</Card>
+
+## What's Tracked?
+
+Only Stagehand methods are tracked in history:
+
+```typescript
+// Tracked
+await stagehand.act("click button");              // ✓
+await stagehand.extract({ instruction: "..." }); // ✓
+await stagehand.observe("find elements");         // ✓
+await page.goto("https://example.com");      // ✓
+
+// Not tracked
+await page.locator("button").click();        // ✗ Native Playwright
+await page.click("button");                  // ✗ Native Playwright
+```
+
+## Best Practices
+
+- **Save history for critical workflows** - Maintain audit trails for production
+- **Inspect history when debugging** - Check the last operations to identify failures
+- **Analyze timing periodically** - Find slow operations and optimize
+- **Combine with metrics** - Get complete visibility into performance and cost
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Deterministic Agent" icon="robot" href="/best-practices/deterministic-agent">
+    Build fast, cached agent workflows
+  </Card>
+
+  <Card title="Observability" icon="chart-line" href="/configuration/observability">
+    Combine history with metrics
+  </Card>
+
+  <Card title="Caching" icon="database" href="/best-practices/caching">
+    Speed up workflows with caching
+  </Card>
+
+  <Card title="Logging" icon="file-lines" href="/configuration/logging">
+    Configure detailed execution traces
+  </Card>
+</CardGroup>
diff --git a/packages/docs/v3/best-practices/mcp-integrations.mdx b/packages/docs/v3/best-practices/mcp-integrations.mdx
new file mode 100644
index 000000000..b2d6e4e66
--- /dev/null
+++ b/packages/docs/v3/best-practices/mcp-integrations.mdx
@@ -0,0 +1,290 @@
+---
+title: "MCP Integrations"
+description: "Using Model Context Protocol (MCP) integrations to enhance agent capabilities"
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## What are MCP Integrations?
+
+MCP (Model Context Protocol) integrations allow you to connect your Stagehand agents to external tools, APIs, and services. This enables agents to perform actions beyond browser automation, such as web search, database operations, and API calls.
+
+<Info>
+MCP integrations make your agents more powerful by combining browser automation with external capabilities. The agent can intelligently decide when to use browser actions versus external tools.
+</Info>
+
+## Connection Options
+
+There are two options for connecting to MCP servers:
+
+1. **Pass a URL directly** - The simplest approach for quick setup
+2. **Create a connection first** - Gives you more control over the connection
+
+<Note>
+MCP client support is currently only available in TypeScript.
+</Note>
+
+## Passing a URL
+
+The simplest way to add MCP integrations is by providing server URLs directly in the agent configuration:
+
+```typescript
+const agent = stagehand.agent({
+  provider: "openai",
+  model: "computer-use-preview",
+  integrations: [
+    `https://mcp.exa.ai/mcp?exaApiKey=${process.env.EXA_API_KEY}`,
+  ],
+  systemPrompt: `You have access to web search through Exa. Use it to find current information before browsing.`,
+  options: {
+    apiKey: process.env.OPENAI_API_KEY,
+  },
+});
+
+await agent.execute("Search for the best headphones of 2025 and go through checkout for the top recommendation");
+```
+
+## Creating a Connection First
+
+Alternatively, you can establish MCP connections first and then pass the client objects:
+
+```typescript
+import { connectToMCPServer } from "@browserbasehq/stagehand";
+
+// Connect to MCP server
+const supabaseClient = await connectToMCPServer(
+  `https://server.smithery.ai/@supabase-community/supabase-mcp/mcp?api_key=${process.env.SMITHERY_API_KEY}`
+);
+
+// You can also pass the config to start a local MCP server
+const notionClient = await connectToMCPServer({
+  command: "npx",
+  args: ["-y", "@notionhq/notion-mcp-server"],
+  env: {
+    NOTION_TOKEN: process.env.NOTION_TOKEN,
+  },
+});
+
+// Use the connected clients (example with Supabase + Notion)
+const agent = stagehand.agent({
+  provider: "openai", 
+  model: "computer-use-preview",
+  integrations: [supabaseClient, notionClient],
+  systemPrompt: `You can interact with Supabase databases and Notion. Use these tools to store and retrieve data.`,
+  options: {
+    apiKey: process.env.OPENAI_API_KEY,
+  },
+});
+
+await agent.execute("Search for restaurants in New Brunswick, NJ and save the first result to the database");
+```
+
+## Authenticated MCP Servers
+
+Some MCP servers require authentication via HTTP request headers. You can pass request headers through `requestOptions`:
+
+```typescript
+const authenticatedClient = await connectToMCPServer({
+  serverUrl: "https://mcp-server.example.com/mcp",
+  requestOptions: {
+    requestInit: {
+      headers: {
+        Authorization: `Bearer ${process.env.MCP_SERVER_API_KEY}`,
+      },
+    },
+  },
+});
+```
+
+
+
+## Multiple Integrations
+
+You can combine multiple MCP integrations in a single agent:
+
+```typescript
+const databaseClient = await connectToMCPServer(/* database config */);
+
+const agent = stagehand.agent({
+  integrations: [
+    `https://search-service.example.com/mcp?apiKey=${process.env.SEARCH_API_KEY}`,
+    databaseClient
+  ],
+  systemPrompt: `You have access to external tools for search and data storage. Use these tools strategically to complete tasks efficiently.`
+});
+```
+
+## Best Practices
+
+### Choose the Right Connection Approach
+<Tabs>
+<Tab title="Passing a URL">
+**When to use:**
+- Simple setup requirements
+- Standard API configurations
+- Getting started quickly
+
+**Benefits:**
+- Minimal code required
+- Automatic connection handling
+- Easy to configure
+</Tab>
+
+<Tab title="Creating a Connection First">
+**When to use:**
+- Custom connection options
+- Connection reuse across agents
+- Advanced error handling
+
+**Benefits:**
+- Full control over connections
+- Better error handling
+- Connection pooling capabilities
+</Tab>
+</Tabs>
+
+### Environment Variables
+
+Always use environment variables for API keys and sensitive information:
+
+```bash
+# .env file
+SEARCH_API_KEY=your_search_service_key
+MCP_SERVICE_API_KEY=your_mcp_service_key
+OPENAI_API_KEY=your_openai_key
+DATABASE_URL=your_database_url
+DATABASE_API_KEY=your_database_key
+```
+
+### Instructions Best Practices
+
+Provide clear instructions about available tools:
+
+<Tabs>
+<Tab title="Good Instructions">
+```typescript
+systemPrompt: `You have access to:
+1. Web search tools - Use to find current information
+2. Database tools - Use to store/retrieve data
+3. Browser automation - Use for web interactions
+
+Always search for current information before making decisions.
+Store important data for later reference.`
+```
+</Tab>
+
+<Tab title="Poor Instructions">
+```typescript
+systemPrompt: "You can search and save data."
+```
+</Tab>
+</Tabs>
+
+### Error Handling
+
+Implement proper error handling for MCP connections:
+
+```typescript
+try {
+  const client = await connectToMCPServer(serverUrl);
+  
+  const agent = stagehand.agent({
+    integrations: [client],
+    // ... other config
+  });
+  
+  const result = await agent.execute(instruction);
+} catch (error) {
+  console.error("MCP integration failed:", error);
+  // Handle fallback behavior
+}
+```
+
+## Troubleshooting
+
+<AccordionGroup>
+<Accordion title="Connection timeouts">
+**Problem:** MCP server connections timing out
+
+**Solutions:**
+- Verify server URLs are correct and accessible
+- Check network connectivity
+- Ensure API keys are valid and have proper permissions
+- Try connecting to servers individually to isolate issues
+</Accordion>
+
+<Accordion title="Tool not being used">
+**Problem:** Agent not using available MCP tools
+
+**Solutions:**
+- Make instructions more specific about when to use tools
+- Ensure API keys are properly configured
+- Check that the MCP server supports the expected tools
+- Verify tool descriptions are clear and actionable
+</Accordion>
+
+<Accordion title="Authentication errors">
+**Problem:** API key or authentication failures
+
+**Solutions:**
+- Verify all required environment variables are set
+- Check API key validity and permissions  
+- Ensure URLs include necessary authentication parameters
+- Test MCP connections independently before using in agents
+</Accordion>
+</AccordionGroup>
+
+## Examples
+
+### Web Search + Browser Automation
+```typescript
+const agent = stagehand.agent({
+  integrations: [`https://mcp.exa.ai/mcp?exaApiKey=${process.env.EXA_API_KEY}`],
+  systemPrompt: `First search for current information, then use the browser to complete tasks based on what you find.`
+});
+
+await agent.execute("Find the best laptop deals for 2025 and navigate to purchase the top recommendation");
+```
+
+### Data Extraction + Storage
+```typescript
+const supabaseClient = await connectToMCPServer(/* config */);
+
+const agent = stagehand.agent({
+  integrations: [supabaseClient],
+  systemPrompt: `Extract data from websites and store it using available database tools.`
+});
+
+await agent.execute("Extract all restaurant information from this directory and save it to the database");
+```
+
+### Multi-tool Workflow
+```typescript
+const agent = stagehand.agent({
+  integrations: [
+    `https://mcp.exa.ai/mcp?exaApiKey=${process.env.EXA_API_KEY}`,
+    supabaseClient
+  ],
+  systemPrompt: `Use all available tools strategically: search for current info, browse websites, and store important data.`
+});
+
+await agent.execute("Research competitor pricing, compare with our site, and store the analysis");
+```
+
+## Further Reading
+
+<CardGroup cols={3}>
+<Card title="Agent Basics" icon="robot" href="/basics/agent">
+  Learn the fundamentals of Stagehand agents
+</Card>
+
+<Card title="MCP Server Setup" icon="server" href="/integrations/mcp/setup">  
+  Set up your own MCP server
+</Card>
+
+<Card title="Custom Tools" icon="wrench" href="/integrations/mcp/tools">
+  Create custom MCP tools
+</Card>
+</CardGroup>
diff --git a/packages/docs/v3/best-practices/prompting-best-practices.mdx b/packages/docs/v3/best-practices/prompting-best-practices.mdx
new file mode 100644
index 000000000..174518881
--- /dev/null
+++ b/packages/docs/v3/best-practices/prompting-best-practices.mdx
@@ -0,0 +1,249 @@
+---
+title: Prompting Best Practices
+description: "Write effective prompts for reliable Stagehand automation"
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+Good prompts make Stagehand reliable. Bad prompts cause failures. Here's how to write prompts that work consistently.
+
+## Act Method
+
+Use `act()` for single actions on web pages. Each action should be focused and clear.
+
+```typescript
+// Good - Single, specific actions
+await stagehand.act("click the 'Add to Cart' button");
+await stagehand.act("type 'user@example.com' into the email field");
+
+// Bad - Multiple actions combined
+await stagehand.act("fill out the form and submit it");
+await stagehand.act("login with credentials and navigate to dashboard");
+```
+
+### Use Element Types, Not Colors
+
+Describe elements by their type and function rather than visual attributes like color.
+
+```typescript
+// Good - Element types and descriptive text
+await stagehand.act("click the 'Sign In' button");
+await stagehand.act("type into the email input field");
+
+// Bad - Color-based descriptions
+await stagehand.act("click the blue button");
+await stagehand.act("type into the white input");
+```
+
+### Use Descriptive Language
+
+```typescript
+// Good - Clear element identification
+await stagehand.act("click the 'Next' button at the bottom of the form");
+await stagehand.act("type into the search bar at the top of the page");
+
+// Bad - Vague descriptions
+await stagehand.act("click next");
+await stagehand.act("type into search");
+```
+
+### Choose the Right Action Verbs
+
+- **Click** for buttons, links, checkboxes
+- **Type** for text inputs
+- **Select** for dropdowns
+- **Check/uncheck** for checkboxes
+- **Upload** for file inputs
+
+```typescript
+// Good
+await stagehand.act("click the submit button");
+await stagehand.act("select 'Option 1' from dropdown");
+
+// Bad
+await stagehand.act("click submit");
+await stagehand.act("choose option 1");
+```
+
+### Protect Sensitive Data
+
+Variables keep sensitive information out of prompts and logs.
+
+```typescript
+// Use variables for sensitive data
+await stagehand.act("type %username% into the email field", {
+  variables: { username: "user@example.com" }
+});
+
+await stagehand.act("type %password% into the password field", {
+  variables: { password: process.env.USER_PASSWORD }
+});
+```
+
+<Warning>
+Set `verbose: 0` in your Stagehand config to prevent secrets from appearing in logs.
+</Warning>
+
+## Extract Method
+
+Use `extract()` to pull structured data from pages. Define clear schemas and provide context.
+
+### Schema Best Practices
+
+Use descriptive field names, correct types, and detailed descriptions. Field descriptions provide context that helps the model understand exactly what to extract.
+
+```typescript
+// Good - Descriptive names, correct types, and helpful descriptions
+const productData = await stagehand.extract(
+  "Extract product information",
+  z.object({
+    productTitle: z.string().describe("The main product name displayed on the page"),
+    priceInDollars: z.number().describe("Current selling price as a number, without currency symbol"),
+    isInStock: z.boolean().describe("Whether the product is available for purchase")
+  })
+);
+
+// Bad - Generic names, wrong types, no descriptions
+const data = await stagehand.extract(
+  "Get product details",
+  z.object({
+    name: z.string(), // Too generic, no context
+    price: z.string(), // Should be number
+    stock: z.string() // Should be boolean, no context
+  })
+);
+```
+
+### Use Proper URL Types
+
+Specify URL types with `z.string().url()` to tell Stagehand to extract URLs.
+
+```typescript
+// Good - Tells Stagehand to extract URLs
+const links = await stagehand.extract(
+  "Extract navigation links",
+  z.array(z.object({
+    text: z.string(),
+    url: z.string().url() // Required for URL extraction
+  }))
+);
+
+// Single URL extraction
+const contactUrl = await stagehand.extract(
+  "extract the contact page URL",
+  z.string().url()
+);
+```
+
+## Observe Method
+
+Use `observe()` to discover actionable elements before acting on them.
+
+### Check Elements First
+
+Verify elements exist before taking action to avoid errors.
+
+```typescript
+// Check for elements first
+const loginButtons = await stagehand.observe("Find the login button");
+
+if (loginButtons.length > 0) {
+  await stagehand.act(loginButtons[0]);
+} else {
+  console.log("No login button found");
+}
+```
+
+### Be Specific About Element Types
+
+```typescript
+// Good - Specific element types
+const submitButtons = await stagehand.observe("Find submit button in the form");
+const dropdowns = await stagehand.observe("Find the state dropdown menu");
+
+// Bad - Too vague
+const elements = await stagehand.observe("Find submit stuff");
+const things = await stagehand.observe("Find state selection");
+```
+
+## Agent Method
+
+Use `agent()` for complex, multi-step workflows. Provide detailed instructions and set appropriate limits.
+
+### Navigate First
+
+Don't include navigation in agent tasks. Handle it separately.
+
+```typescript
+// Good - Navigate first
+await page.goto('https://amazon.com');
+await agent.execute('Search for wireless headphones under $100 and add the best rated one to cart');
+
+// Bad - Navigation in task
+await agent.execute('Go to Amazon, search for headphones, and add one to cart');
+```
+
+### Be Highly Specific
+
+Detailed instructions lead to better results.
+
+```typescript
+// Good - Detailed instructions
+await agent.execute({
+  instruction: "Find Italian restaurants in Brooklyn that are open after 10pm, have outdoor seating, and are rated 4+ stars. Save the top 3 results.",
+  maxSteps: 25
+});
+
+// Bad - Vague instructions
+await agent.execute("Find some good restaurants");
+```
+
+### Set Appropriate Step Limits
+
+Match step limits to task complexity.
+
+```typescript
+// Simple task - fewer steps
+await agent.execute({
+  instruction: "Subscribe to the newsletter with email 'user@example.com'",
+  maxSteps: 10
+});
+
+// Complex task - more steps  
+await agent.execute({
+  instruction: "Research and compare 5 project management tools with pricing and features",
+  maxSteps: 50
+});
+```
+
+### Include Success Criteria
+
+Tell the agent how to know when it's done.
+
+```typescript
+// Good - Clear success criteria
+await agent.execute({
+  instruction: "Add 3 smartphone cases to cart and confirm the cart shows exactly 3 items with total price",
+  maxSteps: 20
+});
+
+// Bad - No validation
+await agent.execute("Add some items to cart");
+```
+
+## Common Mistakes to Avoid
+
+- **Combining multiple actions** - Keep each `act()` call to one action
+- **Using vague descriptions** - Be specific about which elements to interact with  
+- **Exposing sensitive data** - Always use variables for credentials
+- **Skipping validation** - Check results before proceeding
+
+## Testing Your Prompts
+
+1. **Start simple** - Test basic functionality first
+2. **Add complexity gradually** - Build up to complex workflows
+3. **Monitor results** - Use logging to understand what's happening
+4. **Iterate based on failures** - Refine prompts when they don't work
+Remember: Good prompting is iterative. When in doubt, be more specific rather than less.
\ No newline at end of file
diff --git a/packages/docs/v3/best-practices/speed-optimization.mdx b/packages/docs/v3/best-practices/speed-optimization.mdx
new file mode 100644
index 000000000..c77e08aa6
--- /dev/null
+++ b/packages/docs/v3/best-practices/speed-optimization.mdx
@@ -0,0 +1,171 @@
+---
+title: Speed Optimization
+sidebarTitle: Speed Optimization
+description: Optimize Stagehand performance for faster automation and reduced latency
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+Stagehand performance depends on several factors: DOM processing speed, LLM inference time, browser operations, and network latency. This guide provides proven strategies to maximize automation speed.
+
+## Quick Performance Wins
+
+### 1. Plan Ahead with Observe
+
+
+Use a single `observe()` call to plan multiple actions, then execute them efficiently:
+
+```typescript
+// Instead of sequential operations with multiple LLM calls
+await stagehand.act("Fill name field");        // LLM call #1
+await stagehand.act("Fill email field");       // LLM call #2
+await stagehand.act("Select country dropdown"); // LLM call #3
+
+// Use single observe to plan all form fields - one LLM call
+const formFields = await stagehand.observe("Find all form fields to fill");
+
+// Execute all actions without LLM inference
+for (const field of formFields) {
+  await stagehand.act(field); // No LLM calls!
+}
+```
+
+<Note>
+**Performance Tip**: Acting on `observe` results avoids LLM inference entirely. This approach is 2-3x faster than direct `act()` calls and is the recommended pattern for multi-step workflows.
+</Note>
+
+<Card title="Caching Guide" icon="database" href="/best-practices/caching">
+  Learn advanced caching patterns and cache invalidation strategies
+</Card>
+
+### 2. Optimize DOM Processing
+
+Reduce DOM complexity before Stagehand processes the page:
+
+```typescript
+// Remove heavy elements that slow down processing
+await page.evaluate(() => {
+  // Remove video elements
+  document.querySelectorAll('video, iframe').forEach(el => el.remove());
+  
+  // Hide complex animations
+  document.querySelectorAll('[style*="animation"]').forEach(el => {
+    (el as HTMLElement).style.animation = 'none';
+  });
+});
+
+// Then perform Stagehand operations
+await stagehand.act("Click the submit button");
+```
+
+### 3. Set Appropriate Timeouts
+
+Use shorter timeouts for simple operations and longer ones for complex page loads:
+
+```typescript
+// Simple actions - reduce action timeout
+await stagehand.act("Click the login button", {
+  timeout: 5000  // Default is 30000ms, reduce for simple clicks
+});
+
+// Complex page loads - optimize navigation
+const page = stagehand.context.pages()[0];
+await page.goto("https://heavy-spa.com", {
+  waitUntil: "domcontentloaded", // Don't wait for all resources
+  timeout: 15000 // Shorter than default 30s
+});
+```
+
+## Performance Monitoring and Benchmarking
+
+Track performance metrics and measure optimization impact:
+
+### Performance Tracking
+
+```typescript
+class PerformanceTracker {
+  private speedMetrics: Map<string, number[]> = new Map();
+
+  async timedAct(page: Page, prompt: string): Promise<ActResult> {
+    const start = Date.now();
+    const result = await stagehand.act(prompt);
+    const duration = Date.now() - start;
+    
+    if (!this.speedMetrics.has(prompt)) {
+      this.speedMetrics.set(prompt, []);
+    }
+    this.speedMetrics.get(prompt)!.push(duration);
+    
+    console.log(`Action "${prompt}" took ${duration}ms`);
+    return result;
+  }
+
+  getAverageTime(prompt: string): number {
+    const times = this.speedMetrics.get(prompt) || [];
+    return times.reduce((a, b) => a + b, 0) / times.length;
+  }
+}
+```
+
+Example Output:
+```
+Action "Fill form" took 1000ms
+Action "Click submit" took 2000ms
+Action "Confirm submission" took 5000ms
+```
+
+### Before vs After Benchmarking
+
+```typescript
+// Before optimization
+console.time("workflow");
+await stagehand.act("Fill form");
+await stagehand.act("Click submit");
+await stagehand.act("Confirm submission");
+console.timeEnd("workflow"); // 8000ms
+
+// After optimization with observe planning
+console.time("workflow-optimized");
+const workflowActions = await stagehand.observe("Find form, submit, and confirm elements");
+
+// Execute actions sequentially to avoid conflicts
+for (const action of workflowActions) {
+  await stagehand.act(action);
+}
+console.timeEnd("workflow-optimized"); // 500ms
+```
+
+Example Output:
+```
+Workflow took 8000ms
+Optimized workflow took 500ms
+```
+
+<CardGroup cols={1}>
+<Card title="Observability & Metrics" icon="chart-line" href="/configuration/observability">
+  Set up comprehensive performance monitoring
+</Card>
+</CardGroup>
+
+
+## Related Resources
+
+<CardGroup cols={2}>
+<Card title="Caching Strategies" icon="database" href="/best-practices/caching">
+  Advanced caching patterns for maximum performance
+</Card>
+
+<Card title="Cost Optimization" icon="dollar-sign" href="/best-practices/cost-optimization">
+  Balance speed improvements with cost considerations
+</Card>
+
+<Card title="Browser Configuration" icon="window-maximize" href="/configuration/browser">
+  Optimize Browserbase settings for speed
+</Card>
+
+<Card title="Model Selection" icon="brain" href="/configuration/models">
+  Choose the right model for speed vs accuracy
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v3/best-practices/usecase-observe.mdx b/packages/docs/v3/best-practices/usecase-observe.mdx
new file mode 100644
index 000000000..a1c4590a2
--- /dev/null
+++ b/packages/docs/v3/best-practices/usecase-observe.mdx
@@ -0,0 +1,108 @@
+---
+sidebarTitle: Use Cases
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## Real-World Use Cases
+
+### E-commerce Product Discovery
+
+```typescript
+// Discover product interaction elements
+const productActions = await stagehand.observe({
+  instruction: "Find add to cart buttons, size selectors, and product images"
+});
+
+// Categorize actions by type
+const cartButtons = productActions.filter(a => 
+  a.description.toLowerCase().includes('cart')
+);
+const sizeOptions = productActions.filter(a => 
+  a.description.toLowerCase().includes('size')
+);
+
+// Execute purchase workflow
+if (sizeOptions.length > 0) {
+  await stagehand.act(sizeOptions[0]); // Select size first
+}
+if (cartButtons.length > 0) {
+  await stagehand.act(cartButtons[0]); // Then add to cart
+}
+```
+
+### Form Handling & Validation
+
+```typescript
+// Analyze form structure before filling
+const formElements = await stagehand.observe({
+  instruction: "Find form fields, validation messages, and submit buttons"
+});
+
+// Check for required fields
+const requiredFields = formElements.filter(e => 
+  e.description.includes('required') || e.description.includes('*')
+);
+
+console.log(`Found ${requiredFields.length} required fields to complete`);
+
+// Fill form systematically
+for (const field of requiredFields) {
+  await stagehand.act(field);
+  // Add appropriate input based on field type
+}
+```
+
+### Dynamic Content & SPA Navigation
+
+```typescript
+// Wait for and discover dynamically loaded content
+await page.waitForLoadState('networkidle');
+
+const dynamicElements = await stagehand.observe({
+  instruction: "Find newly loaded content, infinite scroll triggers, or loading indicators",
+  domSettleTimeoutMs: 15000 // Wait longer for dynamic content
+});
+
+// Handle infinite scroll
+const scrollTriggers = dynamicElements.filter(e => 
+  e.description.toLowerCase().includes('load more') ||
+  e.description.toLowerCase().includes('scroll')
+);
+
+if (scrollTriggers.length > 0) {
+  await stagehand.act(scrollTriggers[0]);
+  // Recursively observe new content
+  const newContent = await stagehand.observe("Find additional items");
+}
+```
+
+### Multi-Step Workflow Planning
+
+```typescript
+// Plan entire checkout flow upfront
+async function planCheckoutWorkflow() {
+  // Step 1: Cart page analysis
+  await page.goto('/cart');
+  const cartActions = await stagehand.observe("Find checkout and cart modification options");
+  
+  // Step 2: Checkout page analysis  
+  const checkoutButton = cartActions.find(a => a.description.includes('checkout'));
+  if (checkoutButton) await stagehand.act(checkoutButton);
+  
+  const checkoutActions = await stagehand.observe("Find payment forms and shipping options");
+  
+  // Step 3: Plan execution order
+  const shippingFields = checkoutActions.filter(a => a.description.includes('shipping'));
+  const paymentFields = checkoutActions.filter(a => a.description.includes('payment'));
+  const submitButton = checkoutActions.find(a => a.description.includes('complete order'));
+  
+  return { shippingFields, paymentFields, submitButton };
+}
+
+// Execute planned workflow
+const workflow = await planCheckoutWorkflow();
+// Fill shipping → payment → submit
+```
diff --git a/packages/docs/v3/best-practices/user-data.mdx b/packages/docs/v3/best-practices/user-data.mdx
new file mode 100644
index 000000000..8daeed74b
--- /dev/null
+++ b/packages/docs/v3/best-practices/user-data.mdx
@@ -0,0 +1,52 @@
+---
+title: User Data Directory
+sidebarTitle: User Data
+description: Persist browser data between sessions
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+### User Data Directory
+
+Persist browser data between sessions.
+
+#### Local Sessions
+
+For local sessions, use the `userDataDir` option:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  localBrowserLaunchOptions: {
+    userDataDir: "./browser-data",
+  },
+});
+
+await stagehand.init();
+```
+
+#### Browserbase Sessions
+
+For Browserbase sessions, use [contexts](https://docs.browserbase.com/features/contexts) to persist browser data:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  browserbaseSessionCreateParams: {
+    browserSettings: {
+      context: {
+        id: "my-context-id",
+        persist: true,
+      },
+    },
+  },
+});
+
+await stagehand.init();
+console.log("Session ID:", stagehand.sessionId);
+```
\ No newline at end of file
diff --git a/packages/docs/v3/best-practices/using-multiple-tabs.mdx b/packages/docs/v3/best-practices/using-multiple-tabs.mdx
new file mode 100644
index 000000000..28fee3280
--- /dev/null
+++ b/packages/docs/v3/best-practices/using-multiple-tabs.mdx
@@ -0,0 +1,74 @@
+---
+title: 'Using Multiple Tabs'
+description: 'Act on multiple tabs with Stagehand'
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+Many modern web applications open new tabs when users click certain buttons or links. Without proper multitab support, automation scripts break when expected content appears in a new tab rather than the current one. Stagehand's multitab capabilities ensure your automations work seamlessly across multitab workflows.
+
+## The Stagehand Page
+
+Stagehand automatically adapts to multitab workflows. The active page (accessed via `context.activePage()`) always points to the most recently opened or active tab, ensuring your automations continue working even when new tabs are created.
+
+This means you can continue using familiar patterns:
+
+```typescript
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com");
+await stagehand.act("click the button that opens a new tab");
+// page now automatically points to the new tab
+await stagehand.extract("get data from new tab");
+```
+
+<Warning>
+**Important**: [Stagehand Agent](/v3/basics/agent) will always operate on the active page. If you need an agent to work across specific tabs, you'll need to manage page switching manually.
+</Warning>
+
+## Manual Page Management
+
+For more control or multitab workflows, you can manage multiple tabs explicitly:
+
+```typescript
+// Create a second page
+await stagehand.context.newPage();
+const pages = stagehand.context.pages();
+
+const githubPage = pages[0];
+const pythonPage = pages[1];
+
+// Navigate each page to different repositories
+await githubPage.goto("https://github.com/browserbase/stagehand");
+await pythonPage.goto("https://github.com/browserbase/stagehand-python");
+
+// Extract data from both pages simultaneously
+const [stagehandStars, stagehandPythonStars] = await Promise.all([
+  stagehand.extract("extract the repository stars", { page: githubPage }),
+  stagehand.extract("extract the repository stars", { page: pythonPage })
+]);
+
+console.log(`Stagehand stars: ${stagehandStars}`);
+console.log(`Stagehand-Python stars: ${stagehandPythonStars}`);
+```
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Orchestrate complex workflows with Agent" icon="robot" iconType="sharp-solid" href="/v3/basics/agent">
+    Use `Agent` to autonomously execute multi-step tasks and complex workflows.
+  </Card>
+
+  <Card title="Working with iframes" icon="frame" iconType="sharp-solid" href="/v3/best-practices/working-with-iframes">
+    Learn best practices for interacting with elements inside iframes.
+  </Card>
+
+  <Card title="Browser Configuration" icon="browser" iconType="sharp-solid" href="/v3/configuration/browser">
+    Manage browser contexts and sessions for complex automation scenarios.
+  </Card>
+
+  <Card title="Logging & Debugging" icon="bug" iconType="sharp-solid" href="/v3/configuration/logging">
+    Handle errors gracefully and debug automation issues effectively.
+  </Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v3/configuration/browser.mdx b/packages/docs/v3/configuration/browser.mdx
new file mode 100644
index 000000000..9e639bc9b
--- /dev/null
+++ b/packages/docs/v3/configuration/browser.mdx
@@ -0,0 +1,418 @@
+---
+title: Browser
+sidebarTitle: Browser
+description: Configure Stagehand on Browserbase or locally
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+Stagehand supports two primary environments:
+
+- **Browserbase** - Cloud-managed browser infrastructure optimized for production web automation at scale
+- **Local** - Run browsers directly on your machine for development and debugging
+
+## Browserbase Environment
+
+Browserbase provides managed cloud browser infrastructure optimized for web automation at scale. It offers advanced features like stealth mode, proxy support, and persistent contexts.
+
+<Card icon="cloud" title="Browserbase" href="https://docs.browserbase.com" description="Explore the features and benefits of using Browserbase for scalable web automation.">
+  Discover the power of cloud-managed browser infrastructure with Browserbase.
+</Card>
+
+### Multi-Region Support
+
+Stagehand API is available in multiple regions to optimize latency and support data residency requirements. The SDK automatically routes requests to the correct regional API endpoint based on your browser session's region.
+
+| Region | API Endpoint |
+| --- | --- |
+| **us-west-2** (Default) | https://api.stagehand.browserbase.com |
+| **us-east-1** | https://api.use1.stagehand.browserbase.com |
+| **eu-central-1** | https://api.euc1.stagehand.browserbase.com |
+| **ap-southeast-1** | https://api.apse1.stagehand.browserbase.com |
+
+Configure your browser session region in `browserbaseSessionCreateParams`:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  browserbaseSessionCreateParams: {
+    region: "eu-central-1", // Browser runs in Frankfurt
+  },
+});
+
+await stagehand.init();
+```
+
+<Warning>
+The API endpoint must match your browser session region. If there's a mismatch, you'll receive an error:
+`Session is in region 'X' but this API instance serves 'Y'. Please route your request to the X Stagehand API endpoint.`
+</Warning>
+
+### Disabling Stagehand API
+
+If you want to use Stagehand purely as a local library without routing through the Stagehand API, you can disable API mode:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  disableAPI: true, // Disable Stagehand API - runs locally with Browserbase
+});
+
+await stagehand.init();
+```
+
+<Tip>
+Disabling the API is useful when you want to manage browser sessions directly while still using Stagehand's automation features locally.
+</Tip>
+
+### Environment Variables
+
+Before getting started, set up the required environment variables:
+
+<CodeGroup>
+```bash .env
+BROWSERBASE_API_KEY=your_api_key_here
+BROWSERBASE_PROJECT_ID=your_project_id_here
+```
+</CodeGroup>
+
+<Tip>
+Get your API key and Project ID from the [Browserbase Dashboard](https://browserbase.com/overview)
+</Tip>
+
+### Using Stagehand with Browserbase
+
+#### Basic Setup
+
+The simplest way to get started is with default settings:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+});
+
+await stagehand.init();
+```
+
+#### Advanced Configuration
+
+Configure browser settings, proxy support, and other session parameters:
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  // Optional: API Key and Project ID will be pulled directly from your environment
+  apiKey: process.env.BROWSERBASE_API_KEY,
+  projectId: process.env.BROWSERBASE_PROJECT_ID,
+  browserbaseSessionCreateParams: {
+    proxies: true,
+    region: "us-west-2",
+    browserSettings: {
+      viewport: { width: 1920, height: 1080 },
+      blockAds: true,
+    },
+  },
+});
+
+await stagehand.init();
+console.log("Session ID:", stagehand.sessionId);
+```
+
+<Accordion title="Advanced Browserbase Configuration Example">
+    ```typescript
+const stagehand = new Stagehand({
+      env: "BROWSERBASE",
+      apiKey: process.env.BROWSERBASE_API_KEY,
+      projectId: process.env.BROWSERBASE_PROJECT_ID,
+      browserbaseSessionCreateParams: {
+        projectId: process.env.BROWSERBASE_PROJECT_ID!,
+        proxies: true,
+        region: "us-west-2",
+        timeout: 3600, // 1 hour session timeout
+        keepAlive: true, // Available on Startup plan
+        browserSettings: {
+          advancedStealth: false, // this is a Scale Plan feature - reach out to support@browserbase.com to enable
+          blockAds: true,
+          solveCaptchas: true,
+          recordSession: false,
+          viewport: {
+            width: 1920,
+            height: 1080,
+          },
+        },
+        userMetadata: {
+          userId: "automation-user-123",
+          environment: "production",
+        },
+      },
+    });
+    ```
+</Accordion>
+
+### Alternative: Browserbase SDK
+
+If you prefer to manage sessions directly, you can use the Browserbase SDK:
+
+```typescript
+import { Browserbase } from "@browserbasehq/sdk";
+
+const bb = new Browserbase({ 
+  apiKey: process.env.BROWSERBASE_API_KEY! 
+});
+
+const session = await bb.sessions.create({
+  projectId: process.env.BROWSERBASE_PROJECT_ID!,
+  // Add configuration options here
+});
+```
+
+#### Connecting to an Existing Session
+
+Connect to a previously created Browserbase session using its session ID:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  browserbaseSessionID: "existing-session-uuid-here",
+});
+
+await stagehand.init();
+console.log("Resumed Session ID:", stagehand.sessionId);
+```
+
+## Local Environment
+
+The local environment runs browsers directly on your machine, providing full control over browser instances and configurations. Ideal for development, debugging, and scenarios requiring custom browser setups.
+
+### Environment Comparison
+
+| Feature | Browserbase | Local |
+| --- | --- | --- |
+| **Scalability** | High (cloud-managed) | Limited (local resources) |
+| **Stealth Features** | Advanced fingerprinting | Basic stealth |
+| **Proxy Support** | Built-in residential proxies | Manual configuration |
+| **Session Persistence** | Cloud context storage | File-based user data |
+| **Geographic Distribution** | Multi-region deployment | Single machine |
+| **Debugging** | Session recordings & logs | Direct DevTools access |
+| **Setup Complexity** | Environment variables only | Browser installation required |
+| **Cost** | Usage-based pricing | Infrastructure & maintenance |
+| **Best For** | Production, scale, compliance | Development, debugging |
+
+### Basic Local Setup
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL"
+});
+  
+await stagehand.init();
+console.log("Session ID:", stagehand.sessionId);
+```
+
+### Advanced Local Configuration
+
+Customize browser launch options for local development:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  localBrowserLaunchOptions: {
+    headless: false, // Show browser window
+    devtools: true, // Open developer tools
+    viewport: { width: 1280, height: 720 },
+    executablePath: '/opt/google/chrome/chrome', // Custom Chrome path
+    port: 9222, // Fixed CDP debugging port
+    args: [
+      '--no-sandbox',
+      '--disable-setuid-sandbox',
+      '--disable-web-security',
+      '--allow-running-insecure-content',
+    ],
+    userDataDir: './chrome-user-data', // Persist browser data
+    preserveUserDataDir: true, // Keep data after closing
+    chromiumSandbox: false, // Disable sandbox (adds --no-sandbox)
+    ignoreHTTPSErrors: true, // Ignore certificate errors
+    locale: 'en-US', // Set browser language
+    deviceScaleFactor: 1.0, // Display scaling
+    proxy: {
+      server: 'http://proxy.example.com:8080',
+      username: 'user',
+      password: 'pass'
+    },
+    downloadsPath: './downloads', // Download directory
+    acceptDownloads: true, // Allow downloads
+    connectTimeoutMs: 30000, // Connection timeout
+  },
+});
+
+await stagehand.init();
+```
+
+## Advanced Configuration
+
+### Keep Alive
+
+The `keepAlive` option controls whether the browser remains running after `stagehand.close()` is called or when the parent process exits unexpectedly (e.g., crash, `SIGTERM`, `SIGINT`).
+
+By default, Stagehand terminates the browser and cleans up all resources when it shuts down. Setting `keepAlive: true` keeps the browser running independently so you can reconnect to it later.
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  keepAlive: true,
+});
+
+await stagehand.init();
+
+// The browser session continues running after close()
+await stagehand.close();
+
+// Later, reconnect to the same session
+const stagehand2 = new Stagehand({
+  env: "BROWSERBASE",
+  browserbaseSessionID: stagehand.browserbaseSessionID,
+});
+await stagehand2.init();
+```
+
+#### Behavior by Environment
+
+| Behavior | `keepAlive: true` | `keepAlive: false` (default) |
+| --- | --- | --- |
+| **Browserbase** | Session stays active after `close()` | Session is terminated via API |
+| **Local** | Chrome process continues running | Chrome process is killed and temp profile is removed |
+| **On crash/signal** | Browser is left running | Browser is automatically cleaned up |
+
+#### Local Environment
+
+When running locally with `keepAlive: true`, the Chrome process is detached from the Node.js event loop, allowing your script to exit while the browser stays open. This is useful for debugging or for handing off a browser session to another process.
+
+```typescript
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  keepAlive: true,
+  localBrowserLaunchOptions: {
+    headless: false,
+  },
+});
+
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com");
+
+// Browser window stays open after the script exits
+await stagehand.close();
+```
+
+#### Browserbase Environment
+
+On Browserbase, `keepAlive: true` keeps the cloud session active so you can reconnect later using `browserbaseSessionID`. This is useful for long-running workflows that span multiple script executions.
+
+<Note>
+The top-level `keepAlive` option overrides `browserbaseSessionCreateParams.keepAlive` when both are provided.
+</Note>
+
+### Fixed CDP Debugging Port
+
+Specify a fixed Chrome DevTools Protocol (CDP) debugging port instead of using a randomly assigned one.
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  localBrowserLaunchOptions: {
+    port: 9222,
+  },
+});
+
+await stagehand.init();
+```
+
+<Tip>
+If no `port` is specified, a random port will be assigned.
+</Tip>
+
+### DOM Settle Timeout
+
+Configure how long Stagehand waits for the DOM to stabilize before taking actions.
+
+```typescript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  domSettleTimeout: 3000 // Wait up to 3 seconds for DOM to settle
+});
+```
+
+#### What is DOM Settling?
+
+DOM settling ensures that:
+- **Animations complete** before interacting with elements
+- **Lazy-loaded content** has time to appear
+- **JavaScript updates** finish before actions are taken
+- **Dynamic content** is fully rendered
+
+#### When to Adjust
+
+Increase `domSettleTimeout` for pages with:
+- Heavy animations or transitions
+- Lazy-loading or infinite scroll
+- Dynamic JavaScript frameworks (React, Vue, Angular)
+- Complex single-page applications
+
+```typescript
+// For fast, static pages
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  domSettleTimeout: 500 // Minimal wait
+});
+
+// For dynamic, animated pages
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  domSettleTimeout: 5000 // Longer wait for stability
+});
+```
+
+<Warning>
+Setting `domSettleTimeout` too low may cause actions to fail on elements that aren't ready. Setting it too high increases execution time unnecessarily.
+</Warning>
+
+## Troubleshooting
+
+<AccordionGroup>
+<Accordion title="Browserbase Authentication Errors">
+- Verify your `BROWSERBASE_API_KEY` and `BROWSERBASE_PROJECT_ID` are set correctly
+- Check that your API key has the necessary permissions
+- Ensure your Browserbase account has sufficient credits
+</Accordion>
+
+<Accordion title="Local Browser Launch Failures">
+- Install Chrome or Chromium on your system
+- Set the correct `executablePath` for your Chrome installation
+- Check that required dependencies are installed (Linux: `libnss3-dev libatk-bridge2.0-dev libgtk-3-dev libxss1 libasound2`)
+</Accordion>
+
+<Accordion title="Session Timeout Issues">
+- Increase session timeout in `browserbaseSessionCreateParams.timeout`
+- Use `keepAlive: true` for long-running sessions
+- Monitor session usage to avoid unexpected terminations
+</Accordion>
+</AccordionGroup>
\ No newline at end of file
diff --git a/packages/docs/v3/configuration/logging.mdx b/packages/docs/v3/configuration/logging.mdx
new file mode 100644
index 000000000..13ac581cc
--- /dev/null
+++ b/packages/docs/v3/configuration/logging.mdx
@@ -0,0 +1,641 @@
+---
+title: Logging
+sidebarTitle: Logging
+description: Set up logging, debugging, and error tracking for Stagehand workflows
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+Stagehand provides comprehensive logging capabilities to help you debug automation workflows, track execution, and diagnose issues. Configure logging levels, structured output, and debugging tools for both development and production environments.
+
+## Quick Start
+
+Choose your logging setup based on your environment:
+
+<CodeGroup>
+```typescript Development
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  verbose: 2,  // Full debug output
+  // restOfYourConfiguration...
+});
+```
+
+```typescript Production
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  verbose: 1,  // Standard logging - less noise
+  disablePino: true,  // Disable default console logging - no console spam
+  // logger: yourProductionLogger,  // Send to observability platform like Sentry or DataDog
+  // restOfYourConfiguration...
+});
+```
+
+```typescript Testing
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  verbose: 1,
+  // Pino automatically disabled in test environments - no worker thread issues
+  // logger: yourTestLogger,  // Send to test logging framework like Jest
+  // restOfYourConfiguration...
+});
+```
+</CodeGroup>
+
+---
+
+## Operational Logging
+
+Real-time event logging during automation execution.
+
+### Verbosity Level
+
+Control how much detail you see in logs:
+
+<Tabs>
+<Tab title="Level 2: Debug">
+**Use for:** Development, debugging specific issues
+
+```typescript
+const stagehand = new Stagehand({
+  verbose: 2,  // Maximum detail
+  // restOfYourConfiguration...
+});
+```
+
+<Accordion title="Example Output">
+
+```
+[12:34:56] DEBUG: Capturing DOM snapshot
+[12:34:57] DEBUG: DOM contains 847 elements
+[12:34:58] DEBUG: LLM inference started
+[12:34:59] DEBUG: LLM response: {"selector": "#btn-submit", "method": "click"}
+[12:35:00] INFO: act completed successfully
+```
+
+</Accordion>
+</Tab>
+
+<Tab title="Level 1: Info (Default)">
+**Use for:** Standard operations, staging, production
+
+```typescript
+const stagehand = new Stagehand({
+  verbose: 1,  // Default level
+  // restOfYourConfiguration...
+});
+```
+
+
+<Accordion title="Example Output">
+
+```
+[12:34:56] INFO: act started
+[12:35:00] INFO: act completed successfully
+[12:35:01] INFO: extract started
+[12:35:03] INFO: extract completed
+```
+
+</Accordion>
+</Tab>
+
+<Tab title="Level 0: Errors Only">
+**Use for:** Production with external monitoring, minimal noise
+
+```typescript
+const stagehand = new Stagehand({
+  verbose: 0,  // Errors only
+  // restOfYourConfiguration...
+});
+```
+
+<Accordion title="Example Output">
+
+```
+[12:35:05] ERROR: act failed: element not found
+[12:35:10] ERROR: navigation timeout exceeded
+```
+
+</Accordion>
+</Tab>
+</Tabs>
+
+---
+
+### Log Destinations
+
+Logs can be sent to different destinations, including your console and external observability platforms:
+
+<Tabs>
+<Tab title="Pino (Default)">
+Fast, structured, colorized JSON logger with console output.
+
+**When to use:** Development, staging, or production without external observability; can manage multiple Stagehand instances
+
+```typescript
+// Enabled by default - Pino handles console output automatically
+const stagehand = new Stagehand({
+  verbose: 1,
+  // restOfYourConfiguration...
+});
+```
+
+<Accordion title="Auto-disabled when">
+- `process.env.NODE_ENV === "test"`
+- `process.env.JEST_WORKER_ID !== undefined` (Jest tests)
+- `process.env.PLAYWRIGHT_TEST_BASE_DIR !== undefined` (Playwright tests)
+- `process.env.CI === "true"` (CI/CD environments)
+
+**Why auto-disable?** Pino uses worker threads for pretty-printing, which can cause issues in test runners.
+</Accordion>
+</Tab>
+
+<Tab title="Console Fallback">
+Simple console.log/error output.
+
+**When to use:** Automatically activated in tests, or when `disablePino: true` without setting an external logger
+
+```typescript
+const stagehand = new Stagehand({
+  verbose: 1,
+  disablePino: true, // Set to true automatically when a test is detected
+  // restOfYourConfiguration...
+});
+```
+
+<Accordion title="Auto-disabled when">
+- `process.env.NODE_ENV === "test"`
+- `process.env.JEST_WORKER_ID !== undefined` (Jest tests)
+- `process.env.PLAYWRIGHT_TEST_BASE_DIR !== undefined` (Playwright tests)
+- `process.env.CI === "true"` (CI/CD environments)
+
+**Why auto-disable?** Pino uses worker threads for pretty-printing, which can cause issues in test runners.
+</Accordion>
+</Tab>
+<Tab title="Custom Logger">
+Your custom logging function to receive all logs. Works independently of Pino - receives logs regardless of Pino setting.
+
+**When to use:** Development, debugging, or when you don't need querying
+capabilities.
+
+<Steps>
+
+<Step title="Create a simple logger">
+```typescript
+// Simple logger without parsing (for basic console output)
+const simpleLogger = (logLine: LogLine) => {
+  console.log(`[${logLine.level}] ${logLine.message}`);
+
+  // Optional: log raw auxiliary data
+  if (logLine.auxiliary) {
+    console.log('  Context:', logLine.auxiliary);
+  }
+};
+```
+</Step>
+
+<Step title="Pass the logger in your Stagehand instance">
+Then pass the logger in your Stagehand instance:
+
+```typescript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  verbose: 1,
+  logger: simpleLogger,
+  disablePino: true,  // Avoid duplicate processing
+  // restOfYourConfiguration...
+})
+```
+
+</Step>
+</Steps>
+</Tab>
+
+<Tab title="External Logger (Production)">
+Your custom logging function to receive all logs. Works independently of Pino - receives logs regardless of Pino setting.
+
+**When to use:** Production with DataDog, Sentry, CloudWatch, or custom observability platforms for centralized monitoring and enable error alerting. Here's examples using Sentry and DataDog:
+
+<Steps>
+
+<Step title="Create a production logger">
+
+<Tabs>
+
+<Tab title="Sentry">
+
+```typescript
+import * as Sentry from "@sentry/node";
+
+const productionLogger = (logLine: LogLine) => {
+  // Send errors to Sentry
+  if (logLine.level === 0) {
+    Sentry.captureMessage(logLine.message, {
+      level: 'error',
+      extra: aux,
+    });
+  }
+}
+
+// Helper to parse auxiliary data to be flat, numeric, and filterable
+function parseAuxiliary(aux?: LogLine['auxiliary']): Record<string, any> {
+  if (!aux) return {};
+  const parsed: Record<string, any> = {};
+  for (const [key, entry] of Object.entries(aux)) {
+    parsed[key] = entry.type === 'object'
+      ? JSON.parse(entry.value)
+      : entry.value;
+  }
+  return parsed;
+}
+```
+
+</Tab>
+<Tab title="DataDog">
+
+```typescript
+import { datadogLogs } from "@datadog/browser-logs";
+
+const productionLogger = (logLine: LogLine) => {
+  // Send all logs to DataDog
+  datadogLogs.logger.log(logLine.message, {
+    status: logLine.level === 0 ? 'error' : 'info',
+    service: 'stagehand-automation',
+    category: logLine.category,
+    ...aux,
+  });
+}
+
+// Helper to parse auxiliary data to be flat, numeric, and filterable
+function parseAuxiliary(aux?: LogLine['auxiliary']): Record<string, any> {
+  if (!aux) return {};
+  const parsed: Record<string, any> = {};
+  for (const [key, entry] of Object.entries(aux)) {
+    parsed[key] = entry.type === 'object'
+      ? JSON.parse(entry.value)
+      : entry.value;
+  }
+  return parsed;
+}
+```
+</Tab>
+</Tabs>
+
+</Step>
+
+<Step title="Pass the logger in your Stagehand instance">
+
+```typescript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  verbose: 1,
+  logger: productionLogger,
+  disablePino: true,  // Avoid duplicate processing
+  // restOfYourConfiguration...
+})
+```
+
+</Step>
+</Steps>
+
+</Tab>
+</Tabs>
+
+---
+
+## File-Based Session Logging
+
+Enable detailed file-based logging for all Stagehand operations by setting a config directory. This creates comprehensive logs for `agent.execute`, `act`, `observe`, `extract`, CDP events, and LLM requests/responses.
+
+### Setup
+
+Add to your shell configuration (`~/.zshrc`, `~/.bashrc`, etc.):
+
+```bash
+export BROWSERBASE_CONFIG_DIR=~/.config/browserbase
+```
+
+Then reload your shell or run `source ~/.zshrc`.
+
+### Usage
+
+Run your Stagehand script as normal:
+
+```bash
+tsx run_some_script_that_imports_stagehand.ts
+```
+
+Logs are written to `~/.config/browserbase/sessions/<session-id>/` with a `latest` symlink pointing to the most recent session.
+
+### Viewing Logs
+
+<Tabs>
+<Tab title="Real-time Monitoring">
+Follow all logs as they happen:
+
+```bash
+tail -f ~/.config/browserbase/sessions/latest/*.log
+```
+
+Or watch specific log types:
+
+```bash
+# LLM requests and responses only
+tail -f ~/.config/browserbase/sessions/latest/llm_events.log
+
+# CDP (Chrome DevTools Protocol) events only
+tail -f ~/.config/browserbase/sessions/latest/cdp_events.log
+```
+</Tab>
+
+<Tab title="Chronological Review">
+View unified output sorted by timestamp:
+
+```bash
+cat ~/.config/browserbase/sessions/latest/*.log | sort
+```
+</Tab>
+
+<Tab title="Historical Sessions">
+Browse previous session logs:
+
+```bash
+ls ~/.config/browserbase/sessions/
+# Output: 2025-01-06_14-30-45_abc123  2025-01-06_15-45-12_def456  latest
+
+cat ~/.config/browserbase/sessions/2025-01-06_14-30-45_abc123/*.log | sort
+```
+</Tab>
+</Tabs>
+
+### Log Files
+
+Each session directory contains:
+
+| File | Contents |
+|------|----------|
+| `llm_events.log` | LLM requests and responses for act, extract, observe, and agent operations |
+| `cdp_events.log` | Chrome DevTools Protocol calls and events |
+| `stagehand.log` | General Stagehand operations and state changes |
+
+<Note>
+This is especially useful for debugging agent workflows where you need to trace the full sequence of LLM decisions, browser actions, and CDP interactions.
+</Note>
+
+---
+
+## LLM Inference Debugging
+
+<Warning>
+**Development only** - Creates large files and contains page content. Do not use in production.
+</Warning>
+
+Save complete LLM request/response dumps to disk for offline analysis. See exactly what DOM was sent to the LLM and why it chose the wrong element.
+
+```typescript
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  verbose: 2,
+  logInferenceToFile: true,  // Writes files to ./inference_summary/
+});
+```
+
+Creates timestamped files for each LLM call:
+
+```
+./inference_summary/
+├── act_summary/
+│   ├── act_summary.json                      # Aggregate metrics
+│   ├── 20250127_123456_act_call.txt          # LLM request
+│   ├── 20250127_123456_act_response.txt      # LLM response
+│   ├── 20250127_123501_act_call.txt
+│   └── 20250127_123501_act_response.txt
+├── extract_summary/
+│   ├── extract_summary.json
+│   ├── 20250127_123510_extract_call.txt
+│   ├── 20250127_123510_extract_response.txt
+│   ├── 20250127_123511_metadata_call.txt
+│   └── 20250127_123511_metadata_response.txt
+└── observe_summary/
+    ├── observe_summary.json
+    └── ...
+```
+
+**File Types:**
+
+<AccordionGroup>
+<Accordion title="Call File">
+Contains the complete LLM request:
+
+```json
+{
+  "modelCall": "act",
+  "messages": [
+    {
+      "role": "system",
+      "content": "You are a browser automation assistant. You have access to these actions:\n- click\n- type\n- scroll\n..."
+    },
+    {
+      "role": "user",
+      "content": "Click the sign in button\n\nDOM:\n<html>\n  <body>\n    <button id=\"btn-1\">Sign In</button>\n    <button id=\"btn-2\">Sign Up</button>\n  </body>\n</html>"
+    }
+  ]
+}
+```
+</Accordion>
+
+<Accordion title="Response File">
+Contains the LLM output:
+
+```json
+{
+  "modelResponse": "act",
+  "rawResponse": {
+    "selector": "#btn-1",
+    "method": "click",
+    "reasoning": "Found sign in button with ID btn-1"
+  }
+}
+```
+</Accordion>
+
+<Accordion title="Summary File">
+Aggregates all calls with metrics:
+
+```json
+{
+  "act_summary": [
+    {
+      "act_inference_type": "act",
+      "timestamp": "20250127_123456",
+      "LLM_input_file": "20250127_123456_act_call.txt",
+      "LLM_output_file": "20250127_123456_act_response.txt",
+      "prompt_tokens": 3451,
+      "completion_tokens": 45,
+      "inference_time_ms": 951
+    },
+    {
+      "act_inference_type": "act",
+      "timestamp": "20250127_123501",
+      "LLM_input_file": "20250127_123501_act_call.txt",
+      "LLM_output_file": "20250127_123501_act_response.txt",
+      "prompt_tokens": 2890,
+      "completion_tokens": 38,
+      "inference_time_ms": 823
+    }
+  ]
+}
+```
+</Accordion>
+</AccordionGroup>
+
+---
+
+## Reference
+
+### Logging Configuration
+
+All logging options are passed to the Stagehand constructor:
+
+```typescript
+const stagehand = new Stagehand({
+  // ... your other configurations (env, model, etc.)
+
+  // Logging options:
+  verbose?: 0 | 1 | 2;                   // Log level (default: 1)
+  logger?: (line: LogLine) => void;      // External logger function
+  disablePino?: boolean;                 // Disable Pino backend (default: false)
+  logInferenceToFile?: boolean;          // Save LLM requests to disk (default: false)
+});
+```
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `verbose` | `1` | Log level: `0` = errors only, `1` = info, `2` = debug |
+| `logger` | `undefined` | Custom logger function for external platforms |
+| `disablePino` | `false` | Disable Pino (auto `true` in tests) |
+| `logInferenceToFile` | `false` | Save LLM requests to disk (default: false) |
+
+### Log Structure
+
+Each log entry follows a structured format:
+
+```typescript
+interface LogLine {
+  message: string;              // "act completed successfully"
+  level?: 0 | 1 | 2;            // error | info | debug
+  category?: string;            // "action", "llm", "browser", "cache"
+  timestamp?: string;           // ISO 8601 timestamp
+  auxiliary?: {                 // Additional structured metadata
+    [key: string]: {
+      value: string;             // Serialized value
+      type: "object" | "string" | "integer" | "float" | "boolean";
+    };
+  };
+}
+```
+
+<Accordion title="Log Examples">
+
+<Tabs>
+<Tab title="Successful Action">
+```json
+{
+  "category": "action",
+  "message": "act completed successfully",
+  "level": 1,
+  "timestamp": "2025-01-27T12:35:00.123Z",
+  "auxiliary": {
+    "selector": {
+      "value": "#btn-submit",
+      "type": "string"
+    },
+    "executionTime": {
+      "value": "1250",
+      "type": "integer"
+    }
+  }
+}
+```
+</Tab>
+
+<Tab title="LLM Inference">
+```json
+{
+  "category": "llm",
+  "message": "inference completed",
+  "level": 1,
+  "timestamp": "2025-01-27T12:34:58.456Z",
+  "auxiliary": {
+    "model": {
+      "value": "gpt-4o",
+      "type": "string"
+    },
+    "promptTokens": {
+      "value": "3451",
+      "type": "integer"
+    },
+    "completionTokens": {
+      "value": "45",
+      "type": "integer"
+    }
+  }
+}
+```
+</Tab>
+
+<Tab title="Error">
+```json
+{
+  "category": "action",
+  "message": "action failed: element not found",
+  "level": 0,
+  "timestamp": "2025-01-27T12:35:05.789Z",
+  "auxiliary": {
+    "selector": {
+      "value": "#missing-btn",
+      "type": "string"
+    },
+    "url": {
+      "value": "https://example.com/form",
+      "type": "string"
+    }
+  }
+}
+```
+</Tab>
+</Tabs>
+
+</Accordion>
+
+---
+
+## Next Steps
+
+Now that you have logging configured, explore additional debugging and monitoring tools in [the Observability guide](/v3/configuration/observability):
+
+<CardGroup cols={2}>
+<Card title="History API" icon="clock-rotate-left" href="/v3/best-practices/history">
+Track all LLM operations (act, extract, observe, agent) with parameters, results, and timestamps. Perfect for debugging sequences and replaying workflows.
+</Card>
+
+<Card title="Metrics API" icon="chart-line" href="/v3/configuration/observability#real-time-metrics-%26-monitoring">
+Monitor token usage and performance in real-time. Track costs per operation, identify expensive calls, and optimize resource usage.
+</Card>
+
+<Card title="LLM Inference Debugging" icon="microscope" href="/v3/configuration/logging#llm-inference-debugging">
+Save complete LLM request/response dumps to disk. See exactly what DOM was sent to the LLM and why it made specific decisions.
+</Card>
+
+<Card title="Browserbase Session Monitoring" icon="video" href="/v3/configuration/observability#browserbase-session-monitoring">
+Watch your automation visually with session recordings, network monitoring, and real-time browser inspection (Browserbase only).
+</Card>
+</CardGroup>
diff --git a/packages/docs/v3/configuration/models.mdx b/packages/docs/v3/configuration/models.mdx
new file mode 100644
index 000000000..dd829a002
--- /dev/null
+++ b/packages/docs/v3/configuration/models.mdx
@@ -0,0 +1,940 @@
+---
+title: Models
+sidebarTitle: Models
+description: Use any LLM model with Stagehand for optimal performance
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+Understand web pages, plan actions, and interact with complex interfaces with Google, OpenAI, Anthropic, xAI, DeepSeek, Perplexity, Azure, Ollama, the [Vercel AI Gateway](https://vercel.com/docs/ai-gateway), or any other LLM model from [the Vercel AI SDK](https://sdk.vercel.ai/providers).
+
+---
+
+## Configuration Setup
+
+### Quick Start
+
+<Tip>
+  Set your API key in `.env` and Stagehand handles the rest. No explicit
+  configuration needed!
+</Tip>
+
+Get started with Google Gemini (recommended for speed and cost):
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: "google/gemini-2.5-flash"
+  // API key auto-loads from GOOGLE_GENERATIVE_AI_API_KEY - set in your .env
+});
+
+await stagehand.init();
+
+```
+</CodeGroup>
+
+
+---
+
+### First Class Models
+
+Use any model from the following supported providers.
+
+<Tabs>
+<Tab title="Google">
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: "google/gemini-2.5-flash"
+  // API key auto-loads from GOOGLE_GENERATIVE_AI_API_KEY - set in your .env
+});
+
+await stagehand.init();
+```
+
+</CodeGroup>
+[View all supported Google models →](https://ai.google.dev/gemini-api/docs/models)
+</Tab>
+
+<Tab title="Google Vertex">
+
+<Warning>
+Google Vertex requires `experimental: true` in the Stagehand constructor.
+</Warning>
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  experimental: true, // required for Vertex
+  model: {
+    modelName: "vertex/gemini-3-flash-preview",
+    project: "your-gcp-project-id",
+    location: "us-central1",
+    googleAuthOptions: {
+      credentials: {
+        client_email: "your-sa@project.iam.gserviceaccount.com",
+        private_key: process.env.GOOGLE_SERVICE_ACCOUNT_PRIVATE_KEY,
+      },
+    },
+  },
+});
+
+await stagehand.init();
+```
+
+</CodeGroup>
+
+The `model` object accepts:
+- `modelName` — The Vertex model, prefixed with `vertex/` (e.g. `vertex/gemini-3-flash-preview`)
+- `project` — Your GCP project ID
+- `location` — Your Vertex AI region (e.g. `us-central1`)
+- `googleAuthOptions.credentials` — Service account credentials with `client_email` and `private_key`
+
+[View all supported Vertex AI models →](https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models)
+</Tab>
+
+<Tab title="Anthropic">
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: "anthropic/claude-haiku-4-5"
+  // API key auto-loads from ANTHROPIC_API_KEY - set in your .env
+});
+
+await stagehand.init();
+
+```
+</CodeGroup>
+[View all supported Anthropic models →](https://docs.anthropic.com/en/docs/models-overview)
+</Tab>
+
+<Tab title="OpenAI">
+
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: "openai/gpt-5"
+  // API key auto-loads from OPENAI_API_KEY - set in your .env
+});
+
+await stagehand.init();
+```
+
+</CodeGroup>
+[View all supported OpenAI models →](https://platform.openai.com/docs/models)
+</Tab>
+<Tab title="Azure">
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: "azure/gpt-5"
+  // API key auto-loads from AZURE_API_KEY - set in your .env
+});
+
+await stagehand.init();
+
+```
+</CodeGroup>
+[View all supported Azure models →](https://ai.azure.com/catalog)
+</Tab>
+
+<Tab title="Cerebras">
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: "cerebras/llama-4-scout"
+  // API key auto-loads from CEREBRAS_API_KEY - set in your .env
+});
+
+await stagehand.init();
+```
+
+</CodeGroup>
+[View all supported Cerebras models →](https://inference-docs.cerebras.ai/models/overview)
+</Tab>
+
+<Tab title="DeepSeek">
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: "deepseek/deepseek-chat"
+  // API key auto-loads from DEEPSEEK_API_KEY - set in your .env
+});
+
+await stagehand.init();
+
+```
+</CodeGroup>
+[View all supported DeepSeek models →](https://api-docs.deepseek.com/quick_start/pricing)
+</Tab>
+
+<Tab title="Groq">
+
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: "groq/llama-3.1-8b-instant"
+  // API key auto-loads from GROQ_API_KEY - set in your .env
+});
+
+await stagehand.init();
+```
+
+</CodeGroup>
+[View all supported Groq models →](https://console.groq.com/docs/models)
+</Tab>
+
+<Tab title="Mistral">
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: "mistral/codestral-2508"
+  // API key auto-loads from MISTRAL_API_KEY - set in your .env
+});
+
+await stagehand.init();
+
+```
+</CodeGroup>
+[View all supported Mistral models →](https://docs.mistral.ai/getting-started/models)
+</Tab>
+
+<Tab title="Ollama">
+
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: "ollama/llama3.2"
+  // No API key required
+});
+
+await stagehand.init();
+```
+
+</CodeGroup>
+[View all supported Ollama models →](https://ollama.com/library)
+</Tab>
+
+<Tab title="Perplexity">
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: "perplexity/sonar-reasoning"
+  // API key auto-loads from PERPLEXITY_API_KEY - set in your .env
+});
+
+await stagehand.init();
+
+```
+</CodeGroup>
+[View all supported Perplexity models →](https://docs.perplexity.ai/getting-started/models)
+</Tab>
+<Tab title="TogetherAI">
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: "togetherai/Qwen/Qwen3-235B-A22B-Instruct-2507-tput"
+  // API key auto-loads from TOGETHER_AI_API_KEY - set in your .env
+});
+
+await stagehand.init();
+```
+
+</CodeGroup>
+[View all supported TogetherAI models →](https://www.together.ai/models)
+
+</Tab>
+<Tab title="xAI">
+
+<CodeGroup>
+```typescript TypeScript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: "xai/grok-4-fast-reasoning"
+  // API key auto-loads from XAI_API_KEY - set in your .env
+});
+
+await stagehand.init();
+
+```
+</CodeGroup>
+
+[View all xAI models →](https://docs.x.ai/docs/models)
+</Tab>
+
+</Tabs>
+
+---
+
+### Custom Models
+
+Amazon Bedrock, Cohere, all [first class models](/v3/configuration/models#first-class-models), and any model from [the Vercel AI SDK](https://sdk.vercel.ai/providers) is supported.
+
+Use this configuration for custom endpoints and custom retry or caching logic.
+
+We'll use Amazon Bedrock and Google as examples below.
+
+<AccordionGroup>
+<Accordion title="Amazon Bedrock">
+
+<Steps>
+<Step title="Install dependencies">
+Install the Vercel AI SDK for your provider.
+
+<Tabs>
+<Tab title="npm">
+```bash
+npm install @ai-sdk/amazon-bedrock
+```
+
+</Tab>
+<Tab title="pnpm">
+```bash
+pnpm add @ai-sdk/amazon-bedrock
+```
+</Tab>
+<Tab title="yarn">
+```bash
+yarn add @ai-sdk/amazon-bedrock
+```
+</Tab>
+<Tab title="bun">
+```bash
+bun add @ai-sdk/amazon-bedrock
+```
+</Tab>
+</Tabs>
+</Step>
+
+<Step title="Import, create provider, and create client">
+```typescript
+import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
+import { AISdkClient } from '@browserbasehq/stagehand';
+
+const bedrockProvider = createAmazonBedrock({
+  region: 'us-east-1',
+  accessKeyId: 'xxxxxxxxx',
+  secretAccessKey: 'xxxxxxxxx',
+  sessionToken: 'xxxxxxxxx',
+});
+
+const bedrockClient = new AISdkClient({
+  model: bedrockProvider("amazon/nova-pro-latest"),
+});
+
+```
+</Step>
+
+<Step title="Pass client to Stagehand">
+```typescript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  llmClient: bedrockClient
+});
+
+await stagehand.init();
+```
+
+</Step>
+</Steps>
+</Accordion>
+<Accordion title="Google">
+
+<Steps>
+<Step title="Install dependencies">
+Install the Vercel AI SDK for your provider.
+
+<Tabs>
+<Tab title="npm">
+```bash
+npm install @ai-sdk/google
+```
+</Tab>
+<Tab title="pnpm">
+```bash
+pnpm add @ai-sdk/google
+```
+</Tab>
+<Tab title="yarn">
+```bash
+yarn add @ai-sdk/google
+```
+</Tab>
+<Tab title="bun">
+```bash
+bun add @ai-sdk/google
+```
+</Tab>
+</Tabs>
+</Step>
+
+<Step title="Import, create provider, and create client">
+```typescript
+import { createGoogle } from '@ai-sdk/google';
+import { AISdkClient } from '@browserbasehq/stagehand';
+
+const googleProvider = createGoogle({
+  apiKey: process.env.GEMINI_API_KEY,
+});
+
+const googleClient = new AISdkClient({
+  model: googleProvider("google/gemini-2.5-flash"),
+});
+
+```
+</Step>
+
+<Step title="Pass client to Stagehand">
+```typescript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  llmClient: googleClient
+});
+
+await stagehand.init();
+```
+
+</Step>
+</Steps>
+</Accordion>
+<Accordion title="All Providers">
+
+To implement a custom model, follow the steps for the provider you are using. See the Amazon Bedrock and Google examples above. All supported providers and models are in [the Vercel AI SDK](https://sdk.vercel.ai/providers).
+
+<Steps>
+<Step title="Install dependencies">
+Install the Vercel AI SDK for your provider.
+</Step>
+<Step title="Import, create provider, and create client">
+```typescript
+import { createProvider } from '@ai-sdk/provider';
+import { AISdkClient } from '@browserbasehq/stagehand';
+
+const provider = createProvider({
+  apiKey: 'xxxxxxxxx',
+});
+
+const providerClient = new AISdkClient({
+  model: provider("model/name"),
+});
+
+```
+</Step>
+<Step title="Pass client to Stagehand">
+```typescript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  llmClient: providerClient
+});
+
+await stagehand.init();
+```
+
+</Step>
+</Steps>
+</Accordion>
+</AccordionGroup>
+
+
+---
+
+## Choose a Model
+
+Different models excel at different tasks. Consider speed, accuracy, and cost for your use case.
+
+<Card title="Model Selection Guide" href="https://www.stagehand.dev/evals" icon="scale-balanced">
+  Find detailed model comparisons and recommendations on our Model Evaluation page.
+</Card>
+
+**Quick Recommendations**
+
+| Use Case                  | Recommended Model                    | Why                            |
+| ------------------------- | ------------------------------------ | ------------------------------ |
+| **Production** | `google/gemini-2.5-flash`            | Fast, accurate, cost-effective |
+| **Intelligence**     | `google/gemini-3-pro-preview` | Best accuracy on hard tasks    |
+| **Speed**        | `google/gemini-2.5-flash`                 | Fastest response times         |
+| **Cost**     | `google/gemini-2.5-flash`            | Best value per token           |
+| **Local/offline**         | `ollama/qwen3`                    | No API costs, full control     |
+
+
+---
+
+## Advanced Options
+
+### Agent Models (with CUA Support)
+
+**Default**
+
+The Stagehand agent by default uses the same model passed to Stagehand. All models ([first class](/v3/configuration/models#first-class-models) and [custom](/v3/configuration/models#custom-models)) are supported. Here's an example with Gemini:
+
+```typescript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: "google/gemini-2.5-flash",
+  // GOOGLE_GENERATIVE_AI_API_KEY is auto-loaded from .env
+  // ... other stagehand options
+});
+
+// Agent will use google/gemini-2.5-flash
+const agent = stagehand.agent();
+```
+
+**Override (with CUA support)**
+
+However, the stagehand agent also accepts a `model` parameter, which accepts any [first class](/v3/configuration/models#first-class-models) model, including [computer use agents (CUA)](/v3/configuration/models#agent-models-with-cua-support). This is useful when you'd like the agent to use a different model than the one passed to Stagehand.
+
+<Tip>
+  To use a CUA model, you must pass the `mode: "cua"` parameter to the `agent()` method. If a non-CUA model is used, whether specified in Stagehand or overridden in the `agent()` method, an error will be thrown.
+</Tip>
+
+<Warning>
+**Deprecation Notice:** The `cua: true` option is deprecated and will be removed in a future version. Use `mode: "cua"` instead.
+</Warning>
+
+<Tabs>
+<Tab title="Google CUA">
+```typescript
+const agent = stagehand.agent({
+  mode: "cua",
+  model: "google/gemini-2.5-computer-use-preview-10-2025",
+  // GOOGLE_GENERATIVE_AI_API_KEY is auto-loaded from .env
+  // ... other agent options
+});
+```
+</Tab>
+<Tab title="Anthropic CUA">
+```typescript
+const agent = stagehand.agent({
+  mode: "cua",
+  model: "anthropic/claude-sonnet-4-6",
+  // ANTHROPIC_API_KEY is auto-loaded from .env
+  // ... other agent options
+});
+```
+</Tab>
+<Tab title="OpenAI CUA">
+```typescript
+const agent = stagehand.agent({
+  mode: "cua",
+  model: "openai/computer-use-preview",
+  // OPENAI_API_KEY is auto-loaded from .env
+  // ... other agent options
+});
+```
+</Tab>
+<Tab title="Example First Class Model">
+All [first class models](/v3/configuration/models#first-class-models) are supported. Here's an example with Gemini:
+
+```typescript
+const agent = stagehand.agent({
+  model: "google/gemini-2.5-pro",
+  // GOOGLE_GENERATIVE_AI_API_KEY is auto-loaded from .env
+  // ... other agent options
+});
+```
+</Tab>
+</Tabs>
+
+<Accordion title="All Supported CUA Models">
+| Provider | Model |
+| -------- | ----- |
+| Anthropic | `anthropic/claude-haiku-4-5-20251001` |
+| Anthropic | `anthropic/claude-sonnet-4-6` |
+| Anthropic | `anthropic/claude-sonnet-4-5-20250929` |
+| Anthropic | `anthropic/claude-opus-4-5-20251101` |
+| Anthropic | `anthropic/claude-opus-4-6` |
+| Google   | `google/gemini-2.5-computer-use-preview-10-2025` |
+| Google   | `google/gemini-3-flash-preview` |
+| Google   | `google/gemini-3-pro-preview` |
+| Microsoft | `microsoft/fara-7b` |
+| OpenAI   | `openai/computer-use-preview` |
+| OpenAI   | `openai/computer-use-preview-2025-03-11` |
+</Accordion>
+
+<Note>
+  For overriding the agent API key, using a corporate proxy, adding provider-specific options, or other advanced use cases, the agent model can also take the form of an object. To learn more, see the [Agent Reference](/v3/references/agent).
+</Note>
+---
+
+### Custom Endpoints
+
+If you need Azure OpenAI deployments or enterprise deployments.
+
+<Tabs>
+<Tab title="OpenAI">
+
+For OpenAI, you can pass configuration directly without using `llmClient` using the `model` parameter:
+
+```typescript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: {
+    modelName: "openai/gpt-5",
+    apiKey: process.env.OPENAI_API_KEY,
+    baseURL: "https://custom-openai-endpoint.com/v1"
+  }
+});
+```
+
+</Tab>
+
+<Tab title="Anthropic">
+
+For Anthropic, you can pass configuration directly without using `llmClient` using the `model` parameter:
+
+```typescript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: {
+    modelName: "anthropic/claude-haiku-4-5",
+    apiKey: process.env.ANTHROPIC_API_KEY,
+    baseURL: "https://custom-anthropic-endpoint.com",
+  },
+});
+```
+
+  </Tab>
+<Tab title="All Other Providers">
+For all other providers, use `llmClient`. Here's an example with Hugging Face:
+
+```typescript
+// pnpm add @ai-sdk/huggingface
+
+import { createHuggingFace } from "@ai-sdk/huggingface";
+import { AISdkClient } from "@browserbasehq/stagehand";
+
+const huggingFaceProvider = createHuggingFace({
+  apiKey: process.env.HUGGINGFACE_API_KEY,
+  baseURL: "https://custom-huggingface-endpoint.com",
+});
+
+const huggingFaceClient = new AISdkClient({
+  model: huggingFaceProvider("meta-llama/Llama-3.1-8B-Instruct"),
+});
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  llmClient: huggingFaceClient,
+});
+```
+
+</Tab>
+</Tabs>
+
+---
+
+### AI Gateway
+
+The [Vercel AI Gateway](https://vercel.com/docs/ai-gateway) lets you access models from multiple providers (OpenAI, Anthropic, Google, and more) through a single API key and interface. No extra provider SDKs or per-provider API keys needed.
+
+<Tip>
+  The AI Gateway is built into the `ai` package that Stagehand already uses -- no additional dependencies required.
+</Tip>
+
+**Key benefits:**
+- Access models from all major providers with a single `AI_GATEWAY_API_KEY`
+- Automatic provider fallback and dynamic routing based on uptime and latency
+- Usage tracking and observability through the Vercel dashboard
+- Bring Your Own Key (BYOK) support for existing provider credentials
+
+<Tabs>
+<Tab title="Simple">
+
+Use the `gateway/` prefix followed by the provider and model name:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: "gateway/openai/gpt-5"
+  // API key auto-loads from AI_GATEWAY_API_KEY - set in your .env
+});
+
+await stagehand.init();
+```
+
+Works with any model available on the gateway:
+
+```typescript
+// Anthropic via gateway
+model: "gateway/anthropic/claude-sonnet-4.5"
+
+// Google via gateway
+model: "gateway/google/gemini-3-flash-preview"
+```
+
+</Tab>
+<Tab title="Custom Config">
+
+Pass the API key and optional base URL explicitly using the model object format:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: {
+    modelName: "gateway/openai/gpt-5",
+    apiKey: process.env.AI_GATEWAY_API_KEY,
+    baseURL: "https://ai-gateway.vercel.sh/v3/ai" // optional custom endpoint
+  }
+});
+
+await stagehand.init();
+```
+
+</Tab>
+</Tabs>
+
+[View all available AI Gateway models →](https://vercel.com/docs/ai-gateway/models-and-providers)
+
+---
+
+### Extending the AI SDK Client
+
+For advanced use cases like custom retries or caching logic, you can extend the `AISdkClient`:
+
+```typescript
+import { LLMClient } from "@browserbasehq/stagehand";
+
+class CustomRetryClient extends LLMClient {
+  async createChatCompletion(options) {
+    let retries = 3;
+    while (retries > 0) {
+      try {
+        return await super.createChatCompletion(options);
+      } catch (error) {
+        retries--;
+        if (retries === 0) throw error;
+        await new Promise((r) => setTimeout(r, 1000 * (4 - retries)));
+      }
+    }
+  }
+}
+```
+
+<Tip>
+  Need custom caching? Consider using built-in [caching
+  feature](/v3/best-practices/caching).
+</Tip>
+
+---
+
+### Legacy Model Format
+
+<Tip>
+**Recommendation:** Use `provider/model` format. Example:
+- `model: "openai/gpt-4o"` (recommended)
+- `model: "gpt-4o"` (legacy)
+
+</Tip>
+
+The following models work without the `provider/` prefix in the model parameter as part of legacy support:
+
+<AccordionGroup title="Legacy Model Format">
+<Accordion title="Google">
+
+- `gemini-2.5-flash-preview-04-17`
+- `gemini-2.5-pro-preview-03-25`
+- `gemini-2.0-flash`
+- `gemini-2.0-flash-lite`
+- `gemini-1.5-flash`
+- `gemini-1.5-flash-8b`
+- `gemini-1.5-pro`
+
+</Accordion>
+<Accordion title="Anthropic">
+
+- `claude-sonnet-4-6`
+- `claude-sonnet-4-5-20250929`
+- `claude-haiku-4-5-20251001`
+
+</Accordion>
+<Accordion title="OpenAI">
+- `gpt-4o`
+- `gpt-4o-mini`
+- `o1`
+- `o1-mini`
+- `o3`
+- `o3-mini`
+- `gpt-4.1`
+- `gpt-4.1-mini`
+- `gpt-4.1-nano`
+- `o4-mini`
+- `gpt-4.5-preview`
+- `gpt-4o-2024-08-06`
+- `o1-preview`
+
+</Accordion>
+<Accordion title="Cerebras">
+
+- `cerebras-llama-3.3-70b`
+- `cerebras-llama-3.1-8b`
+
+</Accordion>
+<Accordion title="Groq">
+
+- `groq-llama-3.3-70b-versatile`
+- `groq-llama-3.3-70b-specdec`
+- `moonshotai/kimi-k2-instruct`
+
+</Accordion>
+</AccordionGroup>
+
+---
+
+## Troubleshooting
+
+<AccordionGroup>
+<Accordion title="Error: API key not found">
+**Error:** `API key not found`
+
+**Solutions:**
+
+- Check `.env` file has the correct variable name for the provider you are using
+- Ensure environment variables are loaded (use `dotenv`)
+- Restart your application after updating `.env` file
+
+| Provider   | Environment Variable           |
+| ---------- | ------------------------------ |
+| Google     | `GOOGLE_GENERATIVE_AI_API_KEY` or `GEMINI_API_KEY` |
+| Vertex | Service account credentials (see [setup](#first-class-models)) |
+| Anthropic  | `ANTHROPIC_API_KEY`            |
+| OpenAI     | `OPENAI_API_KEY`               |
+| Azure      | `AZURE_API_KEY`                |
+| Cerebras   | `CEREBRAS_API_KEY`             |
+| DeepSeek   | `DEEPSEEK_API_KEY`             |
+| Groq       | `GROQ_API_KEY`                 |
+| Mistral    | `MISTRAL_API_KEY`              |
+| Ollama     | None (local)                   |
+| Perplexity | `PERPLEXITY_API_KEY`           |
+| TogetherAI | `TOGETHER_AI_API_KEY`          |
+| xAI        | `XAI_API_KEY`                  |
+| AI Gateway | `AI_GATEWAY_API_KEY`           |
+
+</Accordion>
+
+<Accordion title="Error: Model not supported">
+**Error:** `Unsupported model`
+
+**Solutions:**
+
+- Use the `provider/model` format: `openai/gpt-5`
+- Verify the model name exists in the provider's documentation
+- Check model name is spelled correctly
+- Ensure your Model API key can access the model
+</Accordion>
+
+<Accordion title="Model doesn't support structured outputs">
+**Error:** `Model does not support structured outputs`
+
+**Solutions:**
+
+- Check our [Model Evaluation page](https://www.stagehand.dev/evals) for recommended models
+</Accordion>
+
+<Accordion title="High costs or slow performance">
+**Symptoms:** Automation is expensive or slow
+
+**Solutions:**
+
+- Switch to cost-effective models (check [evals](https://www.stagehand.dev/evals) for comparisons)
+- Use faster models for simple tasks, powerful ones for complex tasks
+- Implement [caching](/v3/best-practices/caching) for repeated patterns
+</Accordion>
+<Accordion title="Python SDK or custom models">
+Python is now supported in Stagehand v3! The Python SDK uses a BYOB (Bring Your Own Browser) architecture.
+
+**Solutions:**
+
+- See the [Python SDK documentation](/v3/sdk/python) for installation and usage
+- Check the [Python migration guide](/v3/migrations/python) if upgrading from v2
+</Accordion>
+</AccordionGroup>
+
+### Need Help? Contact Support
+
+Can't find a solution? Have a question? Reach out to our support team:
+
+<Card
+  title="Contact Support"
+  icon="envelope"
+  href="mailto:support@browserbase.com"
+>
+  Email us at support@browserbase.com
+</Card>
+
+---
+
+## Next Steps
+
+<CardGroup cols={2}>
+<Card title="Prompting Guide" href="/v3/best-practices/prompting-best-practices" icon="brain">
+  Learn how to prompt LLMs for optimal results
+</Card>
+<Card title="Run Evals" href="/v3/basics/evals" icon="flask-vial">
+  Test which models work best for your specific use case
+</Card>
+
+<Card title="Caching Guide" href="/v3/best-practices/caching" icon="database">
+  Cache responses to reduce costs and improve speed
+</Card>
+<Card
+  title="Optimize Costs"
+  href="/v3/best-practices/cost-optimization"
+  icon="dollar-sign"
+>
+  Reduce LLM spending with caching and smart model selection
+</Card>
+</CardGroup>
diff --git a/packages/docs/v3/configuration/observability.mdx b/packages/docs/v3/configuration/observability.mdx
new file mode 100644
index 000000000..3f8c07750
--- /dev/null
+++ b/packages/docs/v3/configuration/observability.mdx
@@ -0,0 +1,369 @@
+---
+title: Observability
+sidebarTitle: Observability
+description: Track Stagehand automation with session visibility and analytics
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+Stagehand provides powerful observability features to help you monitor, track performance, and analyze your browser automation workflows. Focus on session monitoring, resource usage, and operational insights for both Browserbase and local environments.
+
+## Browserbase Session Monitoring
+
+When running on Browserbase, you gain access to comprehensive cloud-based monitoring and session management through the Browserbase API and dashboard.
+
+<div style={{ textAlign: "center" }}>
+  <img src="/media/observability.gif" alt="Browserbase Session Observability" width="400" />
+</div>
+
+### Live Session Visibility
+
+Browserbase provides real-time visibility into your automation sessions:
+
+**Session Dashboard Features**
+- Real-time browser screen recording and replay
+- Network request monitoring with detailed timing
+- JavaScript console logs and error tracking
+- CPU and memory usage metrics
+- Session status and duration tracking
+
+**Session Management & API Access**
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+import { Browserbase } from "@browserbasehq/sdk";
+
+const browserbase = new Browserbase({
+  apiKey: process.env.BROWSERBASE_API_KEY,
+});
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE"
+});
+
+await stagehand.init();
+
+const sessionInfo = await browserbase.sessions.retrieve(stagehand.sessionId);
+
+console.log("Session status:", sessionInfo.status);
+console.log("Session region:", sessionInfo.region);
+console.log("CPU usage:", sessionInfo.avgCpuUsage);
+console.log("Memory usage:", sessionInfo.memoryUsage);
+console.log("Proxy bytes:", sessionInfo.proxyBytes);
+```
+
+### Session Analytics & Insights
+
+<CardGroup>
+  <Card title="Real-Time Monitoring" icon="chart-line">
+    Monitor live session status, resource usage, and geographic distribution. Scale and manage concurrent sessions with real-time insights.
+  </Card>
+
+  <Card title="Session Recordings" icon="video">
+    Review complete session recordings with frame-by-frame playback. Analyze network requests and debug browser interactions visually.
+  </Card>
+
+  <Card title="API Management" icon="code">
+    Programmatically access session data, automate lifecycle management, and integrate with monitoring systems through our API.
+  </Card>
+
+  <Card title="Usage Monitoring" icon="chart-bar">
+    Track resource consumption, session duration, and API usage. Get detailed breakdowns of costs and utilization across your automation.
+  </Card>
+</CardGroup>
+
+### Session Monitoring & Filtering
+
+Query and monitor sessions by status and metadata:
+
+```typescript
+import { Browserbase } from "@browserbasehq/sdk";
+
+const browserbase = new Browserbase({
+  apiKey: process.env.BROWSERBASE_API_KEY,
+});
+
+// List sessions with filtering
+async function getFilteredSessions() {
+  const sessions = await browserbase.sessions.list({
+    status: 'RUNNING'
+  });
+  
+  return sessions.map(session => ({
+    id: session.id,
+    status: session.status, // RUNNING, COMPLETED, ERROR, TIMED_OUT
+    startedAt: session.startedAt,
+    endedAt: session.endedAt,
+    region: session.region,
+    avgCpuUsage: session.avgCpuUsage,
+    memoryUsage: session.memoryUsage,
+    proxyBytes: session.proxyBytes,
+    userMetadata: session.userMetadata
+  }));
+}
+
+// Query sessions by metadata
+async function querySessionsByMetadata(query: string) {
+  const sessions = await browserbase.sessions.list({
+    q: query
+  });
+  
+  return sessions;
+}
+```
+
+## Local Environment Monitoring
+
+For local development, Stagehand provides performance monitoring and resource tracking capabilities directly on your machine.
+
+### Performance Tracking
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  verbose: 1, // Monitor performance without debug noise
+});
+
+await stagehand.init();
+
+// Track local automation metrics
+const startTime = Date.now();
+const initialMetrics = await stagehand.metrics;
+
+// ... perform automation tasks
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com");
+await stagehand.act("click button");
+await stagehand.extract({ instruction: "get data", schema: DataSchema });
+
+const finalMetrics = await stagehand.metrics;
+const executionTime = Date.now() - startTime;
+
+console.log('Local Performance Summary:', {
+  executionTime: `${executionTime}ms`,
+  totalTokens: finalMetrics.totalPromptTokens + finalMetrics.totalCompletionTokens,
+  totalInferenceTime: `${finalMetrics.totalInferenceTimeMs}ms`,
+  tokensPerSecond: ((finalMetrics.totalPromptTokens + finalMetrics.totalCompletionTokens) / (executionTime / 1000)).toFixed(2)
+});
+```
+
+## Resource Usage Monitoring
+
+When running locally, monitor system resource usage and browser performance:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+import * as os from 'os';
+import { performance } from 'perf_hooks';
+
+class LocalResourceMonitor {
+  private cpuUsage: number[] = [];
+  private memoryUsage: number[] = [];
+  
+  startMonitoring() {
+    const interval = setInterval(() => {
+      // Track system resources
+      const memUsage = process.memoryUsage();
+      this.memoryUsage.push(memUsage.heapUsed / 1024 / 1024); // MB
+      
+      // Track CPU (simplified)
+      const loadAvg = os.loadavg()[0];
+      this.cpuUsage.push(loadAvg);
+    }, 1000);
+    
+    return interval;
+  }
+  
+  getResourceSummary() {
+    return {
+      avgMemoryUsage: this.memoryUsage.reduce((a, b) => a + b, 0) / this.memoryUsage.length,
+      peakMemoryUsage: Math.max(...this.memoryUsage),
+      avgCpuLoad: this.cpuUsage.reduce((a, b) => a + b, 0) / this.cpuUsage.length,
+      totalDataPoints: this.cpuUsage.length
+    };
+  }
+}
+
+const monitor = new LocalResourceMonitor();
+const interval = monitor.startMonitoring();
+
+const stagehand = new Stagehand({ env: "LOCAL" });
+
+// ... run automation
+
+clearInterval(interval);
+console.log('Resource Usage:', monitor.getResourceSummary());
+```
+
+
+  <Card title="LLM Usage" icon="chart-line" href="/v3/basics/evals">
+    Monitor token usage, costs, and speed. Set up automated alerting for critical failures. Implement cost tracking across different environments. Use session analytics to optimize automation workflows.
+  </Card>
+
+
+## Real-Time Metrics & Monitoring
+
+### Basic Usage Tracking
+
+Monitor your automation's resource usage in real-time with `stagehand.metrics`:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({ env: "BROWSERBASE" });
+await stagehand.init();
+
+// Metrics are async in V3
+const metrics = await stagehand.metrics;
+console.log(metrics);
+
+// Monitor during automation
+const startTime = Date.now();
+const initialMetrics = await stagehand.metrics;
+
+// ... perform automation tasks
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com");
+await stagehand.act("click the login button");
+const data = await stagehand.extract({
+  instruction: "extract user info",
+  schema: UserSchema
+});
+
+const finalMetrics = await stagehand.metrics;
+const executionTime = Date.now() - startTime;
+
+console.log('Automation Summary:', {
+  totalTokens: finalMetrics.totalPromptTokens + finalMetrics.totalCompletionTokens,
+  executionTime: `${executionTime}ms`,
+  avgInferenceTime: `${finalMetrics.totalInferenceTimeMs / 3}ms`,
+});
+```
+
+### Understanding Metrics Data
+
+The metrics object provides detailed breakdown by Stagehand operation:
+
+```typescript
+interface StagehandMetrics {
+  // Act operation metrics
+  actPromptTokens: number;
+  actCompletionTokens: number;
+  actReasoningTokens: number;
+  actCachedInputTokens: number;
+  actInferenceTimeMs: number;
+
+  // Extract operation metrics
+  extractPromptTokens: number;
+  extractCompletionTokens: number;
+  extractReasoningTokens: number;
+  extractCachedInputTokens: number;
+  extractInferenceTimeMs: number;
+
+  // Observe operation metrics
+  observePromptTokens: number;
+  observeCompletionTokens: number;
+  observeReasoningTokens: number;
+  observeCachedInputTokens: number;
+  observeInferenceTimeMs: number;
+
+  // Agent operation metrics
+  agentPromptTokens: number;
+  agentCompletionTokens: number;
+  agentReasoningTokens: number;
+  agentCachedInputTokens: number;
+  agentInferenceTimeMs: number;
+
+  // Cumulative totals
+  totalPromptTokens: number;
+  totalCompletionTokens: number;
+  totalReasoningTokens: number;
+  totalCachedInputTokens: number;
+  totalInferenceTimeMs: number;
+}
+```
+
+**Example metrics output:**
+
+```typescript
+const metrics = await stagehand.metrics;
+console.log(metrics);
+
+// {
+//   actPromptTokens: 4011,
+//   actCompletionTokens: 51,
+//   actReasoningTokens: 12,
+//   actCachedInputTokens: 0,
+//   actInferenceTimeMs: 1688,
+//   extractPromptTokens: 4200,
+//   extractCompletionTokens: 243,
+//   extractReasoningTokens: 18,
+//   extractCachedInputTokens: 0,
+//   extractInferenceTimeMs: 4297,
+//   observePromptTokens: 347,
+//   observeCompletionTokens: 43,
+//   observeReasoningTokens: 5,
+//   observeCachedInputTokens: 0,
+//   observeInferenceTimeMs: 903,
+//   agentPromptTokens: 0,
+//   agentCompletionTokens: 0,
+//   agentReasoningTokens: 0,
+//   agentCachedInputTokens: 0,
+//   agentInferenceTimeMs: 0,
+//   totalPromptTokens: 8558,
+//   totalCompletionTokens: 337,
+//   totalReasoningTokens: 35,
+//   totalCachedInputTokens: 0,
+//   totalInferenceTimeMs: 6888
+// }
+```
+
+## Best Practices
+
+<AccordionGroup>
+<Accordion title="Production Monitoring">
+- Track session success rates and failure patterns
+- Monitor resource usage and scaling requirements
+- Set up automated alerting for critical failures
+- Implement cost tracking across different environments
+- Use session analytics to optimize automation workflows
+</Accordion>
+
+<Accordion title="Performance Optimization">
+- Compare Browserbase vs local execution times
+- Monitor token usage and inference costs across models
+- Track geographic performance differences
+- Identify bottlenecks in automation workflows
+- Optimize for cost-effectiveness and speed
+</Accordion>
+
+<Accordion title="Operational Insights">
+- Track session distribution across regions
+- Monitor concurrent session limits and scaling
+- Analyze failure patterns and common error scenarios
+- Use session recordings for root cause analysis
+- Implement custom metadata for workflow categorization
+</Accordion>
+
+<Accordion title="Integration & Alerting">
+- Integrate session APIs with monitoring dashboards
+- Set up automated notifications for session failures  
+- Track SLA compliance and performance benchmarks
+- Monitor resource costs and usage patterns
+- Use analytics data for capacity planning and optimization
+</Accordion>
+</AccordionGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+<Card title="History Tracking" icon="clock-rotate-left" href="/v3/best-practices/history">
+  Track all LLM operations with parameters, results, and timestamps for debugging.
+</Card>
+<Card title="Logging" icon="file-lines" href="/v3/configuration/logging">
+  Configure logging levels, custom loggers, and file-based session logging.
+</Card>
+</CardGroup>
diff --git a/packages/docs/v3/first-steps/ai-rules.mdx b/packages/docs/v3/first-steps/ai-rules.mdx
new file mode 100644
index 000000000..919e9d5cd
--- /dev/null
+++ b/packages/docs/v3/first-steps/ai-rules.mdx
@@ -0,0 +1,466 @@
+---
+title: AI Rules
+description: Using AI to write Stagehand code faster, and better.
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+You're likely using AI to write code, and there's a **right and wrong way to do it.** This page is a collection of rules, configs, and copy‑paste snippets to allow your AI agents/assistants to write performant, Stagehand code as fast as possible. 
+
+## Quickstart
+
+<CardGroup cols={2}>
+  <Card title="Add MCP servers" icon="screwdriver-wrench">
+    Configure Browserbase (Stagehand), Context7, DeepWiki, and Stagehand Docs in your MCP client. 
+  </Card>
+  <Card title="Pin editor rules" icon="memo">
+    Drop in `cursorrules` and `claude.md` so AI agents/assistants always emit Stagehand patterns. 
+  </Card>
+</CardGroup>
+
+## Using MCP Servers
+
+MCP (Model Context Protocol) servers act as intermediaries that connect AI systems to external data sources and tools. These servers enable your coding assistant to access real-time information, execute tasks, and retrieve structured data to enhance code generation accuracy.
+
+The following **MCP servers** provide specialized access to Stagehand documentation and related resources:
+
+<Accordion title="Context7 by Upstash" icon="database">
+Provides semantic search across documentation and codebase context. Context7 enables AI assistants to find relevant code patterns, examples, and implementation details from your project history. It maintains contextual understanding of your development workflow and can surface related solutions from previous work.
+
+**Installation:**
+```json
+{
+  "mcpServers": {
+    "context7": {
+      "command": "npx",
+      "args": ["-y", "@upstash/context7-mcp"]
+    }
+  }
+}
+```
+</Accordion>
+
+<Accordion title="DeepWiki by Cognition" icon="book-open">
+Offers deep indexing of GitHub repositories and documentation. DeepWiki allows AI agents to understand project architecture, API references, and best practices from the entire Stagehand ecosystem. It provides comprehensive knowledge about repository structure, code relationships, and development patterns.
+
+**Installation:**
+```json
+{
+  "mcpServers": {
+    "deepwiki": {
+      "url": "https://mcp.deepwiki.com/mcp"
+    }
+  }
+}
+```
+</Accordion>
+
+<Accordion title="Stagehand Docs by Mintlify" icon="mintbit">
+Direct access to official Stagehand documentation. This MCP server provides AI assistants with up-to-date API references, configuration options, and usage examples for accurate code generation. Mintlify auto-generates this server from the official docs, ensuring your AI assistant always has the latest information.
+
+**Usage:**
+```json
+{
+  "mcpServers": {
+    "stagehand-docs": {
+      "url": "https://docs.stagehand.dev/mcp"
+    }
+  }
+}
+```
+</Accordion>
+
+**How MCP Servers Enhance Your Development:**
+- **Real-time Documentation Access**: AI assistants can query the latest Stagehand docs, examples, and best practices
+- **Context-Aware Code Generation**: Servers provide relevant code patterns and configurations based on your specific use case
+- **Reduced Integration Overhead**: Standardized protocol eliminates the need for custom integrations with each documentation source
+- **Enhanced Accuracy**: AI agents receive structured, up-to-date information rather than relying on potentially outdated training data
+
+<Tip>
+**Prompting tip:** 
+Explicitly ask your coding agent/assistant to use these MCP servers to fetch relevant information from the docs so they have better context and know how to write proper Stagehand code. 
+
+ie. **"Use the stagehand-docs MCP to fetch the act/observe guidelines, then generate code that follows them. Prefer cached observe results."**
+</Tip>
+
+## Editor rule files (copy‑paste)
+
+Drop these in `.cursorrules`, `windsurfrules`, `claude.md`, or any agent rule framework:
+
+<Accordion title="TypeScript">
+
+``````md
+# Stagehand Project
+
+This is a project that uses Stagehand V3, a browser automation framework with AI-powered `act`, `extract`, `observe`, and `agent` methods.
+
+The main class can be imported as `Stagehand` from `@browserbasehq/stagehand`.
+
+**Key Classes:**
+
+- `Stagehand`: Main orchestrator class providing `act`, `extract`, `observe`, and `agent` methods
+- `context`: A `V3Context` object that manages browser contexts and pages
+- `page`: Individual page objects accessed via `stagehand.context.pages()[i]` or created with `stagehand.context.newPage()`
+
+## Initialize
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL", // or "BROWSERBASE"
+  verbose: 2, // 0, 1, or 2
+  model: "openai/gpt-4.1-mini", // or any supported model
+});
+
+await stagehand.init();
+
+// Access the browser context and pages
+const page = stagehand.context.pages()[0];
+const context = stagehand.context;
+
+// Create new pages if needed
+const page2 = await stagehand.context.newPage();
+```
+
+## Act
+
+Actions are called on the `stagehand` instance (not the page). Use atomic, specific instructions:
+
+```typescript
+// Act on the current active page
+await stagehand.act("click the sign in button");
+
+// Act on a specific page (when you need to target a page that isn't currently active)
+await stagehand.act("click the sign in button", { page: page2 });
+```
+
+**Important:** Act instructions should be atomic and specific:
+
+- ✅ Good: "Click the sign in button" or "Type 'hello' into the search input"
+- ❌ Bad: "Order me pizza" or "Type in the search bar and hit enter" (multi-step)
+
+### Observe + Act Pattern (Recommended)
+
+Cache the results of `observe` to avoid unexpected DOM changes:
+
+```typescript
+const instruction = "Click the sign in button";
+
+// Get candidate actions
+const actions = await stagehand.observe(instruction);
+
+// Execute the first action
+await stagehand.act(actions[0]);
+```
+
+To target a specific page:
+
+```typescript
+const actions = await stagehand.observe("select blue as the favorite color", {
+  page: page2,
+});
+await stagehand.act(actions[0], { page: page2 });
+```
+
+## Extract
+
+Extract data from pages using natural language instructions. The `extract` method is called on the `stagehand` instance.
+
+### Basic Extraction (with schema)
+
+```typescript
+import { z } from "zod";
+
+// Extract with explicit schema
+const data = await stagehand.extract(
+  "extract all apartment listings with prices and addresses",
+  z.object({
+    listings: z.array(
+      z.object({
+        price: z.string(),
+        address: z.string(),
+      }),
+    ),
+  }),
+);
+
+console.log(data.listings);
+```
+
+### Simple Extraction (without schema)
+
+```typescript
+// Extract returns a default object with 'extraction' field
+const result = await stagehand.extract("extract the sign in button text");
+
+console.log(result);
+// Output: { extraction: "Sign in" }
+
+// Or destructure directly
+const { extraction } = await stagehand.extract(
+  "extract the sign in button text",
+);
+console.log(extraction); // "Sign in"
+```
+
+### Targeted Extraction
+
+Extract data from a specific element using a selector:
+
+```typescript
+const reason = await stagehand.extract(
+  "extract the reason why script injection fails",
+  z.string(),
+  { selector: "/html/body/div[2]/div[3]/iframe/html/body/p[2]" },
+);
+```
+
+### URL Extraction
+
+When extracting links or URLs, use `z.string().url()`:
+
+```typescript
+const { links } = await stagehand.extract(
+  "extract all navigation links",
+  z.object({
+    links: z.array(z.string().url()),
+  }),
+);
+```
+
+### Extracting from a Specific Page
+
+```typescript
+// Extract from a specific page (when you need to target a page that isn't currently active)
+const data = await stagehand.extract(
+  "extract the placeholder text on the name field",
+  { page: page2 },
+);
+```
+
+## Observe
+
+Plan actions before executing them. Returns an array of candidate actions:
+
+```typescript
+// Get candidate actions on the current active page
+const [action] = await stagehand.observe("Click the sign in button");
+
+// Execute the action
+await stagehand.act(action);
+```
+
+Observing on a specific page:
+
+```typescript
+// Target a specific page (when you need to target a page that isn't currently active)
+const actions = await stagehand.observe("find the next page button", {
+  page: page2,
+});
+await stagehand.act(actions[0], { page: page2 });
+```
+
+## Agent
+
+Use the `agent` method to autonomously execute complex, multi-step tasks.
+
+### Basic Agent Usage
+
+```typescript
+const page = stagehand.context.pages()[0];
+await page.goto("https://www.google.com");
+
+const agent = stagehand.agent({
+  model: "google/gemini-2.0-flash",
+  executionModel: "google/gemini-2.0-flash",
+});
+
+const result = await agent.execute({
+  instruction: "Search for the stock price of NVDA",
+  maxSteps: 20,
+});
+
+console.log(result.message);
+```
+
+### Computer Use Agent (CUA)
+
+For more advanced scenarios using computer-use models:
+
+```typescript
+const agent = stagehand.agent({
+  mode: "cua", // Enable Computer Use Agent mode
+  model: "anthropic/claude-sonnet-4-20250514",
+  // or "google/gemini-2.5-computer-use-preview-10-2025"
+  systemPrompt: `You are a helpful assistant that can use a web browser.
+    Do not ask follow up questions, the user will trust your judgement.`,
+});
+
+await agent.execute({
+  instruction: "Apply for a library card at the San Francisco Public Library",
+  maxSteps: 30,
+});
+```
+
+### Agent with Custom Model Configuration
+
+```typescript
+const agent = stagehand.agent({
+  mode: "cua",
+  model: {
+    modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+    apiKey: process.env.GEMINI_API_KEY,
+  },
+  systemPrompt: `You are a helpful assistant.`,
+});
+```
+
+### Agent with Integrations (MCP/External Tools)
+
+```typescript
+const agent = stagehand.agent({
+  integrations: [`https://mcp.exa.ai/mcp?exaApiKey=${process.env.EXA_API_KEY}`],
+  systemPrompt: `You have access to the Exa search tool.`,
+});
+```
+
+## Advanced Features
+
+### DeepLocator (XPath Targeting)
+
+Target specific elements across shadow DOM and iframes:
+
+```typescript
+await page
+  .deepLocator("/html/body/div[2]/div[3]/iframe/html/body/p")
+  .highlight({
+    durationMs: 5000,
+    contentColor: { r: 255, g: 0, b: 0 },
+  });
+```
+
+### Multi-Page Workflows
+
+```typescript
+const page1 = stagehand.context.pages()[0];
+await page1.goto("https://example.com");
+
+const page2 = await stagehand.context.newPage();
+await page2.goto("https://example2.com");
+
+// Act/extract/observe operate on the current active page by default
+// Pass { page } option to target a specific page
+await stagehand.act("click button", { page: page1 });
+await stagehand.extract("get title", { page: page2 });
+```
+``````
+
+</Accordion>
+
+<Accordion title="Python">
+
+``````md
+# Stagehand Python Project
+
+This is a project that uses [Stagehand Python](https://github.com/browserbase/stagehand-python), which provides AI-powered browser automation with `act`, `extract`, and `observe` methods.
+
+`Stagehand` is a class that provides configuration and browser automation capabilities with:
+- Pages accessed via `stagehand.context.pages()` or `stagehand.context.activePage()`
+- `stagehand.context`: A StagehandContext object (extends Playwright BrowserContext)
+- `stagehand.agent()`: Create AI-powered agents for autonomous multi-step workflows
+- `stagehand.init()`: Initialize the browser session
+- `stagehand.close()`: Clean up resources
+
+`Page` extends Playwright's Page class with AI-powered methods:
+- `act()`: Perform actions on web elements using natural language
+- `extract()`: Extract structured data from pages using schemas
+- `observe()`: Plan actions and get selectors before executing
+
+`Agent` provides autonomous Computer Use Agent capabilities:
+- `execute()`: Perform complex multi-step tasks using natural language instructions
+
+Use the following rules to write code for this project.
+
+- To plan an instruction like "click the sign in button", use Stagehand `observe` to get the action to execute.
+
+You can also pass in the following params:
+
+- The result of `observe` is a list of `ObserveResult` objects that can directly be used as params for `act` like this:
+  
+- When writing code that needs to extract data from the page, use Stagehand `extract`. Use Pydantic models for schemas:
+
+## Initialize
+
+### Configuration Options
+
+Key configuration options in `StagehandConfig`:
+
+## Act
+
+You can act directly with string instructions:
+
+Use variables for dynamic form filling:
+
+**Best Practices:**
+- Cache the results of `observe` to avoid unexpected DOM changes
+- Keep actions atomic and specific (e.g., "Click the sign in button" not "Sign in to the website")
+- Use specific, descriptive instructions
+
+Act `action` should be as atomic and specific as possible, i.e. "Click the sign in button" or "Type 'hello' into the search input".
+AVOID actions that are more than one step, i.e. "Order me pizza" or "Send an email to Paul asking him to call me".
+
+## Extract
+
+### Simple String Extraction
+
+### Structured Extraction with Schema (Recommended)
+Always use Pydantic models for structured data extraction:
+
+### Array Extraction
+For arrays, use List types:
+
+### Complex Object Extraction
+For more complex data structures:
+
+## Agent System
+
+Stagehand provides an Agent System for autonomous web browsing using Computer Use Agents (CUA).
+
+### Creating Agents
+
+### Agent Execution
+
+**Best Practices:**
+- Be specific with instructions: `"Fill out the contact form with name 'John Doe' and submit it"`
+- Break down complex tasks into smaller steps
+- Use error handling with try/except blocks
+- Combine agents for navigation with traditional methods for precise data extraction
+
+## Project Structure Best Practices
+
+- Store configurations in environment variables or config files
+- Use async/await patterns consistently
+- Implement main automation logic in async functions
+- Use async context managers for resource management
+- Use type hints and Pydantic models for data validation
+- Handle exceptions appropriately with try/except blocks
+``````
+
+</Accordion>
+
+## Security notes
+
+- Do not embed secrets in docs or rule files; use env vars in MCP configs.
+- Avoid broad actions that may trigger unintended navigation; prefer `observe` first.
+
+## Resources/references
+
+- Context7 MCP (Upstash)
+  - https://github.com/upstash/context7
+- DeepWiki MCP
+  - https://mcp.deepwiki.com/
+- Stagehand Docs MCP (Mintlify)
+  - https://docs.stagehand.dev/mcp
diff --git a/packages/docs/v3/first-steps/installation.mdx b/packages/docs/v3/first-steps/installation.mdx
new file mode 100644
index 000000000..bd129a69b
--- /dev/null
+++ b/packages/docs/v3/first-steps/installation.mdx
@@ -0,0 +1,151 @@
+---
+title: Installation
+description: Integrate Stagehand into an existing project.
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+Install Stagehand in your current app with the TypeScript SDK.
+
+<Tip>
+We recommend using the Node.js runtime environment to run Stagehand scripts.
+
+**Bun is now supported** as long as you do not integrate Stagehand with Playwright. Playwright is not compatible with Bun.
+</Tip>
+
+<Tabs>
+<Tab title="TypeScript">
+
+### Install dependencies
+
+<CodeGroup>
+```bash npm
+npm install @browserbasehq/stagehand
+```
+
+```bash pnpm
+pnpm add @browserbasehq/stagehand
+```
+
+```bash yarn
+yarn add @browserbasehq/stagehand
+```
+```bash bun icon="sparkles"
+bun add @browserbasehq/stagehand
+```
+</CodeGroup>
+
+<Tip>
+If you plan to run locally, you need to have [Chrome](https://www.google.com/chrome/) installed on your machine. For cloud browser sessions, skip this.
+</Tip>
+
+### Configure environment
+
+Set environment variables (or a `.env` via your framework):
+
+<CodeGroup>
+```bash Bash
+OPENAI_API_KEY=your_api_key
+BROWSERBASE_API_KEY=your_api_key
+BROWSERBASE_PROJECT_ID=your_project_id
+```
+</CodeGroup>
+
+<Note>
+Stagehand does not auto-load `.env` files.
+
+If you use a `.env` file, install and initialize `dotenv` in your own app code:
+
+```bash
+npm install dotenv
+```
+
+```typescript
+import dotenv from "dotenv";
+dotenv.config({ path: ".env" });
+```
+</Note>
+
+### Use in your codebase
+
+Add Stagehand where you need browser automation.
+
+```typescript
+import dotenv from "dotenv";
+import { Stagehand } from "@browserbasehq/stagehand";
+import { z } from "zod";
+
+dotenv.config({ path: ".env" });  // if needed
+
+async function main() {
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE"
+  });
+
+  await stagehand.init();
+  const page = stagehand.context.pages()[0];
+
+  await page.goto("https://example.com");
+
+  // Act on the page
+  await stagehand.act("Click the learn more button");
+
+  // Extract structured data
+  const description = await stagehand.extract("extract the description", z.string());
+
+  console.log(description);
+  await stagehand.close();
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+```
+
+</Tab>
+
+<Tab title="Other Languages">
+
+<Note>
+For Python and other language SDKs, use the **language selector** in the top left corner of the sidebar to view the SDK documentation for your language.
+</Note>
+
+</Tab>
+
+</Tabs>
+
+## Next steps
+
+<CardGroup cols={2}>
+  <Card 
+    title="Configuration"
+    icon="gear"
+    href="/v3/configuration/browser"
+  >
+    Environment, Browserbase vs Local, logging, timeouts, LLM customization
+  </Card>
+  <Card 
+    title="Act"
+    icon="arrow-pointer"
+    href="/v3/basics/act"
+  >
+    Perform precise actions with natural language
+  </Card>
+  <Card 
+    title="Extract"
+    icon="download"
+    href="/v3/basics/extract"
+  >
+    Typed data extraction with Zod schemas
+  </Card>
+  <Card 
+    title="Observe"
+    icon="eye"
+    href="/v3/basics/observe"
+  >
+    Discover elements and suggested actions
+  </Card>
+</CardGroup>
diff --git a/packages/docs/v3/first-steps/introduction.mdx b/packages/docs/v3/first-steps/introduction.mdx
new file mode 100644
index 000000000..0d96e3fbc
--- /dev/null
+++ b/packages/docs/v3/first-steps/introduction.mdx
@@ -0,0 +1,117 @@
+---
+title: Introducing Stagehand
+sidebarTitle: Introduction
+description: Developers use Stagehand to reliably automate the web.
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+Stagehand is a browser automation framework used to control web browsers with natural language and code. By combining the power of AI with the precision of code, Stagehand makes web automation flexible, maintainable, and actually reliable.
+
+## The Problem with Browser Automation
+
+Traditional frameworks like Playwright and Puppeteer force you to write brittle scripts that break with every UI change. Web agents promise to solve this with AI, but leave you at the mercy of unpredictable behavior.
+
+**You're stuck between two bad options:**
+- **Too brittle**: Traditional selectors break when websites change
+- **Too agentic**: AI agents are unpredictable and impossible to debug
+
+## Enter Stagehand
+
+Stagehand gives you the best of both worlds through four powerful primitives that let you choose exactly how much AI to use:
+
+<CardGroup cols={2}>
+  <Card title="Act" icon="play" href="/v3/basics/act">
+    Execute actions using natural language
+  </Card>
+  <Card title="Extract" icon="database" href="/v3/basics/extract">
+    Pull structured data with schemas
+  </Card>
+  <Card title="Observe" icon="eye" href="/v3/basics/observe">
+    Discover available actions on any page
+  </Card>
+  <Card title="Agent" icon="robot" href="/v3/basics/agent">
+    Automate entire workflows autonomously
+  </Card>
+</CardGroup>
+
+```typescript
+// Act - Execute natural language actions
+await stagehand.act("click the login button");
+
+// Extract - Pull structured data
+const price = await stagehand.extract(
+  "extract the price",
+  z.number()
+);
+
+// Observe - Discover available actions
+const actions = await stagehand.observe("find submit buttons");
+
+// Agent - Automate entire workflows
+const agent = stagehand.agent({
+  mode: "cua",
+  model: "google/gemini-2.5-computer-use-preview-10-2025",
+});
+await agent.execute("apply for this job");
+```
+
+
+## Why Developers Choose Stagehand
+
+- **Precise Control**: Mix AI-powered actions with deterministic code. You decide exactly how much AI to use.
+
+- **Actually Repeatable**: Save and replay actions exactly. No more "it worked on my machine" with browser automations.
+
+- **Maintainable at Scale**: One script can automate multiple websites. When sites change, your automations adapt.
+
+- **Composable Tools**: Choose your level of automation with Act, Extract, Observe, and Agent.
+
+## Built for Modern Development
+Stagehand is designed for developers building production browser automations and AI agents that need reliable web access.
+
+<AccordionGroup>
+  <Accordion title="Works Everywhere">
+    Compatible with all Chromium-based browsers: Chrome, Edge, Arc, Brave, and more.
+  </Accordion>
+  <Accordion title="Built by Browserbase">
+    Created and maintained by the team behind enterprise browser infrastructure.
+  </Accordion>
+</AccordionGroup>
+
+## Get Started in 60 Seconds
+<Info>
+  **Pro tip**: For best results, we recommend using Stagehand with [Browserbase](https://www.browserbase.com) for reliable cloud browser infrastructure.
+</Info>
+<CardGroup cols={2}>
+  <Card
+    title="Quickstart"
+    icon="rocket"
+    href="/v3/first-steps/quickstart"
+  >
+    Build your first automation in under a minute
+  </Card>
+  <Card
+    title="Try Director"
+    icon="wand-magic-sparkles"
+    href="https://www.director.ai"
+  >
+    Generate Stagehand scripts with AI
+  </Card>
+  <Card
+    title="View Templates"
+    icon="code"
+    href="https://www.browserbase.com/templates"
+  >
+    See real-world automation examples
+  </Card>
+  <Card
+    title="Join Discord"
+    icon="discord"
+    href="https://stagehand.dev/discord"
+  >
+    Get help from the community
+  </Card>
+</CardGroup>
diff --git a/packages/docs/v3/first-steps/quickstart.mdx b/packages/docs/v3/first-steps/quickstart.mdx
new file mode 100644
index 000000000..b2561d002
--- /dev/null
+++ b/packages/docs/v3/first-steps/quickstart.mdx
@@ -0,0 +1,130 @@
+---
+title: Quickstart
+description: 'Stagehand allows you to build web automations with natural language and code.'
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+If this is your **first time using Stagehand**, you should try [Director](https://director.ai) first. It's an agent that allows you to build Stagehand workflows using natural language. You can also try Stagehand using our [MCP server](/integrations/mcp/introduction) .   
+
+Otherwise, the quickest way to start with Stagehand is with our CLI. It scaffolds a ready‑to‑run Stagehand app with sensible defaults, and an example script.
+
+<Note>
+This quickstart is for **TypeScript**. For other languages, change the language selector in the top left corner.
+</Note>
+
+## 1) Create a sample project
+
+<CodeGroup>
+```bash Bash
+npx create-browser-app
+```
+</CodeGroup>
+
+## 2) Run it
+
+Follow the CLI prompts to enter the project directory and add your API keys. Then run the example script.
+
+<CodeGroup>
+```bash Bash
+cd my-stagehand-app # Enter the project directory
+cp .env.example .env  # Add your API keys
+npm start # Run the example script
+```
+</CodeGroup>
+
+## 3) Use Stagehand (act, extract, observe)
+
+The scaffold includes an index.ts file that contains the example script. Here's what it looks like:
+
+<CodeGroup>
+```typescript TypeScript
+import "dotenv/config";
+import { Stagehand } from "@browserbasehq/stagehand";
+
+async function main() {
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE"
+  });
+
+  await stagehand.init();
+
+  console.log(`Stagehand Session Started`);
+  console.log(`Watch live: https://browserbase.com/sessions/${stagehand.browserbaseSessionID}`);
+
+  const page = stagehand.context.pages()[0];
+
+  await page.goto("https://stagehand.dev");
+
+  const extractResult = await stagehand.extract("Extract the value proposition from the page.");
+  console.log(`Extract result:\n`, extractResult);
+
+  await stagehand.act("Click the 'Evals' button.");
+
+  const observeResult = await stagehand.observe("What can I click on this page?");
+  console.log(`Observe result:\n`, observeResult);
+
+  const agent = stagehand.agent({
+    mode: "cua",
+    model: "google/gemini-2.5-computer-use-preview-10-2025",
+    systemPrompt: "You're a helpful assistant that can control a web browser.",
+  });
+
+  const agentResult = await agent.execute("What is the most accurate model to use in Stagehand?");
+  console.log(`Agent result:\n`, agentResult);
+
+  await stagehand.close();
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+
+```
+</CodeGroup>
+
+<Tip>
+To use, set provider keys in `.env` (e.g., `OPENAI_API_KEY`). For cloud browsers, add `BROWSERBASE_API_KEY` and `BROWSERBASE_PROJECT_ID`.
+</Tip>
+
+## Next steps
+
+Learn about the Stagehand primitives: act, extract, observe, and agent.
+
+<CardGroup cols={2}>
+  <Card 
+    title="Act" 
+    icon="arrow-pointer" 
+    href="/v3/basics/act"
+  >
+    Perform actions on web pages with natural language
+  </Card>
+  
+  <Card 
+    title="Extract" 
+    icon="download" 
+    href="/v3/basics/extract"
+  >
+    Get structured data with Zod schemas
+  </Card>
+  
+  <Card 
+    title="Observe" 
+    icon="eye" 
+    href="/v3/basics/observe"
+  >
+    Discover available elements and actions
+  </Card>
+  
+  <Card 
+    title="Agent" 
+    icon="robot" 
+    href="/v3/basics/agent"
+  >
+    Autonomous multi-step browser workflows
+  </Card>
+</CardGroup>
+
diff --git a/packages/docs/v3/integrations/convex/configuration.mdx b/packages/docs/v3/integrations/convex/configuration.mdx
new file mode 100644
index 000000000..5385b67ed
--- /dev/null
+++ b/packages/docs/v3/integrations/convex/configuration.mdx
@@ -0,0 +1,212 @@
+---
+title: "Use Stagehand in Convex"
+sidebarTitle: Configuration
+description: "Set up AI-powered browser automation in your Convex application"
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+<Card
+  title="Check out the convex-stagehand repo"
+  icon="github"
+  href="https://github.com/browserbase/convex-stagehand"
+>
+  Clone the [GitHub repo](https://github.com/browserbase/convex-stagehand) to get started with Stagehand in Convex.
+</Card>
+
+## Installation
+
+Install the convex-stagehand component and Zod for schema validation:
+
+```bash
+npm install @browserbasehq/convex-stagehand zod
+```
+
+## Configuration
+
+Add the Stagehand component to your `convex/convex.config.ts`:
+
+```typescript convex/convex.config.ts
+import { defineApp } from "convex/server";
+import stagehand from "@browserbasehq/convex-stagehand/convex.config";
+
+const app = defineApp();
+app.use(stagehand, { name: "stagehand" });
+export default app;
+```
+
+## Environment Variables
+
+Set the following environment variables in your [Convex Dashboard](https://dashboard.convex.dev):
+
+| Variable | Description |
+|----------|-------------|
+| `BROWSERBASE_API_KEY` | Your Browserbase API key |
+| `BROWSERBASE_PROJECT_ID` | Your Browserbase project ID |
+| `MODEL_API_KEY` | API key for your LLM provider (OpenAI, Anthropic, etc.) |
+
+## Basic Usage
+
+### Initialize the Client
+
+Create a Stagehand instance in your Convex action:
+
+```typescript convex/actions.ts
+"use node";
+
+import { Stagehand } from "@browserbasehq/convex-stagehand";
+import { components } from "./_generated/api";
+import { action } from "./_generated/server";
+import { z } from "zod";
+
+const stagehand = new Stagehand(components.stagehand, {
+  browserbaseApiKey: process.env.BROWSERBASE_API_KEY!,
+  browserbaseProjectId: process.env.BROWSERBASE_PROJECT_ID!,
+  modelApiKey: process.env.MODEL_API_KEY!,
+});
+```
+
+### Extract Data
+
+Extract structured data from a web page using natural language instructions and Zod schemas:
+
+```typescript
+export const extractProducts = action({
+  handler: async (ctx) => {
+    const data = await stagehand.extract(ctx, {
+      url: "https://example.com/products",
+      instruction: "Extract all product names and prices",
+      schema: z.object({
+        products: z.array(z.object({
+          name: z.string(),
+          price: z.string(),
+        }))
+      })
+    });
+
+    return data.products;
+  }
+});
+```
+
+### Perform Actions
+
+Execute browser interactions using plain English:
+
+```typescript
+export const loginToSite = action({
+  handler: async (ctx) => {
+    const result = await stagehand.act(ctx, {
+      url: "https://example.com/login",
+      action: "Click the login button and wait for the page to load"
+    });
+
+    return result;
+  }
+});
+```
+
+### Observe Elements
+
+Identify interactive elements on a page:
+
+```typescript
+export const findNavLinks = action({
+  handler: async (ctx) => {
+    const actions = await stagehand.observe(ctx, {
+      url: "https://example.com",
+      instruction: "Find all clickable navigation links"
+    });
+
+    return actions;
+  }
+});
+```
+
+### Run Autonomous Tasks
+
+Use the agent API for complex multi-step workflows:
+
+```typescript
+export const searchAndExtract = action({
+  handler: async (ctx) => {
+    const result = await stagehand.agent(ctx, {
+      url: "https://google.com",
+      instruction: "Search for 'convex database' and extract the top 3 results",
+      options: { maxSteps: 10 }
+    });
+
+    return result;
+  }
+});
+```
+
+## Session Management
+
+For workflows that span multiple operations, you can reuse browser sessions:
+
+```typescript
+export const multiStepWorkflow = action({
+  handler: async (ctx) => {
+    // Start a session
+    const session = await stagehand.startSession(ctx, {
+      url: "https://example.com",
+      options: { timeout: 30000, waitUntil: "networkidle" }
+    });
+
+    // Perform multiple operations with the same session
+    await stagehand.act(ctx, {
+      sessionId: session.sessionId,
+      action: "Click the login button"
+    });
+
+    const data = await stagehand.extract(ctx, {
+      sessionId: session.sessionId,
+      instruction: "Extract the user profile information",
+      schema: z.object({
+        name: z.string(),
+        email: z.string(),
+      })
+    });
+
+    // End the session
+    await stagehand.endSession(ctx, { sessionId: session.sessionId });
+
+    return data;
+  }
+});
+```
+
+Session persistence allows you to preserve authentication state and cookies between operations.
+
+## Model Configuration
+
+The default model is `openai/gpt-4o`. You can configure alternative providers:
+
+```typescript
+const stagehand = new Stagehand(components.stagehand, {
+  browserbaseApiKey: process.env.BROWSERBASE_API_KEY!,
+  browserbaseProjectId: process.env.BROWSERBASE_PROJECT_ID!,
+  modelApiKey: process.env.ANTHROPIC_API_KEY!,
+  modelName: "anthropic/claude-sonnet-4-5-20250929",
+});
+```
+
+## Requirements
+
+- Convex 1.29.3 or later
+- A [Browserbase](https://browserbase.com) account with API credentials
+- An API key from a supported LLM provider (OpenAI, Anthropic, etc.)
+
+## References
+
+<CardGroup cols={2}>
+  <Card title="Source Code" icon="github" href="https://github.com/browserbase/convex-stagehand">
+    Browse the complete repository on GitHub
+  </Card>
+  <Card title="Convex Docs" icon="book" href="https://docs.convex.dev">
+    Learn more about Convex
+  </Card>
+</CardGroup>
diff --git a/packages/docs/v3/integrations/convex/introduction.mdx b/packages/docs/v3/integrations/convex/introduction.mdx
new file mode 100644
index 000000000..3c0e30578
--- /dev/null
+++ b/packages/docs/v3/integrations/convex/introduction.mdx
@@ -0,0 +1,43 @@
+---
+title: "Convex"
+sidebarTitle: Introduction
+description: "AI-powered browser automation for Convex applications"
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## Overview
+
+This guide shows you how to use Stagehand with Convex to create AI-powered browser automation within your Convex applications. By the end of this guide, you'll know how to:
+
+- Set up the convex-stagehand component in your Convex app
+- Extract structured data from web pages using natural language
+- Execute browser actions via plain English instructions
+- Build autonomous multi-step workflows with the agent API
+
+## When You'd Use This
+
+The Convex integration is perfect for scenarios where you need browser automation in serverless Convex functions:
+
+- **Data extraction pipelines**: Extract structured data from websites and store it directly in your Convex database
+- **Automated workflows**: Build background jobs that interact with web pages on behalf of users
+- **Form automation**: Automatically fill out and submit forms based on data from your Convex app
+- **Multi-step web processes**: Execute complex browser workflows that require decision-making and adaptation
+
+The integration wraps the Stagehand REST API to provide Convex actions with the ability to control cloud browsers via Browserbase:
+
+1. **Act**: Perform actions like clicking, typing, or navigating using natural language
+2. **Extract**: Extract structured data from web pages with Zod schemas
+3. **Observe**: Identify and analyze interactive elements on the page
+4. **Agent**: Run autonomous multi-step tasks with AI decision-making
+
+<CardGroup cols={2}>
+  <Card title="Source Code" icon="github" href="https://github.com/browserbase/convex-stagehand">
+    Browse the repository on GitHub
+  </Card>
+  <Card title="Convex Configuration" icon="gear" href="/v3/integrations/convex/configuration">
+    Learn how to set up and configure convex-stagehand
+  </Card>
+</CardGroup>
diff --git a/packages/docs/v3/integrations/crew-ai/configuration.mdx b/packages/docs/v3/integrations/crew-ai/configuration.mdx
new file mode 100644
index 000000000..418afa95b
--- /dev/null
+++ b/packages/docs/v3/integrations/crew-ai/configuration.mdx
@@ -0,0 +1,174 @@
+---
+title: "Use CrewAI to Automate Browser Tasks"
+sidebarTitle: Configuration
+description: "Create intelligent agents that can interact with websites and automate browser tasks using natural language instructions"
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+This guide walks you through setting up CrewAI with Browserbase to create agents that can perform web automation tasks using natural language instructions.
+
+## Step 1: Install Dependencies
+
+Install the required packages for CrewAI and Stagehand integration:
+
+```bash
+pip install stagehand crewai crewai-tools
+```
+
+## Step 2: Configure Environment Variables
+
+You'll need API keys from three services:
+
+1. **Browserbase API Key and Project ID**: Get these from your [Browserbase dashboard](https://www.browserbase.com/)
+2. **LLM API Key**: Get an API key from [OpenAI](https://platform.openai.com/api-keys) or [Anthropic](https://console.anthropic.com/)
+
+Store your API keys securely as environment variables:
+
+```bash
+BROWSERBASE_API_KEY="your-browserbase-api-key"
+BROWSERBASE_PROJECT_ID="your-browserbase-project-id"
+OPENAI_API_KEY="your-openai-api-key"
+ANTHROPIC_API_KEY="your-anthropic-api-key"
+```
+
+## Step 3: Create Your First Agent
+
+Create a Python script with a basic CrewAI agent:
+
+```python
+import os
+from crewai import Agent, Task, Crew
+from crewai_tools import StagehandTool
+from stagehand.schemas import AvailableModel
+
+# Get API keys from environment
+browserbase_api_key = os.environ.get("BROWSERBASE_API_KEY")
+browserbase_project_id = os.environ.get("BROWSERBASE_PROJECT_ID")
+model_api_key = os.environ.get("OPENAI_API_KEY")  # or ANTHROPIC_API_KEY
+
+# Initialize the StagehandTool
+stagehand_tool = StagehandTool(
+    api_key=browserbase_api_key,
+    project_id=browserbase_project_id,
+    model_api_key=model_api_key,
+    model_name=AvailableModel.GPT_4O,  # or AvailableModel.CLAUDE_3_7_SONNET_LATEST
+)
+
+# Create an agent with the tool
+researcher = Agent(
+    role="Web Researcher",
+    goal="Find and summarize information from websites",
+    backstory="I'm an expert at finding information online.",
+    verbose=True,
+    tools=[stagehand_tool],
+)
+```
+
+## Step 4: Create and Run a Task
+
+Define a task for your agent and execute it:
+
+```python
+# Create a task that uses the tool
+research_task = Task(
+    description="Go to https://www.example.com and tell me what you see on the homepage.",
+    agent=researcher,
+)
+
+# Run the crew
+crew = Crew(
+    agents=[researcher],
+    tasks=[research_task],
+    verbose=True,
+)
+
+try:
+    result = crew.kickoff()
+    print(result)
+finally:
+    # Clean up resources
+    stagehand_tool.close()
+```
+
+## Step 5: Run Your Script
+
+Execute your Python script:
+
+```bash
+python your_crew_script.py
+```
+
+## Advanced Configuration
+
+Customize the StagehandTool behavior with additional parameters:
+
+```python
+stagehand_tool = StagehandTool(
+    api_key=browserbase_api_key,
+    project_id=browserbase_project_id,
+    model_api_key=model_api_key,
+    model_name=AvailableModel.CLAUDE_3_7_SONNET_LATEST,
+    dom_settle_timeout_ms=5000,  # Wait longer for DOM to settle
+    headless=True,  # Run browser in headless mode
+    self_heal=True,  # Attempt to recover from errors
+    wait_for_captcha_solves=True,  # Wait for CAPTCHA solving
+    verbose=1,  # Control logging verbosity (0-3)
+)
+```
+
+## Example Tasks
+
+<Tabs>
+  <Tab title="Form Submission" value="form-submission" label="Python">
+    ```python
+    form_task = Task(
+        description="""
+        Submit a contact form:
+        1. Go to https://example.com/contact
+        2. Fill out the form with name 'John Doe', email 'john@example.com'
+        3. Submit and confirm success
+        """,
+        agent=researcher,
+    )
+    ```
+  </Tab>
+  <Tab title="Data Extraction" value="data-extraction" label="Python">
+    ```python
+    extraction_task = Task(
+        description="""
+        Extract product information:
+        1. Go to the products page
+        2. Extract all product names, prices, and descriptions
+        3. Format as structured data
+        """,
+        agent=researcher,
+    )
+    ```
+  </Tab>
+  <Tab title="Multi-step Navigation" value="multi-step-navigation" label="Python">
+    ```python
+    navigation_task = Task(
+        description="""
+        Navigate and analyze:
+        1. Start at homepage
+        2. Navigate to products section
+        3. Filter by 'Electronics' category
+        4. Find and extract details of highest-rated product
+        """,
+        agent=researcher,
+    )
+    ```
+  </Tab>
+</Tabs>
+
+<CardGroup cols={2}>
+  <Card title="CrewAI Documentation" icon="book" href="https://docs.crewai.com/">
+    Dive into the CrewAI documentation to learn more about its capabilities and integrations.
+  </Card>
+  <Card title="Browserbase Documentation" icon="book" href="https://docs.browserbase.com/">
+    Access the Browserbase documentation for comprehensive guides and resources.
+  </Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v3/integrations/crew-ai/introduction.mdx b/packages/docs/v3/integrations/crew-ai/introduction.mdx
new file mode 100644
index 000000000..811823d3d
--- /dev/null
+++ b/packages/docs/v3/integrations/crew-ai/introduction.mdx
@@ -0,0 +1,39 @@
+---
+title: "CrewAI Introduction"
+sidebarTitle: Introduction
+description: "Automate browser tasks using natural language instructions with CrewAI"
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## Overview
+
+This guide shows you how to use CrewAI with Browserbase to create intelligent agents that can automate web interactions. By the end of this guide, you'll know how to:
+
+- Set up CrewAI with the StagehandTool
+- Create agents that can interact with websites
+- Automate browser tasks using natural language instructions
+- Extract structured data from web pages
+
+## When You'd Use This
+
+The CrewAI integration is perfect for scenarios where you need intelligent web automation:
+
+- **Research automation**: Have agents research information across multiple websites
+- **Data collection**: Extract structured data from e-commerce sites, job boards, or news sites
+- **Form automation**: Automatically fill out and submit forms based on specific criteria
+- **Multi-step workflows**: Execute complex browser workflows that require decision-making
+
+The StagehandTool wraps the Stagehand Python SDK to provide CrewAI agents with the ability to control a real web browser and interact with websites using three core primitives:
+
+1. **Act**: Perform actions like clicking, typing, or navigating
+2. **Extract**: Extract structured data from web pages
+3. **Observe**: Identify and analyze elements on the page
+
+<CardGroup cols={1}>
+<Card title="CrewAI Configuration" icon="gear" href="/v3/integrations/crew-ai/configuration">
+  Learn how to configure and use the StagehandTool with CrewAI agents for web automation tasks
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v3/integrations/langchain/configuration.mdx b/packages/docs/v3/integrations/langchain/configuration.mdx
new file mode 100644
index 000000000..64f57e58a
--- /dev/null
+++ b/packages/docs/v3/integrations/langchain/configuration.mdx
@@ -0,0 +1,246 @@
+---
+title: "LangChain JS Configuration"
+sidebarTitle: Configuration
+description: "Set up Stagehand with LangChain JS to create intelligent web automation agents"
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+This guide walks you through integrating Stagehand with LangChain JS to build powerful web automation workflows using natural language instructions.
+
+## Step 1: Install Dependencies
+
+Install the required packages for LangChain JS and Stagehand integration:
+
+```bash
+npm install @langchain/langgraph @langchain/community @langchain/core @browserbasehq/stagehand
+```
+
+## Step 2: Configure Environment Variables
+
+For remote browser automation, set up your Browserbase credentials:
+
+```bash
+BROWSERBASE_API_KEY="your-browserbase-api-key"
+BROWSERBASE_PROJECT_ID="your-browserbase-project-id"
+```
+
+## Step 3: Create a Stagehand Instance
+
+Initialize Stagehand with your preferred configuration:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+// For local development
+const stagehand = new Stagehand({
+    env: "LOCAL",
+    verbose: 2,
+    enableCaching: false,
+});
+
+// For production with Browserbase
+const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    verbose: 1,
+    enableCaching: true,
+});
+```
+
+## Step 4: Generate the StagehandToolkit
+
+Create the toolkit that provides LangChain-compatible tools:
+
+```typescript
+import { StagehandToolkit } from '@langchain/community/agents/toolkits/stagehand';
+
+const stagehandToolkit = await StagehandToolkit.fromStagehand(stagehand);
+```
+
+## Step 5: Use Individual Tools
+
+The toolkit provides four specialized tools for web automation:
+
+### Available Tools
+
+- **stagehand_navigate**: Navigate to specific URLs
+- **stagehand_act**: Perform browser actions (clicking, typing, etc.)
+- **stagehand_extract**: Extract structured data using schemas  
+- **stagehand_observe**: Analyze page elements and possible actions
+
+### Basic Tool Usage
+
+```typescript
+import { z } from "zod";
+
+// Navigate to a website
+const navigateTool = stagehandToolkit.tools.find(
+    (t) => t.name === "stagehand_navigate"
+);
+await navigateTool.invoke("https://www.google.com");
+
+// Perform an action
+const actionTool = stagehandToolkit.tools.find(
+    (t) => t.name === "stagehand_act"
+);
+await actionTool.invoke('Search for "OpenAI"');
+
+// Observe the page
+const observeTool = stagehandToolkit.tools.find(
+    (t) => t.name === "stagehand_observe"
+);
+const result = await observeTool.invoke(
+    "What actions can be performed on the current page?"
+);
+console.log(JSON.parse(result));
+
+// Extract structured data
+const extractTool = stagehandToolkit.tools.find(
+    (t) => t.name === "stagehand_extract"
+);
+const extractResult = await extractTool.invoke({
+    instruction: "Extract the main heading and description",
+    schema: z.object({
+        heading: z.string(),
+        description: z.string(),
+    }),
+});
+console.log(extractResult);
+```
+
+## Step 6: Build LangGraph Agents
+
+Integrate with LangGraph for complex automation workflows:
+
+```typescript
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+
+// Create an LLM
+const llm = new ChatOpenAI({
+    model: "gpt-4",
+    temperature: 0,
+});
+
+// Create an agent with Stagehand tools
+const agent = createReactAgent({
+    llm,
+    tools: stagehandToolkit.tools,
+});
+
+// Execute a complex workflow
+const result = await agent.invoke({
+    messages: [
+        {
+            role: "user", 
+            content: "Go to example.com, find the contact form, and extract all the form fields"
+        }
+    ]
+});
+```
+
+## Advanced Configuration
+
+### Custom Stagehand Configuration
+
+```typescript
+const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    verbose: 2,
+    enableCaching: true,
+    headless: true,
+    domSettleTimeoutMs: 5000,
+});
+```
+
+### Error Handling
+
+```typescript
+try {
+    const result = await agent.invoke({
+        messages: [{ role: "user", content: "Navigate to invalid-url.com" }]
+    });
+} catch (error) {
+    console.error("Automation failed:", error);
+} finally {
+    // Clean up resources
+    await stagehand.close();
+}
+```
+
+## Example Workflows
+
+<Tabs>
+  <Tab title="Data Extraction" value="data-extraction" label="TypeScript">
+    ```typescript
+    const extractionAgent = createReactAgent({
+        llm,
+        tools: stagehandToolkit.tools,
+    });
+
+    const result = await extractionAgent.invoke({
+        messages: [{
+            role: "user",
+            content: `
+                Go to news-website.com and extract:
+                1. All article headlines
+                2. Publication dates  
+                3. Author names
+                Format as structured JSON
+            `
+        }]
+    });
+    ```
+  </Tab>
+  <Tab title="Form Automation" value="form-automation" label="TypeScript">
+    ```typescript
+    const formAgent = createReactAgent({
+        llm,
+        tools: stagehandToolkit.tools,
+    });
+
+    const result = await formAgent.invoke({
+        messages: [{
+            role: "user", 
+            content: `
+                Navigate to contact-form.com and:
+                1. Fill out the contact form with:
+                   - Name: John Doe
+                   - Email: john@example.com
+                   - Message: Inquiry about services
+                2. Submit the form
+                3. Confirm submission success
+            `
+        }]
+    });
+    ```
+  </Tab>
+  <Tab title="Multi-site Research" value="multi-site-research" label="TypeScript">
+    ```typescript
+    const researchAgent = createReactAgent({
+        llm,
+        tools: stagehandToolkit.tools,
+    });
+
+    const result = await researchAgent.invoke({
+        messages: [{
+            role: "user",
+            content: `
+                Research product pricing by:
+                1. Visit competitor1.com and extract pricing info
+                2. Visit competitor2.com and extract pricing info  
+                3. Compare features and prices
+                4. Provide summary analysis
+            `
+        }]
+    });
+    ```
+  </Tab>
+</Tabs>
+
+<CardGroup cols={1}>
+  <Card title="LangChain JS Documentation" icon="book" href="https://js.langchain.com/docs/integrations/tools/stagehand/">
+    Official LangChain JS documentation for the Stagehand integration
+  </Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v3/integrations/langchain/introduction.mdx b/packages/docs/v3/integrations/langchain/introduction.mdx
new file mode 100644
index 000000000..4c3941d4b
--- /dev/null
+++ b/packages/docs/v3/integrations/langchain/introduction.mdx
@@ -0,0 +1,33 @@
+---
+title: "Langchain JS Introduction"
+sidebarTitle: Introduction
+description: "Integrate Stagehand with Langchain JS for intelligent web automation"
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## Overview
+
+This guide shows you how to use Stagehand with Langchain JS to create intelligent agents that can automate web interactions. By the end of this guide, you'll know how to:
+
+- Set up the StagehandToolkit with Langchain JS
+- Create agents that can navigate and interact with websites
+- Extract structured data using natural language instructions
+- Build complex automation workflows with LangGraph
+
+## When You'd Use This
+
+The Langchain JS integration is perfect for scenarios where you need intelligent web automation with advanced reasoning:
+
+- **AI-driven research**: Create agents that can research information across multiple websites and synthesize findings
+- **Dynamic form filling**: Automatically fill out complex forms based on contextual requirements
+- **Data extraction workflows**: Extract and transform data from multiple sources with intelligent navigation
+- **Multi-step web processes**: Execute complex browser workflows that require decision-making and adaptation
+
+<CardGroup cols={1}>
+<Card title="Langchain JS Configuration" icon="gear" href="/v3/integrations/langchain/configuration">
+  Learn how to set up and configure the StagehandToolkit with Langchain JS agents
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v3/integrations/mcp/configuration.mdx b/packages/docs/v3/integrations/mcp/configuration.mdx
new file mode 100644
index 000000000..a5e4e0f5c
--- /dev/null
+++ b/packages/docs/v3/integrations/mcp/configuration.mdx
@@ -0,0 +1,391 @@
+---
+title: "Browserbase MCP Server Configuration"
+sidebarTitle: "Configuration"
+description: "Configure your browser automation with command-line flags, environment variables, and advanced options"
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## Configuration Overview
+
+The Browserbase MCP server supports extensive configuration options through command-line flags and environment variables. Configure browser behavior, proxy settings, stealth modes, model selection, and more to customize your browser automation workflows.
+
+<Note>
+Command-line flags are only available when running the server locally (`npx @browserbasehq/mcp-server-browserbase` with flags or local development setup).
+</Note>
+
+## Environment Variables
+
+Configure the essential Browserbase credentials and optional debugging settings:
+
+<CardGroup cols={2}>
+<Card title="BROWSERBASE_API_KEY" icon="key">
+Your Browserbase API key for authentication
+</Card>
+
+<Card title="BROWSERBASE_PROJECT_ID" icon="key">
+Your Browserbase project ID
+</Card>
+
+</CardGroup>
+
+## Command-Line Flags
+
+### Available Flags
+
+| Flag | Description |
+|------|-------------|
+| `--proxies` | Enable Browserbase proxies for the session |
+| `--advancedStealth` | Enable Browserbase Advanced Stealth (Scale Plan only) |
+| `--keepAlive` | Enable Browserbase Keep Alive Session |
+| `--contextId <contextId>` | Specify a Browserbase Context ID to use |
+| `--persist [boolean]` | Whether to persist the Browserbase context (default: true) |
+| `--port <port>` | Port to listen on for HTTP/SHTTP transport |
+| `--host <host>` | Host to bind server to (default: localhost, use 0.0.0.0 for all interfaces) |
+| `--browserWidth <width>` | Browser viewport width (default: 1024) |
+| `--browserHeight <height>` | Browser viewport height (default: 768) |
+| `--modelName <model>` | The model to use for Stagehand (default: gemini-2.0-flash) |
+| `--modelApiKey <key>` | API key for the custom model provider (required when using custom models) |
+| `--experimental` | Enable experimental features (default: false) |
+
+## Configuration Examples
+
+### Basic Configuration
+
+<Tabs>
+<Tab title="Remote URL (SHTTP)">
+
+
+<CodeGroup>
+```json Direct SHTTP
+{
+  "mcpServers": {
+    "browserbase": {
+      "url": "your-smithery-url.com"
+    }
+  }
+}
+```
+</CodeGroup>
+
+When using our remote hosted server, we provide the LLM costs for Gemini, the [best performing model](https://www.stagehand.dev/evals) in [Stagehand](https://www.stagehand.dev).
+</Tab>
+
+<Tab title="NPM Package">
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": ["@browserbasehq/mcp-server-browserbase"],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</Tab>
+
+<Tab title="Local STDIO">
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "node",
+      "args": ["/path/to/mcp-server-browserbase/cli.js"],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</Tab>
+
+<Tab title="Local SHTTP">
+```bash
+# Start server
+node cli.js --port 8931
+```
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "url": "http://localhost:8931/mcp",
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</Tab>
+</Tabs>
+
+### Advanced Features
+
+<Tabs>
+<Tab title="Proxies">
+Enable Browserbase proxies for IP rotation and geo-location testing.
+
+<Panel>
+[Learn more about Browserbase Proxies](https://docs.browserbase.com/features/proxies)
+</Panel>
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": ["@browserbasehq/mcp-server-browserbase", "--proxies"],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</Tab>
+
+<Tab title="Advanced Stealth">
+Enable advanced anti-detection features for enhanced stealth browsing.
+
+<Panel>
+[Learn more about Advanced Stealth](https://docs.browserbase.com/features/stealth-mode#advanced-stealth-mode)
+
+**Note:** Advanced Stealth is only available for Scale Plan users.
+</Panel>
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": ["@browserbasehq/mcp-server-browserbase", "--advancedStealth"],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</Tab>
+
+<Tab title="Contexts">
+Use persistent browser contexts to maintain authentication and state across sessions.
+
+<Panel>
+[Learn more about Browserbase Contexts](https://docs.browserbase.com/features/contexts)
+</Panel>
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": ["@browserbasehq/mcp-server-browserbase", "--contextId", "your_context_id"],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id"
+      }
+    }
+  }
+}
+```
+</Tab>
+</Tabs>
+
+### Browser Customization
+
+<Tabs>
+<Tab title="Viewport Sizing">
+Customize browser window dimensions. Default is 1288x711. Recommended aspect ratios: 16:9.
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": [
+        "@browserbasehq/mcp-server-browserbase",
+        "--browserWidth", "1920",
+        "--browserHeight", "1080"
+      ],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+
+**Common Resolutions:**
+- Desktop: 1920x1080, 1280x720, 1024x768
+- Mobile: 375x667 (iPhone), 360x640 (Android)
+- Tablet: 768x1024 (iPad)
+</Tab>
+
+</Tabs>
+
+## Model Configuration
+
+Configure AI models for enhanced browser automation. Stagehand defaults to Google's Gemini 2.0 Flash but supports multiple providers.
+
+<Warning>
+When using any custom model (non-default), you must provide your own API key for that model provider using the `--modelApiKey` flag.
+</Warning>
+
+<Tabs>
+<Tab title="Available Models">
+**Google Gemini** (Default)
+- `gemini-2.0-flash` (default)
+- `gemini-2.5-pro`
+- `gemini-2.5-flash`
+- `gemini-2.5-flash-lite`
+
+**OpenAI**
+- `gpt-5-2025-08-07`
+- `gpt-4.1-2025-04-14`
+- `gpt-4o`
+- `gpt-4o-mini`
+
+**Anthropic Claude**
+- `claude-sonnet-4-5`
+- `claude-haiku-4-5`
+
+[View full list of supported models](https://docs.stagehand.dev/v3/configuration/models#models)
+</Tab>
+
+<Tab title="Configuration Examples">
+<CodeGroup>
+```json OpenAI GPT-4o
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": [
+        "@browserbasehq/mcp-server-browserbase",
+        "--modelName", "gpt-4o",
+        "--modelApiKey", "your_openai_api_key"
+      ],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id"
+      }
+    }
+  }
+}
+```
+
+```json Claude Sonnet
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": [
+        "@browserbasehq/mcp-server-browserbase",
+        "--modelName", "claude-sonnet-4-6",
+        "--modelApiKey", "your_anthropic_api_key"
+      ],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id"
+      }
+    }
+  }
+}
+```
+</CodeGroup>
+</Tab>
+</Tabs>
+
+## Development Configuration
+
+<Tabs>
+<Tab title="Custom Host/Port">
+Configure custom host and port for SHTTP transport.
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": [
+        "@browserbasehq/mcp-server-browserbase",
+        "--host", "0.0.0.0",
+        "--port", "8080"
+      ],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</Tab>
+</Tabs>
+
+## Best Practices
+
+<Accordion title="Performance - How can I optimize browser automation performance?">
+- Use appropriate viewport sizes for your use case
+- Enable proxies only when needed for geo-location
+- Choose efficient models (Gemini Flash for speed, GPT-4o for accuracy)
+- Reuse contexts for authentication persistence
+</Accordion>
+
+<Accordion title="Security - What security measures should I implement?">
+- Store API keys securely in environment variables
+- Use Advanced Stealth for sensitive operations
+- Implement proper session management
+- Rotate cookies and contexts regularly
+</Accordion>
+
+<Accordion title="Development - What are the recommended development practices?">
+- Enable debug mode during development
+- Use context persistence for faster iteration
+- Test with different viewport sizes
+- Monitor session usage and quotas
+</Accordion>
+
+<Accordion title="Production - How should I configure for production environments?">
+- Use NPM installation for reliability
+- Configure appropriate timeouts
+- Implement error handling and retries
+- Monitor performance and resource usage
+</Accordion>
+
+## Further Reading
+
+<CardGroup cols={3}>
+<Card title="Browserbase Documentation" icon="globe" href="https://docs.browserbase.com">
+Complete platform documentation
+</Card>
+
+<Card title="Stagehand Docs" icon="robot" href="https://docs.stagehand.dev/">
+AI-powered browser automation
+</Card>
+
+<Card title="Support" icon="headset" href="mailto:support@browserbase.com">
+Get help from our team
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v3/integrations/mcp/introduction.mdx b/packages/docs/v3/integrations/mcp/introduction.mdx
new file mode 100644
index 000000000..6c969bdf9
--- /dev/null
+++ b/packages/docs/v3/integrations/mcp/introduction.mdx
@@ -0,0 +1,192 @@
+---
+title: "Browserbase MCP Server"
+sidebarTitle: "Introduction"
+description: "AI-powered browser automation through Model Context Protocol integration with Stagehand"
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## Overview
+
+The Browserbase MCP Server brings powerful browser automation capabilities to Claude through the Model Context Protocol (MCP). Built on top of [Stagehand](https://docs.stagehand.dev/), this integration provides AI-powered web automation using natural language commands.
+
+<Info>
+This server enables Claude to control browsers, navigate websites, interact with web elements, and extract data—all through simple conversational commands.
+</Info>
+
+## Key Features
+
+<CardGroup cols={2}>
+<Card title="Natural Language Automation" icon="wand-magic-sparkles">
+Control browsers using plain English commands like "click the login button" or "fill out the contact form"
+</Card>
+
+<Card title="Web Interaction" icon="browser">
+Navigate, click, and fill forms with ease
+</Card>
+
+<Card title="Data Extraction" icon="download">
+Extract structured data from any website automatically
+
+</Card>
+
+<Card title="Screenshot Capture" icon="camera">
+Capture and analyze webpage screenshots programmatically
+</Card>
+
+</CardGroup>
+
+## Core Benefits
+
+<Tabs>
+<Tab title="Ease of Use">
+<CardGroup cols={2}>
+<Card title="Intuitive Commands" icon="wand-magic-sparkles">
+No need to learn complex selectors or automation syntax. Simply describe what you want to do in natural language.
+</Card>
+
+<Card title="Quick Setup" icon="rocket">
+Get started in minutes with our NPM package or our remote hosted URL.
+</Card>
+
+<Card title="Smart Automation" icon="brain">
+Stagehand's AI understands web page context and can adapt to different layouts and designs.
+</Card>
+</CardGroup>
+</Tab>
+
+<Tab title="Powerful Capabilities">
+<CardGroup cols={2}>
+<Card title="Full Browser Control" icon="browser">
+Navigate, click, type, scroll, and interact with any web element.
+</Card>
+
+<Card title="Data Intelligence" icon="chart-line">
+Extract structured information from complex web pages automatically.
+</Card>
+
+<Card title="Session Persistence" icon="cookie-bite">
+Maintain authentication states and context across multiple interactions.
+</Card>
+</CardGroup>
+</Tab>
+
+<Tab title="Enterprise Ready">
+<CardGroup cols={2}>
+<Card title="Reliable Infrastructure" icon="server">
+Built on Browserbase's cloud browser platform for consistent performance.
+</Card>
+
+<Card title="Scalable Architecture" icon="arrows-up-to-line">
+Handle multiple concurrent sessions and high-volume automation tasks.
+</Card>
+
+<Card title="Security Features" icon="shield-check">
+Stealth mode, proxy support, and advanced anti-detection capabilities.
+</Card>
+
+<Card title="Comprehensive Logging" icon="file-lines">
+Detailed session recordings and debugging information.
+</Card>
+</CardGroup>
+</Tab>
+</Tabs>
+
+## Use Cases
+
+<Tabs>
+<Tab title="Web Scraping & Data Collection">
+<CardGroup cols={2}>
+<Card title="E-commerce Monitoring" icon="store">
+Track product prices, availability, and competitor information
+</Card>
+
+<Card title="Market Research" icon="chart-bar">
+Gather data from multiple sources for analysis and reporting
+</Card>
+
+<Card title="Content Aggregation" icon="newspaper">
+Collect articles, posts, and media from various websites
+</Card>
+
+<Card title="Lead Generation" icon="users">
+Extract contact information and business data from directories
+</Card>
+</CardGroup>
+</Tab>
+
+<Tab title="Testing">
+<CardGroup cols={2}>
+<Card title="Automated Testing" icon="flask">
+Create comprehensive test suites for web applications
+</Card>
+
+<Card title="User Journey Testing" icon="route">
+Simulate real user interactions and workflows
+</Card>
+
+<Card title="Performance Monitoring" icon="gauge">
+Track page load times and user experience metrics
+</Card>
+</CardGroup>
+</Tab>
+
+<Tab title="Workflow Automation">
+<CardGroup cols={2}>
+<Card title="Form Automation" icon="file-contract">
+Automatically fill and submit complex web forms
+</Card>
+
+<Card title="Report Generation" icon="chart-line">
+Extract data and generate automated reports
+</Card>
+
+<Card title="Social Media Management" icon="share-nodes">
+Schedule posts and monitor engagement across platforms
+</Card>
+
+<Card title="Administrative Tasks" icon="clipboard-check">
+Automate repetitive web-based business processes
+</Card>
+</CardGroup>
+</Tab>
+</Tabs>
+
+## Getting Started
+
+<Steps>
+<Step title="Install the MCP Server">
+Choose from NPM installation, remote hosted URL, or local development based on your needs.
+</Step>
+
+<Step title="Configure Authentication">
+Set up your Browserbase API credentials in the MCP configuration. 
+Get your API keys from the [Browserbase Dashboard](https://www.browserbase.com/overview).
+</Step>
+
+<Step title="Start Automating">
+Begin using natural language commands to control browsers through Claude.
+</Step>
+</Steps>
+
+<Tip>
+Ready to get started? Check out our [Setup Guide](/integrations/mcp/setup) for detailed installation instructions.
+</Tip>
+
+## Further Reading
+
+<CardGroup cols={3}>
+<Card title="Setup Guide" icon="rocket" href="/integrations/mcp/setup">
+Get started with installation and configuration
+</Card>
+
+<Card title="Available Tools" icon="wrench" href="/integrations/mcp/tools">
+Explore all available automation tools
+</Card>
+
+<Card title="Configuration Options" icon="gear" href="/integrations/mcp/configuration">
+Customize your browser automation setup
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v3/integrations/mcp/setup.mdx b/packages/docs/v3/integrations/mcp/setup.mdx
new file mode 100644
index 000000000..3d8c17ea0
--- /dev/null
+++ b/packages/docs/v3/integrations/mcp/setup.mdx
@@ -0,0 +1,201 @@
+---
+title: "Browserbase MCP Server Setup"
+sidebarTitle: "Setup"
+description: "Add the Browserbase MCP Server to Claude"
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## Quick Installation
+
+<Card title="Install with Cursor" icon="arrow-pointer" href="cursor://anysphere.cursor-deeplink/mcp/install?name=browserbase&config=eyJjb21tYW5kIjoibnB4IEBicm93c2VyYmFzZWhxL21jcCIsImVudiI6eyJCUk9XU0VSQkFTRV9BUElfS0VZIjoiIiwiQlJPV1NFUkJBU0VfUFJPSkVDVF9JRCI6IiIsIkdFTUlOSV9BUElfS0VZIjoiIn19">
+One-click installation directly in Cursor with pre-configured settings
+</Card>
+
+We support multiple transport methods for our MCP server: STDIO and SHTTP. We recommend using SHTTP with our remote hosted URL to take advantage of the server at full capacity.
+
+## Prerequisites
+
+<Steps>
+<Step title="Get your Browserbase credentials">
+Get your Browserbase API key and project ID from the [Browserbase Dashboard](https://www.browserbase.com/overview).
+
+<Frame>
+<img src="/images/quickstart/api-key.png" alt="Browserbase API Key and Project ID settings" />
+</Frame>
+
+Then copy your API Key and Project ID directly from the input.
+</Step>
+</Steps>
+
+## Installation Methods
+
+<Tabs>
+<Tab title="Remote URL (SHTTP)">
+
+Go to [smithery.ai](https://smithery.ai/server/@browserbasehq/mcp-browserbase) and enter your API keys and configuration to get a remote hosted URL.
+
+![Smithery](../../../images/mcp/smithery.jpg)
+
+<CodeGroup>
+```json Smithery
+{
+  "mcpServers": {
+    "browserbase": {
+      "url": "your-smithery-url.com"
+    }
+  }
+}
+```
+</CodeGroup>
+
+When using our remote hosted server, we provide the LLM costs for Gemini, the [best performing model](https://www.stagehand.dev/evals) in [Stagehand](https://www.stagehand.dev).
+
+</Tab>
+
+<Tab title="NPM Package (STDIO)">
+The easiest way to get started locally is using our NPM package.
+
+<Note>
+If you would like to use a different model, you have to pass the model name and keys in the args. More info [here](https://docs.browserbase.com/integrations/mcp/configuration).
+</Note>
+
+<Steps>
+<Step title="Add to MCP Config">
+Go into your MCP Config JSON and add the Browserbase Server:
+
+<CodeGroup>
+```json Claude Desktop
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "npx",
+      "args": ["@browserbasehq/mcp-server-browserbase"],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</CodeGroup>
+</Step>
+
+<Step title="Restart your MCP client">
+<Check>
+That's it! Reload your MCP client and Claude will be able to use Browserbase.
+</Check>
+</Step>
+</Steps>
+</Tab>
+
+<Tab title="Local Development">
+For local development or customization, you can run the server locally.
+
+<Steps>
+<Step title="Clone and build">
+```bash
+# Clone the Repo
+git clone https://github.com/browserbase/mcp-server-browserbase.git
+cd mcp-server-browserbase
+
+# Install the dependencies and build the project
+npm install && npm run build
+```
+</Step>
+
+<Step title="Choose your transport method">
+You can run locally using either STDIO or Streamable HTTP (SHTTP).
+
+<Tabs>
+<Tab title="STDIO">
+Add the following to your MCP Config JSON file:
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "command": "node",
+      "args": ["/path/to/mcp-server-browserbase/cli.js"],
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</Tab>
+
+<Tab title="SHTTP (Self-hosted)">
+First, run the server:
+
+```bash
+node cli.js --port 8931
+```
+
+Then add this to your MCP Config JSON file:
+
+```json
+{
+  "mcpServers": {
+    "browserbase": {
+      "url": "http://localhost:8931/mcp",
+      "env": {
+        "BROWSERBASE_API_KEY": "your_api_key",
+        "BROWSERBASE_PROJECT_ID": "your_project_id",
+        "GEMINI_API_KEY": "your_gemini_api_key"
+      }
+    }
+  }
+}
+```
+</Tab>
+</Tabs>
+</Step>
+
+<Step title="Restart your client">
+<Check>
+Reload your MCP client and you should be good to go!
+</Check>
+</Step>
+</Steps>
+</Tab>
+</Tabs>
+
+## Verify Installation
+
+<Steps>
+<Step title="Restart your Claude Client">
+Restart/refresh your Claude Client app and you should see the tools available by clicking the 🔨 icon.
+</Step>
+
+<Step title="Test the integration">
+Get started using our MCP Server by asking Claude to navigate to any page and see your Browserbase Browser in action on the [dashboard](https://www.browserbase.com/sessions).
+
+<Tip>
+Try asking Claude: "Navigate to google.com and take a screenshot"
+</Tip>
+</Step>
+</Steps>
+
+## Further Reading
+
+<CardGroup cols={3}>
+<Card title="Model Context Protocol (MCP) Docs" icon="book" href="https://modelcontextprotocol.io/introduction">
+Learn more about the MCP protocol
+</Card>
+
+<Card title="Browserbase Documentation" icon="globe" href="https://docs.browserbase.com">
+Explore Browserbase features and capabilities
+</Card>
+
+<Card title="Support" icon="headset" href="mailto:support@browserbase.com">
+Get help from our support team
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v3/integrations/mcp/tools.mdx b/packages/docs/v3/integrations/mcp/tools.mdx
new file mode 100644
index 000000000..dcd014280
--- /dev/null
+++ b/packages/docs/v3/integrations/mcp/tools.mdx
@@ -0,0 +1,121 @@
+---
+title: "Browserbase MCP Server Tools"
+sidebarTitle: "Tools"
+description: "This guide covers the specialized tools available in the Browserbase MCP server for browser automation and interaction."
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## Overview
+
+The Browserbase MCP server provides comprehensive tools for browser automation and session management. These tools allow you to perform actions like navigating pages, capturing screenshots, manipulating cookies, and managing multiple browser sessions simultaneously.
+
+## Core Browser Automation Tools
+
+These are the primary tools for modern web automation using natural language commands.
+
+<Accordion title="browserbase_stagehand_navigate">
+Navigate to any URL in the browser
+
+<ParamField path="url" type="string" required>
+  The URL to navigate to
+</ParamField>
+</Accordion>
+
+<Accordion title="browserbase_stagehand_act">
+Perform an action on the web page using natural language
+
+<ParamField path="action" type="string" required>
+  The action to perform (e.g., "click the login button", "fill form field")
+</ParamField>
+
+</Accordion>
+
+<Accordion title="browserbase_stagehand_extract">
+Extract all text content from the current page (filters out CSS and JavaScript)
+
+<Info>No input parameters required</Info>
+
+<ParamField path="instruction" type="string">
+  Extracted text content from the current page
+</ParamField>
+</Accordion>
+
+<Accordion title="browserbase_stagehand_observe">
+Observe and find actionable elements on the web page
+
+<ParamField path="instruction" type="string" required>
+  Specific instruction for observation (e.g., "find the login button", "locate search form")
+</ParamField>
+
+</Accordion>
+
+<Accordion title="browserbase_screenshot">
+Capture a PNG screenshot of the current page
+
+<Info>No input parameters required</Info>
+
+<ResponseField name="image" type="string">
+  Base-64 encoded PNG data
+</ResponseField>
+</Accordion>
+
+<Accordion title="browserbase_stagehand_get_url">
+Get the current URL of the browser page
+
+<Info>No input parameters required</Info>
+
+<ResponseField name="url" type="string">
+  Complete URL including protocol, domain, path, and any query parameters or fragments
+</ResponseField>
+</Accordion>
+
+## Session Management
+
+Manage your browser session lifecycle with create and close operations.
+
+<Accordion title="browserbase_session_create">
+Create or reuse a cloud browser session using Browserbase with fully initialized Stagehand
+
+<ParamField path="sessionId" type="string">
+  Optional session ID to use/reuse. If not provided, creates new session
+</ParamField>
+
+</Accordion>
+
+<Accordion title="browserbase_session_close">
+Close the current Browserbase session, disconnect the browser, and cleanup Stagehand instance
+
+<Info>No input parameters required</Info>
+
+</Accordion>
+
+## Resources
+
+<Card title="Screenshot Resources" icon="camera">
+  The server provides access to screenshot resources with URI-based access. 
+
+  example: 
+  ```
+  screenshot://screenshot-name-of-the-screenshot
+  ```
+
+</Card>
+
+## Further Reading
+
+<CardGroup cols={3}>
+<Card title="Model Context Protocol (MCP) Docs" icon="book" href="https://modelcontextprotocol.io/introduction">
+Learn more about the MCP protocol
+</Card>
+
+<Card title="Stagehand Documentation" icon="robot" href="https://docs.stagehand.dev/">
+Explore Stagehand's AI-powered browser automation
+</Card>
+
+<Card title="Support" icon="headset" href="mailto:support@browserbase.com">
+Get help from our support team
+</Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v3/integrations/playwright.mdx b/packages/docs/v3/integrations/playwright.mdx
new file mode 100644
index 000000000..60431f0b9
--- /dev/null
+++ b/packages/docs/v3/integrations/playwright.mdx
@@ -0,0 +1,207 @@
+---
+title: Playwright
+description: Use Stagehand with Playwright for browser automation
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## Overview
+
+Stagehand v3 can work seamlessly with Playwright, allowing you to use Playwright's `Page` objects directly with Stagehand's AI-powered methods like `act()`, `extract()`, and `observe()`.
+
+## Installation
+
+First, install both Stagehand and Playwright:
+
+```bash
+npm install @browserbasehq/stagehand playwright-core
+```
+
+## Quickstart
+
+### Basic Setup
+
+Connect Playwright to Stagehand's browser instance using Chrome DevTools Protocol (CDP):
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+import { chromium } from "playwright-core";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE", // or "LOCAL"
+  model: "openai/gpt-5",
+});
+
+await stagehand.init();
+
+// Connect Playwright to Stagehand's browser
+const browser = await chromium.connectOverCDP({
+  wsEndpoint: stagehand.connectURL(),
+});
+
+const pwContext = browser.contexts()[0];
+const pwPage = pwContext.pages()[0];
+```
+
+### Using Playwright Pages with Stagehand
+
+Once connected, you can use Playwright's `Page` objects with Stagehand's AI-powered methods:
+
+```typescript
+// Navigate using Playwright
+await pwPage.goto("https://example.com");
+
+// Use Stagehand's AI methods with the Playwright page
+await stagehand.act("click the login button", { page: pwPage });
+
+const data = await stagehand.extract(
+  "extract the article title",
+  z.object({ title: z.string() }),
+  { page: pwPage }
+);
+```
+
+## Multi-Page Example
+
+Stagehand works great with multiple Playwright pages:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+import { chromium } from "playwright-core";
+import { z } from "zod";
+
+// Initialize Stagehand
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: "openai/gpt-5",
+});
+
+await stagehand.init();
+
+// Connect Playwright
+const browser = await chromium.connectOverCDP({
+  wsEndpoint: stagehand.connectURL(),
+});
+
+const pwContext = browser.contexts()[0];
+const pwPage1 = pwContext.pages()[0];
+
+// Create a second page
+const pwPage2 = await pwContext.newPage();
+
+// Navigate both pages
+await pwPage1.goto("https://docs.stagehand.dev/first-steps/introduction");
+await pwPage2.goto("https://docs.stagehand.dev/configuration/observability");
+
+// Extract data from both pages concurrently
+const [page1Data, page2Data] = await Promise.all([
+  stagehand.extract(
+    "extract the names of the four stagehand primitives",
+    z.array(z.string()),
+    { page: pwPage1 }
+  ),
+  stagehand.extract(
+    "extract the list of session dashboard features",
+    z.array(z.string()),
+    { page: pwPage2 }
+  ),
+]);
+
+console.log("Page 1 primitives:", page1Data);
+console.log("Page 2 features:", page2Data);
+```
+
+## Complete Example
+
+Here's a full working example:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+import { chromium } from "playwright-core";
+import { z } from "zod";
+
+async function main() {
+  // Initialize Stagehand
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    model: "openai/gpt-5",
+    verbose: 1,
+  });
+
+  await stagehand.init();
+  console.log("Stagehand initialized");
+
+  // Connect Playwright to Stagehand's browser
+  const browser = await chromium.connectOverCDP({
+    wsEndpoint: stagehand.connectURL(),
+  });
+
+  const pwContext = browser.contexts()[0];
+  const pwPage = pwContext.pages()[0];
+
+  // Navigate and interact
+  await pwPage.goto("https://example.com");
+
+  // Use Stagehand's AI methods
+  const actions = await stagehand.observe("find the main heading", {
+    page: pwPage,
+  });
+
+  console.log("Found actions:", actions);
+
+  // Extract data
+  const heading = await stagehand.extract(
+    "extract the main heading text",
+    z.object({ heading: z.string() }),
+    { page: pwPage }
+  );
+
+  console.log("Heading:", heading);
+
+  // Cleanup
+  await stagehand.close();
+}
+
+main();
+```
+
+## Key Points
+
+- **Connect via CDP**: Use `chromium.connectOverCDP()` with `stagehand.connectURL()` as the WebSocket endpoint
+- **Pass the page**: Always pass the Playwright `page` object to Stagehand methods using the `{ page }` option
+- **Multi-page support**: Create multiple pages with `pwContext.newPage()` and pass them to Stagehand methods
+- **Concurrent operations**: Use `Promise.all()` to run multiple Stagehand operations in parallel across different pages
+
+## Environment Variables
+
+When using Browserbase, set your credentials:
+
+```bash
+BROWSERBASE_API_KEY=your_api_key
+BROWSERBASE_PROJECT_ID=your_project_id
+```
+
+For OpenAI (or other providers):
+
+```bash
+OPENAI_API_KEY=your_api_key
+```
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Agent" icon="robot" href="/v3/references/agent">
+    Automate entire workflows
+  </Card>
+  <Card title="Act" icon="play" href="/v3/references/act">
+    Execute actions on web pages
+  </Card>
+  <Card title="Extract" icon="ufo-beam" href="/v3/references/extract">
+    Extract structured data from pages
+  </Card>
+  <Card title="Observe" icon="eye" href="/v3/references/observe">
+    Observe and find elements on pages
+  </Card>
+</CardGroup>
diff --git a/packages/docs/v3/integrations/puppeteer.mdx b/packages/docs/v3/integrations/puppeteer.mdx
new file mode 100644
index 000000000..d104f0998
--- /dev/null
+++ b/packages/docs/v3/integrations/puppeteer.mdx
@@ -0,0 +1,181 @@
+---
+title: Puppeteer
+description: Use Stagehand with Puppeteer for browser automation
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## Overview
+
+Stagehand v3 can work seamlessly with Puppeteer, allowing you to use Puppeteer's `Page` objects directly with Stagehand's AI-powered methods like `act()`, `extract()`, and `observe()`.
+
+## Installation
+
+First, install both Stagehand and Puppeteer:
+
+```bash
+npm install @browserbasehq/stagehand puppeteer-core
+```
+
+## Quickstart
+
+### Basic Setup
+
+Connect Puppeteer to Stagehand's browser instance:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+import puppeteer from "puppeteer-core";
+
+const stagehand = new Stagehand({
+  env: "LOCAL", // or "BROWSERBASE"
+  model: "openai/gpt-5",
+});
+
+await stagehand.init();
+
+// Connect Puppeteer to Stagehand's browser
+const browser = await puppeteer.connect({
+  browserWSEndpoint: stagehand.connectURL(),
+  defaultViewport: null,
+});
+
+const pages = await browser.pages();
+const ppPage = pages[0];
+```
+
+### Using Puppeteer Pages with Stagehand
+
+Once connected, you can use Puppeteer's `Page` objects with Stagehand's AI-powered methods:
+
+```typescript
+// Navigate using Puppeteer
+await ppPage.goto("https://example.com");
+
+// Use Stagehand's AI methods with the Puppeteer page
+await stagehand.act("click the sign in button", { page: ppPage });
+
+const data = await stagehand.extract(
+  "extract the page title",
+  z.object({ title: z.string() }),
+  { page: ppPage }
+);
+```
+
+## Advanced: Multi-Page Usage
+
+Create and manage multiple Puppeteer pages with Stagehand:
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+import puppeteer from "puppeteer-core";
+import { z } from "zod";
+
+async function multiPageExample() {
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    model: "openai/gpt-5",
+  });
+
+  await stagehand.init();
+
+  // Connect Puppeteer
+  const browser = await puppeteer.connect({
+    browserWSEndpoint: stagehand.connectURL(),
+    defaultViewport: null,
+  });
+
+  // Get the first page
+  const pages = await browser.pages();
+  const ppPage1 = pages[0];
+
+  // Create a second page
+  const ppPage2 = await browser.newPage();
+
+  // Navigate both pages
+  await ppPage1.goto("https://example.com");
+  await ppPage2.goto("https://another-site.com");
+
+  // Use Stagehand on different pages
+  await stagehand.act("click the button", { page: ppPage1 });
+
+  const data = await stagehand.extract(
+    "extract the title",
+    z.object({ title: z.string() }),
+    { page: ppPage2 }
+  );
+
+  console.log("Extracted from page 2:", data);
+
+  await stagehand.close();
+}
+```
+
+## Observe + Act Pattern
+
+The recommended pattern for reliable automation:
+
+```typescript
+// Step 1: Observe to find candidate actions
+const actions = await stagehand.observe(
+  "find the submit button",
+  { page: ppPage }
+);
+
+// Step 2: Execute the first action
+if (actions.length > 0) {
+  await stagehand.act(actions[0], { page: ppPage });
+}
+```
+
+This pattern helps avoid DOM changes between observation and action execution.
+
+## Key Points
+
+- **Connect via WebSocket**: Use `puppeteer.connect()` with `stagehand.connectURL()` as the `browserWSEndpoint`
+- **Pass the page**: Always pass the Puppeteer `page` object to Stagehand methods using the `{ page }` option
+- **Disable viewport**: Set `defaultViewport: null` to use Stagehand's viewport settings
+- **Multi-page support**: Create multiple pages with `browser.newPage()` and pass them to Stagehand methods
+
+## Environment Variables
+
+When using Browserbase, set your credentials:
+
+```bash
+BROWSERBASE_API_KEY=your_api_key
+BROWSERBASE_PROJECT_ID=your_project_id
+```
+
+For OpenAI (or other providers):
+
+```bash
+OPENAI_API_KEY=your_api_key
+```
+
+## Comparison: Stagehand Native vs Puppeteer
+
+| Feature | Stagehand Native | With Puppeteer |
+|---------|------------------|----------------|
+| **Setup** | Simple - use `stagehand.context.pages()` | Requires `puppeteer.connect()` |
+| **Page Access** | `stagehand.context.pages()[0]` | `await browser.pages()` |
+| **AI Methods** | `stagehand.act("click")` | `stagehand.act("click", { page: ppPage })` |
+| **Best For** | Pure Stagehand workflows | Existing Puppeteer codebases |
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Agent" icon="robot" href="/v3/references/agent">
+    Automate entire workflows
+  </Card>
+  <Card title="Act" icon="play" href="/v3/references/act">
+    Execute actions on web pages
+  </Card>
+  <Card title="Extract" icon="ufo-beam" href="/v3/references/extract">
+    Extract structured data from pages
+  </Card>
+  <Card title="Observe" icon="eye" href="/v3/references/observe">
+    Observe and find elements on pages
+  </Card>
+</CardGroup>
diff --git a/packages/docs/v3/integrations/selenium.mdx b/packages/docs/v3/integrations/selenium.mdx
new file mode 100644
index 000000000..528321485
--- /dev/null
+++ b/packages/docs/v3/integrations/selenium.mdx
@@ -0,0 +1,132 @@
+---
+title: Selenium
+description: Use Stagehand with Selenium to operate the same browser in tandem
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## Overview
+
+Stagehand v3 can work alongside Selenium WebDriver, allowing both tools to operate on the same browser session simultaneously. This enables you to combine Stagehand's AI-powered automation with Selenium's precise element interactions.
+
+<Warning>
+**Browserbase Only**: This integration requires Browserbase. It does not work with `env: "LOCAL"` because Selenium needs a remote WebDriver endpoint.
+</Warning>
+
+## Installation
+
+Install Stagehand, Selenium, and the Browserbase SDK:
+
+```bash
+npm install @browserbasehq/stagehand selenium-webdriver @browserbasehq/sdk
+```
+
+## Quickstart
+
+### Create Shared Session
+
+Use the Browserbase SDK to create a session that both tools can connect to:
+
+```typescript
+import http from "http";
+import { Builder, Key } from "selenium-webdriver";
+import Browserbase from "@browserbasehq/sdk";
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const bb = new Browserbase({
+  apiKey: process.env.BROWSERBASE_API_KEY,
+});
+
+// Create shared session
+const session = await bb.sessions.create({
+  projectId: process.env.BROWSERBASE_PROJECT_ID,
+});
+
+console.log("Session created:", session.id);
+```
+
+### Connect Stagehand
+
+Initialize Stagehand with the session ID:
+
+```typescript
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  browserbaseSessionID: session.id,
+  model: "openai/gpt-5",
+  verbose: 2,
+});
+
+await stagehand.init();
+```
+
+### Connect Selenium
+
+Use a custom HTTP agent with the session's signing key:
+
+```typescript
+// Create custom HTTP agent with signing key
+const customHttpAgent = new http.Agent({});
+(customHttpAgent as any).addRequest = (req: any, options: any) => {
+  req.setHeader("x-bb-signing-key", session.signingKey);
+  (http.Agent.prototype as any).addRequest.call(customHttpAgent, req, options);
+};
+
+// Connect Selenium WebDriver
+const driver = new Builder()
+  .forBrowser("chrome")
+  .usingHttpAgent(customHttpAgent)
+  .usingServer(session.seleniumRemoteUrl)
+  .build();
+```
+
+### Use Both Tools Together
+
+Now both Stagehand and Selenium operate on the same browser:
+
+```typescript
+// Navigate with Stagehand
+const page = stagehand.context.pages()[0];
+await page.goto("https://www.google.com");
+
+// Extract page content with Stagehand AI
+const pageContent = await stagehand.extract();
+console.log("Page content:", pageContent);
+
+// Use Selenium for precise element interaction
+const searchBox = await driver.findElement({ name: "q" });
+await searchBox.sendKeys("Browserbase automation");
+await searchBox.sendKeys(Key.RETURN);
+
+// Wait for results
+await driver.sleep(2000);
+
+console.log("Search completed!");
+```
+
+## Key Points
+
+- **Shared Session**: Both tools connect to the same Browserbase session
+- **Signing Key**: Selenium requires the session's `signingKey` in HTTP headers
+- **Remote URL**: Use `session.seleniumRemoteUrl` for Selenium's server endpoint
+- **Concurrent Usage**: Both tools can operate on the browser simultaneously
+- **Cleanup**: Close both Stagehand (`await stagehand.close()`) and Selenium (`await driver.quit()`)
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Agent" icon="robot" href="/v3/references/agent">
+    Automate entire workflows
+  </Card>
+  <Card title="Act" icon="play" href="/v3/references/act">
+    Execute actions on web pages
+  </Card>
+  <Card title="Extract" icon="ufo-beam" href="/v3/references/extract">
+    Extract structured data from pages
+  </Card>
+  <Card title="Observe" icon="eye" href="/v3/references/observe">
+    Observe and find elements on pages
+  </Card>
+</CardGroup>
diff --git a/packages/docs/v3/integrations/vercel/configuration.mdx b/packages/docs/v3/integrations/vercel/configuration.mdx
new file mode 100644
index 000000000..8575eed44
--- /dev/null
+++ b/packages/docs/v3/integrations/vercel/configuration.mdx
@@ -0,0 +1,247 @@
+---
+title: Use Stagehand in Next.js
+sidebarTitle: Configuration
+description: Next.js is a popular framework for developing web-based applications in production. It powers Stagehand apps like [Director](https://director.ai), [Brainrot](https://brainrot.run) and [Open Operator](https://operator.browserbase.com).
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+<Card
+  title="Check out the Stagehand Next.js Quickstart"
+  icon="github"
+  href="https://github.com/browserbase/stagehand-nextjs-quickstart"
+>
+  Clone our [GitHub repo](https://github.com/browserbase/stagehand-nextjs-quickstart) to get started with Stagehand (v2) in Next.js.
+</Card>
+
+## Add Stagehand to an existing Next.js project
+If you'd like to start from scratch, you can run:
+
+<Tabs>
+<Tab title="npm">
+```bash
+npm create next-app@latest stagehand-nextjs --yes
+cd stagehand-nextjs
+```
+</Tab>
+<Tab title="pnpm">
+```bash
+pnpm create next-app@latest stagehand-nextjs --yes
+cd stagehand-nextjs
+```
+</Tab>
+<Tab title="yarn">
+```bash
+yarn create next-app@latest stagehand-nextjs --yes
+cd stagehand-nextjs
+```
+</Tab>
+</Tabs>
+
+If you'd like to add Stagehand to an existing Next.js project, you can do so by installing the dependencies:
+<Tabs>
+	<Tab title="npm">
+	```bash
+	npm install @browserbasehq/stagehand @browserbasehq/sdk playwright zod
+	```
+	</Tab>
+
+	<Tab title="pnpm">
+	```bash
+	pnpm add @browserbasehq/stagehand @browserbasehq/sdk playwright zod
+	```
+	</Tab>
+
+	<Tab title="yarn">
+	```bash
+	yarn add @browserbasehq/stagehand @browserbasehq/sdk playwright zod
+	```
+	</Tab>
+</Tabs>
+
+### Add environment variables
+Next, let's add the environment variables to a `.env` file.
+```env
+BROWSERBASE_API_KEY=your-browserbase-api-key
+BROWSERBASE_PROJECT_ID=your-browserbase-project-id
+OPENAI_API_KEY=your-openai-api-key
+```
+
+### Write a server action
+Next, let's define our `main` function as a server action in `app/stagehand/main.ts`. This file will have the following three functions:
+
+1. **`main`: Run the main Stagehand script**
+2. **`runStagehand`: Initialize and run the `main` function**
+3. **`startBBSSession`: Start a Browserbase session**
+
+```ts app/stagehand/main.ts
+// 🤘 Welcome to Stagehand!
+// This file is from the [Stagehand docs](https://docs.stagehand.dev/sections/examples/nextjs).
+
+"use server";
+
+import { Stagehand } from "@browserbasehq/stagehand";
+import { z } from "zod";
+import { Browserbase } from "@browserbasehq/sdk";
+
+/**
+ * Run the main Stagehand script
+ */
+async function main(stagehand: Stagehand) {
+  // You can use the `page` instance to write any Playwright code
+  // For more info: https://playwright.dev/docs/pom
+  const page = stagehand.context.activePage();
+
+  // In this example, we'll get the title of the Stagehand quickstart page
+  await page?.goto("https://docs.stagehand.dev/");
+  await stagehand.act("click the quickstart link");
+  const { title } = await stagehand.extract(
+    "extract the main heading of the page",
+    z.object({
+      title: z.string(),
+    }),
+  );
+
+  return title;
+}
+
+/**
+ * Initialize and run the main() function
+ */
+export async function runStagehand(sessionId?: string) {
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    apiKey: process.env.BROWSERBASE_API_KEY,
+    projectId: process.env.BROWSERBASE_PROJECT_ID,
+    verbose: 1,
+    logger: console.log,
+    browserbaseSessionID: sessionId,
+    disablePino: true,
+  });
+  await stagehand.init();
+  const result = await main(stagehand);
+  console.log(result);
+  await stagehand.close();
+}
+
+/**
+ * Start a Browserbase session
+ */
+export async function startBBSSession() {
+  const browserbase = new Browserbase();
+  const session = await browserbase.sessions.create({
+    projectId: process.env.BROWSERBASE_PROJECT_ID!,
+  });
+  const debugUrl = await browserbase.sessions.debug(session.id);
+  return {
+    sessionId: session.id,
+    debugUrl: debugUrl.debuggerFullscreenUrl,
+  };
+}
+```
+
+### Create a client component
+Next, let's create a client component that will start a Browserbase session and run the `main` function with the server actions we just defined. We'll first create a Browserbase session and embed the session in an iframe before running the `main` function.
+
+```tsx app/components/stagehandEmbed.tsx
+"use client";
+
+import { useCallback, useState } from "react";
+import { runStagehand, startBBSSession } from "@/app/stagehand/main";
+
+export function StagehandEmbed() {
+  const [sessionId, setSessionId] = useState<string | null>(null);
+  const [debugUrl, setDebugUrl] = useState<string | null>(null);
+
+  const startSession = useCallback(async () => {
+    const { sessionId, debugUrl } = await startBBSSession();
+    setSessionId(sessionId);
+    setDebugUrl(debugUrl);
+    await runStagehand(sessionId);
+  }, []);
+
+  return (
+    <div>
+      {!sessionId && <button onClick={startSession}>Start Session</button>}
+      {sessionId && debugUrl && (
+        <iframe src={debugUrl} className="w-full h-full" />
+      )}
+    </div>
+  );
+}
+```
+
+### Use the `StagehandEmbed` component
+Now, we can use the `StagehandEmbed` component in our app.
+
+```tsx app/page.tsx
+import { StagehandEmbed } from "@/app/components/stagehandEmbed";
+
+export default function Home() {
+	return (
+		<main>
+			<StagehandEmbed />
+		</main>
+	)
+}
+```
+
+### Run the app
+To run the app, you can use the following command:
+
+<Tabs>
+<Tab title="npm">
+```bash
+npm run dev
+```
+</Tab>
+<Tab title="pnpm">
+```bash
+pnpm dev
+```
+</Tab>
+<Tab title="yarn">
+```bash
+yarn dev
+```
+</Tab>
+</Tabs>
+
+### Deploy the app
+To deploy the app, you can use the following commands. First, install the Vercel CLI:
+<Tabs>
+<Tab title="npm">
+```bash
+npm add -g vercel
+```
+</Tab>
+<Tab title="pnpm">
+```bash
+pnpm add -g vercel
+```
+</Tab>
+<Tab title="yarn">
+```bash
+yarn add -g vercel
+```
+</Tab>
+</Tabs>
+
+Then, run the following command to deploy the app:
+```bash
+vercel
+```
+
+## References
+
+<CardGroup cols={2}>
+  <Card title="Deploy Template (v2)" icon="rocket" href="https://vercel.com/templates/ai/stagehand-next-js-quickstart">
+    One‑click deploy the Stagehand Next.js template on Vercel (Stagehand v2)
+  </Card>
+  
+  <Card title="Source Cod (v2)" icon="github" href="https://github.com/browserbase/stagehand-nextjs-quickstart">
+    Browse the complete template repository on GitHub (Stagehand v2)
+  </Card>
+</CardGroup>
\ No newline at end of file
diff --git a/packages/docs/v3/integrations/vercel/introduction.mdx b/packages/docs/v3/integrations/vercel/introduction.mdx
new file mode 100644
index 000000000..66b3e5f9f
--- /dev/null
+++ b/packages/docs/v3/integrations/vercel/introduction.mdx
@@ -0,0 +1,63 @@
+---
+title: "Next.js + Vercel"
+sidebarTitle: "Introduction"
+description: "Build and deploy a Stagehand‑powered Next.js app to Vercel"
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## Overview
+
+The Stagehand + Next.js Quickstart is a production‑ready template that pairs Stagehand's AI browser automation with a modern Next.js app, deployable in one click on Vercel.
+
+<CardGroup cols={3}>
+  <Card title="Deploy Template" icon="rocket" href="https://vercel.com/templates/ai/stagehand-next-js-quickstart">
+    One‑click deploy to Vercel with environment setup
+  </Card>
+
+  <Card title="Live Demo" icon="globe" href="https://stagehand-nextjs-quickstart.vercel.app">
+    See the deployed template in action
+  </Card>
+
+  <Card title="Source Code" icon="github" href="https://github.com/browserbase/stagehand-nextjs-quickstart">
+    Browse the repository on GitHub (Stagehand v2)
+  </Card>
+</CardGroup>
+
+## What you get
+
+<CardGroup cols={2}>
+  <Card title="App Router project" icon="browser">
+    Next.js App Router scaffold with Tailwind styling
+  </Card>
+  <Card title="Server‑safe automation" icon="shield-check">
+    Uses Browserbase for cloud browsers (works on Vercel functions)
+  </Card>
+  <Card title="Prewired config" icon="gear">
+    `stagehand.config.ts` with model + provider switching
+  </Card>
+  <Card title="Automation ready" icon="robot">
+    Example usage of Stagehand primitives
+  </Card>
+</CardGroup>
+
+## Requirements
+
+- **Node 18+** locally
+- **Model key**: OpenAI or Anthropic (or plug a custom client)
+- **Browserbase keys**: `BROWSERBASE_API_KEY` and `BROWSERBASE_PROJECT_ID` for cloud browsers
+
+<Tip>
+Local Playwright browsers are not available on Vercel. Set Stagehand to Browserbase when deploying.
+</Tip>
+
+## Links
+
+<CardGroup cols={2}>
+  <Card title="Walkthrough" icon="rocket" href="/integrations/vercel/configuration">
+    Run locally and deploy to Vercel in minutes
+  </Card>
+</CardGroup>
+
diff --git a/packages/docs/v3/migrations/python.mdx b/packages/docs/v3/migrations/python.mdx
new file mode 100644
index 000000000..df7912ffd
--- /dev/null
+++ b/packages/docs/v3/migrations/python.mdx
@@ -0,0 +1,694 @@
+---
+title: Migrate Python v2 to v3
+sidebarTitle: Migrate Python v2 to v3
+description: Complete migration guide from Stagehand Python SDK v2 to the new Stainless-based v3 SDK
+icon: 'snake'
+---
+
+This guide helps you migrate from the legacy Stagehand Python SDK to the new Stainless-based SDK with a **Bring Your Own Browser (BYOB)** architecture.
+
+<Note>
+The new Python SDK is a pure API client. You manage the browser yourself using Playwright, Selenium, Puppeteer, or any other browser automation tool. The SDK handles only the AI-powered operations.
+</Note>
+
+## Overview of Changes
+
+<CardGroup cols={2}>
+  <Card title="BYOB Architecture" icon="browser">
+    You bring your own browser driver (Playwright, Selenium, etc.). The SDK is now a pure API client that handles AI-powered operations.
+  </Card>
+  <Card title="Session-Based API" icon="key">
+    All operations require an explicit `session_id`. Start a session, perform operations, and end it when done.
+  </Card>
+  <Card title="Multi-Browser Control" icon="browsers">
+    Scale browsers easily and control multiple browsers at once by passing the session ID for each browser you want to control.
+  </Card>
+  <Card title="Simplified Client" icon="code">
+    Cleaner initialization with dedicated parameters for API keys and configuration.
+  </Card>
+</CardGroup>
+
+### Current Limitations
+
+<Warning>
+The new SDK does **not yet support**:
+- Custom Python LLM client classes (e.g., `model_client_options`)
+- However, we do support custom endpoints like Bedrock or LLM proxies as long as they are OpenAI-API compatible
+</Warning>
+
+---
+
+## Step-by-Step Migration
+
+### 1. Update Imports
+
+<Tabs>
+<Tab title="Old SDK (v2)">
+
+```python
+import asyncio
+import logging
+from stagehand import Stagehand, StagehandConfig, configure_logging
+
+# Configure logging
+configure_logging(
+    level=logging.INFO,
+    remove_logger_name=True,
+    quiet_dependencies=True,
+)
+```
+
+</Tab>
+<Tab title="New SDK (v3)">
+
+```python
+import os
+from playwright.sync_api import sync_playwright
+from stagehand import Stagehand
+
+# Note: Custom logging configuration is not yet supported.
+# Use standard Python logging if needed:
+import logging
+logging.basicConfig(level=logging.INFO)
+```
+
+</Tab>
+</Tabs>
+
+---
+
+### 2. Client Initialization
+
+<Tabs>
+<Tab title="Old SDK (v2)">
+
+```python
+config = StagehandConfig(
+    env="BROWSERBASE",
+    api_key=os.getenv("BROWSERBASE_API_KEY"),
+    project_id=os.getenv("BROWSERBASE_PROJECT_ID"),
+    headless=False,
+    dom_settle_timeout_ms=3000,
+    model_name="google/gemini-2.0-flash",
+    self_heal=True,
+    wait_for_captcha_solves=True,
+    system_prompt="You are a browser automation assistant...",
+    model_client_options={"apiKey": os.getenv("MODEL_API_KEY")},
+    verbose=2,
+)
+
+stagehand = Stagehand(config)
+await stagehand.init()
+page = stagehand.page
+```
+
+</Tab>
+<Tab title="New SDK (v3)">
+
+```python
+SDK_VERSION = "3.0.6"
+
+# Create the Stagehand API client
+client = Stagehand(
+    browserbase_api_key=os.environ.get("BROWSERBASE_API_KEY"),
+    browserbase_project_id=os.environ.get("BROWSERBASE_PROJECT_ID"),
+    model_api_key=os.environ.get("MODEL_API_KEY"),
+)
+
+# Start a session (returns session metadata)
+start_response = client.sessions.start(
+    model_name="google/gemini-2.0-flash",
+    x_language="python",
+    x_sdk_version=SDK_VERSION,
+)
+session_id = start_response.data.session_id
+print(f"Session started: {session_id}")
+
+# Connect Playwright to the Browserbase session
+playwright = sync_playwright().start()
+browser = playwright.chromium.connect_over_cdp(
+    f"wss://connect.browserbase.com?apiKey={os.environ['BROWSERBASE_API_KEY']}&sessionId={session_id}"
+)
+context = browser.contexts[0]
+page = context.pages[0] if context.pages else context.new_page()
+```
+
+</Tab>
+</Tabs>
+
+<Info>
+**Key differences:**
+- Configuration options like `dom_settle_timeout_ms`, `self_heal`, `system_prompt`, and `verbose` are not available in the new SDK
+- `model_name` is specified when starting a session, not in the config
+- You must connect Playwright separately to interact with the page
+</Info>
+
+---
+
+### 3. Navigation
+
+<Tabs>
+<Tab title="Old SDK (v2)">
+
+```python
+await page.goto("https://google.com/")
+```
+
+</Tab>
+<Tab title="New SDK (v3) - Option A: Playwright">
+
+```python
+# Recommended for simple navigation
+page.goto("https://google.com/")
+```
+
+</Tab>
+<Tab title="New SDK (v3) - Option B: Stagehand API">
+
+```python
+# Use this if you need Stagehand to track navigation state
+client.sessions.navigate(
+    id=session_id,
+    url="https://google.com/",
+    frame_id="",  # Empty string for main frame
+    x_language="python",
+    x_sdk_version=SDK_VERSION,
+)
+```
+
+</Tab>
+</Tabs>
+
+---
+
+### 4. Direct Page Interactions (Playwright)
+
+Any direct page manipulation should use Playwright's native API.
+
+<Tabs>
+<Tab title="Old SDK (v2)">
+
+```python
+# Click using Playwright locator (this was already Playwright)
+await page.get_by_role("link", name="About", exact=True).click()
+
+# Keyboard input
+await page.keyboard.press("Enter")
+```
+
+</Tab>
+<Tab title="New SDK (v3)">
+
+```python
+# Same Playwright API, but synchronous (or use async Playwright if preferred)
+page.get_by_role("link", name="About", exact=True).click()
+
+# Keyboard input
+page.keyboard.press("Enter")
+```
+
+</Tab>
+</Tabs>
+
+<Note>
+In the old SDK, `page` was a Stagehand-enhanced Playwright page. In the new SDK, `page` is a standard Playwright page. Direct Playwright methods work the same way.
+</Note>
+
+---
+
+### 5. AI-Powered Actions (`act`)
+
+<Tabs>
+<Tab title="Old SDK (v2)">
+
+```python
+await page.act("search for openai")
+```
+
+</Tab>
+<Tab title="New SDK (v3)">
+
+```python
+act_response = client.sessions.act(
+    id=session_id,
+    input="search for openai",
+    x_language="python",
+    x_sdk_version=SDK_VERSION,
+)
+print(f"Act completed: {act_response.data.result.message}")
+```
+
+</Tab>
+</Tabs>
+
+#### Acting on an Observed Element
+
+<Tabs>
+<Tab title="Old SDK (v2)">
+
+```python
+observed = await page.observe("find all articles")
+if observed:
+    await page.act(observed[0])
+```
+
+</Tab>
+<Tab title="New SDK (v3)">
+
+```python
+observe_response = client.sessions.observe(
+    id=session_id,
+    instruction="find all articles",
+    x_language="python",
+    x_sdk_version=SDK_VERSION,
+)
+results = observe_response.data.result
+
+if results:
+    element = results[0]
+    act_response = client.sessions.act(
+        id=session_id,
+        input=element,  # Pass the observed element directly
+        x_language="python",
+        x_sdk_version=SDK_VERSION,
+    )
+```
+
+</Tab>
+</Tabs>
+
+---
+
+### 6. Observing Elements (`observe`)
+
+<Tabs>
+<Tab title="Old SDK (v2)">
+
+```python
+observed = await page.observe("find all articles")
+if len(observed) > 0:
+    element = observed[0]
+    print(f"Found element: {element}")
+```
+
+</Tab>
+<Tab title="New SDK (v3)">
+
+```python
+observe_response = client.sessions.observe(
+    id=session_id,
+    instruction="find all articles",
+    x_language="python",
+    x_sdk_version=SDK_VERSION,
+)
+results = observe_response.data.result
+print(f"Found {len(results)} possible actions")
+
+if results:
+    element = results[0]
+    print(f"Found element: {element.description}")
+```
+
+</Tab>
+</Tabs>
+
+---
+
+### 7. Extracting Data (`extract`)
+
+<Tabs>
+<Tab title="Old SDK (v2)">
+
+```python
+data = await page.extract("extract the first result from the search")
+print(data.model_dump_json())
+```
+
+</Tab>
+<Tab title="New SDK (v3)">
+
+```python
+extract_response = client.sessions.extract(
+    id=session_id,
+    instruction="extract the first result from the search",
+    schema={
+        "type": "object",
+        "properties": {
+            "title": {
+                "type": "string",
+                "description": "The title of the first search result"
+            },
+            "url": {
+                "type": "string",
+                "description": "The URL of the first search result"
+            }
+        },
+        "required": ["title"]
+    },
+    x_language="python",
+    x_sdk_version=SDK_VERSION,
+)
+extracted_data = extract_response.data.result
+print(f"Extracted: {extracted_data}")
+```
+
+</Tab>
+</Tabs>
+
+<Warning>
+**Key difference:** The new SDK requires an explicit JSON schema for extraction. This provides better type safety and clearer expectations for the AI model.
+</Warning>
+
+---
+
+### 8. Closing the Session
+
+<Tabs>
+<Tab title="Old SDK (v2)">
+
+```python
+await stagehand.close()
+```
+
+</Tab>
+<Tab title="New SDK (v3)">
+
+```python
+# Clean up Playwright resources
+browser.close()
+playwright.stop()
+
+# End the Stagehand session
+client.sessions.end(
+    id=session_id,
+    x_language="python",
+    x_sdk_version=SDK_VERSION,
+)
+```
+
+</Tab>
+</Tabs>
+
+<Tip>
+**Important:** Always clean up both Playwright and the Stagehand session. Use a `try/finally` block to ensure cleanup happens even on errors.
+</Tip>
+
+---
+
+### 9. Async vs Sync
+
+<Tabs>
+<Tab title="Old SDK (v2) - Async-first">
+
+```python
+async def main():
+    stagehand = Stagehand(config)
+    await stagehand.init()
+    await page.goto("https://example.com")
+    await stagehand.close()
+
+asyncio.run(main())
+```
+
+</Tab>
+<Tab title="New SDK (v3) - Sync-first">
+
+```python
+def main():
+    client = Stagehand(...)
+
+    with sync_playwright() as playwright:
+        # ... setup browser connection
+        page.goto("https://example.com")
+        # ... cleanup
+
+main()
+```
+
+</Tab>
+<Tab title="New SDK (v3) - Async">
+
+```python
+import asyncio
+from playwright.async_api import async_playwright
+
+async def main():
+    client = Stagehand(...)  # Client is sync, but that's OK
+
+    async with async_playwright() as playwright:
+        browser = await playwright.chromium.connect_over_cdp(...)
+        # ... async Playwright operations
+
+asyncio.run(main())
+```
+
+</Tab>
+</Tabs>
+
+---
+
+## Complete Migration Example
+
+<Tabs>
+<Tab title="Before (Old SDK)">
+
+```python
+import asyncio
+import logging
+import os
+
+from dotenv import load_dotenv
+from stagehand import Stagehand, StagehandConfig, configure_logging
+
+configure_logging(level=logging.INFO, remove_logger_name=True, quiet_dependencies=True)
+load_dotenv()
+
+async def main():
+    config = StagehandConfig(
+        env="BROWSERBASE",
+        api_key=os.getenv("BROWSERBASE_API_KEY"),
+        project_id=os.getenv("BROWSERBASE_PROJECT_ID"),
+        headless=False,
+        model_name="google/gemini-2.0-flash",
+        model_client_options={"apiKey": os.getenv("MODEL_API_KEY")},
+        verbose=2,
+    )
+
+    stagehand = Stagehand(config)
+    await stagehand.init()
+    page = stagehand.page
+
+    print(f"Session: {stagehand.session_id}")
+
+    # Navigate
+    await page.goto("https://google.com/")
+
+    # Direct Playwright interaction
+    await page.get_by_role("link", name="About", exact=True).click()
+
+    # AI-powered action
+    await page.goto("https://google.com/")
+    await page.act("search for openai")
+    await page.keyboard.press("Enter")
+
+    # Observe and act
+    observed = await page.observe("find all articles")
+    if observed:
+        await page.act(observed[0])
+
+    # Extract data
+    data = await page.extract("extract the first result")
+    print(data.model_dump_json())
+
+    await stagehand.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+</Tab>
+<Tab title="After (New SDK)">
+
+```python
+import os
+import logging
+
+from dotenv import load_dotenv
+from playwright.sync_api import sync_playwright
+from stagehand import Stagehand
+
+# Standard Python logging (custom Stagehand logging not yet supported)
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+load_dotenv()
+
+SDK_VERSION = "3.0.6"
+
+def main():
+    # Create Stagehand API client
+    client = Stagehand(
+        browserbase_api_key=os.environ.get("BROWSERBASE_API_KEY"),
+        browserbase_project_id=os.environ.get("BROWSERBASE_PROJECT_ID"),
+        model_api_key=os.environ.get("MODEL_API_KEY"),
+    )
+
+    # Start a session
+    start_response = client.sessions.start(
+        model_name="google/gemini-2.0-flash",
+        x_language="python",
+        x_sdk_version=SDK_VERSION,
+    )
+    session_id = start_response.data.session_id
+    logger.info(f"Session started: {session_id}")
+    logger.info(f"View live: https://www.browserbase.com/sessions/{session_id}")
+
+    # Connect Playwright to the Browserbase session
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.connect_over_cdp(
+            f"wss://connect.browserbase.com?apiKey={os.environ['BROWSERBASE_API_KEY']}&sessionId={session_id}"
+        )
+        context = browser.contexts[0]
+        page = context.pages[0] if context.pages else context.new_page()
+
+        try:
+            # Navigate (using Playwright directly)
+            page.goto("https://google.com/")
+            logger.info("Navigated to Google")
+
+            # Direct Playwright interaction
+            page.get_by_role("link", name="About", exact=True).click()
+            logger.info("Clicked About link")
+
+            # Navigate back
+            page.goto("https://google.com/")
+
+            # AI-powered action (using Stagehand API)
+            act_response = client.sessions.act(
+                id=session_id,
+                input="search for openai",
+                x_language="python",
+                x_sdk_version=SDK_VERSION,
+            )
+            logger.info(f"Act completed: {act_response.data.result.message}")
+
+            # Keyboard input (using Playwright)
+            page.keyboard.press("Enter")
+
+            # Wait for results
+            page.wait_for_timeout(2000)
+
+            # Observe elements (using Stagehand API)
+            observe_response = client.sessions.observe(
+                id=session_id,
+                instruction="find all articles",
+                x_language="python",
+                x_sdk_version=SDK_VERSION,
+            )
+            results = observe_response.data.result
+
+            if results:
+                element = results[0]
+                logger.info(f"Found element: {element.description}")
+
+                # Act on observed element
+                client.sessions.act(
+                    id=session_id,
+                    input=element,
+                    x_language="python",
+                    x_sdk_version=SDK_VERSION,
+                )
+            else:
+                logger.warning("No elements found")
+
+            # Extract data (using Stagehand API with schema)
+            extract_response = client.sessions.extract(
+                id=session_id,
+                instruction="extract the first result from the search",
+                schema={
+                    "type": "object",
+                    "properties": {
+                        "title": {"type": "string", "description": "Result title"},
+                        "url": {"type": "string", "description": "Result URL"},
+                        "snippet": {"type": "string", "description": "Result snippet"},
+                    },
+                    "required": ["title"],
+                },
+                x_language="python",
+                x_sdk_version=SDK_VERSION,
+            )
+            logger.info(f"Extracted data: {extract_response.data.result}")
+
+        finally:
+            # Clean up Playwright
+            browser.close()
+
+            # End the Stagehand session
+            client.sessions.end(
+                id=session_id,
+                x_language="python",
+                x_sdk_version=SDK_VERSION,
+            )
+            logger.info("Session ended")
+
+if __name__ == "__main__":
+    main()
+```
+
+</Tab>
+</Tabs>
+
+---
+
+## Quick Reference: Method Mapping
+
+| Old SDK | New SDK |
+|---------|---------|
+| `Stagehand(config)` | `Stagehand(browserbase_api_key=..., ...)` |
+| `await stagehand.init()` | `client.sessions.start(...)` |
+| `stagehand.page` | Connect Playwright separately |
+| `stagehand.session_id` | `start_response.data.session_id` |
+| `await page.goto(url)` | `page.goto(url)` (Playwright) |
+| `await page.act(instruction)` | `client.sessions.act(id=session_id, input=instruction, ...)` |
+| `await page.observe(instruction)` | `client.sessions.observe(id=session_id, instruction=..., ...)` |
+| `await page.extract(instruction)` | `client.sessions.extract(id=session_id, instruction=..., schema=..., ...)` |
+| `await stagehand.close()` | `browser.close()` + `client.sessions.end(id=session_id, ...)` |
+| `configure_logging(...)` | Use standard `logging` module |
+
+---
+
+## Troubleshooting
+
+<AccordionGroup>
+  <Accordion title="Session not found errors">
+    Ensure you're using the correct `session_id` returned from `client.sessions.start()`.
+  </Accordion>
+  
+  <Accordion title="Playwright connection issues">
+    Make sure your Browserbase API key has the correct permissions and the session is still active.
+  </Accordion>
+  
+  <Accordion title="Missing x_language and x_sdk_version parameters">
+    These are required for all session operations. Use `x_language="python"` and `x_sdk_version="3.0.6"` (or the latest version).
+  </Accordion>
+  
+  <Accordion title="Extraction returns unexpected format">
+    The new SDK requires an explicit JSON schema. Make sure your schema matches the expected output structure.
+  </Accordion>
+</AccordionGroup>
+
+---
+
+## Need Help?
+
+<CardGroup cols={3}>
+  <Card title="Documentation" icon="book" href="https://docs.stagehand.dev/">
+    Full Stagehand documentation
+  </Card>
+  <Card title="Browserbase Docs" icon="server" href="https://docs.browserbase.com/">
+    Browserbase documentation
+  </Card>
+  <Card title="GitHub Issues" icon="github" href="https://github.com/browserbase/stagehand-python/issues">
+    Report issues or get help
+  </Card>
+</CardGroup>
diff --git a/packages/docs/v3/migrations/v2.mdx b/packages/docs/v3/migrations/v2.mdx
new file mode 100644
index 000000000..9ddf5eeb9
--- /dev/null
+++ b/packages/docs/v3/migrations/v2.mdx
@@ -0,0 +1,1030 @@
+---
+title: Migrate TypeScript v2 to v3
+sidebarTitle: Migrate TypeScript v2 to v3
+description: Complete migration guide from Stagehand TypeScript SDK v2 to v3
+icon: 'arrow-up-right-dots'
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+## Recommended Migration Process
+
+1. **Backup your project**. If you use a version control system, make sure all previous versions are committed.
+2. **Upgrade to Stagehand v3**.
+3. Follow the breaking changes guide below.
+4. Verify your project is working as expected.
+5. Commit your changes.
+
+## Stagehand v3 Package Version
+
+Update your `package.json` to use Stagehand v3:
+
+```bash Bash
+npm install @browserbasehq/stagehand@latest
+```
+
+## Overview of Major Changes
+
+Stagehand v3 introduces significant improvements to the API design and functionality:
+
+- **Removing Playwright Dependency**: Stagehand v3 is now a standalone library that does not depend on Playwright. **You can still use Stagehand with Playwright, check out our [Playwright integration](/v3/integrations/playwright) for more details.**
+- **Simplified Method Signatures**: Cleaner, more intuitive parameter structures.
+- **Unified Model Configuration**: Model configuration is now consolidated into a single `model` parameter.
+- **Automatic iframe & Shadow DOM Support**: No more manual flags required.
+- **Improved Type Safety**: Better TypeScript inference and type checking.
+- **Enhanced Multi-Page Support**: New Context API for managing multiple pages.
+- **Streamlined Timeouts**: Consistent timeout naming across all methods.
+- **Auto-caching**: Stagehand v3 now automatically caches actions and agent steps using the [file system cache](/best-practices/caching).
+- **Agent Improvements**: Renamed parameters (`instructions` → `systemPrompt`), unified model configuration, and new `executionModel` option for cost optimization.
+
+
+## Breaking Changes
+
+### Stagehand Initialization
+
+#### Model Configuration Consolidation
+
+The `modelName` and `modelClientOptions` parameters have been unified into a single `model` parameter.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  apiKey: process.env.BROWSERBASE_API_KEY,
+  projectId: process.env.BROWSERBASE_PROJECT_ID,
+  modelName: "openai/gpt-5",
+  modelClientOptions: {
+    apiKey: process.env.OPENAI_API_KEY
+    baseURL: "https://custom-proxy.com/v1"
+  }
+});
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+import { Stagehand } from "@browserbasehq/stagehand";
+
+// Option 1: String format (recommended for simplicity, auto-loads model API key from env)
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  apiKey: process.env.BROWSERBASE_API_KEY,
+  projectId: process.env.BROWSERBASE_PROJECT_ID,
+  model: "openai/gpt-5"
+});
+
+// Option 2: Object format (for advanced configuration)
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  apiKey: process.env.BROWSERBASE_API_KEY,
+  projectId: process.env.BROWSERBASE_PROJECT_ID,
+  model: {
+    modelName: "gpt-5",
+    apiKey: process.env.OPENAI_API_KEY,
+    baseURL: "https://custom-proxy.com/v1"
+  }
+});
+```
+
+#### DOM Settle Timeout Rename
+
+The `domSettleTimeoutMs` parameter has been renamed to `domSettleTimeout` for consistency.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  domSettleTimeoutMs: 5000
+});
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  domSettleTimeout: 5000
+});
+```
+
+#### Changes to return value of `stagehand.init()`
+
+The `init()` used to return `debugUrl`, `sessionUrl` and `sessionId`
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+const result = await stagehand.init();
+console.log(result);
+```
+In `v2`, the returned object contains:
+```
+{
+  debugUrl: 'https://www.browserbase.com/devtools/inspector.html?wss=connect.browserbase.com/debug/f8a21b4a-6fa1-4ab9-9007-fbfe61dc14f0/devtools/page/5474B0E0510C5B6E629BEB06E799CD70?debug=true',
+  sessionUrl: 'https://www.browserbase.com/sessions/f8a21b4a-6fa1-4ab9-9007-fbfe61dc14f0',
+  sessionId: 'f8a21b4a-6fa1-4ab9-9007-fbfe61dc14f0'
+}
+```
+In `v3` the return value is `Promise<void>`. The `sessionId`, `sessionUrl`, and `debugUrl` are now directly accessible via the stagehand object:
+```typescript Stagehand v3 icon="/images/typescript.svg"
+console.log("debugUrl: ", stagehand.browserbaseDebugURL)
+console.log("sessionUrl: ", stagehand.browserbaseSessionURL)
+console.log("sessionId: ", stagehand.browserbaseSessionID)
+```
+Example output:
+```
+debugUrl: 'https://www.browserbase.com/devtools/inspector.html?wss=connect.browserbase.com/debug/f8a21b4a-6fa1-4ab9-9007-fbfe61dc14f0/devtools/page/5474B0E0510C5B6E629BEB06E799CD70?debug=true',
+sessionUrl: 'https://www.browserbase.com/sessions/f8a21b4a-6fa1-4ab9-9007-fbfe61dc14f0',
+sessionId: 'f8a21b4a-6fa1-4ab9-9007-fbfe61dc14f0'
+```
+
+#### Caching Changes
+
+The `enableCaching` boolean has been replaced with a `cacheDir` string for more flexible cache management.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  enableCaching: true
+});
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  cacheDir: "./stagehand-cache"  // Specify cache directory
+});
+```
+
+#### Page Access Changes
+
+Direct page access has changed to use the Context API.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+const stagehand = new Stagehand({ env: "LOCAL" });
+await stagehand.init();
+
+// Direct page access
+const page = stagehand.page;
+await page.goto("https://example.com");
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+const stagehand = new Stagehand({ env: "LOCAL" });
+await stagehand.init();
+
+// Access via context
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com");
+
+// Or `await` the active page
+const page = stagehand.context.awaitActivePage();
+await page.goto("https://example.com");
+```
+
+### Context and Multi-Page Management
+
+#### New Context API
+
+v3 introduces a structured Context API for managing multiple pages.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+const stagehand = new Stagehand({ env: "LOCAL" });
+await stagehand.init();
+
+// Limited multi-page support
+const page = stagehand.page;
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+const stagehand = new Stagehand({ env: "LOCAL" });
+await stagehand.init();
+
+// Access all pages
+const pages = stagehand.context.pages();
+const mainPage = pages[0];
+
+// Create new page
+const newPage = await stagehand.context.newPage();
+
+// Set active page
+stagehand.context.setActivePage(newPage);
+
+// implicitly takes action on newPage
+await stagehand.act("click button");
+```
+
+### act() Method Changes
+
+#### Method Signature Simplification
+
+The `action` parameter has been removed from `ActOptions`. Now you only pass the instruction as a string.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+await page.act({
+  action: "click the login button",
+  modelName: "openai/gpt-5-mini",
+  variables: { username: "john" },
+  timeoutMs: 10000,
+  domSettleTimeoutMs: 5000,
+  iframes: true
+});
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+// Clean, simple string instruction
+await stagehand.act("click the login button");
+
+// With options
+await stagehand.act("click the login button", {
+  model: "openai/gpt-5-mini",
+  variables: { username: "john" },
+  timeout: 10000,
+  page: page  // Optional: specify which page
+});
+```
+
+<Note>
+**Method Location Change**: In v3, `act()` is called on the `stagehand` instance, not the `page` object.
+</Note>
+
+#### Model Configuration in act()
+
+Model configuration follows the same pattern as initialization.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+await page.act({
+  action: "fill the form",
+  modelName: "anthropic/claude-sonnet-4-5",
+  modelClientOptions: {
+    apiKey: process.env.ANTHROPIC_API_KEY
+  }
+});
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+// String format
+await stagehand.act("fill the form", {
+  model: "anthropic/claude-sonnet-4-5"
+});
+
+// Object format
+await stagehand.act("fill the form", {
+  model: {
+    modelName: "anthropic/claude-sonnet-4-5",
+    apiKey: process.env.ANTHROPIC_API_KEY
+  }
+});
+```
+
+#### Timeout Parameter Rename
+
+`timeoutMs` has been renamed to `timeout`.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+await page.act({
+  action: "click button",
+  timeoutMs: 15000
+});
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+await stagehand.act("click button", {
+  timeout: 15000
+});
+```
+
+#### Automatic iframe Support
+
+The `iframes` flag has been removed. iframe support is now automatic.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+await page.act({
+  action: "click button inside iframe",
+  iframes: true  // Required to interact with iframes
+});
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+// Automatic iframe support - no flag needed
+await stagehand.act("click button inside iframe");
+```
+
+<Note>
+**Automatic Support**: Stagehand v3 automatically handles iframe and Shadow DOM interactions without requiring explicit flags.
+</Note>
+
+#### Result Structure Changes
+
+The `ActResult` structure has been enhanced with more detailed information.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+const result = await page.act("click the button");
+console.log(result.action);  // Single action string
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+const result = await stagehand.act("click the button");
+console.log(result.actionDescription);  // Overall description
+console.log(result.actions);  // Array of action details
+
+// ActResult structure:
+// {
+//   success: boolean;
+//   message: string;
+//   actionDescription: string;
+//   actions: Array<{
+//     selector: string;
+//     description: string;
+//     method?: string;
+//     arguments?: string[];
+//   }>;
+// }
+```
+
+### extract() Method Changes
+
+#### Method Location and Signature
+
+`extract()` has moved from the page object to the stagehand instance, with a cleaner parameter structure.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+import { z } from "zod";
+
+const result = await page.extract({
+  instruction: "extract product details",
+  schema: z.object({
+    name: z.string(),
+    price: z.number()
+  }),
+  modelName: "openai/gpt-5",
+  domSettleTimeoutMs: 5000,
+  selector: "xpath=/html/body/div",
+  iframes: true
+});
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+import { z } from "zod";
+
+// Cleaner parameter structure
+const result = await stagehand.extract(
+  "extract product details",
+  z.object({
+    name: z.string(),
+    price: z.number()
+  }),
+  {
+    model: "openai/gpt-5",
+    selector: ".container", // NEW: CSS selector support
+    timeout: 10000,
+    page: page  // Optional: specify which page
+  }
+);
+```
+
+<Note>
+**Parameter Order**: In v3, `instruction` and `schema` are separate positional parameters, with `options` as an optional third parameter.
+</Note>
+
+#### Extract Without Schema
+
+Schema-less extraction also has a simpler interface.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+// String instruction
+const result = await page.extract("get the page title");
+// Returns: { extraction: "Page Title" }
+
+// Raw page content
+const content = await page.extract();
+// Returns: { page_text: "..." }
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+// String instruction
+const result = await stagehand.extract("get the page title");
+// Returns: { extraction: "Page Title" }
+
+// Raw page content
+const content = await stagehand.extract();
+// Returns: { pageText: "..." }
+```
+
+#### Model Configuration in extract()
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+const data = await page.extract({
+  instruction: "extract data",
+  schema: DataSchema,
+  modelName: "anthropic/claude-sonnet-4-5",
+  modelClientOptions: {
+    apiKey: process.env.ANTHROPIC_API_KEY
+  }
+});
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+const data = await stagehand.extract(
+  "extract data",
+  DataSchema,
+  {
+    model: "anthropic/claude-sonnet-4-5"
+  }
+);
+```
+
+#### Automatic iframe Support
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+const data = await page.extract({
+  instruction: "extract data from iframe",
+  schema: DataSchema,
+  iframes: true  // Required for iframe content
+});
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+// Automatic iframe support
+const data = await stagehand.extract(
+  "extract data from iframe",
+  DataSchema
+);
+```
+
+#### Array Schema Changes
+
+Array extraction now has a more ergonomic syntax.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+import { z } from "zod";
+
+// Had to wrap array in object
+const ApartmentListingsSchema = z.object({
+  apartments: z.array(z.object({
+    address: z.string(),
+    price: z.string(),
+    bedrooms: z.number()
+  }))
+});
+
+const result = await page.extract({
+  instruction: "extract all apartment listings",
+  schema: ApartmentListingsSchema
+});
+
+// Access via: result.apartments
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+import { z } from "zod";
+
+// Can use array schema directly
+const ApartmentListingsSchema = z.array(
+  z.object({
+    address: z.string(),
+    price: z.string(),
+    bedrooms: z.number()
+  })
+);
+
+const result = await stagehand.extract(
+  "extract all apartment listings",
+  ApartmentListingsSchema
+);
+
+// Result is directly the array
+console.log(result[0].address);
+```
+
+### observe() Method Changes
+
+#### Method Signature Updates
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+const results = await page.observe({
+  instruction: "find all buttons",
+  modelName: "openai/gpt-5",
+  domSettleTimeoutMs: 5000,
+  drawOverlay: true,
+  iframes: true
+});
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+const results = await stagehand.observe("find all buttons", {
+  model: "openai/gpt-5",
+  timeout: 10000,
+  selector: ".container",  // NEW: scope observation to selector
+  page: page  // Optional: specify which page
+});
+```
+
+<Note>
+**Method Location Change**: Like `act()` and `extract()`, `observe()` is now called on the `stagehand` instance.
+</Note>
+
+#### Draw Overlay Removed
+
+The `drawOverlay` option has been removed in v3.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+const results = await page.observe({
+  instruction: "find buttons",
+  drawOverlay: true  // Visual debugging
+});
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+// drawOverlay is no longer available
+const results = await stagehand.observe("find buttons");
+```
+
+#### Automatic iframe Support
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+const results = await page.observe({
+  instruction: "find elements in iframe",
+  iframes: true
+});
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+// Automatic iframe support
+const results = await stagehand.observe("find elements in iframe");
+```
+
+#### Observe with act() Integration
+
+The observe → act workflow remains similar but with updated method signatures.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+const [action] = await page.observe("find the login button");
+await page.act(action);
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+const [action] = await stagehand.observe("find the login button");
+await stagehand.act(action);
+```
+
+### agent() Method Changes
+
+#### Agent Configuration Updates
+
+The agent configuration has been significantly restructured in v3 with renamed parameters and new capabilities.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+const agent = stagehand.agent({
+  provider: "google",
+  model: "gemini-2.5-computer-use-preview-10-2025",
+  instructions: "You are a helpful assistant that can navigate websites.",
+  options: {
+    apiKey: process.env.GEMINI_API_KEY
+  },
+  integrations: ["https://mcp-server.example.com"],
+  tools: customTools
+});
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+const agent = stagehand.agent({
+  model: "google/gemini-2.5-computer-use-preview-10-2025",  // Provider now in model string
+  systemPrompt: "You are a helpful assistant that can navigate websites.",  // Renamed from 'instructions'
+  mode: "cua",  // Computer Use Agent mode
+  integrations: ["https://mcp-server.example.com"],
+  tools: customTools
+});
+```
+
+<Note>
+**Key Changes**:
+- `provider` removed - now part of the model string (e.g., `"anthropic/claude-sonnet-4-5"`)
+- `instructions` renamed to `systemPrompt`
+- `options` removed - use model object format for advanced configuration
+- `executionModel` added - specify a different model for tool execution
+- `cua` flag added - enable/disable Computer Use Agent mode
+</Note>
+
+#### Model Configuration in agent()
+
+Model configuration follows the same unified pattern as other methods.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+const agent = stagehand.agent({
+  provider: "google",
+  model: "gemini-2.5-computer-use-preview-10-2025",
+  options: {
+    apiKey: process.env.GEMINI_API_KEY,
+    baseURL: "https://custom-proxy.com/v1"
+  }
+});
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+// String format (recommended)
+const agent = stagehand.agent({
+  model: "google/gemini-2.5-computer-use-preview-10-2025"
+});
+
+// Object format for advanced configuration
+const agent = stagehand.agent({
+  model: {
+    modelName: "gemini-2.5-computer-use-preview-10-2025",
+    apiKey: process.env.GEMINI_API_KEY,
+    baseURL: "https://custom-proxy.com/v1"
+  }
+});
+```
+
+#### Execute Method Changes
+
+The `execute()` method has been simplified with some options removed and new ones added.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+const result = await agent.execute({
+  instruction: "Search for products",
+  maxSteps: 20,
+  autoScreenshot: true,
+  waitBetweenActions: 1000,
+  context: "Focus on electronics category"
+});
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+const result = await agent.execute({
+  instruction: "Search for products",
+  maxSteps: 20,
+  page: page,  // NEW: specify which page to operate on
+  highlightCursor: true  // NEW: visual cursor for debugging
+});
+```
+
+<Warning>
+**Removed Options**:
+- `autoScreenshot` - no longer available
+- `waitBetweenActions` - no longer available
+- `context` - use the `systemPrompt` in agent config instead
+</Warning>
+
+#### Execution Model Configuration
+
+v3 introduces a new `executionModel` option to use a different (often faster/cheaper) model for tool execution.
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5",  // Main reasoning model
+  executionModel: "anthropic/claude-haiku-4-5"  // Faster model for tool execution (act, extract, observe)
+});
+
+// The agent will use claude-sonnet-4-5 for high-level reasoning
+// but claude-haiku-4-5 for executing individual actions
+const result = await agent.execute("Complete the checkout process");
+```
+
+#### Agent with Multi-Page Support
+
+v3 agents can now specify which page to operate on.
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+const page1 = stagehand.context.pages()[0]
+const page2 = await stagehand.context.newPage();
+
+const agent = stagehand.agent({
+  model: "google/gemini-2.5-computer-use-preview-10-2025"
+});
+
+// Execute on specific page
+await page2.goto("https://example.com/dashboard");
+const result = await agent.execute({
+  instruction: "Export the data table",
+  page: page2  // Operate on page2 instead of default page
+});
+```
+
+### History and Metrics
+
+#### History API
+
+History is now async and returns a promise.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+const history = stagehand.history;
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+const history = await stagehand.history;
+```
+
+#### Metrics API
+
+Metrics is now async and returns a promise.
+
+```typescript Stagehand v2 icon="/images/typescript.svg"
+const metrics = stagehand.metrics;
+```
+
+```typescript Stagehand v3 icon="/images/typescript.svg"
+const metrics = await stagehand.metrics;
+```
+
+## Complete Migration Example
+
+Here's a complete example showing a full migration:
+
+<Tabs>
+<Tab title="Stagehand v2">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+import { z } from "zod";
+
+// Initialize
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  apiKey: process.env.BROWSERBASE_API_KEY,
+  projectId: process.env.BROWSERBASE_PROJECT_ID,
+  modelName: "openai/gpt-5",
+  modelClientOptions: {
+    apiKey: process.env.OPENAI_API_KEY
+  },
+  enableCaching: true,
+  domSettleTimeoutMs: 5000
+});
+
+await stagehand.init();
+const page = stagehand.page;
+
+// Navigate
+await page.goto("https://example.com");
+
+// Act
+await page.act({
+  action: "click the login button",
+  timeoutMs: 10000,
+  iframes: true
+});
+
+// Extract
+const ProductSchema = z.object({
+  name: z.string(),
+  price: z.number(),
+  inStock: z.boolean()
+});
+
+const product = await page.extract({
+  instruction: "extract product details",
+  schema: ProductSchema,
+  domSettleTimeoutMs: 5000,
+  iframes: true
+});
+
+// Observe
+const actions = await page.observe({
+  instruction: "find all buttons",
+  drawOverlay: false,
+  iframes: true
+});
+
+await stagehand.close();
+```
+
+</Tab>
+<Tab title="Stagehand v3">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+import { z } from "zod";
+
+// Initialize - simplified configuration
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  apiKey: process.env.BROWSERBASE_API_KEY,
+  projectId: process.env.BROWSERBASE_PROJECT_ID,
+  model: "openai/gpt-5",  // Unified model configuration
+  cacheDir: "./cache",      // Flexible cache directory
+  domSettleTimeout: 5000    // Consistent naming
+});
+
+await stagehand.init();
+const page = stagehand.context.pages()[0];  // Context API
+
+// Navigate
+await page.goto("https://example.com");
+
+// Act - cleaner interface, automatic iframe support
+await stagehand.act("click the login button", {
+  timeout: 10000
+  // No iframes flag needed - automatic!
+});
+
+// Extract - cleaner parameter order
+const ProductSchema = z.object({
+  name: z.string(),
+  price: z.number(),
+  inStock: z.boolean()
+});
+
+const product = await stagehand.extract(
+  "extract product details",
+  ProductSchema
+  // Automatic iframe support, no extra flags needed
+);
+
+// Observe - simplified
+const actions = await stagehand.observe("find all buttons");
+// Automatic iframe support
+
+// Get metrics
+const metrics = await stagehand.metrics;
+console.log('Total tokens used:',
+  metrics.totalPromptTokens + metrics.totalCompletionTokens);
+
+await stagehand.close();
+```
+
+</Tab>
+</Tabs>
+
+## Quick Reference: Breaking Changes
+
+<Expandable title="Stagehand Initialization">
+
+| Feature | Stagehand v2 | Stagehand v3 |
+|---------|--------------|--------------|
+| **Model Config** | `modelName` + `modelClientOptions` | `model: "provider/model"` or `{ modelName, apiKey, baseURL }` |
+| **DOM Settle** | `domSettleTimeoutMs` | `domSettleTimeout` |
+| **Caching** | `enableCaching: boolean` | `cacheDir: string` |
+| **Page Access** | `stagehand.page` | `stagehand.context.pages()[0]` |
+
+</Expandable>
+
+<Expandable title="act()">
+
+| Feature | Stagehand v2 | Stagehand v3 |
+|---------|--------------|--------------|
+| **Method location** | `page.act()` | `stagehand.act()` |
+| **Parameters** | `{ action, ...options }` | `(instruction, options?)` |
+| **Timeout** | `timeoutMs` | `timeout` |
+| **Result structure** | `{ action }` | `{ actionDescription, actions[] }` |
+
+</Expandable>
+
+<Expandable title="extract()">
+
+| Feature | Stagehand v2 | Stagehand v3 |
+|---------|--------------|--------------|
+| **Method location** | `page.extract()` | `stagehand.extract()` |
+| **Parameters** | `{ instruction, schema, ...options }` | `(instruction, schema, options?)` |
+
+</Expandable>
+
+<Expandable title="observe()">
+
+| Feature | Stagehand v2 | Stagehand v3 |
+|---------|--------------|--------------|
+| **Method location** | `page.observe()` | `stagehand.observe()` |
+| **Draw overlay** | `drawOverlay: boolean` | Removed |
+
+</Expandable>
+
+<Expandable title="agent()">
+
+| Feature | Stagehand v2 | Stagehand v3 |
+|---------|--------------|--------------|
+| **Provider** | `provider: "openai" \| "anthropic"` | Part of model string |
+| **Instructions** | `instructions: string` | `systemPrompt: string` |
+| **Model** | `model: "model-name"` | `model: "provider/model-name"` |
+| **Options** | `options: Record<string, unknown>` | Use model object format |
+| **Execute params** | `autoScreenshot`, `waitBetweenActions`, `context` | Removed; added `page`, `highlightCursor` |
+
+</Expandable>
+
+<Expandable title="Automatic Features">
+
+| Feature | Stagehand v2 | Stagehand v3 |
+|---------|--------------|--------------|
+| **iframe support** | `iframes: true` flag required | Automatic (no flag needed) |
+| **Shadow DOM** | Manual handling | Automatic (no flag needed) |
+
+</Expandable>
+
+<Expandable title="Properties & Methods">
+
+| Feature | Stagehand v2 | Stagehand v3 |
+|---------|--------------|--------------|
+| **History** | `stagehand.history` | `await stagehand.history` |
+| **Metrics** | `stagehand.metrics` | `await stagehand.metrics` |
+
+</Expandable>
+
+## Troubleshooting
+
+### Error: Cannot find property 'page' on Stagehand instance
+
+**Problem**: Direct `stagehand.page` is not supported in Stagehand v3.
+
+**Solution**: Use the Context API or `await` the active page:
+
+```typescript
+// Use context API (recommended)
+const page = stagehand.context.pages()[0];
+
+// Or grab the active page
+const page = await stagehand.context.awaitActivePage();
+```
+
+### Error: act() method not found on page
+
+**Problem**: v3 moved `act()`, `extract()`, and `observe()` to the stagehand instance.
+
+**Solution**: Call these methods on the stagehand instance:
+
+```typescript
+// v2 ❌
+await page.act("click button");
+
+// v3 ✅
+await stagehand.act("click button");
+```
+
+### TypeScript: Model configuration type errors
+
+**Problem**: TypeScript errors with model configuration.
+
+**Solution**: Use the proper format:
+
+```typescript
+// String format
+model: "openai/gpt-5"
+
+// Object format
+model: {
+  modelName: "openai/gpt-5",
+  apiKey: process.env.OPENAI_API_KEY
+}
+```
+
+### Agent configuration errors
+
+**Problem**: Using old `provider` and `instructions` parameters.
+
+**Solution**: Update to v3 format:
+
+```typescript
+// v2 ❌
+const agent = stagehand.agent({
+  provider: "anthropic",
+  model: "claude-sonnet-4-5",
+  instructions: "You are a helpful assistant that..."
+});
+
+// v3 ✅
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5",
+  systemPrompt: "You are a helpful assistant that..."
+});
+```
+
+### Agent execute options not recognized
+
+**Problem**: Using removed options like `autoScreenshot`, `waitBetweenActions`, or `context`.
+
+**Solution**: Remove these options and use v3 alternatives:
+
+```typescript
+// v2 ❌
+await agent.execute({
+  instruction: "task",
+  autoScreenshot: true,
+  waitBetweenActions: 1000,
+  context: "additional context"
+});
+
+// v3 ✅
+const agent = stagehand.agent({
+  model: "google/gemini-2.5-computer-use-preview-10-2025",
+  systemPrompt: "Your context here."  // Move context to systemPrompt
+});
+
+await agent.execute({
+  instruction: "task",
+  highlightCursor: true  // Use new option for visual feedback
+});
+```
+
+## Best Practices for v3
+
+1. **Use the string model format** for simplicity: `model: "openai/gpt-5"`
+2. **Leverage automatic iframe support** - remove all `iframes` flags
+3. **Use the Context API** for multi-page scenarios
+4. **Monitor metrics** to track token usage and optimize costs
+5. **Use history** for debugging and understanding automation flow
+6. **Set appropriate timeouts** based on your use case
+7. **Specify cache directory** to improve performance for repeated actions
+8. **Use executionModel for agents** - configure a faster/cheaper model for tool execution while keeping a powerful model for reasoning (e.g., `model: "anthropic/claude-sonnet-4-5"`, `executionModel: "google/gemini-2.0-flash"`)
+
+## Additional Resources
+
+- [Stagehand v3 Documentation](/v3/first-steps/introduction)
+- [API Reference](/v3/references/stagehand)
+- [Best Practices](/v3/best-practices/caching)
+- [GitHub Issues](https://github.com/browserbase/stagehand/issues)
+
+If you encounter any issues during migration, please [open an issue](https://github.com/browserbase/stagehand/issues) on our GitHub repository.
diff --git a/packages/docs/v3/references/act.mdx b/packages/docs/v3/references/act.mdx
new file mode 100644
index 000000000..5e097298f
--- /dev/null
+++ b/packages/docs/v3/references/act.mdx
@@ -0,0 +1,332 @@
+---
+title: act()
+description: 'Complete API reference for the act() method'
+icon: 'arrow-pointer'
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+<CardGroup cols={1}>
+<Card title="Act" icon="arrow-pointer" href="/v3/basics/act">
+  See how to use act() to perform browser actions
+</Card>
+</CardGroup>
+
+### Method Signatures
+
+<Tabs>
+<Tab title="TypeScript">
+
+```typescript
+// String instruction only
+await stagehand.act(instruction: string): Promise<ActResult>
+
+// Action only - Deterministic (no LLM)
+await stagehand.act(action: Action): Promise<ActResult>
+
+// String instruction with options
+await stagehand.act(instruction: string, options: ActOptions): Promise<ActResult>
+
+```
+
+**Action Interface:**
+```typescript
+interface Action {
+  selector: string;
+  description: string;
+  method: string;
+  arguments: string[];
+}
+```
+
+**ActOptions Interface:**
+```typescript
+interface ActOptions {
+  model?: ModelConfiguration;
+  variables?: Record<string, VariableValue>;
+  timeout?: number;
+  page?: PlaywrightPage | PuppeteerPage | PatchrightPage | Page;
+  serverCache?: boolean;
+}
+
+// VariableValue can be a simple primitive or a rich object:
+type VariableValue =
+  | string
+  | number
+  | boolean
+  | { value: string | number | boolean; description?: string };
+
+// ModelConfiguration can be either a string or an object
+type ModelConfiguration =
+  | string  // Format: "provider/model" (e.g., "openai/gpt-4o", "anthropic/claude-sonnet-4-6")
+  | {
+      modelName: string;  // The model name
+      apiKey?: string;    // Optional: API key override
+      baseURL?: string;   // Optional: Base URL override
+      // Additional provider-specific options
+    }
+```
+
+</Tab>
+
+</Tabs>
+
+### Parameters
+
+<ParamField path="instruction | action" type="string | Action" required>
+  - **Instruction**: Natural language description of the action to perform. Use `%variableName%` syntax to reference variables.
+  - **Action**: A deterministic action to perform: 
+  <Expandable title="Action">
+    <ParamField path="selector" type="string" required>
+      The selector (XPath, CSS selector, etc.) used to target the element
+    </ParamField>
+    <ParamField path="description" type="string" required>
+      Description of the action - used for self-healing
+    </ParamField>
+    <ParamField path="method" type="string" required>
+      The method used (e.g., "click", "fill", "type")
+    </ParamField>
+    <ParamField path="arguments" type="string[]" required>
+      Arguments passed to the method
+    </ParamField>
+  </Expandable>
+</ParamField>
+
+<ParamField path="model" type="ModelConfiguration" optional>
+  Configure the AI model to use for this action. Can be either:
+  - A string in the format `"provider/model"` (e.g., `openai/gpt-5`, `google/gemini-2.5-flash`)
+  - An object with detailed configuration
+
+  <Expandable title="Model Configuration Object">
+    <ParamField path="modelName" type="string" required>
+      The model name (e.g., `anthropic/claude-sonnet-4-5`, `google/gemini-2.5-flash`)
+    </ParamField>
+    <ParamField path="apiKey" type="string" optional>
+      API key for the model provider (overrides default)
+    </ParamField>
+    <ParamField path="baseURL" type="string" optional>
+      Base URL for the API endpoint (for custom endpoints or proxies)
+    </ParamField>
+  </Expandable>
+</ParamField>
+
+<ParamField path="variables" type="Record<string, VariableValue>" optional>
+  Key-value pairs for variable substitution using `%variableName%` syntax in your instruction. Variables are **not shared with LLM providers**, making them ideal for sensitive data like passwords and API keys.
+
+  Values can be simple primitives (`string`, `number`, `boolean`) or rich objects with an optional description (`{ value, description? }`).
+
+  **Example:**
+  ```typescript
+  // Simple values
+  await stagehand.act("type %password% into the password field", {
+    variables: { password: process.env.USER_PASSWORD }
+  });
+
+  // Rich values with descriptions
+  await stagehand.act("type %password% into the password field", {
+    variables: {
+      password: {
+        value: process.env.USER_PASSWORD,
+        description: "The user's login password"
+      }
+    }
+  });
+  ```
+</ParamField>
+
+<ParamField path="timeout" type="number" optional>
+  Maximum time in **milliseconds** to wait for the action to complete. Default varies by configuration.
+</ParamField>
+
+<ParamField path="page" type="PlaywrightPage | PuppeteerPage | PatchrightPage | Page" optional>
+  Optional: Specify which page to perform the action on. Supports multiple browser automation libraries:
+  - **Playwright**: Native Playwright Page objects
+  - **Puppeteer**: Puppeteer Page objects
+  - **Patchright**: Patchright Page objects
+  - **Stagehand Page**: Stagehand's wrapped Page object
+
+  If not specified, defaults to the current "active" page in your Stagehand instance.
+</ParamField>
+
+<ParamField path="serverCache" type="boolean" optional>
+  Override the instance-level `serverCache` setting for this request. When `true`, enables server-side caching. When `false`, disables it.
+
+  <Note>Only applies when `env` is `"BROWSERBASE"`. Has no effect in local environments.</Note>
+
+  Defaults to the value set on the Stagehand constructor (which itself defaults to `true`).
+</ParamField>
+
+### Returns `Promise<ActResult>`
+
+<ResponseField name="success" type="boolean" required>
+  Whether the action completed successfully
+</ResponseField>
+
+<ResponseField name="message" type="string" required>
+  Human-readable message describing the result
+</ResponseField>
+
+<ResponseField name="actionDescription" type="string" required>
+  Instruction that was used to perform the action
+</ResponseField>
+
+<ResponseField name="actions" type="Action[]">
+  Array of actions that were executed
+
+  <Expandable title="Action">
+    <ResponseField name="selector" type="string">
+      The selector (XPath) used to target the element
+    </ResponseField>
+    <ResponseField name="description" type="string">
+      Description of the action
+    </ResponseField>
+    <ResponseField name="method" type="string">
+      The method used (e.g., "click", "fill", "type")
+    </ResponseField>
+    <ResponseField name="arguments" type="string[]">
+      Arguments passed to the method
+    </ResponseField>
+  </Expandable>
+</ResponseField>
+
+<ResponseField name="cacheStatus" type='"HIT" | "MISS"' optional>
+  Indicates whether the result was served from the server-side cache. Only present when running with `env: "BROWSERBASE"` and server-side caching is enabled.
+
+  - **`"HIT"`** - Result was served from cache; no LLM tokens were consumed
+  - **`"MISS"`** - Result was computed fresh and cached for future calls
+</ResponseField>
+
+**Example Response:**
+```json
+{
+  "success": true,
+  "message": "Action completed successfully",
+  "actionDescription": "Clicked the submit button",
+  "actions": [
+    {
+      "selector": "/html/body/form/button[1]",
+      "description": "Submit button at bottom of form",
+      "method": "click",
+      "arguments": []
+    }
+  ]
+}
+```
+
+### Built-in Support
+
+<Note>
+**Iframe and Shadow DOM interactions are supported out of the box.** Stagehand automatically handles iframe traversal and shadow DOM elements without requiring additional configuration or flags.
+</Note>
+
+### Code Examples
+
+<Tabs>
+<Tab title="Basic Usage">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+// Initialize with Browserbase (API key and project ID from environment variables)
+// Set BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID in your environment
+const stagehand = new Stagehand({ env: "BROWSERBASE" });
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+await page.goto("https://example.com");
+
+// Simple action
+await stagehand.act("click the login button");
+```
+
+</Tab>
+<Tab title="Variables">
+
+```typescript
+// Variables are NOT shared with LLM providers
+await stagehand.act("type %username% into the email field", {
+  variables: { username: "user@example.com" }
+});
+
+await stagehand.act("type %password% into the password field", {
+  variables: { password: process.env.USER_PASSWORD }
+});
+
+await stagehand.act("click the login button");
+```
+
+</Tab>
+<Tab title="Custom Model">
+
+```typescript
+// Using string format
+await stagehand.act("choose 'Peach' from the favorite color dropdown", {
+  model: "google/gemini-2.5-flash",
+  timeout: 10000
+});
+
+// Using object format with custom configuration
+await stagehand.act("choose 'Peach' from the favorite color dropdown", {
+  model: {
+    modelName: "google/gemini-2.5-flash",
+    apiKey: process.env.GOOGLE_API_KEY,
+    baseURL: "https://custom-api-endpoint.com"
+  },
+  timeout: 10000
+});
+```
+
+</Tab>
+<Tab title="Multi-Page">
+
+```typescript
+// Create multiple pages
+const page1 = stagehand.context.pages()[0];
+const page2 = await stagehand.context.newPage();
+
+// Perform actions on specific pages
+await stagehand.act("click the first link", { page: page1 });
+await stagehand.act("click the second link", { page: page2 });
+```
+
+</Tab>
+<Tab title="Caching">
+
+<Tip>
+**Auto-caching is now available in v3.** See the [caching guide](/v3/best-practices/caching) for more details.
+</Tip>
+```typescript
+// Observe first to plan the action
+const [action] = await stagehand.observe("click the submit button");
+
+// Cache and reuse the action
+if (action) {
+  await stagehand.act(action);
+}
+
+// Later, reuse the same cached action
+await stagehand.act(action);
+```
+
+</Tab>
+</Tabs>
+
+### Error Types
+
+The following errors may be thrown by the `act()` method:
+
+- **StagehandError** - Base class for all Stagehand-specific errors
+- **StagehandElementNotFoundError** - Target element could not be located using the provided selector(s)
+- **StagehandClickError** - Failed to click on the target element
+- **StagehandEvalError** - Error occurred while evaluating JavaScript in the page context
+- **StagehandDomProcessError** - Error occurred while processing the DOM
+- **StagehandIframeError** - Unable to resolve iframe for the target element
+- **ContentFrameNotFoundError** - Unable to obtain content frame for the selector
+- **XPathResolutionError** - XPath does not resolve in the current page or frames
+- **StagehandShadowRootMissingError** - No shadow root present on the resolved host element
+- **LLMResponseError** - Error in LLM response processing
+- **MissingLLMConfigurationError** - No LLM API key or client configured
+- **UnsupportedModelError** - The specified model is not supported for this operation
+- **InvalidAISDKModelFormatError** - Model string does not follow the required `provider/model` format
\ No newline at end of file
diff --git a/packages/docs/v3/references/agent.mdx b/packages/docs/v3/references/agent.mdx
new file mode 100644
index 000000000..be702649f
--- /dev/null
+++ b/packages/docs/v3/references/agent.mdx
@@ -0,0 +1,869 @@
+---
+title: agent()
+description: 'Complete API reference for the agent() method'
+icon: 'robot'
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+<CardGroup cols={1}>
+<Card title="Agent" icon="robot" href="/v3/basics/agent">
+  See how to use agent() to create autonomous AI agents for multi-step browser workflows
+</Card>
+</CardGroup>
+
+### Agent Creation
+
+<Tabs>
+<Tab title="TypeScript">
+
+```typescript
+// Create agent instance
+const agent = stagehand.agent(config?: AgentConfig): AgentInstance
+```
+
+**AgentConfig Interface:**
+```typescript
+interface AgentConfig {
+  systemPrompt?: string;
+  integrations?: (Client | string)[];
+  tools?: ToolSet;
+  /** @deprecated Use `mode: "cua"` instead */
+  cua?: boolean;
+  model?: string | AgentModelConfig<string>;
+  executionModel?: string | AgentModelConfig<string>;
+  stream?: boolean; // Enable streaming mode (experimental)
+  mode?: "dom" | "hybrid" | "cua"; // Tool mode
+}
+
+// AgentModelConfig for advanced configuration
+type AgentModelConfig<TModelName extends string = string> = {
+  modelName: TModelName;
+} & Record<string, unknown>;
+```
+
+**AgentInstance Interface:**
+```typescript
+interface AgentInstance {
+  execute: (instructionOrOptions: string | AgentExecuteOptions) => Promise<AgentResult>;
+}
+```
+
+</Tab>
+
+</Tabs>
+
+### Agent Configuration
+
+<ParamField path="systemPrompt" type="string" optional>
+  Custom system prompt to provide to the agent. Overrides the default system prompt and defines agent behavior.
+</ParamField>
+
+<ParamField path="model" type="string | AgentModelConfig" optional>
+  The model to use for agent functionality. Can be either:
+  - A string in the format `"provider/model"` (e.g., `"openai/computer-use-preview"`, `"anthropic/claude-sonnet-4-20250514"`)
+  - An object with `modelName` and additional provider-specific options
+
+  **Available CUA Models:**
+  - `"anthropic/claude-haiku-4-5-20251001"`
+  - `"anthropic/claude-sonnet-4-6"`
+  - `"anthropic/claude-sonnet-4-5-20250929"`
+  - `"anthropic/claude-opus-4-5-20251101"`
+  - `"anthropic/claude-opus-4-6"`
+  - `"google/gemini-2.5-computer-use-preview-10-2025"`
+  - `"google/gemini-3-flash-preview"`
+  - `"google/gemini-3-pro-preview"`
+  - `"microsoft/fara-7b"`
+  - `"openai/computer-use-preview"`
+  - `"openai/computer-use-preview-2025-03-11"`
+
+  <Expandable title="AgentModelConfig Object">
+    <ParamField path="modelName" type="string" required>
+      The model name
+    </ParamField>
+    <ParamField path="[key: string]" type="unknown" optional>
+      Additional provider-specific options (e.g., `apiKey`, `baseURL`)
+    </ParamField>
+  </Expandable>
+</ParamField>
+
+<ParamField path="executionModel" type="string | AgentModelConfig" optional>
+  The model to use for tool execution (observe/act calls within agent tools). If not specified, inherits from the main model configuration.
+
+  **Format:** `"provider/model"` (e.g., `"openai/gpt-4o-mini"`, `"google/gemini-2.0-flash-exp"`)
+</ParamField>
+
+<ParamField path="cua" type="boolean" optional>
+  <Warning>**Deprecated:** Use `mode: "cua"` instead. This option will be removed in a future version.</Warning>
+  
+  Indicates whether Computer Use Agent (CUA) mode is enabled. When false, the agent uses standard tool-based operation instead of computer control.
+</ParamField>
+
+<ParamField path="integrations" type="(Client | string)[]" optional>
+  MCP (Model Context Protocol) integrations for external tools and services.
+
+  **Array of:** MCP server URLs (strings) or connected Client objects
+</ParamField>
+
+<ParamField path="tools" type="ToolSet" optional>
+  Custom tool definitions to extend agent capabilities using the AI SDK ToolSet format.
+</ParamField>
+
+<ParamField path="stream" type="boolean" optional>
+  Enable streaming mode for the agent. When `true`, `execute()` returns `AgentStreamResult` with `textStream` for incremental output. When `false` (default), `execute()` returns `AgentResult` after completion.
+  
+  **Default:** `false`
+  
+  <Warning>**Non-CUA agents only.** Requires `experimental: true`. Not available when `mode: "cua"`.</Warning>
+</ParamField>
+
+<ParamField path="mode" type='"dom" | "hybrid" | "cua"' optional>
+  Tool mode for the agent. Determines which set of tools are available to the agent.
+  
+  **Modes:**
+  - `"dom"` (default): Uses DOM-based tools (`act`, `fillForm`) for structured page interactions. Works with any model.
+  - `"hybrid"`: Uses both DOM-based and coordinate-based tools (`act`, `click`, `type`, `dragAndDrop`, `clickAndHold`, `fillForm`) for visual/screenshot-based interactions. Requires models with reliable coordinate-based action capabilities.
+  - `"cua"`: Uses Computer Use Agent (CUA) providers like Anthropic Claude, Google Gemini, or OpenAI for screenshot-based automation. This is the preferred way to enable CUA mode (replaces the deprecated `cua: true` option).
+  
+  **Default:** `"dom"`
+  
+  <Warning>
+  **Hybrid Mode Model Requirements:** Only use hybrid mode with models that can reliably perform coordinate-based actions:
+  - **Google:** `google/gemini-3-flash-preview`
+  - **Anthropic:** `anthropic/claude-sonnet-4-20250514`, `anthropic/claude-sonnet-4-5-20250929`, `anthropic/claude-haiku-4-5-20251001`
+  
+  Requires `experimental: true` in Stagehand constructor.
+  </Warning>
+</ParamField>
+
+### Execute Method
+
+<Tabs>
+<Tab title="Non-Streaming">
+
+```typescript
+// String instruction
+await agent.execute(instruction: string): Promise<AgentResult>
+
+// With options
+await agent.execute(options: AgentExecuteOptions): Promise<AgentResult>
+```
+
+**AgentExecuteOptions Interface:**
+```typescript
+interface AgentExecuteOptions {
+  instruction: string;
+  maxSteps?: number;
+  page?: PlaywrightPage | PuppeteerPage | PatchrightPage | Page;
+  highlightCursor?: boolean;
+  messages?: ModelMessage[]; // Continue from previous conversation (experimental)
+  signal?: AbortSignal; // Cancel execution (experimental)
+  excludeTools?: string[]; // Tools to exclude from this execution (experimental)
+  output?: ZodObject; // Zod schema for structured output (experimental)
+  callbacks?: AgentExecuteCallbacks;
+}
+
+interface AgentExecuteCallbacks {
+  prepareStep?: PrepareStepFunction<ToolSet>;
+  onStepFinish?: GenerateTextOnStepFinishCallback<ToolSet>;
+}
+```
+
+</Tab>
+
+<Tab title="Streaming">
+
+```typescript
+// With stream: true in AgentConfig
+await agent.execute(options: AgentStreamExecuteOptions): Promise<AgentStreamResult>
+```
+
+**AgentStreamExecuteOptions Interface:**
+```typescript
+interface AgentStreamExecuteOptions {
+  instruction: string;
+  maxSteps?: number;
+  page?: PlaywrightPage | PuppeteerPage | PatchrightPage | Page;
+  highlightCursor?: boolean;
+  messages?: ModelMessage[]; // Continue from previous conversation (experimental)
+  signal?: AbortSignal; // Cancel execution (experimental)
+  excludeTools?: string[]; // Tools to exclude from this execution (experimental)
+  output?: ZodObject; // Zod schema for structured output (experimental)
+  callbacks?: AgentStreamCallbacks;
+}
+
+interface AgentStreamCallbacks {
+  prepareStep?: PrepareStepFunction<ToolSet>;
+  onStepFinish?: StreamTextOnStepFinishCallback<ToolSet>;
+  onChunk?: StreamTextOnChunkCallback<ToolSet>;
+  onFinish?: StreamTextOnFinishCallback<ToolSet>;
+  onError?: StreamTextOnErrorCallback;
+  onAbort?: (event: { steps: Array<StepResult<ToolSet>> }) => void | Promise<void>;
+}
+```
+
+</Tab>
+
+</Tabs>
+
+### Execute Parameters
+
+<ParamField path="instruction" type="string" required>
+  High-level task description in natural language.
+</ParamField>
+
+<ParamField path="maxSteps" type="number" optional>
+  Maximum number of actions the agent can take before stopping.
+
+  **Default:** `20`
+</ParamField>
+
+<ParamField path="page" type="PlaywrightPage | PuppeteerPage | PatchrightPage | Page" optional>
+  Optional: Specify which page to perform the agent execution on. Supports multiple browser automation libraries:
+  - **Playwright**: Native Playwright Page objects
+  - **Puppeteer**: Puppeteer Page objects
+  - **Patchright**: Patchright Page objects
+  - **Stagehand Page**: Stagehand's wrapped Page object
+
+  If not specified, defaults to the current "active" page in your Stagehand instance.
+</ParamField>
+
+<ParamField path="highlightCursor" type="boolean" optional>
+  Whether to show a visual cursor on the page during agent execution. Useful for debugging and demonstrations.
+
+  **Default:** `false`
+</ParamField>
+
+<ParamField path="messages" type="ModelMessage[]" optional>
+  Previous conversation messages to continue from. Pass the `messages` from a previous `AgentResult` to continue that conversation.
+
+  <Warning>**Non-CUA agents only.** Requires `experimental: true`. Not available when `mode: "cua"`.</Warning>
+</ParamField>
+
+<ParamField path="signal" type="AbortSignal" optional>
+  An `AbortSignal` that can be used to cancel the agent execution. When aborted, the agent will stop and throw an `AgentAbortError`.
+
+  <Warning>**Non-CUA agents only.** Requires `experimental: true`. Not available when `mode: "cua"`.</Warning>
+</ParamField>
+
+<ParamField path="excludeTools" type="string[]" optional>
+  Tools to exclude from this execution. Pass an array of tool names to prevent the agent from using those tools.
+
+  **Available tools by mode:**
+
+  **DOM mode (default):** `act`, `fillForm`, `ariaTree`, `extract`, `goto`, `scroll`, `keys`, `navback`, `screenshot`, `think`, `wait`, `search`
+
+  **Hybrid mode:** `click`, `type`, `dragAndDrop`, `clickAndHold`, `fillFormVision`, `act`, `ariaTree`, `extract`, `goto`, `scroll`, `keys`, `navback`, `screenshot`, `think`, `wait`, `search`
+
+  <Warning>**Non-CUA agents only.** Requires `experimental: true`. Not available when `cua: true`.</Warning>
+</ParamField>
+
+<ParamField path="output" type="ZodObject" optional>
+  A Zod schema defining structured output data to return when the task completes. The agent will populate this data based on the information it gathered during execution. The result will be available in `AgentResult.output`.
+
+  <Warning>**Non-CUA agents only.** Requires `experimental: true`. Not available when `mode: "cua"`.</Warning>
+
+  ```typescript
+  import { z } from "zod";
+
+  const result = await agent.execute({
+    instruction: "Find the cheapest flight from NYC to LA",
+    output: z.object({
+      price: z.string().describe("The price of the flight"),
+      airline: z.string().describe("The airline name"),
+      departureTime: z.string().describe("Departure time"),
+    }),
+  });
+
+  console.log(result.output); // { price: "$199", airline: "Delta", departureTime: "8:00 AM" }
+  ```
+</ParamField>
+
+<ParamField path="callbacks" type="AgentExecuteCallbacks | AgentStreamCallbacks" optional>
+  Callbacks to hook into the agent's execution lifecycle. The available callbacks depend on whether streaming is enabled.
+
+  <Warning>**Non-CUA agents only.** Requires `experimental: true`. Not available when `mode: "cua"`.</Warning>
+
+  <Expandable title="Non-Streaming Callbacks (AgentExecuteCallbacks)">
+    <ParamField path="prepareStep" type="PrepareStepFunction<ToolSet>" optional>
+      Called before each step to modify settings. You can change the model, tool choices, active tools, system prompt, and input messages for each step.
+    </ParamField>
+    <ParamField path="onStepFinish" type="GenerateTextOnStepFinishCallback<ToolSet>" optional>
+      Called when each step (LLM call) completes. Provides access to tool calls, reasoning, and step results.
+    </ParamField>
+  </Expandable>
+
+  <Expandable title="Streaming Callbacks (AgentStreamCallbacks)">
+    <ParamField path="prepareStep" type="PrepareStepFunction<ToolSet>" optional>
+      Called before each step to modify settings.
+    </ParamField>
+    <ParamField path="onStepFinish" type="StreamTextOnStepFinishCallback<ToolSet>" optional>
+      Called when each step completes during streaming.
+    </ParamField>
+    <ParamField path="onChunk" type="StreamTextOnChunkCallback<ToolSet>" optional>
+      Called for each chunk of the stream. Stream processing will pause until the callback promise resolves.
+    </ParamField>
+    <ParamField path="onFinish" type="StreamTextOnFinishCallback<ToolSet>" optional>
+      Called when the stream finishes successfully.
+    </ParamField>
+    <ParamField path="onError" type="StreamTextOnErrorCallback" optional>
+      Called when an error occurs during streaming.
+    </ParamField>
+    <ParamField path="onAbort" type="(event: { steps: StepResult[] }) => void | Promise<void>" optional>
+      Called when the stream is aborted via the `signal` option.
+    </ParamField>
+  </Expandable>
+</ParamField>
+
+### Response
+
+**Returns:** `Promise<AgentResult>` (non-streaming) or `Promise<AgentStreamResult>` (streaming)
+
+<Tabs>
+<Tab title="Non-Streaming">
+
+**AgentResult Interface:**
+```typescript
+interface AgentResult {
+  success: boolean;
+  message: string;
+  actions: AgentAction[];
+  completed: boolean;
+  metadata?: Record<string, unknown>;
+  messages?: ModelMessage[]; // Conversation history for continuation (experimental)
+  output?: Record<string, unknown>; // Structured output data (experimental)
+  usage?: {
+    input_tokens: number;
+    output_tokens: number;
+    reasoning_tokens?: number;
+    cached_input_tokens?: number;
+    inference_time_ms: number;
+  };
+}
+
+// AgentAction can contain various tool-specific fields
+interface AgentAction {
+  type: string;
+  reasoning?: string;
+  taskCompleted?: boolean;
+  action?: string;
+  timeMs?: number;        // wait tool
+  pageText?: string;      // ariaTree tool
+  pageUrl?: string;       // ariaTree tool
+  instruction?: string;   // various tools
+  timestamp?: number;     // Action timestamp
+  [key: string]: unknown; // Additional tool-specific fields
+}
+```
+
+</Tab>
+
+<Tab title="Streaming">
+
+**AgentStreamResult Interface:**
+```typescript
+interface AgentStreamResult {
+  // Async iterable of text chunks for incremental output
+  textStream: AsyncIterable<string>;
+  
+  // Async iterable of all stream events (tool calls, messages, etc.)
+  fullStream: AsyncIterable<StreamPart>;
+  
+  // Promise that resolves to the final AgentResult when streaming completes
+  result: Promise<AgentResult>;
+  
+  // Additional properties from StreamTextResult<ToolSet, never>
+  // See Vercel AI SDK documentation for full details
+}
+```
+
+</Tab>
+</Tabs>
+
+<ResponseField name="success" type="boolean">
+  Whether the task was completed successfully.
+</ResponseField>
+
+<ResponseField name="message" type="string">
+  Description of the execution result and status.
+</ResponseField>
+
+<ResponseField name="actions" type="AgentAction[]">
+  Array of individual actions taken during execution. Each action contains tool-specific data.
+</ResponseField>
+
+<ResponseField name="completed" type="boolean">
+  Whether the agent believes the task is fully complete.
+</ResponseField>
+
+<ResponseField name="metadata" type="Record<string, unknown>" optional>
+  Additional execution metadata and debugging information.
+</ResponseField>
+
+<ResponseField name="messages" type="ModelMessage[]" optional>
+  The conversation messages from this execution. Pass these to a subsequent `execute()` call via the `messages` option to continue the conversation.
+
+  <Note>**Non-CUA agents only.** Requires `experimental: true`.</Note>
+</ResponseField>
+
+<ResponseField name="output" type="Record<string, unknown>" optional>
+  Custom structured output data extracted based on the `output` Zod schema provided in execute options. Only populated if an `output` schema was provided.
+
+  <Note>**Non-CUA agents only.** Requires `experimental: true`.</Note>
+</ResponseField>
+
+<ResponseField name="usage" type="object" optional>
+  Token usage and performance metrics.
+
+  <Expandable title="Usage Metrics">
+    <ResponseField name="input_tokens" type="number">
+      Number of input tokens used
+    </ResponseField>
+    <ResponseField name="output_tokens" type="number">
+      Number of output tokens generated
+    </ResponseField>
+    <ResponseField name="reasoning_tokens" type="number" optional>
+      Number of reasoning tokens (if supported by the model)
+    </ResponseField>
+    <ResponseField name="cached_input_tokens" type="number" optional>
+      Number of cached input tokens (if supported by the model)
+    </ResponseField>
+    <ResponseField name="inference_time_ms" type="number">
+      Total inference time in milliseconds
+    </ResponseField>
+  </Expandable>
+</ResponseField>
+
+### Example Response
+```json
+{
+  "success": true,
+  "message": "Task completed successfully",
+  "actions": [
+    {
+      "type": "act",
+      "instruction": "click the submit button",
+      "reasoning": "User requested to submit the form",
+      "taskCompleted": false
+    },
+    {
+      "type": "observe",
+      "instruction": "check if submission was successful",
+      "taskCompleted": true
+    }
+  ],
+  "completed": true,
+  "metadata": {
+    "steps_taken": 2
+  },
+  "output": {
+    "price": "$199",
+    "airline": "Delta",
+    "departureTime": "8:00 AM"
+  },
+  "usage": {
+    "input_tokens": 1250,
+    "output_tokens": 340,
+    "reasoning_tokens": 42,
+    "cached_input_tokens": 0,
+    "inference_time_ms": 2500
+  }
+}
+```
+
+### Code Examples
+
+<Tabs>
+<Tab title="Basic Usage">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+// Initialize with Browserbase (API key and project ID from environment variables)
+// Set BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID in your environment
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  model: "anthropic/claude-sonnet-4-20250514"
+});
+await stagehand.init();
+
+const page = stagehand.context.pages()[0];
+// Create agent with default configuration
+const agent = stagehand.agent();
+
+// Navigate to a page
+await page.goto("https://www.google.com");
+
+// Execute a task
+const result = await agent.execute("Search for 'Stagehand automation' and click the first result");
+
+console.log(result.message);
+console.log(`Completed: ${result.completed}`);
+console.log(`Actions taken: ${result.actions.length}`);
+```
+
+</Tab>
+<Tab title="Custom Configuration">
+
+```typescript
+// Create agent with custom model and system prompt
+const agent = stagehand.agent({
+  model: "openai/computer-use-preview",
+  systemPrompt: "You are a helpful assistant that can navigate websites efficiently. Always verify actions before proceeding.",
+  executionModel: "openai/gpt-4o-mini"  // Use faster model for tool execution
+});
+
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com");
+
+const result = await agent.execute({
+  instruction: "Fill out the contact form with test data",
+  maxSteps: 10,
+  highlightCursor: true
+});
+```
+
+</Tab>
+<Tab title="Advanced Model Config">
+
+```typescript
+// Using AgentModelConfig for advanced configuration
+const agent = stagehand.agent({
+  model: {
+    modelName: "anthropic/claude-sonnet-4-20250514",
+    apiKey: process.env.ANTHROPIC_API_KEY,
+    baseURL: "https://custom-proxy.com/v1"
+  }
+});
+
+const result = await agent.execute("Complete the checkout process");
+```
+
+</Tab>
+<Tab title="Multi-Page">
+
+```typescript
+const page1 = stagehand.context.pages()[0];
+const page2 = await stagehand.context.newPage();
+
+const agent = stagehand.agent();
+
+// Execute on specific page
+await page2.goto("https://example.com/dashboard");
+const result = await agent.execute({
+  instruction: "Export the data table",
+  page: page2
+});
+```
+
+</Tab>
+<Tab title="Streaming">
+
+```typescript
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  experimental: true, // Required for streaming
+});
+await stagehand.init();
+
+const page = stagehand.context.pages()[0];
+await page.goto("https://amazon.com");
+
+// Create a streaming agent
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5-20250929",
+  stream: true,
+});
+
+const streamResult = await agent.execute({
+  instruction: "Search for headphones and find the best deal",
+  maxSteps: 20,
+});
+
+// Stream text output incrementally
+for await (const delta of streamResult.textStream) {
+  process.stdout.write(delta);
+}
+
+// Get the final result
+const finalResult = await streamResult.result;
+console.log("Completed:", finalResult.completed);
+```
+
+</Tab>
+<Tab title="Callbacks">
+
+```typescript
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  experimental: true,
+});
+await stagehand.init();
+
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5-20250929",
+});
+
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com");
+
+const result = await agent.execute({
+  instruction: "Fill out the contact form",
+  maxSteps: 10,
+  callbacks: {
+    prepareStep: async (stepContext) => {
+      console.log(`Starting step ${stepContext.stepNumber}`);
+      return stepContext;
+    },
+    onStepFinish: async (event) => {
+      console.log(`Step finished: ${event.finishReason}`);
+      if (event.toolCalls) {
+        for (const tc of event.toolCalls) {
+          console.log(`Tool: ${tc.toolName}`, tc.input);
+        }
+      }
+    },
+  },
+});
+```
+
+</Tab>
+<Tab title="Abort Signal">
+
+```typescript
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  experimental: true,
+});
+await stagehand.init();
+
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5-20250929",
+});
+
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com");
+
+const controller = new AbortController();
+
+// Abort after 30 seconds
+setTimeout(() => controller.abort("Timeout exceeded"), 30000);
+
+try {
+  const result = await agent.execute({
+    instruction: "Complete a complex multi-step workflow",
+    maxSteps: 50,
+    signal: controller.signal,
+  });
+} catch (error) {
+  if (error.name === "AgentAbortError") {
+    console.log("Task cancelled:", error.message);
+  }
+}
+```
+
+</Tab>
+<Tab title="Message Continuation">
+
+```typescript
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  experimental: true,
+});
+await stagehand.init();
+
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5-20250929",
+});
+
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com/shop");
+
+// First execution
+const firstResult = await agent.execute({
+  instruction: "Search for laptops and list the top 3 options",
+  maxSteps: 10,
+});
+
+// Continue conversation with context from first run
+const secondResult = await agent.execute({
+  instruction: "Filter those results by price under $1000",
+  maxSteps: 10,
+  messages: firstResult.messages, // Pass previous messages
+});
+
+// Chain further with accumulated context
+const thirdResult = await agent.execute({
+  instruction: "Add the best-rated one to cart",
+  maxSteps: 10,
+  messages: secondResult.messages,
+});
+
+console.log("Final:", thirdResult.message);
+```
+
+</Tab>
+<Tab title="MCP Integrations">
+
+```typescript
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+
+// Create agent with MCP integrations
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-20250514",
+  integrations: [
+    "https://mcp-server.example.com",  // MCP server URL
+    mcpClientInstance  // Or pre-connected Client object
+  ]
+});
+
+const result = await agent.execute("Use the external tool to process this data");
+```
+
+</Tab>
+<Tab title="Exclude Tools">
+
+```typescript
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  experimental: true, // Required for excludeTools
+});
+await stagehand.init();
+
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5-20250929",
+});
+
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com");
+
+// Exclude specific tools from this execution
+const result = await agent.execute({
+  instruction: "Navigate the page and click buttons",
+  maxSteps: 15,
+  excludeTools: ["screenshot", "extract", "search"],
+});
+
+console.log("Completed:", result.completed);
+```
+
+</Tab>
+<Tab title="Hybrid Mode">
+
+```typescript
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  experimental: true, // Required for hybrid mode
+});
+await stagehand.init();
+
+// Create agent with hybrid mode for coordinate-based interactions
+const agent = stagehand.agent({
+  mode: "hybrid",
+  model: "google/gemini-3-flash-preview", // Use a model that supports coordinate-based actions
+});
+
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com/form");
+
+const result = await agent.execute({
+  instruction: "Fill out the registration form with test data",
+  maxSteps: 15,
+  highlightCursor: true, // Enabled by default in hybrid mode
+});
+
+console.log("Completed:", result.completed);
+```
+
+</Tab>
+<Tab title="Structured Output">
+
+```typescript
+import { z } from "zod";
+
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  experimental: true, // Required for structured output
+});
+await stagehand.init();
+
+const agent = stagehand.agent({
+  model: "anthropic/claude-sonnet-4-5-20250929",
+});
+
+const page = stagehand.context.pages()[0];
+await page.goto("https://www.google.com/flights");
+
+// Define output schema to receive structured data
+const result = await agent.execute({
+  instruction: "Find the cheapest flight from NYC to LA for next week",
+  maxSteps: 20,
+  output: z.object({
+    price: z.string().describe("The price of the flight"),
+    airline: z.string().describe("The airline name"),
+    departureTime: z.string().describe("Departure time"),
+    arrivalTime: z.string().describe("Arrival time"),
+    flightNumber: z.string().optional().describe("Flight number if available"),
+  }),
+});
+
+// Access the structured output
+console.log("Flight found:");
+console.log(`  Price: ${result.output?.price}`);
+console.log(`  Airline: ${result.output?.airline}`);
+console.log(`  Departure: ${result.output?.departureTime}`);
+console.log(`  Arrival: ${result.output?.arrivalTime}`);
+```
+
+</Tab>
+<Tab title="Custom Tools">
+
+```typescript
+import { tool } from "@browserbasehq/stagehand";
+import { z } from "zod";
+
+// Define custom tools using the tool helper from @browserbasehq/stagehand
+const customTools = {
+  calculateTotal: tool({
+    description: "Calculate the total of items in cart",
+    parameters: z.object({
+      items: z.array(z.object({
+        price: z.number(),
+        quantity: z.number()
+      }))
+    }),
+    execute: async ({ items }) => {
+      const total = items.reduce((sum, item) => sum + (item.price * item.quantity), 0);
+      return { total };
+    }
+  })
+};
+
+const agent = stagehand.agent({
+  model: "openai/computer-use-preview",
+  tools: customTools
+});
+
+const result = await agent.execute("Calculate the total cost of items in the shopping cart");
+```
+
+</Tab>
+</Tabs>
+
+### Error Types
+
+The following errors may be thrown by the `agent()` method:
+
+- **StagehandError** - Base class for all Stagehand-specific errors
+- **StagehandInitError** - Agent was not properly initialized
+- **MissingLLMConfigurationError** - No LLM API key or client configured
+- **UnsupportedModelError** - The specified model is not supported for agent functionality
+- **UnsupportedModelProviderError** - The specified model provider is not supported
+- **InvalidAISDKModelFormatError** - Model string does not follow the required `provider/model` format
+- **MCPConnectionError** - Failed to connect to MCP server
+- **StagehandDefaultError** - General execution error with detailed message
+- **AgentAbortError** - Thrown when agent execution is cancelled via an `AbortSignal`
+- **StreamingCallbacksInNonStreamingModeError** - Thrown when streaming-only callbacks (`onChunk`, `onFinish`, `onError`, `onAbort`) are used without `stream: true`
+- **ExperimentalNotConfiguredError** - Thrown when experimental features (callbacks, signal, messages, streaming) are used without `experimental: true` in Stagehand constructor
\ No newline at end of file
diff --git a/packages/docs/v3/references/context.mdx b/packages/docs/v3/references/context.mdx
new file mode 100644
index 000000000..1ac50eaa3
--- /dev/null
+++ b/packages/docs/v3/references/context.mdx
@@ -0,0 +1,705 @@
+---
+title: context
+description: 'Complete API reference for the browser context'
+icon: 'window'
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+<CardGroup cols={1}>
+<Card title="Stagehand" icon="wand-magic-sparkles" href="/v3/references/stagehand">
+  Learn about the main Stagehand object
+</Card>
+</CardGroup>
+
+## Overview
+
+The `context` object manages the browser context, which is a container for multiple pages (tabs). It provides methods for creating new pages, accessing existing pages, and managing which page is currently active.
+
+Access the context through your Stagehand instance:
+
+```typescript
+const stagehand = new Stagehand({ env: "BROWSERBASE" });
+await stagehand.init();
+const context = stagehand.context;
+```
+
+## Methods
+
+### newPage()
+
+Create a new page (tab) in the browser.
+
+```typescript
+await context.newPage(url?: string): Promise<Page>
+```
+
+<ParamField path="url" type="string" optional>
+  The URL to navigate to in the new page.
+
+  **Default:** `"about:blank"`
+</ParamField>
+
+**Returns:** `Promise<Page>` - The newly created page object.
+
+The new page is automatically set as the active page.
+
+### pages()
+
+Get all open pages in the browser context.
+
+```typescript
+context.pages(): Page[]
+```
+
+**Returns:** `Page[]` - Array of all open pages, ordered from oldest to newest.
+
+### activePage()
+
+Get the currently active page.
+
+```typescript
+context.activePage(): Page | undefined
+```
+
+**Returns:** `Page | undefined` - The most recently used page, or `undefined` if no pages exist.
+
+The active page is determined by:
+1. Most recently interacted with page
+2. Most recently created page if no interaction history
+3. `undefined` if all pages have been closed
+
+### setActivePage()
+
+Set a specific page as the active page.
+
+```typescript
+context.setActivePage(page: Page): void
+```
+
+<ParamField path="page" type="Page" required>
+  The page to set as active. Must be a page that exists in this context.
+</ParamField>
+
+This method:
+- Marks the page as most recently used
+- Brings the tab to the foreground (in headed mode)
+- Makes it the default page for subsequent operations
+
+### addInitScript()
+
+Inject JavaScript that runs before any page scripts on every navigation.
+
+```typescript
+await context.addInitScript<Arg>(
+  script: string | { path?: string; content?: string } | ((arg: Arg) => unknown),
+  arg?: Arg,
+): Promise<void>
+```
+
+<ParamField
+  path="script"
+  type="string | { path?: string; content?: string } | (arg: Arg) => unknown"
+  required
+>
+  Provide the script to inject. Pass raw source code, reference a file on disk,
+  or supply a function that Stagehand serializes before sending to the browser.
+</ParamField>
+
+<ParamField path="arg" type="Arg" optional>
+  Extra data that is JSON-serialized and passed to your function. Only supported
+  when `script` is a function.
+</ParamField>
+
+This method:
+- Runs at document start, and installs the script on all currently open pages and replays it on every
+  navigation of those pages
+- Automatically applies the same script to any pages created after calling
+  `context.addInitScript()`
+- Allows referencing preload files via `{ path: "./preloads/dom-hooks.js" }`,
+  mirroring Playwright's `sourceURL` behavior for readable stack traces
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({ env: "LOCAL" });
+await stagehand.init();
+const context = stagehand.context;
+
+// Add some JavaScript to automatically accept alert dialogs
+await context.addInitScript(() => {
+   window.alert = () => {};
+   window.confirm = () => true;
+   window.prompt = () => '';
+ });
+```
+
+### setExtraHTTPHeaders()
+
+Set HTTP headers that will be included in every request made by all pages in the browser context.
+
+```typescript
+await context.setExtraHTTPHeaders(headers: Record<string, string>): Promise<void>
+```
+
+<ParamField path="headers" type="Record<string, string>" required>
+  A plain object of header name–value pairs. All values must be strings.
+</ParamField>
+
+This method:
+- Applies the headers to all existing pages in the context immediately
+- Automatically applies the same headers to any pages created after calling `setExtraHTTPHeaders()`
+- Calling it again replaces all previously set extra headers (it does not merge)
+- To clear all extra headers, pass an empty object: `await context.setExtraHTTPHeaders({})`
+
+<Note>
+Headers set via `context.setExtraHTTPHeaders()` are context-wide. They apply to every network request from every page in the context, including navigation requests, XHR/fetch calls, and subresource loads.
+</Note>
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({ env: "LOCAL" });
+await stagehand.init();
+const context = stagehand.context;
+
+// Set custom headers for all requests
+await context.setExtraHTTPHeaders({
+  "X-Custom-Token": "my-secret-token",
+  "Accept-Language": "en-US",
+});
+
+// All subsequent requests from any page in this context
+// will include these headers
+const page = await context.newPage("https://example.com");
+```
+
+### cookies()
+
+Retrieve browser cookies, optionally filtered by URL(s).
+
+```typescript
+await context.cookies(urls?: string | string[]): Promise<Cookie[]>
+```
+
+<ParamField path="urls" type="string | string[]" optional>
+  A single URL or array of URLs to filter cookies by. When provided, only cookies that match the domain, path, and secure requirements of the given URLs are returned.
+
+  **Default:** Returns all cookies when omitted.
+</ParamField>
+
+**Returns:** `Promise<Cookie[]>` - Array of cookie objects.
+
+```typescript
+// Get all cookies
+const allCookies = await context.cookies();
+
+// Get cookies for a specific URL
+const siteCookies = await context.cookies("https://example.com");
+
+// Get cookies for multiple URLs
+const cookies = await context.cookies([
+  "https://example.com",
+  "https://api.example.com",
+]);
+```
+
+### addCookies()
+
+Set one or more cookies in the browser context.
+
+```typescript
+await context.addCookies(cookies: CookieParam[]): Promise<void>
+```
+
+<ParamField path="cookies" type="CookieParam[]" required>
+  Array of cookie parameters to set. Each cookie must provide either `url` or both `domain` and `path` — providing both `url` and `domain` (or `url` and `path`) will throw a validation error.
+</ParamField>
+
+<Note>
+Cookies set via `context.addCookies()` are shared across all pages in the context, scoped by domain and path.
+</Note>
+
+```typescript
+// Set a cookie using a URL
+await context.addCookies([
+  {
+    name: "session",
+    value: "abc123",
+    url: "https://example.com",
+  },
+]);
+
+// Set a cookie using domain and path
+await context.addCookies([
+  {
+    name: "token",
+    value: "xyz789",
+    domain: ".example.com",
+    path: "/",
+    secure: true,
+    httpOnly: true,
+    sameSite: "Strict",
+  },
+]);
+```
+
+<Warning>
+Setting `sameSite: "None"` requires `secure: true`. Stagehand will throw a validation error if this requirement is not met.
+</Warning>
+
+### clearCookies()
+
+Clear cookies from the browser context. Can clear all cookies or selectively filter by name, domain, or path.
+
+```typescript
+await context.clearCookies(options?: ClearCookieOptions): Promise<void>
+```
+
+<ParamField path="options" type="ClearCookieOptions" optional>
+  Filter options to selectively clear cookies. When omitted, all cookies are cleared.
+
+  <Expandable title="ClearCookieOptions">
+    <ParamField path="name" type="string | RegExp" optional>
+      Match cookies by name. Supports exact string match or RegExp.
+    </ParamField>
+
+    <ParamField path="domain" type="string | RegExp" optional>
+      Match cookies by domain. Supports exact string match or RegExp.
+    </ParamField>
+
+    <ParamField path="path" type="string | RegExp" optional>
+      Match cookies by path. Supports exact string match or RegExp.
+    </ParamField>
+  </Expandable>
+</ParamField>
+
+```typescript
+// Clear all cookies
+await context.clearCookies();
+
+// Clear cookies by exact name
+await context.clearCookies({ name: "session" });
+
+// Clear cookies by domain pattern
+await context.clearCookies({ domain: /\.example\.com$/ });
+
+// Combine filters (a cookie must match ALL provided filters to be cleared)
+await context.clearCookies({
+  name: "token",
+  domain: ".example.com",
+});
+```
+
+### close()
+
+Close the browser context and all associated pages.
+
+```typescript
+await context.close(): Promise<void>
+```
+
+This method:
+- Closes the CDP connection
+- Cleans up all pages
+- Clears all internal mappings
+
+**Note:** This is typically called internally by `stagehand.close()`. You usually don't need to call this directly.
+
+## Code Examples
+
+<Tabs>
+<Tab title="Basic Usage">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+// Initialize with Browserbase (API key and project ID from environment variables)
+// Set BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID in your environment
+const stagehand = new Stagehand({ env: "BROWSERBASE" });
+await stagehand.init();
+const context = stagehand.context;
+
+// Create a new page
+const page1 = await context.newPage("https://example.com");
+console.log("Created page 1");
+
+// Create another page
+const page2 = await context.newPage("https://another-site.com");
+console.log("Created page 2");
+
+// Get all pages
+const allPages = context.pages();
+console.log(`Total pages: ${allPages.length}`);
+
+await stagehand.close();
+```
+
+</Tab>
+<Tab title="Multi-Page Workflow">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({ env: "LOCAL" });
+await stagehand.init();
+const context = stagehand.context;
+
+// Start with main page
+const mainPage = context.pages()[0];
+await mainPage.goto("https://example.com");
+
+// Open additional pages
+const dashboardPage = await context.newPage("https://example.com/dashboard");
+const settingsPage = await context.newPage("https://example.com/settings");
+
+// Work with specific page
+context.setActivePage(dashboardPage);
+await stagehand.act("click the export button");
+
+// Switch to another page
+context.setActivePage(settingsPage);
+await stagehand.act("enable notifications");
+
+// Back to main page
+context.setActivePage(mainPage);
+await stagehand.act("click the logout button");
+
+await stagehand.close();
+```
+
+</Tab>
+<Tab title="Page Management">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({ env: "LOCAL" });
+await stagehand.init();
+const context = stagehand.context;
+
+// Create multiple pages
+const pages = await Promise.all([
+  context.newPage("https://site1.com"),
+  context.newPage("https://site2.com"),
+  context.newPage("https://site3.com"),
+]);
+
+console.log(`Opened ${pages.length} pages`);
+
+// Get the active page
+const active = context.activePage();
+console.log(`Active page URL: ${active?.url()}`);
+
+// Iterate through all pages
+for (const page of context.pages()) {
+  console.log(`Page URL: ${page.url()}`);
+  console.log(`Page title: ${await page.title()}`);
+}
+
+await stagehand.close();
+```
+
+</Tab>
+<Tab title="Parallel Operations">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+import { z } from "zod";
+
+const stagehand = new Stagehand({ env: "LOCAL" });
+await stagehand.init();
+const context = stagehand.context;
+
+// Create pages for different sites
+const page1 = await context.newPage("https://site1.com");
+const page2 = await context.newPage("https://site2.com");
+const page3 = await context.newPage("https://site3.com");
+
+const schema = z.object({
+  title: z.string(),
+  description: z.string()
+});
+
+// Extract data from all pages in parallel
+const results = await Promise.all([
+  stagehand.extract("get page info", schema, { page: page1 }),
+  stagehand.extract("get page info", schema, { page: page2 }),
+  stagehand.extract("get page info", schema, { page: page3 })
+]);
+
+console.log("Extracted data:", results);
+
+await stagehand.close();
+```
+
+</Tab>
+<Tab title="Active Page Tracking">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({ env: "LOCAL" });
+await stagehand.init();
+const context = stagehand.context;
+
+// Create pages
+const homePage = await context.newPage("https://example.com");
+const aboutPage = await context.newPage("https://example.com/about");
+const contactPage = await context.newPage("https://example.com/contact");
+
+// The last created page (contactPage) is now active
+console.log("Active:", context.activePage()?.url());
+// Output: "https://example.com/contact"
+
+// Switch to home page
+context.setActivePage(homePage);
+console.log("Active:", context.activePage()?.url());
+// Output: "https://example.com"
+
+// Now act on the active page (homePage)
+await stagehand.act("click the header link");
+
+await stagehand.close();
+```
+
+</Tab>
+<Tab title="Custom HTTP Headers">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({ env: "LOCAL" });
+await stagehand.init();
+const context = stagehand.context;
+
+// Set authorization headers for all requests
+await context.setExtraHTTPHeaders({
+  Authorization: "Bearer my-api-token",
+});
+
+// Navigate — the headers are sent with every request
+const page = context.pages()[0];
+await page.goto("https://api.example.com/dashboard");
+
+// Headers also apply to new pages
+const page2 = await context.newPage("https://api.example.com/settings");
+
+// Replace headers (previous headers are removed)
+await context.setExtraHTTPHeaders({
+  Authorization: "Bearer refreshed-token",
+  "X-Request-Id": "abc-123",
+});
+
+await stagehand.close();
+```
+
+</Tab>
+<Tab title="Cookie Management">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({ env: "LOCAL" });
+await stagehand.init();
+const context = stagehand.context;
+const page = context.pages()[0];
+
+await page.goto("https://example.com");
+
+// Set authentication cookies
+await context.addCookies([
+  {
+    name: "session_id",
+    value: "abc123",
+    domain: ".example.com",
+    path: "/",
+    httpOnly: true,
+    secure: true,
+    sameSite: "Lax",
+  },
+]);
+
+// Read cookies back
+const cookies = await context.cookies("https://example.com");
+console.log("Cookies:", cookies);
+
+// Clear specific cookies
+await context.clearCookies({ name: "session_id" });
+
+// Clear all cookies
+await context.clearCookies();
+
+await stagehand.close();
+```
+
+</Tab>
+</Tabs>
+
+## Working with Active Pages
+
+The context tracks which page is currently active:
+
+```typescript
+const stagehand = new Stagehand({ env: "LOCAL" });
+await stagehand.init();
+
+// Get the current active page
+const activePage = stagehand.context.activePage();
+
+// Create a new page - it becomes active
+const newPage = await stagehand.context.newPage();
+
+// Now context.activePage() returns newPage
+await newPage.goto("https://example.com");
+```
+
+## Relationship Between Context and Page
+
+- **Context** manages the browser-level state and multiple pages
+- **Page** represents a single tab/window with content
+- Creating a new page via `context.newPage()` automatically sets it as active
+- You can explicitly control the active page with `context.setActivePage()`
+- Use `context.activePage()` to get the currently active page
+
+```typescript
+// Get the active page
+const activePage = stagehand.context.activePage();
+
+// Or get the first page directly
+const firstPage = stagehand.context.pages()[0];
+```
+
+## Best Practices
+
+1. **Create pages explicitly** - Use `context.newPage()` instead of relying on popups or window.open
+2. **Track page references** - Store page objects in variables for easier management
+3. **Set active page before operations** - Ensure the correct page is active before calling Stagehand methods
+4. **Clean up properly** - Call `stagehand.close()` to close all pages and the context
+5. **Handle page order** - Remember that `context.pages()` returns pages in creation order
+6. **Use parallel operations** - Work with multiple pages simultaneously for better performance
+
+## Common Patterns
+
+### Tab Management
+
+```typescript
+// Keep track of pages by purpose
+const pages = {
+  home: await context.newPage("https://example.com"),
+  dashboard: await context.newPage("https://example.com/dashboard"),
+  settings: await context.newPage("https://example.com/settings")
+};
+
+// Switch between tabs
+context.setActivePage(pages.dashboard);
+await stagehand.act("view report");
+
+context.setActivePage(pages.settings);
+await stagehand.act("update preferences");
+```
+
+### Bulk Data Collection
+
+```typescript
+const urls = [
+  "https://site1.com",
+  "https://site2.com",
+  "https://site3.com"
+];
+
+// Open all pages
+const pages = await Promise.all(
+  urls.map(url => context.newPage(url))
+);
+
+// Extract data from each
+const data = await Promise.all(
+  pages.map(page => stagehand.extract("get data", schema, { page }))
+);
+```
+
+### Conditional Page Management
+
+```typescript
+// Only create a page if needed
+if (needsDashboard) {
+  const dashboard = await context.newPage("https://example.com/dashboard");
+  context.setActivePage(dashboard);
+  await stagehand.act("generate report");
+}
+
+// Check if we have multiple pages
+if (context.pages().length > 1) {
+  console.log("Multiple tabs open");
+}
+```
+
+## Error Handling
+
+Context methods may throw the following errors:
+
+- **Timeout errors** - `newPage()` timeout waiting for page to attach
+- **CDP errors** - Connection errors with Chrome DevTools Protocol
+- **Invalid page errors** - Attempting to set an active page that doesn't exist in the context
+- **StagehandSetExtraHTTPHeadersError** - `setExtraHTTPHeaders()` failed to apply headers to one or more sessions. The error includes a `failures` array with per-session details
+
+Always handle errors appropriately:
+
+```typescript
+try {
+  const page = await context.newPage("https://example.com");
+} catch (error) {
+  console.error("Failed to create page:", error.message);
+}
+```
+
+## Type Definitions
+
+```typescript
+interface V3Context {
+  newPage(url?: string): Promise<Page>;
+  pages(): Page[];
+  activePage(): Page | undefined;
+  setActivePage(page: Page): void;
+  setExtraHTTPHeaders(headers: Record<string, string>): Promise<void>;
+  cookies(urls?: string | string[]): Promise<Cookie[]>;
+  addCookies(cookies: CookieParam[]): Promise<void>;
+  clearCookies(options?: ClearCookieOptions): Promise<void>;
+  close(): Promise<void>;
+}
+
+interface Cookie {
+  name: string;
+  value: string;
+  domain: string;
+  path: string;
+  /** Unix time in seconds. -1 means session cookie. */
+  expires: number;
+  httpOnly: boolean;
+  secure: boolean;
+  sameSite: "Strict" | "Lax" | "None";
+}
+
+interface CookieParam {
+  name: string;
+  value: string;
+  /** If provided, domain/path/secure are derived from this URL. */
+  url?: string;
+  domain?: string;
+  path?: string;
+  /** Unix timestamp in seconds. -1 or omitted = session cookie. */
+  expires?: number;
+  httpOnly?: boolean;
+  secure?: boolean;
+  sameSite?: "Strict" | "Lax" | "None";
+}
+
+interface ClearCookieOptions {
+  name?: string | RegExp;
+  domain?: string | RegExp;
+  path?: string | RegExp;
+}
+```
diff --git a/packages/docs/v3/references/deeplocator.mdx b/packages/docs/v3/references/deeplocator.mdx
new file mode 100644
index 000000000..914dddeb2
--- /dev/null
+++ b/packages/docs/v3/references/deeplocator.mdx
@@ -0,0 +1,454 @@
+---
+title: deepLocator
+description: 'Complete API reference for the deepLocator method'
+icon: 'layer-group'
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+<CardGroup cols={1}>
+<Card title="Locator" icon="crosshairs" href="/v3/references/locator">
+  Learn about the standard Locator class
+</Card>
+</CardGroup>
+
+## Overview
+
+The `deepLocator()` method creates a special locator that can traverse iframe boundaries and shadow DOM using a simplified syntax. It automatically resolves the correct frame for each operation, making cross-frame interactions seamless.
+
+Access via the page object:
+
+```typescript
+const stagehand = new Stagehand({ env: "BROWSERBASE" });
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+// Deep locator with iframe traversal
+const button = page.deepLocator("iframe#myframe >> button.submit");
+await button.click();
+```
+
+## Syntax
+
+### page.deepLocator()
+
+Create a deep locator that can cross iframe and shadow DOM boundaries.
+
+```typescript
+page.deepLocator(selector: string): DeepLocatorDelegate
+```
+
+<ParamField path="selector" type="string" required>
+  Selector string with optional iframe hop notation (`>>`).
+
+  Supports:
+  - **CSS selectors** - Standard CSS syntax
+  - **XPath** - Prefix with `xpath=` or start with `/`
+  - **Hop notation** - Use `>>` to traverse into iframes
+  - **Deep XPath** - Automatically handles iframe steps in XPath
+</ParamField>
+
+**Returns:** `DeepLocatorDelegate` - A locator-like object that resolves frames on each action.
+
+## Hop Notation
+
+The `>>` operator allows you to traverse into iframes in a readable way:
+
+```typescript
+// Syntax: parent-selector >> child-selector >> target-selector
+page.deepLocator("iframe#outer >> iframe.inner >> button")
+```
+
+Each segment before `>>` represents an iframe to traverse into. The final segment is the target element.
+
+### Examples
+
+```typescript
+// Single iframe hop
+page.deepLocator("iframe#payment >> input#card-number")
+
+// Multiple iframe hops
+page.deepLocator("iframe#level1 >> iframe#level2 >> div.content")
+
+// XPath with hops
+page.deepLocator("//iframe[@id='myframe'] >> //button[@class='submit']")
+
+// CSS with XPath target
+page.deepLocator("iframe.widget >> xpath=//div[@data-id='123']")
+```
+
+## Deep XPath
+
+When using XPath, `deepLocator` automatically recognizes `iframe` steps and traverses into them:
+
+```typescript
+// Automatically traverses into iframes
+page.deepLocator("//iframe//button")
+page.deepLocator("//iframe[@id='myframe']//input[@name='email']")
+page.deepLocator("//iframe[1]//iframe[2]//div[@class='target']")
+```
+
+The locator intelligently parses the XPath, identifies iframe boundaries, and resolves the correct frame for the final selector.
+
+## Methods
+
+`DeepLocatorDelegate` provides the same API as `Locator`, with automatic frame resolution:
+
+### Interaction Methods
+
+All interaction methods from [`Locator`](/v3/references/locator) are available:
+
+- **`click(options?)`** - Click the element
+- **`fill(value)`** - Fill an input
+- **`type(text, options?)`** - Type text
+- **`hover()`** - Hover over element
+- **`selectOption(values)`** - Select dropdown options
+- **`scrollTo(percent)`** - Scroll element
+
+### State Methods
+
+- **`isVisible()`** - Check visibility
+- **`isChecked()`** - Check checkbox state
+- **`inputValue()`** - Get input value
+- **`textContent()`** - Get text content
+- **`innerText()`** - Get visible text
+- **`innerHtml()`** - Get HTML content
+
+### Selection Methods
+
+- **`count()`** - Count matching elements
+- **`nth(index)`** - Select by index
+- **`first()`** - Get first element
+
+### Utility Methods
+
+- **`highlight(options?)`** - Highlight element
+- **`centroid()`** - Get center coordinates
+- **`backendNodeId()`** - Get DOM node ID
+- **`sendClickEvent(options?)`** - Dispatch click event
+
+All methods work identically to `Locator`, but automatically resolve the correct frame before executing.
+
+## Code Examples
+
+<Tabs>
+<Tab title="Basic Iframe Traversal">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+// Initialize with Browserbase (API key and project ID from environment variables)
+// Set BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID in your environment
+const stagehand = new Stagehand({ env: "BROWSERBASE" });
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+await page.goto("https://example.com");
+
+// Click button inside iframe
+const button = page.deepLocator("iframe#widget >> button.submit");
+await button.click();
+
+// Fill input in nested iframe
+const input = page.deepLocator("iframe#outer >> iframe#inner >> input#email");
+await input.fill("user@example.com");
+
+await stagehand.close();
+```
+
+</Tab>
+<Tab title="Multiple Iframes">
+
+```typescript
+// Three-level iframe nesting
+await page.deepLocator(
+  "iframe#level1 >> iframe#level2 >> iframe#level3 >> div.target"
+).click();
+
+// Different selectors at each level
+await page.deepLocator(
+  "iframe.container >> #payment-frame >> input[name=cardNumber]"
+).fill("4111111111111111");
+
+// Mixed CSS and XPath
+await page.deepLocator(
+  "iframe.widget >> xpath=//button[contains(text(), 'Submit')]"
+).click();
+```
+
+</Tab>
+<Tab title="Deep XPath">
+
+```typescript
+// Simple iframe traversal with XPath
+const content = page.deepLocator("//iframe//div[@class='content']");
+const text = await content.textContent();
+
+// Multiple iframe levels
+const button = page.deepLocator(
+  "//iframe[@id='outer']//iframe[@class='inner']//button"
+);
+await button.click();
+
+// XPath with predicates
+const input = page.deepLocator(
+  "//iframe[1]//form[@id='myform']//input[@type='text'][1]"
+);
+await input.fill("test value");
+```
+
+</Tab>
+<Tab title="Element Selection">
+
+```typescript
+// Count elements across iframes
+const buttons = page.deepLocator("iframe#widget >> button");
+const count = await buttons.count();
+console.log(`Found ${count} buttons in iframe`);
+
+// Select specific element
+const firstButton = buttons.first();
+await firstButton.click();
+
+const thirdButton = buttons.nth(2);
+await thirdButton.click();
+
+// Get text from all elements
+for (let i = 0; i < count; i++) {
+  const btn = buttons.nth(i);
+  const text = await btn.innerText();
+  console.log(`Button ${i}:`, text);
+}
+```
+
+</Tab>
+<Tab title="Payment Forms">
+
+```typescript
+// Common use case: payment iframe
+const paymentFrame = "iframe#stripe-payment-element";
+
+// Fill card details
+await page.deepLocator(`${paymentFrame} >> input[name="cardnumber"]`)
+  .fill("4242424242424242");
+
+await page.deepLocator(`${paymentFrame} >> input[name="exp-date"]`)
+  .fill("12/25");
+
+await page.deepLocator(`${paymentFrame} >> input[name="cvc"]`)
+  .fill("123");
+
+await page.deepLocator(`${paymentFrame} >> input[name="postal"]`)
+  .fill("12345");
+
+// Submit
+await page.deepLocator(`${paymentFrame} >> button[type="submit"]`)
+  .click();
+```
+
+</Tab>
+<Tab title="State Checks">
+
+```typescript
+// Check visibility across iframe
+const modal = page.deepLocator("iframe#app >> .modal");
+if (await modal.isVisible()) {
+  console.log("Modal is visible in iframe");
+}
+
+// Get values from iframe inputs
+const email = page.deepLocator("iframe#form >> input#email");
+const value = await email.inputValue();
+console.log("Email value:", value);
+
+// Check checkbox in iframe
+const checkbox = page.deepLocator("iframe#settings >> input#subscribe");
+const checked = await checkbox.isChecked();
+console.log("Subscribed:", checked);
+
+// Highlight element in iframe for debugging
+await page.deepLocator("iframe#widget >> .error-message")
+  .highlight({ durationMs: 2000 });
+```
+
+</Tab>
+</Tabs>
+
+## Comparison with Standard Locator
+
+### Standard Locator (Single Frame)
+
+```typescript
+// Only works in the main frame
+const button = page.locator("button.submit");
+await button.click();
+
+// Cannot access elements inside iframes
+const iframeButton = page.locator("iframe >> button"); // ❌ Won't work
+```
+
+### Deep Locator (Cross-Frame)
+
+```typescript
+// Works across iframe boundaries
+const button = page.deepLocator("iframe#widget >> button.submit");
+await button.click(); // ✅ Automatically traverses into iframe
+
+// Can handle nested iframes
+const nested = page.deepLocator("iframe#a >> iframe#b >> button");
+await nested.click(); // ✅ Handles multiple levels
+```
+
+## When to Use deepLocator
+
+Use `deepLocator()` when:
+
+1. **Targeting elements inside iframes** - Payment forms, embedded widgets, third-party content
+2. **Working with nested iframes** - Multiple levels of iframe nesting
+3. **XPath crosses iframe boundaries** - When XPath naturally includes iframe steps
+4. **Simpler syntax preferred** - Use `>>` instead of manual frame switching
+
+Use standard `locator()` when:
+
+1. **Elements are in main frame** - No iframe traversal needed
+2. **Performance critical** - Standard locator is slightly faster (no frame resolution)
+3. **Working with frame references** - You already have the frame object
+
+## Best Practices
+
+1. **Use specific selectors** - Make each segment unique to avoid ambiguity
+2. **Keep hop chains short** - Simpler is better for maintainability
+3. **Name your iframes** - Use IDs or classes on iframes for easier targeting
+4. **Test incrementally** - Verify each segment works before adding more
+5. **Cache selectors** - Store complex selectors in variables for reuse
+6. **Use highlight() for debugging** - Verify you're targeting the right element
+
+## Common Patterns
+
+### Named Iframe References
+
+```typescript
+// Define iframe selectors
+const PAYMENT_FRAME = "iframe#stripe-payment";
+const WIDGET_FRAME = "iframe.embedded-widget";
+
+// Use in deep locators
+await page.deepLocator(`${PAYMENT_FRAME} >> input#card`).fill("4242");
+await page.deepLocator(`${WIDGET_FRAME} >> button`).click();
+```
+
+### Conditional Iframe Interaction
+
+```typescript
+const errorInIframe = page.deepLocator("iframe#form >> .error-message");
+if (await errorInIframe.isVisible()) {
+  const errorText = await errorInIframe.textContent();
+  console.error("Form error:", errorText);
+}
+```
+
+### Dynamic Frame Selection
+
+```typescript
+// Select iframe by attribute
+const frameSelector = `iframe[data-widget-id="${widgetId}"]`;
+const button = page.deepLocator(`${frameSelector} >> button.action`);
+await button.click();
+```
+
+## Error Handling
+
+Deep locator operations may throw:
+
+- **Element not found** - Selector doesn't match in the target frame
+- **Frame not found** - Iframe selector doesn't resolve
+- **Timeout errors** - Frame or element resolution timed out
+- **Invalid selector** - Malformed selector syntax
+
+Handle errors appropriately:
+
+```typescript
+try {
+  await page.deepLocator("iframe#widget >> button").click();
+} catch (error) {
+  console.error("Deep locator failed:", error.message);
+  // Fallback or retry logic
+}
+```
+
+## Advanced Usage
+
+### Combining with Page Methods
+
+```typescript
+// Navigate then use deep locator
+await page.goto("https://example.com");
+await page.waitForLoadState("networkidle");
+
+const iframeButton = page.deepLocator("iframe#app >> button");
+await iframeButton.click();
+```
+
+### With AI-Powered Methods
+
+```typescript
+// Use observe to find elements in iframes
+const actions = await stagehand.observe("find buttons in the payment iframe");
+
+// Then use deep locator for precise interaction
+await page.deepLocator("iframe#payment >> button.submit").click();
+```
+
+## Technical Details
+
+### How It Works
+
+1. **Parse selector** - Splits on `>>` or parses XPath for iframe steps
+2. **Build frame chain** - Creates FrameLocator chain for each iframe segment
+3. **Resolve final frame** - Navigates through frames to find target frame
+4. **Create locator** - Returns a locator in the correct frame context
+5. **Lazy execution** - Frame resolution happens fresh on each action
+
+### Frame Resolution
+
+Deep locators use the internal `FrameLocator` and `resolveLocatorWithHops` logic to:
+
+- Track frame hierarchies
+- Handle OOPIF (out-of-process iframes)
+- Support shadow DOM piercing
+- Maintain frame references during navigation
+
+## Type Definitions
+
+```typescript
+interface DeepLocatorDelegate {
+  // Actions
+  click(options?: { button?: MouseButton; clickCount?: number }): Promise<void>;
+  fill(value: string): Promise<void>;
+  type(text: string, options?: { delay?: number }): Promise<void>;
+  hover(): Promise<void>;
+  selectOption(values: string | string[]): Promise<string[]>;
+  scrollTo(percent: number | string): Promise<void>;
+
+  // State
+  isVisible(): Promise<boolean>;
+  isChecked(): Promise<boolean>;
+  inputValue(): Promise<string>;
+  textContent(): Promise<string>;
+  innerText(): Promise<string>;
+  innerHtml(): Promise<string>;
+
+  // Selection
+  count(): Promise<number>;
+  nth(index: number): DeepLocatorDelegate;
+  first(): DeepLocatorDelegate;
+
+  // Utilities
+  highlight(options?: HighlightOptions): Promise<void>;
+  centroid(): Promise<{ x: number; y: number }>;
+  backendNodeId(): Promise<BackendNodeId>;
+  sendClickEvent(options?: EventOptions): Promise<void>;
+}
+```
diff --git a/packages/docs/v3/references/extract.mdx b/packages/docs/v3/references/extract.mdx
new file mode 100644
index 000000000..e46b36a17
--- /dev/null
+++ b/packages/docs/v3/references/extract.mdx
@@ -0,0 +1,425 @@
+---
+title: extract()
+description: 'Complete API reference for the extract() method'
+icon: 'ufo-beam'
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+<CardGroup cols={1}>
+<Card title="Extract" icon="ufo-beam" href="/v3/basics/extract">
+  See how to use extract() to extract structured data from web pages
+</Card>
+</CardGroup>
+
+### Method Signatures
+
+<Tabs>
+<Tab title="TypeScript">
+
+```typescript
+// No parameters (raw page content)
+await stagehand.extract(): Promise<{ pageText: string }>
+
+// Options only (for example, for targeted extraction)
+await stagehand.extract(options: ExtractOptions): Promise<{ pageText: string }>
+
+// String instruction only
+await stagehand.extract(instruction: string): Promise<{ extraction: string }>
+
+// With schema
+await stagehand.extract<T extends ZodTypeAny>(
+  instruction: string,
+  schema: T,
+  options?: ExtractOptions
+): Promise<z.infer<T>>
+```
+
+**ExtractOptions Interface:**
+```typescript
+interface ExtractOptions {
+  model?: ModelConfiguration;
+  timeout?: number;
+  selector?: string;
+  page?: PlaywrightPage | PuppeteerPage | PatchrightPage | Page;
+  serverCache?: boolean;
+}
+
+// ModelConfiguration can be either a string or an object
+type ModelConfiguration =
+  | string  // Format: "provider/model" (e.g., "openai/gpt-5-mini", "anthropic/claude-sonnet-4-5")
+  | {
+      modelName: string;  // The model name
+      apiKey?: string;    // Optional: API key override
+      baseURL?: string;   // Optional: Base URL override
+      // Additional provider-specific options
+    }
+```
+
+</Tab>
+
+</Tabs>
+
+### Parameters
+
+<ParamField path="instruction" type="string" optional>
+  Natural language description of what data to extract. If omitted with no schema, returns raw page text.
+</ParamField>
+
+<ParamField path="schema" type="ZodTypeAny" optional>
+  Zod schema defining the structure of data to extract. Ensures type safety and validation. The return type is automatically inferred from the schema.
+</ParamField>
+
+<ParamField path="model" type="ModelConfiguration" optional>
+  Configure the AI model to use for this action. Can be either:
+  - A string in the format `"provider/model"` (e.g., `openai/gpt-5`, `google/gemini-2.5-flash`)
+  - An object with detailed configuration
+
+  <Expandable title="Model Configuration Object">
+    <ParamField path="modelName" type="string" required>
+      The model name (e.g., `anthropic/claude-sonnet-4-5`, `google/gemini-2.5-flash`)
+    </ParamField>
+    <ParamField path="apiKey" type="string" optional>
+      API key for the model provider (overrides default)
+    </ParamField>
+    <ParamField path="baseURL" type="string" optional>
+      Base URL for the API endpoint (for custom endpoints or proxies)
+    </ParamField>
+  </Expandable>
+</ParamField>
+
+<ParamField path="timeout" type="number" optional>
+  Maximum time in milliseconds to wait for the extraction to complete. Default varies by configuration.
+</ParamField>
+
+<ParamField path="selector" type="string" optional>
+  Optional selector (XPath, CSS selector, etc.) to limit extraction scope to a specific part of the page. Reduces token usage and improves accuracy.
+</ParamField>
+
+<ParamField path="page" type="PlaywrightPage | PuppeteerPage | PatchrightPage | Page" optional>
+  Optional: Specify which page to perform the extraction on. Supports multiple browser automation libraries:
+  - **Playwright**: Native Playwright Page objects
+  - **Puppeteer**: Puppeteer Page objects
+  - **Patchright**: Patchright Page objects
+  - **Stagehand Page**: Stagehand's wrapped Page object
+
+  If not specified, defaults to the current "active" page in your Stagehand instance.
+</ParamField>
+
+<ParamField path="serverCache" type="boolean" optional>
+  Override the instance-level `serverCache` setting for this request. When `true`, enables server-side caching. When `false`, disables it.
+
+  <Note>Only applies when `env` is `"BROWSERBASE"`. Has no effect in local environments.</Note>
+
+  Defaults to the value set on the Stagehand constructor (which itself defaults to `true`).
+</ParamField>
+
+### Built-in Support
+
+<Note>
+**Iframe and Shadow DOM interactions are supported out of the box.** Stagehand automatically handles iframe traversal and shadow DOM elements without requiring additional configuration or flags.
+</Note>
+
+### Response Types
+
+<Tabs>
+<Tab title="With Schema">
+**Returns:** `Promise<z.infer<T> & { cacheStatus?: "HIT" | "MISS" }>` where T is your schema
+
+The returned object will be strictly typed according to your Zod schema definition. The optional `cacheStatus` field indicates whether the result was served from the server-side cache (`"HIT"`) or computed fresh (`"MISS"`). Only present when running with `env: "BROWSERBASE"` and server-side caching is enabled.
+</Tab>
+
+<Tab title="String Only">
+**Returns:** `Promise<{ extraction: string; cacheStatus?: "HIT" | "MISS" }>`
+
+`extraction`: Simple string extraction without schema validation. The optional `cacheStatus` field indicates cache hit or miss when using Browserbase with server-side caching.
+</Tab>
+
+<Tab title="No Parameters">
+**Returns:** `Promise<{ pageText: string }>`
+
+`pageText`: Raw accessibility tree representation of page content.
+</Tab>
+</Tabs>
+
+### Code Examples
+
+<Tabs>
+<Tab title="Single Object">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+import { z } from 'zod';
+
+// Initialize with Browserbase (API key and project ID from environment variables)
+// Set BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID in your environment
+const stagehand = new Stagehand({ env: "BROWSERBASE" });
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+await page.goto("https://example.com/product");
+
+// Schema definition
+const ProductSchema = z.object({
+  name: z.string(),
+  price: z.number(),
+  inStock: z.boolean()
+});
+
+// Extraction with v3 API
+const product = await stagehand.extract(
+  "extract product details", 
+  ProductSchema
+);
+```
+
+#### Example Response
+```json
+{
+  "name": "Product Name",
+  "price": 100,
+  "inStock": true
+}
+```
+
+</Tab>
+<Tab title="Arrays">
+
+```typescript
+import { z } from 'zod';
+
+// Schema definition
+const ApartmentListingsSchema = z.array(
+  z.object({
+    address: z.string(),
+    price: z.string(),
+    bedrooms: z.number()
+  })
+);
+
+// Extraction with v3 API
+const listings = await stagehand.extract(
+  "extract all apartment listings",
+  ApartmentListingsSchema
+);
+```
+
+#### Example Response
+```json
+[
+  {
+    "address": "123 Main St",
+    "price": "$100,000",
+    "bedrooms": 3
+  },
+  {
+    "address": "456 Elm St",
+    "price": "$150,000",
+    "bedrooms": 2
+  }
+]
+```
+
+</Tab>
+<Tab title="URLs">
+
+```typescript
+import { z } from 'zod';
+
+// Schema definition
+const NavigationSchema = z.object({
+  links: z.array(z.object({
+    text: z.string(),
+    url: z.string().url()  // URL validation
+  }))
+});
+
+// Extraction with v3 API
+const links = await stagehand.extract(
+  "extract navigation links",
+  NavigationSchema
+);
+```
+
+#### Example Response
+```json
+{
+  "links": [
+    {
+      "text": "Home",
+      "url": "https://example.com"
+    }
+  ]
+}
+```
+
+</Tab>
+<Tab title="Scoped">
+
+```typescript
+import { z } from 'zod';
+
+const ProductSchema = z.object({
+  name: z.string(),
+  price: z.number(),
+  description: z.string()
+});
+
+// Extract from specific page section with v3 API
+const data = await stagehand.extract(
+  "extract product info from this section",
+  ProductSchema,
+  { selector: "/html/body/div/div" }
+);
+```
+
+#### Example Response
+```json
+{
+  "name": "Product Name",
+  "price": 100,
+  "description": "Product description"
+}
+```
+
+</Tab>
+<Tab title="Schema-less">
+
+```typescript
+// String only extraction
+const title = await stagehand.extract("get the page title");
+// Returns: { extraction: "Page Title" }
+
+// Raw page content
+const content = await stagehand.extract();
+// Returns: { pageText: "Accessibility Tree: ..." }
+```
+
+#### Example Response
+```json
+{
+  "extraction": "Page Title"
+}
+```
+
+</Tab>
+<Tab title="Advanced">
+
+```typescript
+import { z } from 'zod';
+
+// Schema with descriptions and validation
+const ProductSchema = z.object({
+  price: z.number().describe("Product price in USD"),
+  rating: z.number().min(0).max(5).describe("Customer rating out of 5"),
+  available: z.boolean().describe("Whether product is in stock"),
+  tags: z.array(z.string()).optional()
+});
+
+// Nested schema
+const EcommerceSchema = z.object({
+  product: z.object({
+    name: z.string(),
+    price: z.object({
+      current: z.number(),
+      original: z.number().optional()
+    })
+  }),
+  reviews: z.array(z.object({
+    rating: z.number(),
+    comment: z.string()
+  }))
+});
+```
+
+#### Example Response
+```json
+{
+  "product": {
+    "name": "Product Name",
+    "price": {
+      "current": 100,
+      "original": 120
+    }
+  },
+  "reviews": [
+    {
+      "rating": 4,
+      "comment": "Great product!"
+    }
+  ]
+}
+```
+
+</Tab>
+</Tabs>
+
+### Additional Examples
+
+<Tabs>
+<Tab title="Custom Model">
+
+```typescript
+import { z } from 'zod';
+
+const DataSchema = z.object({
+  title: z.string(),
+  content: z.string()
+});
+
+// Using string format
+const data1 = await stagehand.extract(
+  "extract article data",
+  DataSchema,
+  { model: "openai/gpt-5-mini" }
+);
+
+// Using object format with custom configuration
+const data2 = await stagehand.extract(
+  "extract article data",
+  DataSchema,
+  {
+    model: {
+      modelName: "claude-sonnet-4-6",
+      apiKey: process.env.ANTHROPIC_API_KEY
+    }
+  }
+);
+```
+
+</Tab>
+<Tab title="Multi-Page">
+
+```typescript
+import { z } from 'zod';
+
+const page1 = stagehand.context.pages()[0];
+const page2 = await stagehand.context.newPage();
+
+const Schema = z.object({ title: z.string() });
+
+const data1 = await stagehand.extract("get title", Schema, { page: page1 });
+const data2 = await stagehand.extract("get title", Schema, { page: page2 });
+```
+
+</Tab>
+</Tabs>
+
+### Error Types
+
+The following errors may be thrown by the `extract()` method:
+
+- **StagehandError** - Base class for all Stagehand-specific errors
+- **ZodSchemaValidationError** - Extracted data does not match the provided Zod schema
+- **StagehandDomProcessError** - Error occurred while processing the DOM
+- **StagehandEvalError** - Error occurred while evaluating JavaScript in the page context
+- **StagehandIframeError** - Unable to resolve iframe for the target element
+- **ContentFrameNotFoundError** - Unable to obtain content frame for the selector
+- **XPathResolutionError** - XPath does not resolve in the current page or frames
+- **StagehandShadowRootMissingError** - No shadow root present on the resolved host element
+- **LLMResponseError** - Error in LLM response processing
+- **MissingLLMConfigurationError** - No LLM API key or client configured
+- **UnsupportedModelError** - The specified model is not supported for this operation
+- **InvalidAISDKModelFormatError** - Model string does not follow the required `provider/model` format
\ No newline at end of file
diff --git a/packages/docs/v3/references/locator.mdx b/packages/docs/v3/references/locator.mdx
new file mode 100644
index 000000000..1be700d58
--- /dev/null
+++ b/packages/docs/v3/references/locator.mdx
@@ -0,0 +1,649 @@
+---
+title: locator
+description: 'Complete API reference for the Locator class'
+icon: 'crosshairs'
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+<CardGroup cols={1}>
+<Card title="Page" icon="browser" href="/v3/references/page">
+  Learn about the Page object that creates locators
+</Card>
+</CardGroup>
+
+## Overview
+
+The `Locator` class provides precise element interaction capabilities. It resolves CSS or XPath selectors within a frame and performs low-level actions using Chrome DevTools Protocol (CDP).
+
+Create a locator through the page object:
+
+```typescript
+const stagehand = new Stagehand({ env: "LOCAL" });
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+// Create a locator
+const button = page.locator("button.submit");
+await button.click();
+```
+
+## Key Features
+
+- **Lazy resolution** - Selectors are resolved fresh on each action
+- **Isolated execution** - Runs in an isolated world, separate from page scripts
+- **CDP-based** - Uses Chrome DevTools Protocol for reliable interactions
+- **Automatic cleanup** - Releases remote objects automatically
+- **Iframe support** - Works seamlessly with iframes and shadow DOM
+
+## Interaction Methods
+
+### click()
+
+Click the element at its visual center.
+
+```typescript
+await locator.click(options?: ClickOptions): Promise<void>
+```
+
+<ParamField path="button" type='"left" | "right" | "middle"' optional>
+  Mouse button to use for the click.
+
+  **Default:** `"left"`
+</ParamField>
+
+<ParamField path="clickCount" type="number" optional>
+  Number of consecutive clicks (for double-click, triple-click).
+
+  **Default:** `1`
+</ParamField>
+
+The method:
+1. Scrolls element into view
+2. Gets element geometry
+3. Moves mouse to center
+4. Dispatches mousePressed and mouseReleased events
+
+### fill()
+
+Fill an input, textarea, or contenteditable element.
+
+```typescript
+await locator.fill(value: string): Promise<void>
+```
+
+<ParamField path="value" type="string" required>
+  The text value to fill into the element.
+</ParamField>
+
+The method intelligently handles different input types:
+- Uses native value setter for special inputs (date, number, etc.)
+- Types text character-by-character for regular inputs
+- Clears existing content before filling
+
+### type()
+
+Type text into the element with optional delay between keystrokes.
+
+```typescript
+await locator.type(text: string, options?: TypeOptions): Promise<void>
+```
+
+<ParamField path="text" type="string" required>
+  The text to type.
+</ParamField>
+
+<ParamField path="delay" type="number" optional>
+  Delay in milliseconds between each keystroke.
+
+  If not specified, uses `Input.insertText` for efficiency.
+</ParamField>
+
+### hover()
+
+Move the mouse cursor to the element's center without clicking.
+
+```typescript
+await locator.hover(): Promise<void>
+```
+
+Scrolls the element into view and dispatches a mouse move event.
+
+### selectOption()
+
+Select one or more options in a `<select>` element.
+
+```typescript
+await locator.selectOption(values: string | string[]): Promise<string[]>
+```
+
+<ParamField path="values" type="string | string[]" required>
+  Option value(s) to select. For multi-select elements, pass an array.
+</ParamField>
+
+**Returns:** `Promise<string[]>` - Array of values that were actually selected.
+
+### setInputFiles()
+
+Set files on an `<input type="file">` element.
+
+```typescript
+await locator.setInputFiles(files: FileInput): Promise<void>
+```
+
+<ParamField path="files" type="string | string[] | FilePayload | FilePayload[]" required>
+  File paths or file payloads to upload.
+
+  **File Path:** Absolute or relative path to a file
+
+  **File Payload:** Object with `{ name, mimeType, buffer }`
+</ParamField>
+
+**FilePayload Interface:**
+```typescript
+interface FilePayload {
+  name: string;
+  mimeType: string;
+  buffer: ArrayBuffer | Uint8Array | Buffer | string;
+}
+```
+
+Pass an empty array to clear the file selection.
+
+## State Methods
+
+### isVisible()
+
+Check if the element is visible.
+
+```typescript
+await locator.isVisible(): Promise<boolean>
+```
+
+**Returns:** `Promise<boolean>` - `true` if element is attached and visible.
+
+### isChecked()
+
+Check if a checkbox or radio button is checked.
+
+```typescript
+await locator.isChecked(): Promise<boolean>
+```
+
+**Returns:** `Promise<boolean>` - `true` if checked. Also considers `aria-checked` for ARIA widgets.
+
+### inputValue()
+
+Get the current value of an input element.
+
+```typescript
+await locator.inputValue(): Promise<string>
+```
+
+**Returns:** `Promise<string>` - The element's input value.
+
+Works with: `<input>`, `<textarea>`, `<select>`, contenteditable elements.
+
+### textContent()
+
+Get the element's text content (raw).
+
+```typescript
+await locator.textContent(): Promise<string>
+```
+
+**Returns:** `Promise<string>` - The element's `textContent` property.
+
+### innerText()
+
+Get the element's visible text (layout-aware).
+
+```typescript
+await locator.innerText(): Promise<string>
+```
+
+**Returns:** `Promise<string>` - The element's `innerText` property.
+
+### innerHtml()
+
+Get the element's HTML content.
+
+```typescript
+await locator.innerHtml(): Promise<string>
+```
+
+**Returns:** `Promise<string>` - The element's `innerHtml`.
+
+## Selection Methods
+
+### count()
+
+Get the number of elements matching the selector.
+
+```typescript
+await locator.count(): Promise<number>
+```
+
+**Returns:** `Promise<number>` - Count of matching elements.
+
+### nth()
+
+Get a locator for the element at a specific index.
+
+```typescript
+locator.nth(index: number): Locator
+```
+
+<ParamField path="index" type="number" required>
+  Zero-based index of the element to select.
+</ParamField>
+
+**Returns:** `Locator` - New locator targeting the nth element.
+
+```typescript
+// Get the third button
+const thirdButton = page.locator("button").nth(2);
+await thirdButton.click();
+```
+
+### first()
+
+Get a locator for the first matching element.
+
+```typescript
+locator.first(): Locator
+```
+
+**Returns:** `Locator` - Returns the same locator (querySelector already returns first match).
+
+## Utility Methods
+
+### highlight()
+
+Visually highlight the element with an overlay.
+
+```typescript
+await locator.highlight(options?: HighlightOptions): Promise<void>
+```
+
+<ParamField path="durationMs" type="number" optional>
+  How long to display the highlight in milliseconds.
+
+  **Default:** `800`
+</ParamField>
+
+<ParamField path="borderColor" type="{ r, g, b, a? }" optional>
+  Border color RGBA values (0-255).
+
+  **Default:** `{ r: 255, g: 0, b: 0, a: 0.9 }` (red)
+</ParamField>
+
+<ParamField path="contentColor" type="{ r, g, b, a? }" optional>
+  Content fill color RGBA values (0-255).
+
+  **Default:** `{ r: 255, g: 200, b: 0, a: 0.2 }` (yellow)
+</ParamField>
+
+Useful for debugging and visual verification.
+
+### scrollTo()
+
+Scroll the element to a specific position.
+
+```typescript
+await locator.scrollTo(percent: number | string): Promise<void>
+```
+
+<ParamField path="percent" type="number | string" required>
+  Scroll position as percentage (0-100).
+</ParamField>
+
+For `<html>` or `<body>` elements, scrolls the window. Otherwise, scrolls the element itself.
+
+### centroid()
+
+Get the center coordinates of the element.
+
+```typescript
+await locator.centroid(): Promise<{ x: number; y: number }>
+```
+
+**Returns:** `Promise<{ x, y }>` - Center point in CSS pixels.
+
+### backendNodeId()
+
+Get the DOM backend node ID for the element.
+
+```typescript
+await locator.backendNodeId(): Promise<BackendNodeId>
+```
+
+**Returns:** `Promise<BackendNodeId>` - Unique identifier for the DOM node.
+
+Useful for identity comparisons without maintaining element handles.
+
+### sendClickEvent()
+
+Dispatch a DOM click event directly on the element.
+
+```typescript
+await locator.sendClickEvent(options?: EventOptions): Promise<void>
+```
+
+<ParamField path="bubbles" type="boolean" optional>
+  Whether the event bubbles.
+
+  **Default:** `true`
+</ParamField>
+
+<ParamField path="cancelable" type="boolean" optional>
+  Whether the event is cancelable.
+
+  **Default:** `true`
+</ParamField>
+
+<ParamField path="composed" type="boolean" optional>
+  Whether the event crosses shadow DOM boundaries.
+
+  **Default:** `true`
+</ParamField>
+
+<ParamField path="detail" type="number" optional>
+  Click count detail.
+
+  **Default:** `1`
+</ParamField>
+
+This dispatches an event directly without synthesizing real pointer input. Useful for elements that rely on click handlers without needing hit-testing.
+
+## Code Examples
+
+<Tabs>
+<Tab title="Basic Interaction">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+// Initialize with Browserbase (API key and project ID from environment variables)
+// Set BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID in your environment
+const stagehand = new Stagehand({ env: "BROWSERBASE" });
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+await page.goto("https://example.com");
+
+// Click a button
+const submitButton = page.locator("button[type=submit]");
+await submitButton.click();
+
+// Fill an input
+const emailInput = page.locator("input[name=email]");
+await emailInput.fill("user@example.com");
+
+// Type with delay
+const searchBox = page.locator("input[type=search]");
+await searchBox.type("stagehand", { delay: 100 });
+
+await stagehand.close();
+```
+
+</Tab>
+<Tab title="Forms">
+
+```typescript
+// Fill multiple form fields
+const form = page.locator("form#login");
+
+await page.locator("#username").fill("myuser");
+await page.locator("#password").fill("mypass");
+
+// Select from dropdown
+await page.locator("select#country").selectOption("US");
+
+// Multi-select
+await page.locator("select#skills").selectOption(["js", "ts", "react"]);
+
+// Check checkbox
+const termsCheckbox = page.locator("input#terms");
+const isChecked = await termsCheckbox.isChecked();
+if (!isChecked) {
+  await termsCheckbox.click();
+}
+
+// Submit
+await page.locator("button[type=submit]").click();
+```
+
+</Tab>
+<Tab title="File Upload">
+
+```typescript
+// Upload from file path
+const fileInput = page.locator("input[type=file]");
+await fileInput.setInputFiles("/path/to/document.pdf");
+
+// Upload multiple files
+await fileInput.setInputFiles([
+  "/path/to/image1.jpg",
+  "/path/to/image2.jpg"
+]);
+
+// Upload from buffer
+await fileInput.setInputFiles({
+  name: "data.json",
+  mimeType: "application/json",
+  buffer: JSON.stringify({ key: "value" })
+});
+
+// Clear file selection
+await fileInput.setInputFiles([]);
+```
+
+</Tab>
+<Tab title="Element Selection">
+
+```typescript
+// Count elements
+const buttons = page.locator("button");
+const count = await buttons.count();
+console.log(`Found ${count} buttons`);
+
+// Click the first button
+await buttons.first().click();
+
+// Click the third button
+await buttons.nth(2).click();
+
+// Iterate with nth
+for (let i = 0; i < count; i++) {
+  const button = buttons.nth(i);
+  const text = await button.innerText();
+  console.log(`Button ${i}: ${text}`);
+}
+```
+
+</Tab>
+<Tab title="State Checks">
+
+```typescript
+// Check visibility
+const modal = page.locator(".modal");
+if (await modal.isVisible()) {
+  console.log("Modal is visible");
+}
+
+// Check checkbox state
+const checkbox = page.locator("input#subscribe");
+const checked = await checkbox.isChecked();
+console.log("Subscribed:", checked);
+
+// Get input value
+const email = page.locator("input#email");
+const value = await email.inputValue();
+console.log("Email:", value);
+
+// Get text content
+const heading = page.locator("h1");
+const text = await heading.textContent();
+console.log("Heading:", text);
+```
+
+</Tab>
+<Tab title="Advanced Actions">
+
+```typescript
+// Hover to reveal menu
+const menuButton = page.locator("button.menu");
+await menuButton.hover();
+
+// Wait for submenu
+await page.waitForLoadState("networkidle");
+
+// Click submenu item
+await page.locator("a.submenu-item").click();
+
+// Highlight for debugging
+await page.locator("div.error").highlight({
+  durationMs: 2000,
+  borderColor: { r: 255, g: 0, b: 0 },
+  contentColor: { r: 255, g: 0, b: 0, a: 0.1 }
+});
+
+// Scroll element into position
+const section = page.locator("#section-3");
+await section.scrollTo(50); // Scroll to 50%
+
+// Get element position
+const { x, y } = await section.centroid();
+console.log(`Element center: ${x}, ${y}`);
+```
+
+</Tab>
+</Tabs>
+
+## Selector Support
+
+Locators support both CSS and XPath selectors:
+
+### CSS Selectors
+
+```typescript
+page.locator("button");                    // Tag
+page.locator(".submit-btn");              // Class
+page.locator("#login-form");              // ID
+page.locator("button.primary");           // Tag + class
+page.locator("input[type=email]");        // Attribute
+page.locator("div > p");                  // Child
+page.locator("h1 + p");                   // Adjacent sibling
+page.locator("div.container button");     // Descendant
+```
+
+### XPath Selectors
+
+```typescript
+page.locator("//button");                               // Tag
+page.locator("//button[@class='submit']");             // Attribute
+page.locator("//div[@id='content']//p");               // Descendant
+page.locator("//button[contains(text(), 'Submit')]");  // Text content
+page.locator("(//button)[1]");                         // First button
+page.locator("//input[@type='text'][1]");              // First text input
+```
+
+## Best Practices
+
+1. **Use specific selectors** - Prefer IDs or unique attributes over generic selectors
+2. **Chain with nth()** - Use `locator().nth()` instead of putting index in selector
+3. **Check state before action** - Use `isVisible()`, `isChecked()` for conditional logic
+4. **Let locators auto-resolve** - Don't store element handles, use locators which re-resolve
+5. **Use fill() for inputs** - Prefer `fill()` over `click()` + `type()` for better reliability
+6. **Handle file uploads properly** - Use absolute paths or buffer payloads for `setInputFiles()`
+7. **Highlight for debugging** - Use `highlight()` during development to verify targeting
+
+## Common Patterns
+
+### Conditional Interaction
+
+```typescript
+const errorMessage = page.locator(".error-message");
+if (await errorMessage.isVisible()) {
+  const text = await errorMessage.textContent();
+  console.log("Error:", text);
+}
+```
+
+### Wait and Interact
+
+```typescript
+// Locators automatically wait during actions
+const dynamicButton = page.locator("button.dynamic");
+await dynamicButton.click(); // Waits for element to exist
+```
+
+### Loop Through Elements
+
+```typescript
+const items = page.locator("li.item");
+const count = await items.count();
+
+for (let i = 0; i < count; i++) {
+  const item = items.nth(i);
+  const text = await item.innerText();
+  console.log(`Item ${i}:`, text);
+}
+```
+
+## Error Handling
+
+Locator methods may throw the following errors:
+
+- **Element not found** - Selector doesn't match any elements
+- **Element not visible** - Element exists but is not visible (for actions requiring visibility)
+- **Invalid selector** - Malformed CSS or XPath selector
+- **Timeout errors** - Operation exceeded timeout limits
+- **CDP errors** - Chrome DevTools Protocol communication errors
+
+Handle errors appropriately:
+
+```typescript
+try {
+  await page.locator("button.submit").click();
+} catch (error) {
+  console.error("Click failed:", error.message);
+}
+```
+
+## Type Definitions
+
+```typescript
+interface Locator {
+  // Actions
+  click(options?: { button?: MouseButton; clickCount?: number }): Promise<void>;
+  fill(value: string): Promise<void>;
+  type(text: string, options?: { delay?: number }): Promise<void>;
+  hover(): Promise<void>;
+  selectOption(values: string | string[]): Promise<string[]>;
+  setInputFiles(files: FileInput): Promise<void>;
+
+  // State
+  isVisible(): Promise<boolean>;
+  isChecked(): Promise<boolean>;
+  inputValue(): Promise<string>;
+  textContent(): Promise<string>;
+  innerText(): Promise<string>;
+  innerHtml(): Promise<string>;
+
+  // Selection
+  count(): Promise<number>;
+  nth(index: number): Locator;
+  first(): Locator;
+
+  // Utilities
+  highlight(options?: HighlightOptions): Promise<void>;
+  scrollTo(percent: number | string): Promise<void>;
+  centroid(): Promise<{ x: number; y: number }>;
+  backendNodeId(): Promise<BackendNodeId>;
+  sendClickEvent(options?: EventOptions): Promise<void>;
+}
+```
diff --git a/packages/docs/v3/references/observe.mdx b/packages/docs/v3/references/observe.mdx
new file mode 100644
index 000000000..11e0fd733
--- /dev/null
+++ b/packages/docs/v3/references/observe.mdx
@@ -0,0 +1,284 @@
+---
+title: observe()
+description: 'Complete API reference for the observe() method'
+icon: 'magnifying-glass'
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+<CardGroup cols={1}>
+<Card title="Observe" icon="magnifying-glass" href="/v3/basics/observe">
+  See how to use observe() to discover actionable elements and analyze web page structure
+</Card>
+</CardGroup>
+
+### Method Signatures
+
+<Tabs>
+<Tab title="TypeScript">
+
+```typescript
+// String instruction only
+await stagehand.observe(instruction: string): Promise<Action[]>
+
+// String instruction with options
+await stagehand.observe(instruction: string, options: ObserveOptions): Promise<Action[]>
+```
+
+**ObserveOptions Interface:**
+```typescript
+interface ObserveOptions {
+  model?: ModelConfiguration;
+  timeout?: number;
+  selector?: string;
+  page?: PlaywrightPage | PuppeteerPage | PatchrightPage | Page;
+  serverCache?: boolean;
+}
+
+// ModelConfiguration can be either a string or an object
+type ModelConfiguration =
+  | string  // Format: "provider/model" (e.g., "openai/gpt-4o", "anthropic/claude-sonnet-4-6")
+  | {
+      modelName: string;  // The model name
+      apiKey?: string;    // Optional: API key override
+      baseURL?: string;   // Optional: Base URL override
+      // Additional provider-specific options
+    }
+```
+
+</Tab>
+
+</Tabs>
+
+### Parameters
+
+<ParamField path="instruction" type="string" required>
+  Natural language description of elements or actions to discover. If not provided, defaults to finding all interactive elements on the page.
+</ParamField>
+
+<ParamField path="model" type="ModelConfiguration" optional>
+  Configure the AI model to use for this observation. Can be either:
+  - A string in the format `"provider/model"` (e.g., `"openai/gpt-4o"`, `"anthropic/claude-sonnet-4-6"`)
+  - An object with detailed configuration
+
+  <Expandable title="Model Configuration Object">
+    <ParamField path="modelName" type="string" required>
+      The model name (e.g., "gpt-4o", "claude-sonnet-4-6", "gemini-2.5-flash")
+    </ParamField>
+    <ParamField path="apiKey" type="string" optional>
+      API key for the model provider (overrides default)
+    </ParamField>
+    <ParamField path="baseURL" type="string" optional>
+      Base URL for the API endpoint (for custom endpoints or proxies)
+    </ParamField>
+  </Expandable>
+</ParamField>
+
+<ParamField path="timeout" type="number" optional>
+  Maximum time in milliseconds to wait for the observation to complete. Default varies by configuration.
+</ParamField>
+
+<ParamField path="selector" type="string" optional>
+  Optional XPath selector to focus the observation on a specific part of the page. Useful for narrowing down the search area.
+</ParamField>
+
+<ParamField path="page" type="PlaywrightPage | PuppeteerPage | PatchrightPage | Page" optional>
+  Optional: Specify which page to perform the observation on. Supports multiple browser automation libraries:
+  - **Playwright**: Native Playwright Page objects
+  - **Puppeteer**: Puppeteer Page objects
+  - **Patchright**: Patchright Page objects
+  - **Stagehand Page**: Stagehand's wrapped Page object
+
+  If not specified, defaults to the current "active" page in your Stagehand instance.
+</ParamField>
+
+<ParamField path="serverCache" type="boolean" optional>
+  Override the instance-level `serverCache` setting for this request. When `true`, enables server-side caching. When `false`, disables it.
+
+  <Note>Only applies when `env` is `"BROWSERBASE"`. Has no effect in local environments.</Note>
+
+  Defaults to the value set on the Stagehand constructor (which itself defaults to `true`).
+</ParamField>
+
+### Returns `Promise<Action[]>`
+
+Array of discovered actionable elements, ordered by relevance.
+
+<ResponseField name="selector" type="string">
+  XPath selector that precisely locates the element on the page.
+</ResponseField>
+
+<ResponseField name="description" type="string">
+  Human-readable description of the element and its purpose.
+</ResponseField>
+
+<ResponseField name="method" type="string" optional>
+  Suggested interaction method for the element (e.g., `"click"`, `"fill"`, `"type"`).
+</ResponseField>
+
+<ResponseField name="arguments" type="string[]" optional>
+  Additional parameters for the suggested action, if applicable.
+</ResponseField>
+
+**Action Interface:**
+```typescript
+interface Action {
+  selector: string;        // XPath selector to locate element
+  description: string;     // Human-readable description
+  method?: string;         // Suggested action method
+  arguments?: string[];    // Additional action parameters
+}
+```
+
+**Example Response:**
+```json
+[
+  {
+    "selector": "/html/body/div[1]/header/nav/button[1]",
+    "description": "Login button in the navigation bar",
+    "method": "click",
+    "arguments": []
+  },
+  {
+    "selector": "/html/body/main/form/input[1]",
+    "description": "Email input field in the login form",
+    "method": "fill",
+    "arguments": []
+  }
+]
+```
+
+### Built-in Support
+
+<Note>
+**Iframe and Shadow DOM interactions are supported out of the box.** Stagehand automatically handles iframe traversal and shadow DOM elements without requiring additional configuration or flags.
+</Note>
+
+### Code Examples
+
+<Tabs>
+<Tab title="Basic Usage">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+// Initialize with Browserbase (API key and project ID from environment variables)
+// Set BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID in your environment
+const stagehand = new Stagehand({ env: "BROWSERBASE" });
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+await page.goto("https://example.com");
+
+// Basic element discovery
+const buttons = await stagehand.observe("find all clickable buttons");
+const formFields = await stagehand.observe("locate form input fields");
+
+// Working with results
+const [loginButton] = await stagehand.observe("find the login button");
+if (loginButton) {
+  console.log("Found:", loginButton.description);
+  console.log("Selector:", loginButton.selector);
+  await stagehand.act(loginButton); // Execute the action
+}
+```
+
+</Tab>
+<Tab title="Custom Model">
+
+```typescript
+// Using string format model
+const elements = await stagehand.observe("find important call-to-action buttons", {
+  model: "openai/gpt-4o",
+  timeout: 45000
+});
+
+// Using object format with custom configuration
+const actions = await stagehand.observe("find navigation links", {
+  model: {
+    modelName: "claude-sonnet-4-6",
+    apiKey: process.env.ANTHROPIC_API_KEY
+  },
+  timeout: 30000
+});
+```
+
+</Tab>
+<Tab title="Scoped">
+
+```typescript
+// Focus observation on a specific part of the page
+const tableActions = await stagehand.observe("find all table rows", {
+  selector: "/html/body/main/table"
+});
+```
+
+</Tab>
+<Tab title="Multi-Page">
+
+```typescript
+// Observe on specific pages
+const page1 = stagehand.context.pages()[0];
+const page2 = await stagehand.context.newPage();
+
+const page1Actions = await stagehand.observe("find navigation", { page: page1 });
+const page2Actions = await stagehand.observe("find buttons", { page: page2 });
+```
+
+</Tab>
+<Tab title="Filter Results">
+
+```typescript
+const submitButtons = await stagehand.observe("find all submit buttons");
+const primarySubmit = submitButtons.find(btn =>
+  btn.description.toLowerCase().includes('primary')
+);
+```
+
+</Tab>
+</Tabs>
+
+### Integration Patterns
+
+```typescript
+// Observe → Act workflow
+const actions = await stagehand.observe("find checkout elements");
+for (const action of actions) {
+  await stagehand.act(action);
+  await page.waitForTimeout(1000);
+}
+
+// Observe → Extract workflow
+const tables = await stagehand.observe("find data tables");
+if (tables.length > 0) {
+  const data = await stagehand.extract({
+    instruction: "extract the table data",
+    selector: tables[0].selector,
+    schema: DataSchema
+  });
+}
+
+// Element validation
+const requiredElements = await stagehand.observe("find the login form");
+if (requiredElements.length === 0) {
+  throw new Error("Login form not found");
+}
+```
+
+### Error Types
+
+The following errors may be thrown by the `observe()` method:
+
+- **StagehandError** - Base class for all Stagehand-specific errors
+- **StagehandDomProcessError** - Error occurred while processing the DOM
+- **StagehandEvalError** - Error occurred while evaluating JavaScript in the page context
+- **StagehandIframeError** - Unable to resolve iframe for the target element
+- **ContentFrameNotFoundError** - Unable to obtain content frame for the selector
+- **XPathResolutionError** - XPath does not resolve in the current page or frames
+- **StagehandShadowRootMissingError** - No shadow root present on the resolved host element
+- **LLMResponseError** - Error in LLM response processing
+- **MissingLLMConfigurationError** - No LLM API key or client configured
+- **UnsupportedModelError** - The specified model is not supported for this operation
+- **InvalidAISDKModelFormatError** - Model string does not follow the required `provider/model` format
diff --git a/packages/docs/v3/references/page.mdx b/packages/docs/v3/references/page.mdx
new file mode 100644
index 000000000..818699da5
--- /dev/null
+++ b/packages/docs/v3/references/page.mdx
@@ -0,0 +1,1049 @@
+---
+title: page
+description: 'Complete API reference for the Stagehand Page object'
+icon: 'page'
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+<CardGroup cols={1}>
+<Card title="Page" icon="browser" href="/v3/references/page">
+  Learn about the Stagehand Page object and browser navigation
+</Card>
+</CardGroup>
+
+## Overview
+
+The `page` object is the main interface for interacting with browser pages in Stagehand. It provides standard browser automation capabilities for navigation, interaction, and page inspection.
+
+Access the page object through your Stagehand instance:
+
+```typescript
+const stagehand = new Stagehand({ env: "LOCAL" });
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+```
+
+## Navigation Methods
+
+### goto()
+
+Navigate the page to a URL and wait for a lifecycle state.
+
+```typescript
+await page.goto(url: string, options?: GotoOptions): Promise<Response | null>
+```
+
+Returns a [Response](/v3/references/response) when the navigation produces a network document request, otherwise `null` (e.g. `data:` URLs or same-document navigations).
+
+<ParamField path="url" type="string" required>
+  The URL to navigate to. Can be absolute or relative.
+</ParamField>
+
+<ParamField path="waitUntil" type="LoadState" optional>
+  When to consider navigation succeeded.
+
+  **Options:**
+  - `"load"` - Wait for the load event
+  - `"domcontentloaded"` - Wait for DOMContentLoaded event (default)
+  - `"networkidle"` - Wait for network to be idle
+
+  **Default:** `"domcontentloaded"`
+</ParamField>
+
+<ParamField path="timeoutMs" type="number" optional>
+  Maximum time to wait for navigation in milliseconds.
+
+  **Default:** `15000`
+</ParamField>
+
+### reload()
+
+Reload the current page.
+
+```typescript
+await page.reload(options?: ReloadOptions): Promise<Response | null>
+```
+
+Resolves with a [Response](/v3/references/response) for the refreshed document when one is reported, otherwise `null`.
+
+<ParamField path="waitUntil" type="LoadState" optional>
+  When to consider reload complete. See `goto()` for options.
+</ParamField>
+
+<ParamField path="timeoutMs" type="number" optional>
+  Maximum time to wait for reload in milliseconds.
+
+  **Default:** `15000`
+</ParamField>
+
+<ParamField path="ignoreCache" type="boolean" optional>
+  Whether to bypass the browser cache.
+
+  **Default:** `false`
+</ParamField>
+
+### goBack()
+
+Navigate back in browser history.
+
+```typescript
+await page.goBack(options?: NavigationOptions): Promise<Response | null>
+```
+
+Returns a [Response](/v3/references/response) when the history entry triggers a network fetch; otherwise `null`.
+
+<ParamField path="waitUntil" type="LoadState" optional>
+  When to consider navigation complete.
+</ParamField>
+
+<ParamField path="timeoutMs" type="number" optional>
+  Maximum time to wait in milliseconds.
+
+  **Default:** `15000`
+</ParamField>
+
+### goForward()
+
+Navigate forward in browser history.
+
+```typescript
+await page.goForward(options?: NavigationOptions): Promise<Response | null>
+```
+
+Returns a [Response](/v3/references/response) when the navigation loads a new document from the network; otherwise `null`.
+
+<ParamField path="waitUntil" type="LoadState" optional>
+  When to consider navigation complete.
+</ParamField>
+
+<ParamField path="timeoutMs" type="number" optional>
+  Maximum time to wait in milliseconds.
+
+  **Default:** `15000`
+</ParamField>
+
+## Page Information
+
+### url()
+
+Get the current page URL (synchronous).
+
+```typescript
+page.url(): string
+```
+
+**Returns:** The current page URL as a string.
+
+### title()
+
+Get the current page title.
+
+```typescript
+await page.title(): Promise<string>
+```
+
+**Returns:** The page title as a string.
+
+## Interaction Methods
+
+### click()
+
+Click at absolute page coordinates.
+
+```typescript
+await page.click(x: number, y: number, options?: ClickOptions): Promise<string>
+```
+
+**Returns:** A string containing the XPath of the clicked element when `returnXpath` is `true`, otherwise an empty string.
+
+<ParamField path="x" type="number" required>
+  X coordinate in CSS pixels.
+</ParamField>
+
+<ParamField path="y" type="number" required>
+  Y coordinate in CSS pixels.
+</ParamField>
+
+<ParamField path="options" type="object" optional>
+  Optional click configuration.
+
+  <Expandable title="properties">
+    <ParamField path="button" type="string">
+      Mouse button to use: `"left"` | `"right"` | `"middle"`
+
+      Default: `"left"`
+    </ParamField>
+
+    <ParamField path="clickCount" type="number">
+      Number of consecutive clicks.
+
+      Default: `1`
+    </ParamField>
+
+    <ParamField path="returnXpath" type="boolean">
+      If `true`, the returned string contains the XPath of the clicked element. If `false`, returns an empty string.
+
+      Default: `false`
+    </ParamField>
+  </Expandable>
+</ParamField>
+
+### hover()
+
+Hover at absolute page coordinates without clicking.
+
+```typescript
+await page.hover(x: number, y: number, options?: HoverOptions): Promise<string>
+```
+
+**Returns:** A string containing the XPath of the hovered element when `returnXpath` is `true`, otherwise an empty string.
+
+<ParamField path="x" type="number" required>
+  X coordinate in CSS pixels.
+</ParamField>
+
+<ParamField path="y" type="number" required>
+  Y coordinate in CSS pixels.
+</ParamField>
+
+<ParamField path="options" type="object" optional>
+  Optional hover configuration.
+
+  <Expandable title="properties">
+    <ParamField path="returnXpath" type="boolean">
+      If `true`, the returned string contains the XPath of the hovered element. If `false`, returns an empty string.
+
+      Default: `false`
+    </ParamField>
+  </Expandable>
+</ParamField>
+
+### scroll()
+
+Scroll at absolute page coordinates using mouse wheel events.
+
+```typescript
+await page.scroll(x: number, y: number, deltaX: number, deltaY: number, options?: ScrollOptions): Promise<string>
+```
+
+**Returns:** A string containing the XPath of the element at the scroll position when `returnXpath` is `true`, otherwise an empty string.
+
+<ParamField path="x" type="number" required>
+  X coordinate in CSS pixels where the scroll occurs.
+</ParamField>
+
+<ParamField path="y" type="number" required>
+  Y coordinate in CSS pixels where the scroll occurs.
+</ParamField>
+
+<ParamField path="deltaX" type="number" required>
+  Horizontal scroll amount in pixels. Positive values scroll right.
+</ParamField>
+
+<ParamField path="deltaY" type="number" required>
+  Vertical scroll amount in pixels. Positive values scroll down.
+</ParamField>
+
+<ParamField path="options" type="object" optional>
+  Optional scroll configuration.
+
+  <Expandable title="properties">
+    <ParamField path="returnXpath" type="boolean">
+      If `true`, the returned string contains the XPath of the element at the scroll position. If `false`, returns an empty string.
+
+      Default: `false`
+    </ParamField>
+  </Expandable>
+</ParamField>
+
+### dragAndDrop()
+
+Drag from one position to another using mouse events.
+
+```typescript
+const [fromXpath, toXpath] = await page.dragAndDrop(fromX, fromY, toX, toY, options?)
+```
+
+**Returns:** An array of two strings containing the XPaths of the elements at the start and end positions when `returnXpath` is `true`, otherwise empty strings.
+
+<ParamField path="fromX" type="number" required>
+  Starting X coordinate in CSS pixels.
+</ParamField>
+
+<ParamField path="fromY" type="number" required>
+  Starting Y coordinate in CSS pixels.
+</ParamField>
+
+<ParamField path="toX" type="number" required>
+  Ending X coordinate in CSS pixels.
+</ParamField>
+
+<ParamField path="toY" type="number" required>
+  Ending Y coordinate in CSS pixels.
+</ParamField>
+
+<ParamField path="options" type="object" optional>
+  Optional drag configuration.
+
+  <Expandable title="properties">
+    <ParamField path="button" type="string">
+      Mouse button to use: `"left"` | `"right"` | `"middle"`
+
+      Default: `"left"`
+    </ParamField>
+
+    <ParamField path="steps" type="number">
+      Number of intermediate mouse move events during the drag.
+
+      Default: `1`
+    </ParamField>
+
+    <ParamField path="delay" type="number">
+      Delay in milliseconds between intermediate move events.
+
+      Default: `0`
+    </ParamField>
+
+    <ParamField path="returnXpath" type="boolean">
+      If `true`, the returned array contains the XPaths of the elements at the start and end positions. If `false`, returns empty strings.
+
+      Default: `false`
+    </ParamField>
+  </Expandable>
+</ParamField>
+
+### type()
+
+Type text into the page (dispatches keyboard events).
+
+```typescript
+await page.type(text: string, options?: TypeOptions): Promise<void>
+```
+
+<ParamField path="text" type="string" required>
+  The text to type.
+</ParamField>
+
+<ParamField path="options" type="object" optional>
+  Optional typing configuration.
+
+  <Expandable title="properties">
+    <ParamField path="delay" type="number">
+      Delay between key presses in milliseconds.
+    </ParamField>
+
+    <ParamField path="withMistakes" type="boolean">
+      Simulates typing with occasional mistakes and corrections.
+
+      Default: `false`
+    </ParamField>
+  </Expandable>
+</ParamField>
+
+### locator()
+
+Create a locator for querying elements.
+
+```typescript
+page.locator(selector: string): Locator
+```
+
+<ParamField path="selector" type="string" required>
+  CSS selector or XPath for the element.
+</ParamField>
+
+**Returns:** A `Locator` object for interacting with the element.
+
+## Evaluation
+
+### evaluate()
+
+Evaluate JavaScript code in the page context.
+
+```typescript
+await page.evaluate<R, Arg>(
+  pageFunctionOrExpression: string | ((arg: Arg) => R | Promise<R>),
+  arg?: Arg
+): Promise<R>
+```
+
+<ParamField path="pageFunctionOrExpression" type="string | function" required>
+  JavaScript expression as a string or a function to execute in the page context.
+</ParamField>
+
+<ParamField path="arg" type="any" optional>
+  Optional argument to pass to the function.
+</ParamField>
+
+**Returns:** The result of the evaluation (must be JSON-serializable).
+
+## Initialization Scripts
+
+### addInitScript()
+
+Inject JavaScript that runs before any of the page's scripts on every navigation.
+
+```typescript
+await page.addInitScript<Arg>(
+  script: string | { path?: string; content?: string } | ((arg: Arg) => unknown),
+  arg?: Arg,
+): Promise<void>
+```
+
+<ParamField
+  path="script"
+  type="string | { path?: string; content?: string } | (arg: Arg) => unknown"
+  required
+>
+  Provide the script to inject. Pass raw source, reference a preload file on disk,
+  or supply a function that Stagehand serializes before sending to the browser.
+</ParamField>
+
+<ParamField path="arg" type="Arg" optional>
+  Extra data that is JSON-serialized and passed to your function. Only supported
+  when `script` is a function.
+</ParamField>
+
+This method:
+- Runs at document start for the current page (including adopted iframe sessions) on every navigation
+- Reinstalls the script for all future navigations of this page without affecting other pages
+- Mirrors Playwright's `page.addInitScript()` ordering semantics; use  [`context.addInitScript()`](/v3/references/context#addinitscript) to target every page in the context
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({ env: "LOCAL" });
+await stagehand.init();
+const context = stagehand.context;
+const page = await context.awaitActivePage();
+
+await page.addInitScript(() => {
+  window.Math.random = () => 42;
+});
+
+await page.goto("https://example.com", { waitUntil: "load" });
+
+const result = await page.evaluate(() => Math.random());
+console.log("Math.random() returned:", result);
+
+// Math.random() returned: 42
+```
+
+## Screenshot
+
+### screenshot()
+
+Capture a screenshot of the page.
+
+```typescript
+await page.screenshot(options?: ScreenshotOptions): Promise<Buffer>
+```
+
+<ParamField path="fullPage" type="boolean" optional>
+  Capture the entire scrollable page instead of just the current viewport.
+
+  **Default:** `false`
+</ParamField>
+
+<ParamField path="clip" type="ScreenshotClip" optional>
+  Limit the capture to the provided rectangle in CSS pixels (`{ x, y, width, height }`).
+  Cannot be combined with `fullPage`.
+</ParamField>
+
+<ParamField path="type" type="'png' | 'jpeg'" optional>
+  Image format for the screenshot.
+
+  **Default:** `"png"`
+</ParamField>
+
+<ParamField path="quality" type="number" optional>
+  JPEG quality (0–100). Only used when `type` is `"jpeg"`.
+</ParamField>
+
+<ParamField path="scale" type="'css' | 'device'" optional>
+  Rendering scale. Use `"css"` for one pixel per CSS pixel, or `"device"` for the
+  device pixel ratio.
+
+  **Default:** `"device"`
+</ParamField>
+
+<ParamField path="animations" type="'allow' | 'disabled'" optional>
+  Control CSS/Web animations and transitions. `"disabled"` fast-forwards finite
+  animations and pauses infinite ones before capture.
+
+  **Default:** `"allow"`
+</ParamField>
+
+<ParamField path="caret" type="hide | initial" optional>
+  Hide the text caret during capture (`"hide"`) or leave it untouched (`"initial"`).
+
+  **Default:** `"hide"`
+</ParamField>
+
+<ParamField path="mask" type="Locator[]" optional>
+  List of locators to cover with a colored overlay while the screenshot is taken.
+</ParamField>
+
+<ParamField path="maskColor" type="string" optional>
+  CSS color to use for masked overlays.
+
+  **Default:** `#FF00FF`
+</ParamField>
+
+<ParamField path="style" type="string" optional>
+  Additional CSS text injected into every frame just before capture. Useful for
+  hiding or tweaking dynamic UI.
+</ParamField>
+
+<ParamField path="omitBackground" type="boolean" optional>
+  Make the default page background transparent (PNG only).
+
+  **Default:** `false`
+</ParamField>
+
+<ParamField path="timeout" type="number" optional>
+  Maximum time in milliseconds to wait for the capture before throwing.
+</ParamField>
+
+<ParamField path="path" type="string" optional>
+  Write the screenshot to the provided file path. The image is still returned as
+  a buffer.
+</ParamField>
+
+**Returns:** A `Promise<Buffer>` containing the screenshot image data.
+
+## Page Snapshot
+
+### snapshot()
+
+Capture a structured accessibility snapshot of the current page. The returned data combines a human-readable accessibility tree with lookup maps so you can relate each node to DOM selectors or URLs.
+
+```typescript
+await page.snapshot(options?: PageSnapshotOptions): Promise<SnapshotResult>
+```
+
+<ParamField path="options" type="PageSnapshotOptions" optional>
+  Optional configuration for the snapshot.
+
+  <Expandable title="properties">
+    <ParamField path="includeIframes" type="boolean">
+      Whether to include iframe content in the snapshot.
+
+      **Default:** `true`
+    </ParamField>
+  </Expandable>
+</ParamField>
+
+**Returns:** A `Promise<SnapshotResult>` describing the captured accessibility tree.
+
+<Expandable title="SnapshotResult properties">
+  <ParamField path="formattedTree" type="string">
+    Multiline text representing the accessibility tree hierarchy with encoded IDs.
+  </ParamField>
+  <ParamField path="xpathMap" type="Record<string, string>">
+    Maps each encoded ID to the element's absolute XPath for quick DOM lookups.
+  </ParamField>
+  <ParamField path="urlMap" type="Record<string, string>">
+    Maps encoded IDs for link-like nodes to their resolved URLs.
+  </ParamField>
+</Expandable>
+
+See [SnapshotResult](#snapshotresult) for the static type definition.
+
+The formatted tree represents every accessibility node with:
+- A unique encoded ID in brackets (e.g., `[0-1]`) for cross-referencing with the maps
+- The node's accessibility role (`RootWebArea`, `heading`, `link`, `button`, etc.)
+- The node's accessible name, when available
+
+**Example formatted output:**
+
+```txt
+[0-1] RootWebArea: Example Domain
+  [0-3] heading: Example Domain
+  [0-5] paragraph: This domain is for use in illustrative examples in documents.
+  [0-8] link: More information...
+```
+
+**Example usage:**
+
+```typescript
+const page = stagehand.context.pages()[0];
+await page.goto("https://example.com");
+
+const { formattedTree, xpathMap, urlMap } = await page.snapshot();
+
+// Print the accessibility tree
+console.log(formattedTree);
+
+// Look up a specific element's XPath by encoded ID
+const linkId = "0-8";
+console.log(xpathMap[linkId]); // e.g., "/html/body/div/p[2]/a"
+
+// Resolve a link's URL via the urlMap
+console.log(urlMap[linkId]); // e.g., "https://www.example.com"
+
+// Exclude iframe content when you only need the main document
+const mainDocumentSnapshot = await page.snapshot({ includeIframes: false });
+```
+
+## Viewport
+
+### setViewportSize()
+
+Set the page viewport size.
+
+```typescript
+await page.setViewportSize(
+  width: number,
+  height: number,
+  options?: ViewportOptions
+): Promise<void>
+```
+
+<ParamField path="width" type="number" required>
+  Viewport width in CSS pixels.
+</ParamField>
+
+<ParamField path="height" type="number" required>
+  Viewport height in CSS pixels.
+</ParamField>
+
+<ParamField path="deviceScaleFactor" type="number" optional>
+  Device scale factor (pixel ratio).
+
+  **Default:** `1`
+</ParamField>
+
+## Wait Methods
+
+### waitForLoadState()
+
+Wait for the page to reach a specific lifecycle state.
+
+```typescript
+await page.waitForLoadState(state: LoadState, timeoutMs?: number): Promise<void>
+```
+
+<ParamField path="state" type="LoadState" required>
+  The lifecycle state to wait for.
+
+  **Options:** `"load"`, `"domcontentloaded"`, `"networkidle"`
+</ParamField>
+
+<ParamField path="timeoutMs" type="number" optional>
+  Maximum time to wait in milliseconds.
+
+  **Default:** `15000`
+</ParamField>
+
+### waitForSelector()
+
+Wait for an element matching the selector to reach a specific state in the DOM. Uses a MutationObserver for efficiency, pierces shadow DOM by default, and supports iframe hops when needed.
+
+```typescript
+await page.waitForSelector(
+  selector: string,
+  options?: {
+    state?: "attached" | "detached" | "visible" | "hidden";
+    timeout?: number;
+    pierceShadow?: boolean;
+  }
+): Promise<boolean>
+```
+
+<ParamField path="selector" type="string" required>
+  CSS selector or XPath expression to wait for. Supports iframe hops (e.g., `/html/div/iframe/html/div/button`).
+</ParamField>
+
+<ParamField path="options" type="object" optional>
+  Optional wait configuration.
+
+  <Expandable title="properties">
+    <ParamField path="state" type="'attached' | 'detached' | 'visible' | 'hidden'">
+      Element state to wait for.
+
+      **Options:**
+      - `"attached"` - Element is present in DOM (even if hidden)
+      - `"detached"` - Element is removed from DOM
+      - `"visible"` - Element is visible
+      - `"hidden"` - Element is hidden
+
+      **Default:** `"visible"`
+    </ParamField>
+
+    <ParamField path="timeout" type="number">
+      Maximum time to wait in milliseconds before timing out.
+
+      **Default:** `30000`
+    </ParamField>
+
+    <ParamField path="pierceShadow" type="boolean">
+      Whether to search inside open and closed shadow DOM boundaries.
+
+      **Default:** `true`
+    </ParamField>
+  </Expandable>
+</ParamField>
+
+**Returns:** `true` when the condition is met.
+
+**Throws:** Error if timeout is reached before the condition is met.
+
+## Events
+
+### on("console")
+
+Listen for console output produced by the page and any adopted iframe sessions. Returns the page instance so calls can be chained.
+
+```typescript
+import type { ConsoleMessage } from "@browserbasehq/stagehand";
+
+const handleConsole = (message: ConsoleMessage) => {
+  console.log(`[${message.type()}] ${message.text()}`);
+  console.log("Arguments:", message.args());
+  const location = message.location();
+  if (location?.url) {
+    console.log(`Emitted from ${location.url}:${location.lineNumber ?? 0}`);
+  }
+};
+
+page.on("console", handleConsole);
+```
+
+`ConsoleMessage` exposes helpers for working with console events:
+
+- `message.type()` – console API category such as `log`, `error`, or `warning`
+- `message.text()` – string representation of the console arguments
+- `message.args()` – underlying CDP `RemoteObject` arguments array
+- `message.location()` – source URL, line, and column when available
+- `message.timestamp()` – CDP timestamp for the event
+- `message.raw()` – access to the original `Runtime.consoleAPICalledEvent`
+
+### once("console")
+
+Register a listener that removes itself after the first console event.
+
+```typescript
+page.once("console", (message) => {
+  console.log("First console message:", message.text());
+});
+```
+
+### off("console")
+
+Remove a previously registered listener. The reference must match the original listener passed to `on()`.
+
+```typescript
+page.off("console", handleConsole);
+```
+
+## Code Examples
+
+<Tabs>
+<Tab title="Basic Navigation">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+// Initialize with Browserbase (API key and project ID from environment variables)
+// Set BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID in your environment
+const stagehand = new Stagehand({ env: "BROWSERBASE" });
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+// Navigate to a URL
+await page.goto("https://example.com");
+
+// Get current URL and title
+console.log("URL:", page.url());
+console.log("Title:", await page.title());
+
+// Navigate back and forward
+await page.goBack();
+await page.goForward();
+
+// Reload the page
+await page.reload();
+```
+
+</Tab>
+<Tab title="Screenshots">
+
+```typescript
+// Capture viewport screenshot
+const screenshot = await page.screenshot();
+await fs.writeFile("screenshot.png", screenshot);
+
+// Capture full page screenshot
+const fullPage = await page.screenshot({ fullPage: true });
+await fs.writeFile("fullpage.png", fullPage);
+
+// Capture JPEG with styling overrides and a masked element
+const styled = await page.screenshot({
+  type: "jpeg",
+  quality: 80,
+  style: "body { filter: grayscale(1); }",
+  mask: [page.locator(".ads-banner")],
+  maskColor: "rgba(0, 0, 0, 0.3)",
+});
+await fs.writeFile("styled.jpg", styled);
+```
+
+</Tab>
+<Tab title="JavaScript Evaluation">
+
+```typescript
+// Execute JavaScript expression
+const pageHeight = await page.evaluate("document.body.scrollHeight");
+console.log("Page height:", pageHeight);
+
+// Execute function with arguments
+const result = await page.evaluate((selector) => {
+  const element = document.querySelector(selector);
+  return element ? element.textContent : null;
+}, "h1");
+console.log("H1 text:", result);
+
+// Async function evaluation
+const data = await page.evaluate(async () => {
+  const response = await fetch("/api/data");
+  return response.json();
+});
+```
+
+</Tab>
+<Tab title="Interaction">
+
+```typescript
+// Click at coordinates
+await page.click(100, 200);
+
+// Double click
+await page.click(100, 200, { clickCount: 2 });
+
+// Click and get the XPath of the clicked element
+const xpath = await page.click(100, 200, { returnXpath: true });
+console.log("Clicked element xpath:", xpath); // e.g., "/html/body/div[1]/button"
+
+// Hover at coordinates
+await page.hover(300, 150);
+
+// Hover and get the XPath of the hovered element
+const hoverXpath = await page.hover(300, 150, { returnXpath: true });
+
+// Scroll down at a position
+await page.scroll(400, 300, 0, 200); // scroll down 200px
+
+// Drag and drop between two points
+const [fromXpath, toXpath] = await page.dragAndDrop(100, 100, 300, 300, { returnXpath: true });
+
+// Type text
+await page.type("Hello, World!");
+
+// Type with delay between keystrokes
+await page.type("Slow typing", { delay: 100 });
+
+// Use locator for element interaction
+const button = page.locator("button.submit");
+await button.click();
+```
+
+</Tab>
+<Tab title="Wait for Load">
+
+```typescript
+// Navigate and wait for full load
+await page.goto("https://example.com", {
+  waitUntil: "load",
+  timeoutMs: 30000
+});
+
+// Wait for network idle after navigation
+await page.goto("https://spa-app.com", {
+  waitUntil: "networkidle"
+});
+
+// Wait for specific load state
+await page.waitForLoadState("domcontentloaded");
+```
+
+</Tab>
+<Tab title="Wait for Selector">
+
+```typescript
+// Wait for element to be visible (default)
+await page.waitForSelector("#submit-btn");
+
+// Wait for element to appear with custom timeout
+await page.waitForSelector(".loading-spinner", {
+  state: "visible",
+  timeout: 10000
+});
+
+// Wait for element to be removed from DOM
+await page.waitForSelector(".loading-spinner", {
+  state: "detached"
+});
+
+// Wait for element to become hidden
+await page.waitForSelector(".modal", {
+  state: "hidden"
+});
+
+// Wait for element inside an iframe
+await page.waitForSelector("iframe#checkout >> .pay-button");
+
+// Wait for element in shadow DOM (enabled by default)
+await page.waitForSelector("#shadow-button", {
+  pierceShadow: true
+});
+
+// Wait for element with XPath
+await page.waitForSelector("/html/div/button");
+```
+
+</Tab>
+<Tab title="Viewport">
+
+```typescript
+// Set viewport size
+await page.setViewportSize(1920, 1080);
+
+// Set mobile viewport with device scale
+await page.setViewportSize(375, 667, {
+  deviceScaleFactor: 2
+});
+
+// Then take a screenshot at this size
+const screenshot = await page.screenshot();
+```
+
+</Tab>
+<Tab title="Snapshot">
+
+```typescript
+// Capture the page's accessibility tree snapshot
+const { formattedTree, xpathMap, urlMap } = await page.snapshot();
+
+// The formattedTree shows the page structure:
+// [0-1] RootWebArea: Example Domain
+//   [0-3] heading: Example Domain
+//   [0-8] link: More information...
+
+console.log(formattedTree);
+
+// Use xpathMap to get the XPath selector for any element by ID
+const linkXpath = xpathMap["0-8"];
+console.log("Link XPath:", linkXpath); // "/html/body/div/p[2]/a"
+
+// Use urlMap to get URLs associated with link elements
+const linkUrl = urlMap["0-8"];
+console.log("Link URL:", linkUrl); // "https://www.iana.org/domains/example"
+
+// Exclude iframe content from the snapshot
+const mainPageOnly = await page.snapshot({ includeIframes: false });
+```
+
+</Tab>
+</Tabs>
+
+## Types
+
+### LoadState
+
+```typescript
+type LoadState = "load" | "domcontentloaded" | "networkidle";
+```
+
+- **`"load"`** - Wait for the `load` event (all resources loaded)
+- **`"domcontentloaded"`** - Wait for the `DOMContentLoaded` event (DOM is ready)
+- **`"networkidle"`** - Wait for network connections to be idle
+
+### AnyPage
+
+```typescript
+type AnyPage = PlaywrightPage | PuppeteerPage | PatchrightPage | Page;
+```
+
+Stagehand supports multiple browser automation libraries. The `AnyPage` type represents any compatible page object.
+
+### ScreenshotClip
+
+```typescript
+interface ScreenshotClip {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+```
+
+Represents the CSS-pixel rectangle to capture when `clip` is provided.
+
+### ScreenshotOptions
+
+```typescript
+interface ScreenshotOptions {
+  fullPage?: boolean;
+  clip?: ScreenshotClip;
+  type?: "png" | "jpeg";
+  quality?: number;
+  scale?: "css" | "device";
+  animations?: "allow" | "disabled";
+  caret?: "hide" | "initial";
+  mask?: Locator[];
+  maskColor?: string;
+  style?: string;
+  omitBackground?: boolean;
+  timeout?: number;
+  path?: string;
+}
+```
+
+Matches Playwright's screenshot signature with sensible defaults to control how a
+capture is produced.
+
+### PageSnapshotOptions
+
+```typescript
+type PageSnapshotOptions = {
+  includeIframes?: boolean;
+};
+```
+
+- **`includeIframes`** - Whether to include iframe content in the snapshot. Defaults to `true`
+
+### SnapshotResult
+
+```typescript
+type SnapshotResult = {
+  formattedTree: string;
+  xpathMap: Record<string, string>;
+  urlMap: Record<string, string>;
+};
+```
+
+- **`formattedTree`** - A formatted string representation of the page's accessibility tree with encoded IDs, roles, and names
+- **`xpathMap`** - A mapping from encoded element IDs to their absolute XPath selectors
+- **`urlMap`** - A mapping from encoded element IDs to their associated URLs (for links and other navigable elements)
+
+## Error Handling
+
+Page methods may throw the following errors:
+
+- **Navigation Errors** - Timeout or network issues during navigation
+- **Evaluation Errors** - JavaScript execution errors in `evaluate()`
+- **Interaction Errors** - Failed clicks or typing operations
+- **Screenshot Errors** - Issues capturing screenshots
+
+All errors should be caught and handled appropriately:
+
+```typescript
+try {
+  await page.goto("https://example.com");
+} catch (error) {
+  console.error("Navigation failed:", error.message);
+}
+```
diff --git a/packages/docs/v3/references/response.mdx b/packages/docs/v3/references/response.mdx
new file mode 100644
index 000000000..ed46fc04c
--- /dev/null
+++ b/packages/docs/v3/references/response.mdx
@@ -0,0 +1,254 @@
+---
+title: Response
+description: 'Complete API reference for the Response object'
+icon: 'reply'
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+<CardGroup cols={1}>
+<Card title="Navigation" icon="compass" href="/v3/references/page">
+  See how pages expose Response objects from navigation methods
+</Card>
+</CardGroup>
+
+## Overview
+
+`Response` mirrors Playwright’s [Response](https://playwright.dev/docs/api/class-response) interface and is returned from Stagehand navigation helpers such as `page.goto()`, `page.reload()`, `page.goBack()`, and `page.goForward()`. It provides a convenient way to inspect the HTTP metadata associated with a navigation, retrieve the response body on demand, and monitor when the underlying request finishes.
+
+Stagehand automatically returns `null` for navigations that do not yield a network request (for example `data:` URLs, `about:blank`, or same-document history changes), matching Playwright’s behaviour.
+
+## Getting a Response
+
+```typescript
+const response = await page.goto("https://example.com", {
+  waitUntil: "networkidle",
+});
+
+if (!response) {
+  throw new Error("Navigation did not produce a network response");
+}
+
+console.log("Status", response.status(), response.statusText());
+const body = await response.text();
+```
+
+When a navigation does not produce a response object you will receive `null`, allowing you to branch early:
+
+```typescript
+const inline = await page.goto("data:text/html,<h1>inline</h1>");
+if (inline === null) {
+  // No network fetch happened; handle accordingly
+}
+```
+
+## Status & Metadata
+
+### url()
+
+```typescript
+response.url(): string
+```
+
+Returns the final URL associated with the navigation request.
+
+### status()
+
+```typescript
+response.status(): number
+```
+
+Returns the HTTP status code.
+
+### statusText()
+
+```typescript
+response.statusText(): string
+```
+
+Returns the human-readable status text (for example `OK`).
+
+### ok()
+
+```typescript
+response.ok(): boolean
+```
+
+Convenience helper that resolves to `true` for 2xx responses and `false` otherwise.
+
+### frame()
+
+```typescript
+response.frame(): Frame | null
+```
+
+Returns the Stagehand `Frame` that initiated the navigation. When the frame is no longer available, `null` is returned.
+
+### fromServiceWorker()
+
+```typescript
+response.fromServiceWorker(): boolean
+```
+
+Indicates whether the response was served from a Service Worker fetch handler.
+
+### securityDetails()
+
+```typescript
+await response.securityDetails(): Promise<Protocol.Network.SecurityDetails | null>
+```
+
+Resolves with TLS/security metadata when available (issuer, protocol, validity window). Returns `null` for insecure or non-network responses.
+
+### serverAddr()
+
+```typescript
+await response.serverAddr(): Promise<{ ipAddress: string; port: number } | null>
+```
+
+Provides the remote IP/port reported by Chrome, when known.
+
+## Header Helpers
+
+### headers()
+
+```typescript
+response.headers(): Record<string, string>
+```
+
+Returns a lowercase header map, matching Playwright’s `headers()` behaviour.
+
+### allHeaders()
+
+```typescript
+await response.allHeaders(): Promise<Record<string, string>>
+```
+
+Includes additional headers only surfaced via Chrome’s `responseReceivedExtraInfo` event (such as `set-cookie`).
+
+### headerValue()
+
+```typescript
+await response.headerValue(name: string): Promise<string | null>
+```
+
+Returns a comma-joined string of all values for the specified header. Resolves to `null` when the header is absent.
+
+### headerValues()
+
+```typescript
+await response.headerValues(name: string): Promise<string[]>
+```
+
+Returns an array of header values, keeping multiple entries separate.
+
+### headersArray()
+
+```typescript
+await response.headersArray(): Promise<Array<{ name: string; value: string }>>
+```
+
+Returns the header list while preserving the original casing and order reported by the browser.
+
+## Body Helpers
+
+### body()
+
+```typescript
+await response.body(): Promise<Buffer>
+```
+
+Fetches the raw response body. The buffer is base64-decoded for you when Chrome sends it that way.
+
+### text()
+
+```typescript
+await response.text(): Promise<string>
+```
+
+Returns the response body decoded as UTF-8 text.
+
+### json()
+
+```typescript
+await response.json<T = unknown>(): Promise<T>
+```
+
+Parses the response body as JSON. Throws if the body cannot be parsed or is not valid JSON.
+
+<Note>
+All body helper calls (`body()`, `text()`, `json()`) only succeed once the browser reports the response body is available. Stagehand handles this timing automatically.
+</Note>
+
+## Completion
+
+### finished()
+
+```typescript
+await response.finished(): Promise<null | Error>
+```
+
+Resolves to `null` when the main navigation request completes successfully, or to an `Error` if Chrome reports `Network.loadingFailed`. This mirrors Playwright’s `response.finished()` contract and is especially helpful for catching late failures such as network resets or blocked responses.
+
+```typescript
+const result = await response.finished();
+if (result instanceof Error) {
+  console.error("Navigation failed", result.message);
+}
+```
+
+## Usage Patterns
+
+### Inspect status and headers
+
+```typescript
+const response = await page.goto("https://httpbin.org/headers");
+
+if (response) {
+  console.log(response.status(), response.statusText());
+  const headers = await response.headersArray();
+  headers.forEach(({ name, value }) => {
+    console.log(`${name}: ${value}`);
+  });
+}
+```
+
+### Handle non-network navigations
+
+```typescript
+const result = await page.goto("data:text/html,<p>inline</p>");
+
+if (result === null) {
+  console.log("No network response (data URL)");
+} else {
+  // Process as usual
+}
+```
+
+### Await completion
+
+```typescript
+const response = await page.goto("https://example.com/slow");
+
+if (response) {
+  const finished = await response.finished();
+  if (finished instanceof Error) {
+    console.error("Navigation failed", finished.message);
+  }
+}
+```
+
+## Returned From
+
+- `await page.goto(url, options?)`
+- `await page.reload(options?)`
+- `await page.goBack(options?)`
+- `await page.goForward(options?)`
+
+Each method resolves with `Response | null` depending on whether Chrome reported a document-level network response.
+
+## See Also
+
+- [Page reference](/v3/references/page) for details on navigation helpers
diff --git a/packages/docs/v3/references/stagehand.mdx b/packages/docs/v3/references/stagehand.mdx
new file mode 100644
index 000000000..2db99796a
--- /dev/null
+++ b/packages/docs/v3/references/stagehand.mdx
@@ -0,0 +1,645 @@
+---
+title: Stagehand
+description: 'Complete API reference for the Stagehand class'
+icon: 'hand-horns'
+---
+import { V3Banner } from '/snippets/v3-banner.mdx';
+
+<V3Banner />
+
+
+<CardGroup cols={1}>
+<Card title="Getting Started" icon="rocket" href="/v3/first-steps/quickstart">
+  The fastest way to start using Stagehand
+</Card>
+</CardGroup>
+
+## Overview
+
+The `Stagehand` class is the main entry point for Stagehand v3. It manages browser lifecycle, provides AI-powered automation methods, and handles both local and remote browser environments.
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand(options);
+await stagehand.init();
+```
+
+## Constructor
+
+### new Stagehand()
+
+Create a new Stagehand instance.
+
+```typescript
+const stagehand = new Stagehand(options: V3Options);
+```
+
+**V3Options Interface:**
+```typescript
+interface V3Options {
+  env: "LOCAL" | "BROWSERBASE";
+
+  // Browserbase options (required when env = "BROWSERBASE")
+  apiKey?: string;
+  projectId?: string;
+  browserbaseSessionID?: string;
+  browserbaseSessionCreateParams?: Browserbase.Sessions.SessionCreateParams;
+
+  // Local browser options
+  localBrowserLaunchOptions?: LocalBrowserLaunchOptions;
+
+  // AI/LLM configuration
+  model?: ModelConfiguration;
+  llmClient?: LLMClient;
+  systemPrompt?: string;
+
+  // Behavior options
+  selfHeal?: boolean;
+  experimental?: boolean;
+  domSettleTimeout?: number;
+  cacheDir?: string;
+  keepAlive?: boolean;
+  serverCache?: boolean;
+
+  // Logging options
+  verbose?: 0 | 1 | 2;
+  logInferenceToFile?: boolean;
+  disablePino?: boolean;
+  logger?: (line: LogLine) => void;
+}
+```
+
+### Configuration Parameters
+
+<ParamField path="env" type='"LOCAL" | "BROWSERBASE"' required>
+  Environment to run the browser in.
+
+  - **`"LOCAL"`** - Run browser locally using Chrome/Chromium
+  - **`"BROWSERBASE"`** - Run browser on Browserbase cloud platform
+</ParamField>
+
+#### Browserbase Options
+
+<ParamField path="apiKey" type="string" optional>
+  Browserbase API key. Required when `env` is `"BROWSERBASE"`.
+
+  Can also be set via `BROWSERBASE_API_KEY` environment variable.
+</ParamField>
+
+<ParamField path="projectId" type="string" optional>
+  Browserbase project ID. Required when `env` is `"BROWSERBASE"`.
+
+  Can also be set via `BROWSERBASE_PROJECT_ID` environment variable.
+</ParamField>
+
+<ParamField path="browserbaseSessionID" type="string" optional>
+  Resume an existing Browserbase session by ID instead of creating a new one.
+</ParamField>
+
+<ParamField path="browserbaseSessionCreateParams" type="object" optional>
+  Additional parameters for Browserbase session creation. See [Browserbase documentation](https://docs.browserbase.com) for details.
+</ParamField>
+
+#### Local Browser Options
+
+<ParamField path="localBrowserLaunchOptions" type="LocalBrowserLaunchOptions" optional>
+  Configuration for local Chrome/Chromium browser.
+
+  <Expandable title="LocalBrowserLaunchOptions">
+    <ParamField path="headless" type="boolean" optional>
+      Run browser in headless mode.
+
+      **Default:** `true`
+    </ParamField>
+
+    <ParamField path="executablePath" type="string" optional>
+      Path to Chrome/Chromium executable.
+    </ParamField>
+
+    <ParamField path="port" type="number" optional>
+      Fixed Chrome DevTools Protocol (CDP) debugging port for external tool connections.
+
+      **Default:** Randomly assigned
+    </ParamField>
+
+    <ParamField path="args" type="string[]" optional>
+      Additional Chrome launch arguments.
+    </ParamField>
+
+    <ParamField path="userDataDir" type="string" optional>
+      Path to user data directory for browser profile.
+    </ParamField>
+
+    <ParamField path="viewport" type="{ width: number; height: number }" optional>
+      Default viewport size.
+    </ParamField>
+
+    <ParamField path="devtools" type="boolean" optional>
+      Auto-open DevTools for each tab.
+
+      **Default:** `false`
+    </ParamField>
+
+    <ParamField path="proxy" type="object" optional>
+      Proxy configuration.
+
+      **Properties:** `server`, `bypass`, `username`, `password`
+    </ParamField>
+
+    <ParamField path="ignoreHTTPSErrors" type="boolean" optional>
+      Ignore HTTPS certificate errors.
+
+      **Default:** `false`
+    </ParamField>
+
+    <ParamField path="cdpUrl" type="string" optional>
+      Attach to existing Chrome instance via CDP WebSocket URL.
+    </ParamField>
+  </Expandable>
+</ParamField>
+
+#### AI/LLM Configuration
+
+<ParamField path="model" type="ModelConfiguration" optional>
+  Configure the AI model to use for automation. Can be either:
+  - A string in the format `"provider/model"` (e.g., `"openai/gpt-4o"`, `"anthropic/claude-sonnet-4-6"`)
+  - An object with detailed configuration
+
+  <Expandable title="Model Configuration Object">
+    <ParamField path="modelName" type="string" required>
+      The model name (e.g., "gpt-4o", "claude-sonnet-4-6", "gemini-2.5-flash")
+    </ParamField>
+    <ParamField path="apiKey" type="string" optional>
+      API key for the model provider (overrides environment variables)
+    </ParamField>
+    <ParamField path="baseURL" type="string" optional>
+      Base URL for the API endpoint (for custom endpoints or proxies)
+    </ParamField>
+  </Expandable>
+</ParamField>
+
+<ParamField path="llmClient" type="LLMClient" optional>
+  Provide a custom LLM client implementation instead of using the default.
+</ParamField>
+
+<ParamField path="systemPrompt" type="string" optional>
+  Custom system prompt to guide AI behavior across all operations.
+</ParamField>
+
+#### Behavior Options
+
+<ParamField path="selfHeal" type="boolean" optional>
+  Enable self-healing mode where actions can recover from failures.
+
+  **Default:** `true`
+</ParamField>
+
+<ParamField path="experimental" type="boolean" optional>
+  Enable experimental features (may change between versions).
+
+  **Default:** `false`
+  <Warning>**Use with caution in production**. Experimental features may break or change between versions without notice.</Warning>
+
+</ParamField>
+
+<ParamField path="domSettleTimeout" type="number" optional>
+  Default timeout for waiting for DOM to stabilize (in milliseconds).
+
+  **Default:** `30000`
+</ParamField>
+
+<ParamField path="cacheDir" type="string" optional>
+  Directory path for caching action observations to improve performance.
+</ParamField>
+
+<ParamField path="keepAlive" type="boolean" optional>
+  Controls whether the browser remains running after `stagehand.close()` is called or the parent process exits unexpectedly.
+
+  - **`true`** - Browser continues running independently. On Browserbase, the session stays active. Locally, the Chrome process is kept alive.
+  - **`false`** - Browser is terminated and resources are cleaned up on close or crash.
+
+  When set, this overrides any value in `browserbaseSessionCreateParams.keepAlive`.
+
+  **Default:** `false`
+</ParamField>
+
+<ParamField path="serverCache" type="boolean" optional>
+  Enable or disable server-side caching for `act()`, `extract()`, and `observe()` requests. When enabled, repeated calls with the same inputs return instantly without consuming LLM tokens.
+
+  <Note>Only applies when `env` is `"BROWSERBASE"`. Has no effect in local environments.</Note>
+
+  Can be overridden per-call via the `serverCache` option on `act()`, `extract()`, and `observe()`.
+
+  **Default:** `true`
+</ParamField>
+
+#### Logging Options
+
+<ParamField path="verbose" type="0 | 1 | 2" optional>
+  Logging verbosity level.
+
+  - **`0`** - Minimal logging
+  - **`1`** - Standard logging (default)
+  - **`2`** - Detailed debug logging
+
+  **Default:** `1`
+</ParamField>
+
+<ParamField path="logInferenceToFile" type="boolean" optional>
+  Log AI inference details to files for debugging.
+
+  **Default:** `false`
+</ParamField>
+
+<ParamField path="disablePino" type="boolean" optional>
+  Disable the Pino logging backend (useful for custom logging integrations).
+
+  **Default:** `false`
+</ParamField>
+
+<ParamField path="logger" type="(line: LogLine) => void" optional>
+  Custom logger function to receive log events.
+</ParamField>
+
+## Methods
+
+### init()
+
+Initialize the Stagehand instance and launch the browser.
+
+```typescript
+await stagehand.init(): Promise<void>
+```
+
+**Must be called before using any other methods.**
+
+### close()
+
+Close the browser and clean up resources.
+
+```typescript
+await stagehand.close(options?: { force?: boolean }): Promise<void>
+```
+
+<ParamField path="force" type="boolean" optional>
+  Force close even if already closing.
+
+  **Default:** `false`
+</ParamField>
+
+<Note>
+When `keepAlive` is `true`, calling `close()` disconnects Stagehand from the browser without terminating it. The browser session continues running independently and can be reconnected to later using `browserbaseSessionID`. When `keepAlive` is `false` (the default), `close()` fully terminates the browser and cleans up all resources.
+</Note>
+
+### agent()
+
+Create an AI agent instance for autonomous multi-step workflows.
+
+```typescript
+stagehand.agent(config?: AgentConfig): AgentInstance
+```
+
+See the [agent() reference](/v3/references/agent) for detailed documentation.
+
+## Properties
+
+### page
+
+Access pages for browser automation. Pages are accessed through the context.
+
+```typescript
+// Get the first page (created automatically on init)
+const page = stagehand.context.pages()[0];
+
+// Or get the active page
+const activePage = stagehand.context.activePage();
+
+// Create a new page
+const newPage = await stagehand.context.newPage();
+```
+
+**Type:** [`Page`](/v3/references/page)
+
+The page object provides methods for:
+- Navigation (`goto()`, `reload()`, `goBack()`, `goForward()`)
+- Interaction (`click()`, `type()`, `keyPress()`, `locator()`, `deepLocator()`)
+- Inspection (`url()`, `title()`, `screenshot()`)
+- JavaScript evaluation (`evaluate()`)
+
+<Note>
+**Important:** AI-powered methods ([`act()`](/v3/references/act), [`extract()`](/v3/references/extract), [`observe()`](/v3/references/observe)) are called on the stagehand instance, not on the page object.
+</Note>
+
+### context
+
+Access the browser context for managing multiple pages.
+
+```typescript
+const context = stagehand.context;
+```
+
+**Type:** `V3Context`
+
+The context object provides:
+- `newPage()` - Create a new page/tab
+- `pages()` - Get all open pages
+- `setActivePage(page)` - Switch active page
+
+### metrics
+
+Get usage metrics for AI operations.
+
+```typescript
+const metrics = await stagehand.metrics;
+```
+
+**Returns:** `Promise<StagehandMetrics>`
+
+**StagehandMetrics Interface:**
+```typescript
+interface StagehandMetrics {
+  // Act metrics
+  actPromptTokens: number;
+  actCompletionTokens: number;
+  actReasoningTokens: number;
+  actCachedInputTokens: number;
+  actInferenceTimeMs: number;
+
+  // Extract metrics
+  extractPromptTokens: number;
+  extractCompletionTokens: number;
+  extractReasoningTokens: number;
+  extractCachedInputTokens: number;
+  extractInferenceTimeMs: number;
+
+  // Observe metrics
+  observePromptTokens: number;
+  observeCompletionTokens: number;
+  observeReasoningTokens: number;
+  observeCachedInputTokens: number;
+  observeInferenceTimeMs: number;
+
+  // Agent metrics
+  agentPromptTokens: number;
+  agentCompletionTokens: number;
+  agentReasoningTokens: number;
+  agentCachedInputTokens: number;
+  agentInferenceTimeMs: number;
+
+  // Totals
+  totalPromptTokens: number;
+  totalCompletionTokens: number;
+  totalReasoningTokens: number;
+  totalCachedInputTokens: number;
+  totalInferenceTimeMs: number;
+}
+```
+
+### history
+
+Get the history of all operations performed.
+
+```typescript
+const history = await stagehand.history;
+```
+
+**Returns:** `Promise<ReadonlyArray<HistoryEntry>>`
+
+**HistoryEntry Interface:**
+```typescript
+interface HistoryEntry {
+  method: "act" | "extract" | "observe" | "navigate";
+  parameters: unknown;
+  result: unknown;
+  timestamp: string;
+}
+```
+
+### browserbaseSessionID
+
+Browserbase session identifier for the active Browserbase run.
+
+```typescript
+const sessionId = stagehand.browserbaseSessionID;
+```
+
+**Type:** `string | undefined` — undefined for LOCAL runs or before `init()`.
+
+### browserbaseSessionURL
+
+Shareable link to the active Browserbase session dashboard.
+
+```typescript
+const sessionUrl = stagehand.browserbaseSessionURL;
+```
+
+**Type:** `string | undefined` — undefined until a Browserbase session is active.
+
+### browserbaseDebugURL
+
+Debugger URL returned by Browserbase for direct CDP inspection.
+
+```typescript
+const debugUrl = stagehand.browserbaseDebugURL;
+```
+
+**Type:** `string | undefined` — undefined for LOCAL runs or if Browserbase doesn’t provide one.
+
+## Code Examples
+
+<Tabs>
+<Tab title="Browserbase">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+// Remote browser on Browserbase
+const stagehand = new Stagehand({
+  env: "BROWSERBASE",
+  apiKey: process.env.BROWSERBASE_API_KEY,
+  projectId: process.env.BROWSERBASE_PROJECT_ID,
+  model: "anthropic/claude-sonnet-4-6"
+});
+
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+await page.goto("https://example.com");
+const data = await stagehand.extract("get page title", z.object({
+  title: z.string()
+}));
+
+await stagehand.close();
+```
+
+</Tab>
+<Tab title="Local">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+// Local browser
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  model: "openai/gpt-4o"
+});
+
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+// Use the page
+await page.goto("https://example.com");
+await stagehand.act("click the login button");
+
+// Cleanup
+await stagehand.close();
+```
+
+</Tab>
+<Tab title="Custom Model Config">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  model: {
+    modelName: "gpt-4o",
+    apiKey: process.env.OPENAI_API_KEY,
+    baseURL: "https://custom-proxy.com/v1"
+  },
+  systemPrompt: "You are a helpful automation assistant.",
+  verbose: 2,
+  selfHeal: true
+});
+
+await stagehand.init();
+```
+
+</Tab>
+<Tab title="Multi-Page">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({ env: "LOCAL" });
+await stagehand.init();
+
+// Get the first page
+const page1 = stagehand.context.pages()[0];
+await page1.goto("https://example.com");
+
+// Create second page
+const page2 = await stagehand.context.newPage();
+await page2.goto("https://another-site.com");
+
+// Switch active page
+stagehand.context.setActivePage(page2);
+
+// Now context.activePage() returns page2
+await stagehand.act("click the button");
+
+await stagehand.close();
+```
+
+</Tab>
+<Tab title="With Metrics">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  model: "openai/gpt-4o"
+});
+
+await stagehand.init();
+const page = stagehand.context.pages()[0];
+
+await page.goto("https://example.com");
+await stagehand.act("fill out the form");
+await stagehand.extract("get form data", schema);
+
+// Get usage metrics
+const metrics = await stagehand.metrics;
+console.log("Total tokens used:", metrics.totalPromptTokens + metrics.totalCompletionTokens);
+console.log("Act operations:", {
+  tokens: metrics.actPromptTokens + metrics.actCompletionTokens,
+  time: metrics.actInferenceTimeMs
+});
+
+await stagehand.close();
+```
+
+</Tab>
+<Tab title="With Custom Logger">
+
+```typescript
+import { Stagehand } from "@browserbasehq/stagehand";
+
+const stagehand = new Stagehand({
+  env: "LOCAL",
+  verbose: 2,
+  logger: (logLine) => {
+    console.log(`[${logLine.category}] ${logLine.message}`);
+    if (logLine.auxiliary) {
+      console.log("Details:", logLine.auxiliary);
+    }
+  }
+});
+
+await stagehand.init();
+// All operations will now log through your custom logger
+```
+
+</Tab>
+</Tabs>
+
+## Error Handling
+
+Stagehand methods may throw the following errors:
+
+- **StagehandInitError** - Failed to initialize Stagehand
+- **StagehandNotInitializedError** - Methods called before `init()`
+- **BrowserbaseSessionNotFoundError** - Browserbase session not found
+- **MissingLLMConfigurationError** - No LLM API key or client configured
+- **MissingEnvironmentVariableError** - Required environment variable not set
+- **StagehandEnvironmentError** - Invalid environment configuration
+
+Always handle errors appropriately:
+
+```typescript
+try {
+  const stagehand = new Stagehand({ env: "LOCAL" });
+  await stagehand.init();
+  // ... use stagehand
+} catch (error) {
+  console.error("Stagehand error:", error.message);
+} finally {
+  await stagehand?.close();
+}
+```
+
+## Best Practices
+
+1. **Always call `init()`** before using any other methods
+2. **Always call `close()`** when done to clean up resources
+3. **Use try-finally** to ensure cleanup even on errors
+4. **Set appropriate timeouts** based on your use case
+5. **Enable `selfHeal`** for more robust automation
+6. **Use metrics** to monitor token usage and costs
+7. **Configure custom logger** for production debugging
+8. **Cache directory** can significantly improve performance for repeated actions
+
+## Environment Variables
+
+Stagehand recognizes the following environment variables:
+
+- `BROWSERBASE_API_KEY` - Browserbase API key
+- `BROWSERBASE_PROJECT_ID` - Browserbase project ID
+- `OPENAI_API_KEY` - OpenAI API key
+- `ANTHROPIC_API_KEY` - Anthropic API key
+- `GOOGLE_API_KEY` - Google AI API key
+
+These can be overridden by passing values in the constructor options.
diff --git a/packages/docs/v3/sdk/go.mdx b/packages/docs/v3/sdk/go.mdx
new file mode 100644
index 000000000..e82261bc3
--- /dev/null
+++ b/packages/docs/v3/sdk/go.mdx
@@ -0,0 +1,635 @@
+---
+title: "Go SDK"
+description: "Official Stagehand SDK for Go"
+---
+
+<Note>
+  This documentation is automatically synced from the [Go SDK GitHub repository](https://github.com/browserbase/stagehand-go).
+</Note>
+
+## What is Stagehand?
+
+Stagehand is a browser automation framework used to control web browsers with natural language and code. By combining the power of AI with the precision of code, Stagehand makes web automation flexible, maintainable, and actually reliable.
+
+## Why Stagehand?
+
+Most existing browser automation tools either require you to write low-level code in a framework like Selenium, Playwright, or Puppeteer, or use high-level agents that can be unpredictable in production. By letting developers choose what to write in code vs. natural language (and bridging the gap between the two) Stagehand is the natural choice for browser automations in production.
+
+1. **Choose when to write code vs. natural language**: use AI when you want to navigate unfamiliar pages, and use code when you know exactly what you want to do.
+
+2. **Go from AI-driven to repeatable workflows**: Stagehand lets you preview AI actions before running them, and also helps you easily cache repeatable actions to save time and tokens.
+
+3. **Write once, run forever**: Stagehand's auto-caching combined with self-healing remembers previous actions, runs without LLM inference, and knows when to involve AI whenever the website changes and your automation breaks.
+
+## Installation
+
+```go
+import (
+	"github.com/browserbase/stagehand-go" // imported as stagehand
+)
+```
+
+Or to pin the version:
+
+```sh
+go get -u 'github.com/browserbase/stagehand-go@v0.17.1'
+```
+
+## Requirements
+
+This library requires Go 1.22+.
+
+## Usage
+
+The full API of this library can be found in [api.md](https://github.com/browserbase/stagehand-go/blob/main/api.md).
+
+```go
+package main
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/browserbase/stagehand-go"
+	"github.com/browserbase/stagehand-go/option"
+)
+
+func main() {
+	// Create a new Stagehand client with your credentials
+	client := stagehand.NewClient(
+		option.WithBrowserbaseAPIKey("My Browserbase API Key"),       // defaults to os.LookupEnv("BROWSERBASE_API_KEY")
+		option.WithBrowserbaseProjectID("My Browserbase Project ID"), // defaults to os.LookupEnv("BROWSERBASE_PROJECT_ID")
+		option.WithModelAPIKey("My Model API Key"),                   // defaults to os.LookupEnv("MODEL_API_KEY")
+	)
+
+	// Start a new browser session
+	startResponse, err := client.Sessions.Start(context.TODO(), stagehand.SessionStartParams{
+		ModelName: "gpt-5-nano",
+	})
+	if err != nil {
+		panic(err.Error())
+	}
+	fmt.Printf("Session started: %s\n", startResponse.Data.SessionID)
+
+	sessionID := startResponse.Data.SessionID
+
+	// Navigate to a webpage
+	_, err = client.Sessions.Navigate(
+		context.TODO(),
+		sessionID,
+		stagehand.SessionNavigateParams{
+			URL: "https://news.ycombinator.com",
+		},
+	)
+	if err != nil {
+		panic(err.Error())
+	}
+	fmt.Println("Navigated to Hacker News")
+
+	// Use Observe to find possible actions on the page
+	observeResponse, err := client.Sessions.Observe(
+		context.TODO(),
+		sessionID,
+		stagehand.SessionObserveParams{
+			Instruction: stagehand.String("find the link to view comments for the top post"),
+		},
+	)
+	if err != nil {
+		panic(err.Error())
+	}
+
+	actions := observeResponse.Data.Result
+	fmt.Printf("Found %d possible actions\n", len(actions))
+
+	if len(actions) == 0 {
+		fmt.Println("No actions found")
+		return
+	}
+
+	// Take the first action returned by Observe
+	action := actions[0]
+	fmt.Printf("Acting on: %s\n", action.Description)
+
+	// Pass the structured action to Act
+	// The action contains selector, description, method, and arguments
+	actResponse, err := client.Sessions.Act(
+		context.TODO(),
+		sessionID,
+		stagehand.SessionActParams{
+			Input: stagehand.SessionActParamsInputUnion{
+				OfAction: &stagehand.ActionParam{
+					Description: action.Description,
+					Selector:    action.Selector,
+					Method:      stagehand.String(action.Method),
+					Arguments:   action.Arguments,
+				},
+			},
+		},
+	)
+	if err != nil {
+		panic(err.Error())
+	}
+	fmt.Printf("Act completed: %s\n", actResponse.Data.Result.Message)
+
+	// Extract structured data from the page using a JSON schema
+	extractResponse, err := client.Sessions.Extract(
+		context.TODO(),
+		sessionID,
+		stagehand.SessionExtractParams{
+			Instruction: stagehand.String("extract the text of the top comment"),
+			Schema: map[string]any{
+				"type": "object",
+				"properties": map[string]any{
+					"commentText": map[string]any{
+						"type":        "string",
+						"description": "The text content of the top comment",
+					},
+					"author": map[string]any{
+						"type":        "string",
+						"description": "The username of the comment author",
+					},
+				},
+			},
+		},
+	)
+	if err != nil {
+		panic(err.Error())
+	}
+	fmt.Printf("Extracted: %+v\n", extractResponse.Data.Result)
+
+	// Run an autonomous agent to accomplish a goal
+	// The agent can navigate, click, type, and interact with pages
+	executeResponse, err := client.Sessions.Execute(
+		context.TODO(),
+		sessionID,
+		stagehand.SessionExecuteParams{
+			ExecuteOptions: stagehand.SessionExecuteParamsExecuteOptions{
+				Instruction: "Find the profile page for the top commenter",
+				MaxSteps:    stagehand.Float(10),
+			},
+			AgentConfig: stagehand.SessionExecuteParamsAgentConfig{
+				// Model config with provider/model format and API key
+				Model: stagehand.ModelConfigUnionParam{
+					OfModelConfigModelConfigObject: &stagehand.ModelConfigModelConfigObjectParam{
+						ModelName: "openai/gpt-4.1-mini",
+						APIKey:    stagehand.String("sk-your-api-key"),
+					},
+				},
+				Cua: stagehand.Bool(false),
+			},
+		},
+	)
+	if err != nil {
+		panic(err.Error())
+	}
+	fmt.Printf("Agent result: %s\n", executeResponse.Data.Result.Message)
+
+	// End the session to clean up resources
+	_, err = client.Sessions.End(
+		context.TODO(),
+		sessionID,
+		stagehand.SessionEndParams{},
+	)
+	if err != nil {
+		panic(err.Error())
+	}
+	fmt.Println("Session ended")
+}
+```
+
+### Running the example
+
+A complete working example is available in `examples/basic.go`. To run it:
+
+1. **Set up environment variables** by creating a `.env` file in the repository root:
+
+```bash
+BROWSERBASE_API_KEY=your_browserbase_api_key
+BROWSERBASE_PROJECT_ID=your_browserbase_project_id
+MODEL_API_KEY=your_openai_api_key
+```
+
+You can get your Browserbase API key and project ID from the [Browserbase dashboard](https://www.browserbase.com/).
+
+2. **Install dependencies**:
+
+```bash
+go mod tidy
+```
+
+3. **Run the example**:
+
+```bash
+go run examples/basic.go
+```
+
+The example demonstrates the full Stagehand workflow: starting a session, navigating to a page, observing actions, clicking elements, extracting data, and running an autonomous agent.
+
+### Request fields
+
+The stagehand library uses the [`omitzero`](https://tip.golang.org/doc/go1.24#encodingjsonpkgencodingjson)
+semantics from the Go 1.24+ `encoding/json` release for request fields.
+
+Required primitive fields (`int64`, `string`, etc.) feature the tag `json:"...,required"`. These
+fields are always serialized, even their zero values.
+
+Optional primitive types are wrapped in a `param.Opt[T]`. These fields can be set with the provided constructors, `stagehand.String(string)`, `stagehand.Int(int64)`, etc.
+
+Any `param.Opt[T]`, map, slice, struct or string enum uses the
+tag `json:"...,omitzero"`. Its zero value is considered omitted.
+
+The `param.IsOmitted(any)` function can confirm the presence of any `omitzero` field.
+
+```go
+p := stagehand.ExampleParams{
+	ID:   "id_xxx",                // required property
+	Name: stagehand.String("..."), // optional property
+
+	Point: stagehand.Point{
+		X: 0,                // required field will serialize as 0
+		Y: stagehand.Int(1), // optional field will serialize as 1
+		// ... omitted non-required fields will not be serialized
+	},
+
+	Origin: stagehand.Origin{}, // the zero value of [Origin] is considered omitted
+}
+```
+
+To send `null` instead of a `param.Opt[T]`, use `param.Null[T]()`.
+To send `null` instead of a struct `T`, use `param.NullStruct[T]()`.
+
+```go
+p.Name = param.Null[string]()       // 'null' instead of string
+p.Point = param.NullStruct[Point]() // 'null' instead of struct
+
+param.IsNull(p.Name)  // true
+param.IsNull(p.Point) // true
+```
+
+Request structs contain a `.SetExtraFields(map[string]any)` method which can send non-conforming
+fields in the request body. Extra fields overwrite any struct fields with a matching
+key. For security reasons, only use `SetExtraFields` with trusted data.
+
+To send a custom value instead of a struct, use `param.Override[T](https://github.com/browserbase/stagehand-go/blob/main/value)`.
+
+```go
+// In cases where the API specifies a given type,
+// but you want to send something else, use [SetExtraFields]:
+p.SetExtraFields(map[string]any{
+	"x": 0.01, // send "x" as a float instead of int
+})
+
+// Send a number instead of an object
+custom := param.Override[stagehand.FooParams](https://github.com/browserbase/stagehand-go/blob/main/12)
+```
+
+### Request unions
+
+Unions are represented as a struct with fields prefixed by "Of" for each of its variants,
+only one field can be non-zero. The non-zero field will be serialized.
+
+Sub-properties of the union can be accessed via methods on the union struct.
+These methods return a mutable pointer to the underlying data, if present.
+
+```go
+// Only one field can be non-zero, use param.IsOmitted() to check if a field is set
+type AnimalUnionParam struct {
+	OfCat *Cat `json:",omitzero,inline`
+	OfDog *Dog `json:",omitzero,inline`
+}
+
+animal := AnimalUnionParam{
+	OfCat: &Cat{
+		Name: "Whiskers",
+		Owner: PersonParam{
+			Address: AddressParam{Street: "3333 Coyote Hill Rd", Zip: 0},
+		},
+	},
+}
+
+// Mutating a field
+if address := animal.GetOwner().GetAddress(); address != nil {
+	address.ZipCode = 94304
+}
+```
+
+### Response objects
+
+All fields in response structs are ordinary value types (not pointers or wrappers).
+Response structs also include a special `JSON` field containing metadata about
+each property.
+
+```go
+type Animal struct {
+	Name   string `json:"name,nullable"`
+	Owners int    `json:"owners"`
+	Age    int    `json:"age"`
+	JSON   struct {
+		Name        respjson.Field
+		Owner       respjson.Field
+		Age         respjson.Field
+		ExtraFields map[string]respjson.Field
+	} `json:"-"`
+}
+```
+
+To handle optional data, use the `.Valid()` method on the JSON field.
+`.Valid()` returns true if a field is not `null`, not present, or couldn't be marshaled.
+
+If `.Valid()` is false, the corresponding field will simply be its zero value.
+
+```go
+raw := `{"owners": 1, "name": null}`
+
+var res Animal
+json.Unmarshal([]byte(raw), &res)
+
+// Accessing regular fields
+
+res.Owners // 1
+res.Name   // ""
+res.Age    // 0
+
+// Optional field checks
+
+res.JSON.Owners.Valid() // true
+res.JSON.Name.Valid()   // false
+res.JSON.Age.Valid()    // false
+
+// Raw JSON values
+
+res.JSON.Owners.Raw()                  // "1"
+res.JSON.Name.Raw() == "null"          // true
+res.JSON.Name.Raw() == respjson.Null   // true
+res.JSON.Age.Raw() == ""               // true
+res.JSON.Age.Raw() == respjson.Omitted // true
+```
+
+These `.JSON` structs also include an `ExtraFields` map containing
+any properties in the json response that were not specified
+in the struct. This can be useful for API features not yet
+present in the SDK.
+
+```go
+body := res.JSON.ExtraFields["my_unexpected_field"].Raw()
+```
+
+### Response Unions
+
+In responses, unions are represented by a flattened struct containing all possible fields from each of the
+object variants.
+To convert it to a variant use the `.AsFooVariant()` method or the `.AsAny()` method if present.
+
+If a response value union contains primitive values, primitive fields will be alongside
+the properties but prefixed with `Of` and feature the tag `json:"...,inline"`.
+
+```go
+type AnimalUnion struct {
+	// From variants [Dog], [Cat]
+	Owner Person `json:"owner"`
+	// From variant [Dog]
+	DogBreed string `json:"dog_breed"`
+	// From variant [Cat]
+	CatBreed string `json:"cat_breed"`
+	// ...
+
+	JSON struct {
+		Owner respjson.Field
+		// ...
+	} `json:"-"`
+}
+
+// If animal variant
+if animal.Owner.Address.ZipCode == "" {
+	panic("missing zip code")
+}
+
+// Switch on the variant
+switch variant := animal.AsAny().(type) {
+case Dog:
+case Cat:
+default:
+	panic("unexpected type")
+}
+```
+
+### RequestOptions
+
+This library uses the functional options pattern. Functions defined in the
+`option` package return a `RequestOption`, which is a closure that mutates a
+`RequestConfig`. These options can be supplied to the client or at individual
+requests. For example:
+
+```go
+client := stagehand.NewClient(
+	// Adds a header to every request made by the client
+	option.WithHeader("X-Some-Header", "custom_header_info"),
+)
+
+client.Sessions.Start(context.TODO(), ...,
+	// Override the header
+	option.WithHeader("X-Some-Header", "some_other_custom_header_info"),
+	// Add an undocumented field to the request body, using sjson syntax
+	option.WithJSONSet("some.json.path", map[string]string{"my": "object"}),
+)
+```
+
+The request option `option.WithDebugLog(nil)` may be helpful while debugging.
+
+See the [full list of request options](https://pkg.go.dev/github.com/browserbase/stagehand-go/option).
+
+### Errors
+
+When the API returns a non-success status code, we return an error with type
+`*stagehand.Error`. This contains the `StatusCode`, `*http.Request`, and
+`*http.Response` values of the request, as well as the JSON of the error body
+(much like other response objects in the SDK).
+
+To handle errors, we recommend that you use the `errors.As` pattern:
+
+```go
+_, err := client.Sessions.Start(context.TODO(), stagehand.SessionStartParams{
+	ModelName: "openai/gpt-5-nano",
+})
+if err != nil {
+	var apierr *stagehand.Error
+	if errors.As(err, &apierr) {
+		println(string(apierr.DumpRequest(true)))  // Prints the serialized HTTP request
+		println(string(apierr.DumpResponse(true))) // Prints the serialized HTTP response
+	}
+	panic(err.Error()) // GET "/v1/sessions/start": 400 Bad Request { ... }
+}
+```
+
+When other errors occur, they are returned unwrapped; for example,
+if HTTP transport fails, you might receive `*url.Error` wrapping `*net.OpError`.
+
+### Timeouts
+
+Requests do not time out by default; use context to configure a timeout for a request lifecycle.
+
+Note that if a request is [retried](#retries), the context timeout does not start over.
+To set a per-retry timeout, use `option.WithRequestTimeout()`.
+
+```go
+// This sets the timeout for the request, including all the retries.
+ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+defer cancel()
+client.Sessions.Start(
+	ctx,
+	stagehand.SessionStartParams{
+		ModelName: "openai/gpt-5-nano",
+	},
+	// This sets the per-retry timeout
+	option.WithRequestTimeout(20*time.Second),
+)
+```
+
+### Retries
+
+Certain errors will be automatically retried 2 times by default, with a short exponential backoff.
+We retry by default all connection errors, 408 Request Timeout, 409 Conflict, 429 Rate Limit,
+and >=500 Internal errors.
+
+You can use the `WithMaxRetries` option to configure or disable this:
+
+```go
+// Configure the default for all requests:
+client := stagehand.NewClient(
+	option.WithMaxRetries(0), // default is 2
+)
+
+// Override per-request:
+client.Sessions.Start(
+	context.TODO(),
+	stagehand.SessionStartParams{
+		ModelName: "openai/gpt-5-nano",
+	},
+	option.WithMaxRetries(5),
+)
+```
+
+### Accessing raw response data (e.g. response headers)
+
+You can access the raw HTTP response data by using the `option.WithResponseInto()` request option. This is useful when
+you need to examine response headers, status codes, or other details.
+
+```go
+// Create a variable to store the HTTP response
+var response *http.Response
+response, err := client.Sessions.Start(
+	context.TODO(),
+	stagehand.SessionStartParams{
+		ModelName: "openai/gpt-5-nano",
+	},
+	option.WithResponseInto(&response),
+)
+if err != nil {
+	// handle error
+}
+fmt.Printf("%+v\n", response)
+
+fmt.Printf("Status Code: %d\n", response.StatusCode)
+fmt.Printf("Headers: %+#v\n", response.Header)
+```
+
+### Making custom/undocumented requests
+
+This library is typed for convenient access to the documented API. If you need to access undocumented
+endpoints, params, or response properties, the library can still be used.
+
+#### Undocumented endpoints
+
+To make requests to undocumented endpoints, you can use `client.Get`, `client.Post`, and other HTTP verbs.
+`RequestOptions` on the client, such as retries, will be respected when making these requests.
+
+```go
+var (
+    // params can be an io.Reader, a []byte, an encoding/json serializable object,
+    // or a "…Params" struct defined in this library.
+    params map[string]any
+
+    // result can be an []byte, *http.Response, a encoding/json deserializable object,
+    // or a model defined in this library.
+    result *http.Response
+)
+err := client.Post(context.Background(), "/unspecified", params, &result)
+if err != nil {
+    …
+}
+```
+
+#### Undocumented request params
+
+To make requests using undocumented parameters, you may use either the `option.WithQuerySet()`
+or the `option.WithJSONSet()` methods.
+
+```go
+params := FooNewParams{
+    ID:   "id_xxxx",
+    Data: FooNewParamsData{
+        FirstName: stagehand.String("John"),
+    },
+}
+client.Foo.New(context.Background(), params, option.WithJSONSet("data.last_name", "Doe"))
+```
+
+#### Undocumented response properties
+
+To access undocumented response properties, you may either access the raw JSON of the response as a string
+with `result.JSON.RawJSON()`, or get the raw JSON of a particular field on the result with
+`result.JSON.Foo.Raw()`.
+
+Any fields that are not present on the response struct will be saved and can be accessed by `result.JSON.ExtraFields()` which returns the extra fields as a `map[string]Field`.
+
+### Middleware
+
+We provide `option.WithMiddleware` which applies the given
+middleware to requests.
+
+```go
+func Logger(req *http.Request, next option.MiddlewareNext) (res *http.Response, err error) {
+	// Before the request
+	start := time.Now()
+	LogReq(req)
+
+	// Forward the request to the next handler
+	res, err = next(req)
+
+	// Handle stuff after the request
+	end := time.Now()
+	LogRes(res, err, start - end)
+
+    return res, err
+}
+
+client := stagehand.NewClient(
+	option.WithMiddleware(Logger),
+)
+```
+
+When multiple middlewares are provided as variadic arguments, the middlewares
+are applied left to right. If `option.WithMiddleware` is given
+multiple times, for example first in the client then the method, the
+middleware in the client will run first and the middleware given in the method
+will run next.
+
+You may also replace the default `http.Client` with
+`option.WithHTTPClient(client)`. Only one http client is
+accepted (this overwrites any previous client) and receives requests after any
+middleware has been applied.
+
+## Semantic versioning
+
+This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:
+
+1. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals.)_
+2. Changes that we do not expect to impact the vast majority of users in practice.
+
+We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.
+
+We are keen for your feedback; please open an [issue](https://www.github.com/browserbase/stagehand-go/issues) with questions, bugs, or suggestions.
+
+## Contributing
+
+See [the contributing documentation](https://github.com/browserbase/stagehand-go/blob/main/./CONTRIBUTING.md).
\ No newline at end of file
diff --git a/packages/docs/v3/sdk/java.mdx b/packages/docs/v3/sdk/java.mdx
new file mode 100644
index 000000000..568677269
--- /dev/null
+++ b/packages/docs/v3/sdk/java.mdx
@@ -0,0 +1,873 @@
+---
+title: "Java SDK"
+description: "Official Stagehand SDK for Java"
+---
+
+<Note>
+  This documentation is automatically synced from the [Java SDK GitHub repository](https://github.com/browserbase/stagehand-java).
+</Note>
+
+## What is Stagehand?
+
+Stagehand is a browser automation framework used to control web browsers with natural language and code. By combining the power of AI with the precision of code, Stagehand makes web automation flexible, maintainable, and actually reliable.
+
+## Why Stagehand?
+
+Most existing browser automation tools either require you to write low-level code in a framework like Selenium, Playwright, or Puppeteer, or use high-level agents that can be unpredictable in production. By letting developers choose what to write in code vs. natural language (and bridging the gap between the two) Stagehand is the natural choice for browser automations in production.
+
+1. **Choose when to write code vs. natural language**: use AI when you want to navigate unfamiliar pages, and use code when you know exactly what you want to do.
+
+2. **Go from AI-driven to repeatable workflows**: Stagehand lets you preview AI actions before running them, and also helps you easily cache repeatable actions to save time and tokens.
+
+3. **Write once, run forever**: Stagehand's auto-caching combined with self-healing remembers previous actions, runs without LLM inference, and knows when to involve AI whenever the website changes and your automation breaks.
+
+## Installation
+
+### Gradle
+
+```java
+implementation("com.browserbase.api:stagehand-java:0.6.1")
+```
+
+### Maven
+
+```xml
+<dependency>
+  <groupId>com.browserbase.api</groupId>
+  <artifactId>stagehand-java</artifactId>
+  <version>0.6.1</version>
+</dependency>
+```
+
+## Requirements
+
+This library requires Java 8 through Java 21. Java 22+ is not currently supported.
+
+## Running the Example
+
+A complete working example is available at [`stagehand-java-example/src/main/java/com/stagehand/api/example/Main.java`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-example/src/main/java/com/stagehand/api/example/Main.java).
+
+To run it, first export the required environment variables, then use Gradle:
+
+```bash
+export BROWSERBASE_API_KEY="your-bb-api-key"
+export BROWSERBASE_PROJECT_ID="your-bb-project-uuid"
+export MODEL_API_KEY="sk-proj-your-llm-api-key"
+
+./gradlew :stagehand-java-example:run
+```
+
+## Usage
+
+This example demonstrates the full Stagehand workflow: starting a session, navigating to a page, observing possible actions, acting on elements, extracting data, and running an autonomous agent.
+
+```java
+import com.browserbase.api.client.StagehandClient;
+import com.browserbase.api.client.okhttp.StagehandOkHttpClient;
+import com.browserbase.api.core.JsonValue;
+import com.browserbase.api.models.sessions.*;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+public class Main {
+    public static void main(String[] args) {
+        // Create client using environment variables:
+        // BROWSERBASE_API_KEY, BROWSERBASE_PROJECT_ID, MODEL_API_KEY
+        StagehandClient client = StagehandOkHttpClient.fromEnv();
+
+        // Start a new browser session
+        SessionStartResponse startResponse = client.sessions().start(
+            SessionStartParams.builder()
+                .modelName("openai/gpt-5-nano")
+                .build()
+        );
+
+        String sessionId = startResponse.data().sessionId();
+        System.out.println("Session started: " + sessionId);
+
+        try {
+            // Navigate to a webpage
+            client.sessions().navigate(
+                SessionNavigateParams.builder()
+                    .id(sessionId)
+                    .url("https://news.ycombinator.com")
+                    .build()
+            );
+            System.out.println("Navigated to Hacker News");
+
+            // Observe to find possible actions on the page
+            SessionObserveResponse observeResponse = client.sessions().observe(
+                SessionObserveParams.builder()
+                    .id(sessionId)
+                    .instruction("find the link to view comments for the top post")
+                    .build()
+            );
+
+            List<SessionObserveResponse.Data.Result> results = observeResponse.data().result();
+            System.out.println("Found " + results.size() + " possible actions");
+
+            if (results.isEmpty()) {
+                System.out.println("No actions found");
+                return;
+            }
+
+            // Take the first action returned by Observe
+            // Convert the result to an Action to pass to Act
+            SessionObserveResponse.Data.Result result = results.get(0);
+            Action action = JsonValue.from(result).convert(Action.class);
+            System.out.println("Acting on: " + action.description());
+
+            // Pass the structured action to Act
+            SessionActResponse actResponse = client.sessions().act(
+                SessionActParams.builder()
+                    .id(sessionId)
+                    .input(action)
+                    .build()
+            );
+            System.out.println("Act completed: " + actResponse.data().result().message());
+
+            // Extract structured data from the page using a JSON schema
+            SessionExtractResponse extractResponse = client.sessions().extract(
+                SessionExtractParams.builder()
+                    .id(sessionId)
+                    .instruction("extract the text of the top comment on this page")
+                    .schema(SessionExtractParams.Schema.builder()
+                        .putAdditionalProperty("type", JsonValue.from("object"))
+                        .putAdditionalProperty("properties", JsonValue.from(Map.of(
+                            "commentText", Map.of(
+                                "type", "string",
+                                "description", "The text content of the top comment"
+                            ),
+                            "author", Map.of(
+                                "type", "string",
+                                "description", "The username of the comment author"
+                            )
+                        )))
+                        .putAdditionalProperty("required", JsonValue.from(List.of("commentText")))
+                        .build())
+                    .build()
+            );
+
+            JsonValue extractedResult = extractResponse.data()._result();
+            System.out.println("Extracted data: " + extractedResult);
+
+            // Get the author from the extracted data
+            String author = extractedResult.asObject()
+                .flatMap(obj -> Optional.ofNullable(obj.get("author")))
+                .flatMap(JsonValue::asString)
+                .orElse("unknown");
+            System.out.println("Looking up profile for author: " + author);
+
+            // Run an autonomous agent to accomplish a complex task
+            SessionExecuteResponse executeResponse = client.sessions().execute(
+                SessionExecuteParams.builder()
+                    .id(sessionId)
+                    .executeOptions(SessionExecuteParams.ExecuteOptions.builder()
+                        .instruction(String.format(
+                            "Find any personal website, GitHub, or LinkedIn profile for user '%s'. " +
+                            "Click on their username to view their profile page.",
+                            author
+                        ))
+                        .maxSteps(10.0)
+                        .build())
+                    .agentConfig(SessionExecuteParams.AgentConfig.builder()
+                        .model(ModelConfig.ofModelConfigObject(
+                            ModelConfig.ModelConfigObject.builder()
+                                .modelName("openai/gpt-5-nano")
+                                .apiKey(System.getenv("MODEL_API_KEY"))
+                                .build()
+                        ))
+                        .cua(false)
+                        .build())
+                    .build()
+            );
+
+            System.out.println("Agent completed: " + executeResponse.data().result().message());
+            System.out.println("Agent success: " + executeResponse.data().result().success());
+
+        } finally {
+            // End the browser session to clean up resources
+            client.sessions().end(
+                SessionEndParams.builder()
+                    .id(sessionId)
+                    .build()
+            );
+            System.out.println("Session ended");
+        }
+    }
+}
+```
+
+## Client configuration
+
+Configure the client using system properties or environment variables:
+
+```java
+import com.browserbase.api.client.StagehandClient;
+import com.browserbase.api.client.okhttp.StagehandOkHttpClient;
+
+// Configures using the `stagehand.browserbaseApiKey`, `stagehand.browserbaseProjectId`, `stagehand.modelApiKey` and `stagehand.baseUrl` system properties
+// Or configures using the `BROWSERBASE_API_KEY`, `BROWSERBASE_PROJECT_ID`, `MODEL_API_KEY` and `STAGEHAND_BASE_URL` environment variables
+StagehandClient client = StagehandOkHttpClient.fromEnv();
+```
+
+Or manually:
+
+```java
+import com.browserbase.api.client.StagehandClient;
+import com.browserbase.api.client.okhttp.StagehandOkHttpClient;
+
+StagehandClient client = StagehandOkHttpClient.builder()
+    .browserbaseApiKey("My Browserbase API Key")
+    .browserbaseProjectId("My Browserbase Project ID")
+    .modelApiKey("My Model API Key")
+    .build();
+```
+
+Or using a combination of the two approaches:
+
+```java
+import com.browserbase.api.client.StagehandClient;
+import com.browserbase.api.client.okhttp.StagehandOkHttpClient;
+
+StagehandClient client = StagehandOkHttpClient.builder()
+    // Configures using the `stagehand.browserbaseApiKey`, `stagehand.browserbaseProjectId`, `stagehand.modelApiKey` and `stagehand.baseUrl` system properties
+    // Or configures using the `BROWSERBASE_API_KEY`, `BROWSERBASE_PROJECT_ID`, `MODEL_API_KEY` and `STAGEHAND_BASE_URL` environment variables
+    .fromEnv()
+    .browserbaseApiKey("My Browserbase API Key")
+    .build();
+```
+
+See this table for the available options:
+
+| Setter                 | System property                  | Environment variable     | Required | Default value                             |
+| ---------------------- | -------------------------------- | ------------------------ | -------- | ----------------------------------------- |
+| `browserbaseApiKey`    | `stagehand.browserbaseApiKey`    | `BROWSERBASE_API_KEY`    | true     | -                                         |
+| `browserbaseProjectId` | `stagehand.browserbaseProjectId` | `BROWSERBASE_PROJECT_ID` | true     | -                                         |
+| `modelApiKey`          | `stagehand.modelApiKey`          | `MODEL_API_KEY`          | true     | -                                         |
+| `baseUrl`              | `stagehand.baseUrl`              | `STAGEHAND_BASE_URL`     | true     | `"https://api.stagehand.browserbase.com"` |
+
+System properties take precedence over environment variables.
+
+> [!TIP]
+> Don't create more than one client in the same application. Each client has a connection pool and
+> thread pools, which are more efficient to share between requests.
+
+### Modifying configuration
+
+To temporarily use a modified client configuration, while reusing the same connection and thread pools, call `withOptions()` on any client or service:
+
+```java
+import com.browserbase.api.client.StagehandClient;
+
+StagehandClient clientWithOptions = client.withOptions(optionsBuilder -> {
+    optionsBuilder.modelApiKey("sk-your-llm-api-key-here");
+    optionsBuilder.maxRetries(42);
+});
+```
+
+The `withOptions()` method does not affect the original client or service.
+
+## Requests and responses
+
+To send a request to the Stagehand API, build an instance of some `Params` class and pass it to the corresponding client method. When the response is received, it will be deserialized into an instance of a Java class.
+
+For example, `client.sessions().act(...)` should be called with an instance of `SessionActParams`, and it will return an instance of `SessionActResponse`.
+
+## Immutability
+
+Each class in the SDK has an associated [builder](https://blogs.oracle.com/javamagazine/post/exploring-joshua-blochs-builder-design-pattern-in-java) or factory method for constructing it.
+
+Each class is [immutable](https://docs.oracle.com/javase/tutorial/essential/concurrency/immutable.html) once constructed. If the class has an associated builder, then it has a `toBuilder()` method, which can be used to convert it back to a builder for making a modified copy.
+
+Because each class is immutable, builder modification will _never_ affect already built class instances.
+
+## Asynchronous execution
+
+The default client is synchronous. To switch to asynchronous execution, call the `async()` method:
+
+```java
+import com.browserbase.api.client.StagehandClient;
+import com.browserbase.api.client.okhttp.StagehandOkHttpClient;
+import com.browserbase.api.models.sessions.SessionActParams;
+import com.browserbase.api.models.sessions.SessionActResponse;
+import java.util.concurrent.CompletableFuture;
+
+// Configures using the `stagehand.browserbaseApiKey`, `stagehand.browserbaseProjectId`, `stagehand.modelApiKey` and `stagehand.baseUrl` system properties
+// Or configures using the `BROWSERBASE_API_KEY`, `BROWSERBASE_PROJECT_ID`, `MODEL_API_KEY` and `STAGEHAND_BASE_URL` environment variables
+StagehandClient client = StagehandOkHttpClient.fromEnv();
+
+SessionActParams params = SessionActParams.builder()
+    .id("00000000-your-session-id-000000000000")
+    .input("click the first link on the page")
+    .build();
+CompletableFuture<SessionActResponse> response = client.async().sessions().act(params);
+```
+
+Or create an asynchronous client from the beginning:
+
+```java
+import com.browserbase.api.client.StagehandClientAsync;
+import com.browserbase.api.client.okhttp.StagehandOkHttpClientAsync;
+import com.browserbase.api.models.sessions.SessionActParams;
+import com.browserbase.api.models.sessions.SessionActResponse;
+import java.util.concurrent.CompletableFuture;
+
+// Configures using the `stagehand.browserbaseApiKey`, `stagehand.browserbaseProjectId`, `stagehand.modelApiKey` and `stagehand.baseUrl` system properties
+// Or configures using the `BROWSERBASE_API_KEY`, `BROWSERBASE_PROJECT_ID`, `MODEL_API_KEY` and `STAGEHAND_BASE_URL` environment variables
+StagehandClientAsync client = StagehandOkHttpClientAsync.fromEnv();
+
+SessionActParams params = SessionActParams.builder()
+    .id("00000000-your-session-id-000000000000")
+    .input("click the first link on the page")
+    .build();
+CompletableFuture<SessionActResponse> response = client.sessions().act(params);
+```
+
+The asynchronous client supports the same options as the synchronous one, except most methods return `CompletableFuture`s.
+
+## Streaming
+
+The SDK defines methods that return response "chunk" streams, where each chunk can be individually processed as soon as it arrives instead of waiting on the full response. Streaming methods generally correspond to [SSE](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events) or [JSONL](https://jsonlines.org) responses.
+
+Some of these methods may have streaming and non-streaming variants, but a streaming method will always have a `Streaming` suffix in its name, even if it doesn't have a non-streaming variant.
+
+These streaming methods return [`StreamResponse`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/core/http/StreamResponse.kt) for synchronous clients:
+
+```java
+import com.browserbase.api.core.http.StreamResponse;
+import com.browserbase.api.models.sessions.StreamEvent;
+
+try (StreamResponse<StreamEvent> streamResponse = client.sessions().actStreaming(params)) {
+    streamResponse.stream().forEach(chunk -> {
+        System.out.println(chunk);
+    });
+    System.out.println("No more chunks!");
+}
+```
+
+Or [`AsyncStreamResponse`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/core/http/AsyncStreamResponse.kt) for asynchronous clients:
+
+```java
+import com.browserbase.api.core.http.AsyncStreamResponse;
+import com.browserbase.api.models.sessions.StreamEvent;
+import java.util.Optional;
+
+client.async().sessions().actStreaming(params).subscribe(chunk -> {
+    System.out.println(chunk);
+});
+
+// If you need to handle errors or completion of the stream
+client.async().sessions().actStreaming(params).subscribe(new AsyncStreamResponse.Handler<>() {
+    @Override
+    public void onNext(StreamEvent chunk) {
+        System.out.println(chunk);
+    }
+
+    @Override
+    public void onComplete(Optional<Throwable> error) {
+        if (error.isPresent()) {
+            System.out.println("Something went wrong!");
+            throw new RuntimeException(error.get());
+        } else {
+            System.out.println("No more chunks!");
+        }
+    }
+});
+
+// Or use futures
+client.async().sessions().actStreaming(params)
+    .subscribe(chunk -> {
+        System.out.println(chunk);
+    })
+    .onCompleteFuture();
+    .whenComplete((unused, error) -> {
+        if (error != null) {
+            System.out.println("Something went wrong!");
+            throw new RuntimeException(error);
+        } else {
+            System.out.println("No more chunks!");
+        }
+    });
+```
+
+Async streaming uses a dedicated per-client cached thread pool [`Executor`](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executor.html) to stream without blocking the current thread. This default is suitable for most purposes.
+
+To use a different `Executor`, configure the subscription using the `executor` parameter:
+
+```java
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+
+Executor executor = Executors.newFixedThreadPool(4);
+client.async().sessions().actStreaming(params).subscribe(
+    chunk -> System.out.println(chunk), executor
+);
+```
+
+Or configure the client globally using the `streamHandlerExecutor` method:
+
+```java
+import com.browserbase.api.client.StagehandClient;
+import com.browserbase.api.client.okhttp.StagehandOkHttpClient;
+import java.util.concurrent.Executors;
+
+StagehandClient client = StagehandOkHttpClient.builder()
+    .fromEnv()
+    .streamHandlerExecutor(Executors.newFixedThreadPool(4))
+    .build();
+```
+
+## Raw responses
+
+The SDK defines methods that deserialize responses into instances of Java classes. However, these methods don't provide access to the response headers, status code, or the raw response body.
+
+To access this data, prefix any HTTP method call on a client or service with `withRawResponse()`:
+
+```java
+import com.browserbase.api.core.http.Headers;
+import com.browserbase.api.core.http.HttpResponseFor;
+import com.browserbase.api.models.sessions.SessionStartParams;
+import com.browserbase.api.models.sessions.SessionStartResponse;
+
+SessionStartParams params = SessionStartParams.builder()
+    .modelName("openai/gpt-5-nano")
+    .build();
+HttpResponseFor<SessionStartResponse> response = client.sessions().withRawResponse().start(params);
+
+int statusCode = response.statusCode();
+Headers headers = response.headers();
+```
+
+You can still deserialize the response into an instance of a Java class if needed:
+
+```java
+import com.browserbase.api.models.sessions.SessionStartResponse;
+
+SessionStartResponse parsedResponse = response.parse();
+```
+
+## Error handling
+
+The SDK throws custom unchecked exception types:
+
+- [`StagehandServiceException`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/errors/StagehandServiceException.kt): Base class for HTTP errors. See this table for which exception subclass is thrown for each HTTP status code:
+
+  | Status | Exception                                                                                                                          |
+  | ------ | ---------------------------------------------------------------------------------------------------------------------------------- |
+  | 400    | [`BadRequestException`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/errors/BadRequestException.kt)                     |
+  | 401    | [`UnauthorizedException`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/errors/UnauthorizedException.kt)                 |
+  | 403    | [`PermissionDeniedException`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/errors/PermissionDeniedException.kt)         |
+  | 404    | [`NotFoundException`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/errors/NotFoundException.kt)                         |
+  | 422    | [`UnprocessableEntityException`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/errors/UnprocessableEntityException.kt)   |
+  | 429    | [`RateLimitException`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/errors/RateLimitException.kt)                       |
+  | 5xx    | [`InternalServerException`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/errors/InternalServerException.kt)             |
+  | others | [`UnexpectedStatusCodeException`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/errors/UnexpectedStatusCodeException.kt) |
+
+  [`SseException`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/errors/SseException.kt) is thrown for errors encountered during [SSE streaming](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events) after a successful initial HTTP response.
+
+- [`StagehandIoException`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/errors/StagehandIoException.kt): I/O networking errors.
+
+- [`StagehandRetryableException`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/errors/StagehandRetryableException.kt): Generic error indicating a failure that could be retried by the client.
+
+- [`StagehandInvalidDataException`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/errors/StagehandInvalidDataException.kt): Failure to interpret successfully parsed data. For example, when accessing a property that's supposed to be required, but the API unexpectedly omitted it from the response.
+
+- [`StagehandException`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/errors/StagehandException.kt): Base class for all exceptions. Most errors will result in one of the previously mentioned ones, but completely generic errors may be thrown using the base class.
+
+## Logging
+
+The SDK uses the standard [OkHttp logging interceptor](https://github.com/square/okhttp/tree/master/okhttp-logging-interceptor).
+
+Enable logging by setting the `STAGEHAND_LOG` environment variable to `info`:
+
+```sh
+export STAGEHAND_LOG=info
+```
+
+Or to `debug` for more verbose logging:
+
+```sh
+export STAGEHAND_LOG=debug
+```
+
+## ProGuard and R8
+
+Although the SDK uses reflection, it is still usable with [ProGuard](https://github.com/Guardsquare/proguard) and [R8](https://developer.android.com/topic/performance/app-optimization/enable-app-optimization) because `stagehand-java-core` is published with a [configuration file](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/resources/META-INF/proguard/stagehand-java-core.pro) containing [keep rules](https://www.guardsquare.com/manual/configuration/usage).
+
+ProGuard and R8 should automatically detect and use the published rules, but you can also manually copy the keep rules if necessary.
+
+## Jackson
+
+The SDK depends on [Jackson](https://github.com/FasterXML/jackson) for JSON serialization/deserialization. It is compatible with version 2.13.4 or higher, but depends on version 2.18.2 by default.
+
+The SDK throws an exception if it detects an incompatible Jackson version at runtime (e.g. if the default version was overridden in your Maven or Gradle config).
+
+If the SDK threw an exception, but you're _certain_ the version is compatible, then disable the version check using the `checkJacksonVersionCompatibility` on [`StagehandOkHttpClient`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-client-okhttp/src/main/kotlin/com/browserbase/api/client/okhttp/StagehandOkHttpClient.kt) or [`StagehandOkHttpClientAsync`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-client-okhttp/src/main/kotlin/com/browserbase/api/client/okhttp/StagehandOkHttpClientAsync.kt).
+
+> [!CAUTION]
+> We make no guarantee that the SDK works correctly when the Jackson version check is disabled.
+
+## Network options
+
+### Retries
+
+The SDK automatically retries 2 times by default, with a short exponential backoff between requests.
+
+Only the following error types are retried:
+
+- Connection errors (for example, due to a network connectivity problem)
+- 408 Request Timeout
+- 409 Conflict
+- 429 Rate Limit
+- 5xx Internal
+
+The API may also explicitly instruct the SDK to retry or not retry a request.
+
+To set a custom number of retries, configure the client using the `maxRetries` method:
+
+```java
+import com.browserbase.api.client.StagehandClient;
+import com.browserbase.api.client.okhttp.StagehandOkHttpClient;
+
+StagehandClient client = StagehandOkHttpClient.builder()
+    .fromEnv()
+    .maxRetries(4)
+    .build();
+```
+
+### Timeouts
+
+Requests time out after 1 minute by default.
+
+To set a custom timeout, configure the method call using the `timeout` method:
+
+```java
+import com.browserbase.api.models.sessions.SessionStartResponse;
+
+SessionStartResponse response = client.sessions().start(
+  params, RequestOptions.builder().timeout(Duration.ofSeconds(30)).build()
+);
+```
+
+Or configure the default for all method calls at the client level:
+
+```java
+import com.browserbase.api.client.StagehandClient;
+import com.browserbase.api.client.okhttp.StagehandOkHttpClient;
+import java.time.Duration;
+
+StagehandClient client = StagehandOkHttpClient.builder()
+    .fromEnv()
+    .timeout(Duration.ofSeconds(30))
+    .build();
+```
+
+### Proxies
+
+To route requests through a proxy, configure the client using the `proxy` method:
+
+```java
+import com.browserbase.api.client.StagehandClient;
+import com.browserbase.api.client.okhttp.StagehandOkHttpClient;
+import java.net.InetSocketAddress;
+import java.net.Proxy;
+
+StagehandClient client = StagehandOkHttpClient.builder()
+    .fromEnv()
+    .proxy(new Proxy(
+      Proxy.Type.HTTP, new InetSocketAddress(
+        "https://example.com", 8080
+      )
+    ))
+    .build();
+```
+
+### HTTPS
+
+> [!NOTE]
+> Most applications should not call these methods, and instead use the system defaults. The defaults include
+> special optimizations that can be lost if the implementations are modified.
+
+To configure how HTTPS connections are secured, configure the client using the `sslSocketFactory`, `trustManager`, and `hostnameVerifier` methods:
+
+```java
+import com.browserbase.api.client.StagehandClient;
+import com.browserbase.api.client.okhttp.StagehandOkHttpClient;
+
+StagehandClient client = StagehandOkHttpClient.builder()
+    .fromEnv()
+    // If `sslSocketFactory` is set, then `trustManager` must be set, and vice versa.
+    .sslSocketFactory(yourSSLSocketFactory)
+    .trustManager(yourTrustManager)
+    .hostnameVerifier(yourHostnameVerifier)
+    .build();
+```
+
+### Custom HTTP client
+
+The SDK consists of three artifacts:
+
+- `stagehand-java-core`
+  - Contains core SDK logic
+  - Does not depend on [OkHttp](https://square.github.io/okhttp)
+  - Exposes [`StagehandClient`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/client/StagehandClient.kt), [`StagehandClientAsync`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/client/StagehandClientAsync.kt), [`StagehandClientImpl`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/client/StagehandClientImpl.kt), and [`StagehandClientAsyncImpl`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/client/StagehandClientAsyncImpl.kt), all of which can work with any HTTP client
+- `stagehand-java-client-okhttp`
+  - Depends on [OkHttp](https://square.github.io/okhttp)
+  - Exposes [`StagehandOkHttpClient`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-client-okhttp/src/main/kotlin/com/browserbase/api/client/okhttp/StagehandOkHttpClient.kt) and [`StagehandOkHttpClientAsync`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-client-okhttp/src/main/kotlin/com/browserbase/api/client/okhttp/StagehandOkHttpClientAsync.kt), which provide a way to construct [`StagehandClientImpl`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/client/StagehandClientImpl.kt) and [`StagehandClientAsyncImpl`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/client/StagehandClientAsyncImpl.kt), respectively, using OkHttp
+- `stagehand-java`
+  - Depends on and exposes the APIs of both `stagehand-java-core` and `stagehand-java-client-okhttp`
+  - Does not have its own logic
+
+This structure allows replacing the SDK's default HTTP client without pulling in unnecessary dependencies.
+
+#### Customized [`OkHttpClient`](https://square.github.io/okhttp/3.x/okhttp/okhttp3/OkHttpClient.html)
+
+> [!TIP]
+> Try the available [network options](#network-options) before replacing the default client.
+
+To use a customized `OkHttpClient`:
+
+1. Replace your [`stagehand-java` dependency](#installation) with `stagehand-java-core`
+2. Copy `stagehand-java-client-okhttp`'s [`OkHttpClient`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-client-okhttp/src/main/kotlin/com/browserbase/api/client/okhttp/OkHttpClient.kt) class into your code and customize it
+3. Construct [`StagehandClientImpl`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/client/StagehandClientImpl.kt) or [`StagehandClientAsyncImpl`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/client/StagehandClientAsyncImpl.kt), similarly to [`StagehandOkHttpClient`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-client-okhttp/src/main/kotlin/com/browserbase/api/client/okhttp/StagehandOkHttpClient.kt) or [`StagehandOkHttpClientAsync`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-client-okhttp/src/main/kotlin/com/browserbase/api/client/okhttp/StagehandOkHttpClientAsync.kt), using your customized client
+
+### Completely custom HTTP client
+
+To use a completely custom HTTP client:
+
+1. Replace your [`stagehand-java` dependency](#installation) with `stagehand-java-core`
+2. Write a class that implements the [`HttpClient`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/core/http/HttpClient.kt) interface
+3. Construct [`StagehandClientImpl`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/client/StagehandClientImpl.kt) or [`StagehandClientAsyncImpl`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/client/StagehandClientAsyncImpl.kt), similarly to [`StagehandOkHttpClient`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-client-okhttp/src/main/kotlin/com/browserbase/api/client/okhttp/StagehandOkHttpClient.kt) or [`StagehandOkHttpClientAsync`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-client-okhttp/src/main/kotlin/com/browserbase/api/client/okhttp/StagehandOkHttpClientAsync.kt), using your new client class
+
+## Undocumented API functionality
+
+The SDK is typed for convenient usage of the documented API. However, it also supports working with undocumented or not yet supported parts of the API.
+
+### Parameters
+
+To set undocumented parameters, call the `putAdditionalHeader`, `putAdditionalQueryParam`, or `putAdditionalBodyProperty` methods on any `Params` class:
+
+```java
+import com.browserbase.api.core.JsonValue;
+import com.browserbase.api.models.sessions.SessionActParams;
+
+SessionActParams params = SessionActParams.builder()
+    .putAdditionalHeader("Secret-Header", "42")
+    .putAdditionalQueryParam("secret_query_param", "42")
+    .putAdditionalBodyProperty("secretProperty", JsonValue.from("42"))
+    .build();
+```
+
+These can be accessed on the built object later using the `_additionalHeaders()`, `_additionalQueryParams()`, and `_additionalBodyProperties()` methods.
+
+To set undocumented parameters on _nested_ headers, query params, or body classes, call the `putAdditionalProperty` method on the nested class:
+
+```java
+import com.browserbase.api.core.JsonValue;
+import com.browserbase.api.models.sessions.SessionActParams;
+
+SessionActParams params = SessionActParams.builder()
+    .options(SessionActParams.Options.builder()
+        .putAdditionalProperty("secretProperty", JsonValue.from("42"))
+        .build())
+    .build();
+```
+
+These properties can be accessed on the nested built object later using the `_additionalProperties()` method.
+
+To set a documented parameter or property to an undocumented or not yet supported _value_, pass a [`JsonValue`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/core/Values.kt) object to its setter:
+
+```java
+import com.browserbase.api.core.JsonValue;
+import com.browserbase.api.models.sessions.SessionActParams;
+
+SessionActParams params = SessionActParams.builder()
+    .input(JsonValue.from(42))
+    .build();
+```
+
+The most straightforward way to create a [`JsonValue`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/core/Values.kt) is using its `from(...)` method:
+
+```java
+import com.browserbase.api.core.JsonValue;
+import java.util.List;
+import java.util.Map;
+
+// Create primitive JSON values
+JsonValue nullValue = JsonValue.from(null);
+JsonValue booleanValue = JsonValue.from(true);
+JsonValue numberValue = JsonValue.from(42);
+JsonValue stringValue = JsonValue.from("Hello World!");
+
+// Create a JSON array value equivalent to `["Hello", "World"]`
+JsonValue arrayValue = JsonValue.from(List.of(
+  "Hello", "World"
+));
+
+// Create a JSON object value equivalent to `{ "a": 1, "b": 2 }`
+JsonValue objectValue = JsonValue.from(Map.of(
+  "a", 1,
+  "b", 2
+));
+
+// Create an arbitrarily nested JSON equivalent to:
+// {
+//   "a": [1, 2],
+//   "b": [3, 4]
+// }
+JsonValue complexValue = JsonValue.from(Map.of(
+  "a", List.of(
+    1, 2
+  ),
+  "b", List.of(
+    3, 4
+  )
+));
+```
+
+Normally a `Builder` class's `build` method will throw [`IllegalStateException`](https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalStateException.html) if any required parameter or property is unset.
+
+To forcibly omit a required parameter or property, pass [`JsonMissing`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/core/Values.kt):
+
+```java
+import com.browserbase.api.core.JsonMissing;
+import com.browserbase.api.models.sessions.SessionActParams;
+
+SessionActParams params = SessionActParams.builder()
+    .input("Click the login button")
+    .id(JsonMissing.of())
+    .build();
+```
+
+### Response properties
+
+To access undocumented response properties, call the `_additionalProperties()` method:
+
+```java
+import com.browserbase.api.core.JsonValue;
+import java.util.Map;
+
+Map<String, JsonValue> additionalProperties = client.sessions().act(params)._additionalProperties();
+JsonValue secretPropertyValue = additionalProperties.get("secretProperty");
+
+String result = secretPropertyValue.accept(new JsonValue.Visitor<>() {
+    @Override
+    public String visitNull() {
+        return "It's null!";
+    }
+
+    @Override
+    public String visitBoolean(boolean value) {
+        return "It's a boolean!";
+    }
+
+    @Override
+    public String visitNumber(Number value) {
+        return "It's a number!";
+    }
+
+    // Other methods include `visitMissing`, `visitString`, `visitArray`, and `visitObject`
+    // The default implementation of each unimplemented method delegates to `visitDefault`, which throws by default, but can also be overridden
+});
+```
+
+To access a property's raw JSON value, which may be undocumented, call its `_` prefixed method:
+
+```java
+import com.browserbase.api.core.JsonField;
+import com.browserbase.api.models.sessions.SessionActParams;
+import java.util.Optional;
+
+JsonField<SessionActParams.Input> input = client.sessions().act(params)._input();
+
+if (input.isMissing()) {
+  // The property is absent from the JSON response
+} else if (input.isNull()) {
+  // The property was set to literal null
+} else {
+  // Check if value was provided as a string
+  // Other methods include `asNumber()`, `asBoolean()`, etc.
+  Optional<String> jsonString = input.asString();
+
+  // Try to deserialize into a custom type
+  MyClass myObject = input.asUnknown().orElseThrow().convert(MyClass.class);
+}
+```
+
+### Response validation
+
+In rare cases, the API may return a response that doesn't match the expected type. For example, the SDK may expect a property to contain a `String`, but the API could return something else.
+
+By default, the SDK will not throw an exception in this case. It will throw [`StagehandInvalidDataException`](https://github.com/browserbase/stagehand-java/blob/main/stagehand-java-core/src/main/kotlin/com/browserbase/api/errors/StagehandInvalidDataException.kt) only if you directly access the property.
+
+If you would prefer to check that the response is completely well-typed upfront, then either call `validate()`:
+
+```java
+import com.browserbase.api.models.sessions.SessionActResponse;
+
+SessionActResponse response = client.sessions().act(params).validate();
+```
+
+Or configure the method call to validate the response using the `responseValidation` method:
+
+```java
+import com.browserbase.api.models.sessions.SessionActResponse;
+
+SessionActResponse response = client.sessions().act(
+  params, RequestOptions.builder().responseValidation(true).build()
+);
+```
+
+Or configure the default for all method calls at the client level:
+
+```java
+import com.browserbase.api.client.StagehandClient;
+import com.browserbase.api.client.okhttp.StagehandOkHttpClient;
+
+StagehandClient client = StagehandOkHttpClient.builder()
+    .fromEnv()
+    .responseValidation(true)
+    .build();
+```
+
+## FAQ
+
+### Why don't you use plain `enum` classes?
+
+Java `enum` classes are not trivially [forwards compatible](https://www.stainless.com/blog/making-java-enums-forwards-compatible). Using them in the SDK could cause runtime exceptions if the API is updated to respond with a new enum value.
+
+### Why do you represent fields using `JsonField<T>` instead of just plain `T`?
+
+Using `JsonField<T>` enables a few features:
+
+- Allowing usage of [undocumented API functionality](#undocumented-api-functionality)
+- Lazily [validating the API response against the expected shape](#response-validation)
+- Representing absent vs explicitly null values
+
+### Why don't you use [`data` classes](https://kotlinlang.org/docs/data-classes.html)?
+
+It is not [backwards compatible to add new fields to a data class](https://kotlinlang.org/docs/api-guidelines-backward-compatibility.html#avoid-using-data-classes-in-your-api) and we don't want to introduce a breaking change every time we add a field to a class.
+
+### Why don't you use checked exceptions?
+
+Checked exceptions are widely considered a mistake in the Java programming language. In fact, they were omitted from Kotlin for this reason.
+
+Checked exceptions:
+
+- Are verbose to handle
+- Encourage error handling at the wrong level of abstraction, where nothing can be done about the error
+- Are tedious to propagate due to the [function coloring problem](https://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function)
+- Don't play well with lambdas (also due to the function coloring problem)
+
+## Semantic versioning
+
+This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:
+
+1. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals.)_
+2. Changes that we do not expect to impact the vast majority of users in practice.
+
+We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.
+
+We are keen for your feedback; please open an [issue](https://www.github.com/browserbase/stagehand-java/issues) with questions, bugs, or suggestions.
\ No newline at end of file
diff --git a/packages/docs/v3/sdk/python.mdx b/packages/docs/v3/sdk/python.mdx
new file mode 100644
index 000000000..96518315b
--- /dev/null
+++ b/packages/docs/v3/sdk/python.mdx
@@ -0,0 +1,551 @@
+---
+title: "Python SDK"
+description: "Official Stagehand SDK for Python"
+---
+
+<Note>
+  This documentation is automatically synced from the [Python SDK GitHub repository](https://github.com/browserbase/stagehand-python).
+</Note>
+
+<Note>
+  Migrating from the old v2 Python SDK? See our [migration guide here](/v3/migrations/python).
+</Note>
+
+## What is Stagehand?
+
+Stagehand is a browser automation framework used to control web browsers with natural language and code. By combining the power of AI with the precision of code, Stagehand makes web automation flexible, maintainable, and actually reliable.
+
+## Why Stagehand?
+
+Most existing browser automation tools either require you to write low-level code in a framework like Selenium, Playwright, or Puppeteer, or use high-level agents that can be unpredictable in production. By letting developers choose what to write in code vs. natural language (and bridging the gap between the two) Stagehand is the natural choice for browser automations in production.
+
+1. **Choose when to write code vs. natural language**: use AI when you want to navigate unfamiliar pages, and use code when you know exactly what you want to do.
+
+2. **Go from AI-driven to repeatable workflows**: Stagehand lets you preview AI actions before running them, and also helps you easily cache repeatable actions to save time and tokens.
+
+3. **Write once, run forever**: Stagehand's auto-caching combined with self-healing remembers previous actions, runs without LLM inference, and knows when to involve AI whenever the website changes and your automation breaks.
+
+## Installation
+
+```sh
+uv pip install stagehand
+```
+
+For local development or when working from this repository, sync the dependency lockfile with `uv` (see the Local development section below) before running project scripts.
+
+## Requirements
+
+Python 3.9 or higher.
+
+## Running the Example
+
+A complete working example is available at [`examples/full_example.py`](https://github.com/browserbase/stagehand-python/blob/main/examples/full_example.py).
+
+To run it, first export the required environment variables, then use Python:
+
+```bash
+export BROWSERBASE_API_KEY="your-bb-api-key"
+export BROWSERBASE_PROJECT_ID="your-bb-project-uuid"
+export MODEL_API_KEY="sk-proj-your-llm-api-key"
+
+uv run python examples/full_example.py
+```
+
+## Local mode example
+
+If you want to run Stagehand locally, use the local example (`examples/local_example.py`). It shows how to configure the client for `server="local"`.
+
+Local mode runs Stagehand’s embedded server and launches a **local Chrome/Chromium** browser (it is **not bundled** with the Python wheel), so you must have Chrome installed on the machine running the example.
+
+If Chrome is installed but Stagehand can’t find it, set `CHROME_PATH` to your browser executable (or pass `browser.launchOptions.executablePath` when starting the session).
+
+Common Windows paths:
+- `C:\Program Files\Google\Chrome\Application\chrome.exe`
+- `C:\Program Files (x86)\Google\Chrome\Application\chrome.exe`
+
+PowerShell:
+
+```powershell
+# optional if you don't already have Chrome installed
+winget install -e --id Google.Chrome
+
+# optional if Stagehand can't auto-detect Chrome
+$env:CHROME_PATH="C:\Program Files\Google\Chrome\Application\chrome.exe"
+
+uv run python examples/local_example.py
+```
+
+```bash
+uv pip install stagehand
+uv run python examples/local_example.py
+```
+
+## Streaming logging example
+
+See [`examples/logging_example.py`](https://github.com/browserbase/stagehand-python/blob/main/examples/logging_example.py) for a remote-only flow that streams `StreamEvent`s with `verbose=2`, `stream_response=True`, and `x_stream_response="true"` so you can watch the SDK’s logs as they arrive.
+
+```bash
+uv run python examples/logging_example.py
+```
+
+<details>
+<summary><strong>Local development</strong></summary>
+
+This repository relies on `uv` to install the sanctioned Python version and dependencies. After cloning, bootstrap the environment with:
+
+```sh
+./scripts/bootstrap
+```
+Once the environment is ready, execute repo scripts with `uv run`:
+
+```sh
+uv run python examples/full_example.py
+```
+</details>
+
+## Usage
+
+This example demonstrates the full Stagehand workflow: starting a session, navigating to a page, observing possible actions, acting on elements, extracting data, and running an autonomous agent.
+
+```python
+import asyncio
+
+from stagehand import AsyncStagehand
+
+async def main() -> None:
+    # Create client using environment variables:
+    # BROWSERBASE_API_KEY, BROWSERBASE_PROJECT_ID, MODEL_API_KEY
+    client = AsyncStagehand()
+
+    # Start a new browser session (returns a session helper bound to a session_id)
+    session = await client.sessions.create(model_name="openai/gpt-5-nano")
+
+    print(f"Session started: {session.id}")
+
+    try:
+        # Navigate to a webpage
+        await session.navigate(
+            url="https://news.ycombinator.com",
+        )
+        print("Navigated to Hacker News")
+
+        # Observe to find possible actions on the page
+        observe_response = await session.observe(
+            instruction="find the link to view comments for the top post",
+        )
+
+        results = observe_response.data.result
+        print(f"Found {len(results)} possible actions")
+        if not results:
+            return
+
+        # Take the first action returned by Observe and pass it to Act
+        action = results[0].to_dict(exclude_none=True)
+        print("Acting on:", action.get("description"))
+
+        act_response = await session.act(input=action)
+        print("Act completed:", act_response.data.result.message)
+
+        # Extract structured data from the page using a JSON schema
+        extract_response = await session.extract(
+            instruction="extract the text of the top comment on this page",
+            schema={
+                "type": "object",
+                "properties": {
+                    "commentText": {"type": "string"},
+                    "author": {"type": "string"},
+                },
+                "required": ["commentText"],
+            },
+        )
+
+        extracted = extract_response.data.result
+        author = extracted.get("author", "unknown") if isinstance(extracted, dict) else "unknown"
+        print("Extracted author:", author)
+
+        # Run an autonomous agent to accomplish a complex task
+        execute_response = await session.execute(
+            execute_options={
+                "instruction": f"Find any personal website, GitHub, or LinkedIn profile for the Hacker News user '{author}'.",
+                "max_steps": 10,
+            },
+            agent_config={"model": "openai/gpt-5-nano"},
+            timeout=300.0,
+        )
+
+        print("Agent completed:", execute_response.data.result.message)
+        print("Agent success:", execute_response.data.result.success)
+    finally:
+        # End the browser session to clean up resources
+        await session.end()
+        print("Session ended")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Client configuration
+
+Configure the client using environment variables:
+
+```python
+from stagehand import AsyncStagehand
+
+client = AsyncStagehand()
+```
+
+Or manually:
+
+```python
+from stagehand import AsyncStagehand
+
+client = AsyncStagehand(
+    browserbase_api_key="My Browserbase API Key",
+    browserbase_project_id="My Browserbase Project ID",
+    model_api_key="My Model API Key",
+)
+```
+
+Or using a combination of the two approaches:
+
+```python
+from stagehand import AsyncStagehand
+
+client = AsyncStagehand(
+    # Configures using environment variables
+    browserbase_api_key="My Browserbase API Key",  # override just this one
+)
+```
+
+See this table for the available options:
+
+| Keyword argument         | Environment variable     | Required | Default value                             |
+| ------------------------ | ------------------------ | -------- | ----------------------------------------- |
+| `browserbase_api_key`    | `BROWSERBASE_API_KEY`    | true     | -                                         |
+| `browserbase_project_id` | `BROWSERBASE_PROJECT_ID` | true     | -                                         |
+| `model_api_key`          | `MODEL_API_KEY`          | true     | -                                         |
+| `base_url`               | `STAGEHAND_BASE_URL`     | false    | `"https://api.stagehand.browserbase.com"` |
+
+Keyword arguments take precedence over environment variables.
+
+> [!TIP]
+> Don't create more than one client in the same application. Each client has a connection pool, which is more efficient to share between requests.
+
+### Modifying configuration
+
+To temporarily use a modified client configuration while reusing the same connection pool, call `with_options()` on any client:
+
+```python
+client_with_options = client.with_options(model_api_key="sk-your-llm-api-key-here", max_retries=42)
+```
+
+The `with_options()` method does not affect the original client.
+
+## Requests and responses
+
+To send a request to the Stagehand API, call the corresponding client method using keyword arguments.
+
+Nested request parameters are dictionaries typed using [`TypedDict`](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods like:
+
+- Serializing back into JSON: `model.to_json()`
+- Converting to a dictionary: `model.to_dict()`
+
+## Immutability
+
+Response objects are Pydantic models. If you want to build a modified copy, prefer `model.model_copy(update={...})` (Pydantic v2) rather than mutating in place.
+
+## Asynchronous execution
+
+This SDK recommends using `AsyncStagehand` and `await`ing each API call:
+
+```python
+import asyncio
+from stagehand import AsyncStagehand
+
+async def main() -> None:
+    client = AsyncStagehand()
+    session = await client.sessions.create(model_name="openai/gpt-5-nano")
+    response = await session.act(input="click the first link on the page")
+    print(response.data)
+
+asyncio.run(main())
+```
+
+### With aiohttp
+
+By default, the async client uses `httpx` for HTTP requests. For improved concurrency performance you may also use `aiohttp` as the HTTP backend.
+
+Install `aiohttp`:
+
+```sh
+uv run pip install stagehand[aiohttp]
+```
+
+Then instantiate the client with `http_client=DefaultAioHttpClient()`:
+
+```python
+import asyncio
+from stagehand import AsyncStagehand, DefaultAioHttpClient
+
+async def main() -> None:
+    async with AsyncStagehand(http_client=DefaultAioHttpClient()) as client:
+        session = await client.sessions.create(model_name="openai/gpt-5-nano")
+        response = await session.act(input="click the first link on the page")
+        print(response.data)
+
+asyncio.run(main())
+```
+
+## Streaming responses
+
+We provide support for streaming responses using Server-Sent Events (SSE).
+
+To enable SSE streaming, you must:
+
+1. Ask the server to stream by setting `x_stream_response="true"` (header), and
+2. Tell the client to parse an SSE stream by setting `stream_response=True`.
+
+```python
+import asyncio
+
+from stagehand import AsyncStagehand
+
+async def main() -> None:
+    async with AsyncStagehand() as client:
+        session = await client.sessions.create(model_name="openai/gpt-5-nano")
+
+        stream = await client.sessions.act(
+            id=session.id,
+            input="click the first link on the page",
+            stream_response=True,
+            x_stream_response="true",
+        )
+        async for event in stream:
+            # event is a StreamEvent (type: "system" | "log")
+            print(event.type, event.data)
+
+asyncio.run(main())
+```
+
+## Raw responses
+
+The SDK defines methods that deserialize responses into Pydantic models. However, these methods don't provide access to response headers, status code, or the raw response body.
+
+To access this data, prefix any HTTP method call on a client or service with `with_raw_response`:
+
+```python
+import asyncio
+
+from stagehand import AsyncStagehand
+
+async def main() -> None:
+    async with AsyncStagehand() as client:
+        response = await client.sessions.with_raw_response.start(model_name="openai/gpt-5-nano")
+        print(response.headers.get("X-My-Header"))
+
+        session = response.parse()  # get the object that `sessions.start()` would have returned
+        print(session.data)
+
+asyncio.run(main())
+```
+
+### `.with_streaming_response`
+
+The `with_raw_response` interface eagerly reads the full response body when you make the request.
+
+To stream the response body (not SSE), use `with_streaming_response` instead. It requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`.
+
+```python
+import asyncio
+
+from stagehand import AsyncStagehand
+
+async def main() -> None:
+    async with AsyncStagehand() as client:
+        async with client.sessions.with_streaming_response.start(model_name="openai/gpt-5-nano") as response:
+            print(response.headers.get("X-My-Header"))
+            async for line in response.iter_lines():
+                print(line)
+
+asyncio.run(main())
+```
+
+## Error handling
+
+When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `stagehand.APIConnectionError` is raised.
+
+When the API returns a non-success status code (that is, 4xx or 5xx response), a subclass of `stagehand.APIStatusError` is raised, containing `status_code` and `response` properties.
+
+All errors inherit from `stagehand.APIError`.
+
+```python
+import asyncio
+
+import stagehand
+from stagehand import AsyncStagehand
+
+async def main() -> None:
+    async with AsyncStagehand() as client:
+        try:
+            await client.sessions.start(model_name="openai/gpt-5-nano")
+        except stagehand.APIConnectionError as e:
+            print("The server could not be reached")
+            print(e.__cause__)  # an underlying Exception, likely raised within httpx.
+        except stagehand.RateLimitError:
+            print("A 429 status code was received; we should back off a bit.")
+        except stagehand.APIStatusError as e:
+            print("A non-200-range status code was received")
+            print(e.status_code)
+            print(e.response)
+
+asyncio.run(main())
+```
+
+Error codes are as follows:
+
+| Status Code | Error Type                 |
+| ----------- | -------------------------- |
+| 400         | `BadRequestError`          |
+| 401         | `AuthenticationError`      |
+| 403         | `PermissionDeniedError`    |
+| 404         | `NotFoundError`            |
+| 422         | `UnprocessableEntityError` |
+| 429         | `RateLimitError`           |
+| >=500       | `InternalServerError`      |
+| N/A         | `APIConnectionError`       |
+
+### Retries
+
+Certain errors are automatically retried 2 times by default, with a short exponential backoff. Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict, 429 Rate Limit, and >=500 Internal errors are all retried by default.
+
+You can use the `max_retries` option to configure or disable retry settings:
+
+```python
+import asyncio
+
+from stagehand import AsyncStagehand
+
+async def main() -> None:
+    async with AsyncStagehand(max_retries=0) as client:
+        # Or, configure per-request:
+        await client.with_options(max_retries=5).sessions.start(model_name="openai/gpt-5-nano")
+
+asyncio.run(main())
+```
+
+### Timeouts
+
+By default requests time out after 1 minute. You can configure this with a `timeout` option, which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/timeouts/#fine-tuning-the-configuration) object.
+
+On timeout, an `APITimeoutError` is thrown. Note that requests that time out are [retried twice by default](#retries).
+
+## Logging
+
+The SDK uses the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.
+
+Enable logging by setting the `STAGEHAND_LOG` environment variable to `info`:
+
+```sh
+export STAGEHAND_LOG=info
+```
+
+Or to `debug` for more verbose logging:
+
+```sh
+export STAGEHAND_LOG=debug
+```
+
+## Undocumented API functionality
+
+This library is typed for convenient access to the documented API, but you can still access undocumented endpoints, request params, or response properties when needed.
+
+### Undocumented endpoints
+
+To make requests to undocumented endpoints, use `client.get`, `client.post`, and other HTTP verbs. Client options (such as retries) are respected.
+
+```python
+import httpx
+from stagehand import AsyncStagehand
+
+import asyncio
+
+async def main() -> None:
+    async with AsyncStagehand() as client:
+        response = await client.post("/foo", cast_to=httpx.Response, body={"my_param": True})
+        print(response.headers.get("x-foo"))
+
+asyncio.run(main())
+```
+
+### Undocumented request params
+
+To send extra params that aren't available as keyword args, use `extra_query`, `extra_body`, and `extra_headers`.
+
+### Undocumented response properties
+
+To access undocumented response properties, you can access extra fields like `response.unknown_prop`. You can also get all extra fields as a dict with [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).
+
+## Response validation
+
+In rare cases, the API may return a response that doesn't match the expected type.
+
+By default, the SDK is permissive and will only raise an error if you later try to use the invalid data.
+
+If you would prefer to validate responses upfront, instantiate the client with `_strict_response_validation=True`. An `APIResponseValidationError` will be raised if the API responds with invalid data for the expected schema.
+
+```python
+import asyncio
+
+from stagehand import APIResponseValidationError, AsyncStagehand
+
+try:
+    async def main() -> None:
+        async with AsyncStagehand(_strict_response_validation=True) as client:
+            await client.sessions.start(model_name="openai/gpt-5-nano")
+
+    asyncio.run(main())
+except APIResponseValidationError as e:
+    print("Response failed schema validation:", e)
+```
+
+## FAQ
+
+### Why are some values typed as `Literal[...]` instead of Python `Enum`s?
+
+Using `Literal[...]` types is forwards compatible: the API can introduce new enum values without breaking older SDKs at runtime.
+
+### How can I tell whether `None` means `null` or “missing” in a response?
+
+In an API response, a field may be explicitly `null`, or missing entirely; in either case its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:
+
+```python
+if response.my_field is None:
+    if "my_field" not in response.model_fields_set:
+        print('Got json like {}, without a "my_field" key present at all.')
+    else:
+        print('Got json like {"my_field": null}.')
+```
+
+## Semantic versioning
+
+This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:
+
+1. Changes that only affect static types, without breaking runtime behavior.
+2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals.)_
+3. Changes that we do not expect to impact the vast majority of users in practice.
+
+We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.
+
+We are keen for your feedback; please open an [issue](https://www.github.com/browserbase/stagehand-python/issues) with questions, bugs, or suggestions.
+
+### Determining the installed version
+
+If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.
+
+You can determine the version that is being used at runtime with:
+
+```python
+import stagehand
+
+print(stagehand.__version__)
+```
\ No newline at end of file
diff --git a/packages/docs/v3/sdk/ruby.mdx b/packages/docs/v3/sdk/ruby.mdx
new file mode 100644
index 000000000..56aa268a2
--- /dev/null
+++ b/packages/docs/v3/sdk/ruby.mdx
@@ -0,0 +1,359 @@
+---
+title: "Ruby SDK"
+description: "Official Stagehand SDK for Ruby"
+---
+
+<Note>
+  This documentation is automatically synced from the [Ruby SDK GitHub repository](https://github.com/browserbase/stagehand-ruby).
+</Note>
+
+## What is Stagehand?
+
+Stagehand is a browser automation framework used to control web browsers with natural language and code. By combining the power of AI with the precision of code, Stagehand makes web automation flexible, maintainable, and actually reliable.
+
+## Why Stagehand?
+
+Most existing browser automation tools either require you to write low-level code in a framework like Selenium, Playwright, or Puppeteer, or use high-level agents that can be unpredictable in production. By letting developers choose what to write in code vs. natural language (and bridging the gap between the two) Stagehand is the natural choice for browser automations in production.
+
+1. **Choose when to write code vs. natural language**: use AI when you want to navigate unfamiliar pages, and use code when you know exactly what you want to do.
+
+2. **Go from AI-driven to repeatable workflows**: Stagehand lets you preview AI actions before running them, and also helps you easily cache repeatable actions to save time and tokens.
+
+3. **Write once, run forever**: Stagehand's auto-caching combined with self-healing remembers previous actions, runs without LLM inference, and knows when to involve AI whenever the website changes and your automation breaks.
+
+## Installation
+
+To use this gem, install via Bundler by adding the following to your application's `Gemfile`:
+
+```ruby
+gem "stagehand", "~> 0.6.2"
+```
+
+## Usage
+
+```ruby
+require "bundler/setup"
+require "stagehand"
+
+# Create a new Stagehand client with your credentials
+client = Stagehand::Client.new(
+  browserbase_api_key: ENV["BROWSERBASE_API_KEY"],      # defaults to ENV["BROWSERBASE_API_KEY"]
+  browserbase_project_id: ENV["BROWSERBASE_PROJECT_ID"], # defaults to ENV["BROWSERBASE_PROJECT_ID"]
+  model_api_key: ENV["MODEL_API_KEY"]                   # defaults to ENV["MODEL_API_KEY"]
+)
+
+# Start a new browser session
+start_response = client.sessions.start(
+  model_name: "openai/gpt-5-nano"
+)
+puts "Session started: #{start_response.data.session_id}"
+
+session_id = start_response.data.session_id
+
+# Navigate to a webpage
+client.sessions.navigate(
+  session_id,
+  url: "https://news.ycombinator.com"
+)
+puts "Navigated to Hacker News"
+
+# Use Observe to find possible actions on the page
+observe_response = client.sessions.observe(
+  session_id,
+  instruction: "find the link to view comments for the top post"
+)
+
+actions = observe_response.data.result
+puts "Found #{actions.length} possible actions"
+
+# Take the first action returned by Observe
+action = actions.first
+puts "Acting on: #{action.description}"
+
+# Pass the structured action to Act
+# Convert the observe result to a hash and ensure method is set to "click"
+act_response = client.sessions.act(
+  session_id,
+  input: action.to_h.merge(method: "click")
+)
+puts "Act completed: #{act_response.data.result[:message]}"
+
+# Extract data from the page
+# We're now on the comments page, so extract the top comment text
+extract_response = client.sessions.extract(
+  session_id,
+  instruction: "extract the text of the top comment on this page",
+  schema: {
+    type: "object",
+    properties: {
+      comment_text: {
+        type: "string",
+        description: "The text content of the top comment"
+      },
+      author: {
+        type: "string",
+        description: "The username of the comment author"
+      }
+    },
+    required: ["comment_text"]
+  }
+)
+puts "Extracted data: #{extract_response.data.result}"
+
+# Get the author from the extracted data
+extracted_data = extract_response.data.result
+author = extracted_data[:author]
+puts "Looking up profile for author: #{author}"
+
+# Use the Agent to find the author's profile
+# Execute runs an autonomous agent that can navigate and interact with pages
+execute_response = client.sessions.execute(
+  session_id,
+  execute_options: {
+    instruction: "Find any personal website, GitHub, LinkedIn, or other best profile URL for the Hacker News user '#{author}'. " \
+                 "Click on their username to go to their profile page and look for any links they have shared.",
+    max_steps: 15
+  },
+  agent_config: {
+    model: Stagehand::ModelConfig::ModelConfigObject.new(
+      model_name: "openai/gpt-5-nano",
+      api_key: ENV["MODEL_API_KEY"]
+    ),
+    cua: false
+  }
+)
+puts "Agent completed: #{execute_response.data.result[:message]}"
+puts "Agent success: #{execute_response.data.result[:success]}"
+puts "Agent actions taken: #{execute_response.data.result[:actions]&.length || 0}"
+
+# End the session to cleanup browser resources
+client.sessions.end_(session_id)
+puts "Session ended"
+```
+
+### Running the Example
+
+Set the required environment variables and run the example script:
+
+```bash
+# Set your credentials
+export BROWSERBASE_API_KEY="your-browserbase-api-key"
+export BROWSERBASE_PROJECT_ID="your-browserbase-project-id"
+export MODEL_API_KEY="your-openai-api-key"
+
+# Install dependencies and run
+bundle install
+bundle exec ruby examples/basic.rb
+```
+
+### Streaming
+
+We provide support for streaming responses using Server-Sent Events (SSE).
+
+```ruby
+stream = stagehand.sessions.act_streaming(
+  "00000000-your-session-id-000000000000",
+  input: "click the first link on the page"
+)
+
+stream.each do |session|
+  puts(session.data)
+end
+```
+
+### Handling errors
+
+When the library is unable to connect to the API, or if the API returns a non-success status code (i.e., 4xx or 5xx response), a subclass of `Stagehand::Errors::APIError` will be thrown:
+
+```ruby
+begin
+  session = stagehand.sessions.start(model_name: "openai/gpt-5-nano")
+rescue Stagehand::Errors::APIConnectionError => e
+  puts("The server could not be reached")
+  puts(e.cause)  # an underlying Exception, likely raised within `net/http`
+rescue Stagehand::Errors::RateLimitError => e
+  puts("A 429 status code was received; we should back off a bit.")
+rescue Stagehand::Errors::APIStatusError => e
+  puts("Another non-200-range status code was received")
+  puts(e.status)
+end
+```
+
+Error codes are as follows:
+
+| Cause            | Error Type                 |
+| ---------------- | -------------------------- |
+| HTTP 400         | `BadRequestError`          |
+| HTTP 401         | `AuthenticationError`      |
+| HTTP 403         | `PermissionDeniedError`    |
+| HTTP 404         | `NotFoundError`            |
+| HTTP 409         | `ConflictError`            |
+| HTTP 422         | `UnprocessableEntityError` |
+| HTTP 429         | `RateLimitError`           |
+| HTTP >= 500      | `InternalServerError`      |
+| Other HTTP error | `APIStatusError`           |
+| Timeout          | `APITimeoutError`          |
+| Network error    | `APIConnectionError`       |
+
+### Retries
+
+Certain errors will be automatically retried 2 times by default, with a short exponential backoff.
+
+Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict, 429 Rate Limit, >=500 Internal errors, and timeouts will all be retried by default.
+
+You can use the `max_retries` option to configure or disable this:
+
+```ruby
+# Configure the default for all requests:
+stagehand = Stagehand::Client.new(
+  max_retries: 0 # default is 2
+)
+
+# Or, configure per-request:
+stagehand.sessions.start(model_name: "openai/gpt-5-nano", request_options: {max_retries: 5})
+```
+
+### Timeouts
+
+By default, requests will time out after 60 seconds. You can use the timeout option to configure or disable this:
+
+```ruby
+# Configure the default for all requests:
+stagehand = Stagehand::Client.new(
+  timeout: nil # default is 60
+)
+
+# Or, configure per-request:
+stagehand.sessions.start(model_name: "openai/gpt-5-nano", request_options: {timeout: 5})
+```
+
+On timeout, `Stagehand::Errors::APITimeoutError` is raised.
+
+Note that requests that time out are retried by default.
+
+## Advanced concepts
+
+### BaseModel
+
+All parameter and response objects inherit from `Stagehand::Internal::Type::BaseModel`, which provides several conveniences, including:
+
+1. All fields, including unknown ones, are accessible with `obj[:prop]` syntax, and can be destructured with `obj => {prop: prop}` or pattern-matching syntax.
+
+2. Structural equivalence for equality; if two API calls return the same values, comparing the responses with == will return true.
+
+3. Both instances and the classes themselves can be pretty-printed.
+
+4. Helpers such as `#to_h`, `#deep_to_h`, `#to_json`, and `#to_yaml`.
+
+### Making custom or undocumented requests
+
+#### Undocumented properties
+
+You can send undocumented parameters to any endpoint, and read undocumented response properties, like so:
+
+Note: the `extra_` parameters of the same name overrides the documented parameters.
+
+```ruby
+response =
+  stagehand.sessions.start(
+    model_name: "openai/gpt-5-nano",
+    request_options: {
+      extra_query: {my_query_parameter: value},
+      extra_body: {my_body_parameter: value},
+      extra_headers: {"my-header": value}
+    }
+  )
+
+puts(response[:my_undocumented_property])
+```
+
+#### Undocumented request params
+
+If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` under the `request_options:` parameter when making a request, as seen in the examples above.
+
+#### Undocumented endpoints
+
+To make requests to undocumented endpoints while retaining the benefit of auth, retries, and so on, you can make requests using `client.request`, like so:
+
+```ruby
+response = client.request(
+  method: :post,
+  path: '/undocumented/endpoint',
+  query: {"dog": "woof"},
+  headers: {"useful-header": "interesting-value"},
+  body: {"hello": "world"}
+)
+```
+
+### Concurrency & connection pooling
+
+The `Stagehand::Client` instances are threadsafe, but are only are fork-safe when there are no in-flight HTTP requests.
+
+Each instance of `Stagehand::Client` has its own HTTP connection pool with a default size of 99. As such, we recommend instantiating the client once per application in most settings.
+
+When all available connections from the pool are checked out, requests wait for a new connection to become available, with queue time counting towards the request timeout.
+
+Unless otherwise specified, other classes in the SDK do not have locks protecting their underlying data structure.
+
+## Sorbet
+
+This library provides comprehensive [RBI](https://sorbet.org/docs/rbi) definitions, and has no dependency on sorbet-runtime.
+
+You can provide typesafe request parameters like so:
+
+```ruby
+stagehand.sessions.act("00000000-your-session-id-000000000000", input: "click the first link on the page")
+```
+
+Or, equivalently:
+
+```ruby
+# Hashes work, but are not typesafe:
+stagehand.sessions.act("00000000-your-session-id-000000000000", input: "click the first link on the page")
+
+# You can also splat a full Params class:
+params = Stagehand::SessionActParams.new(input: "click the first link on the page")
+stagehand.sessions.act("00000000-your-session-id-000000000000", **params)
+```
+
+### Enums
+
+Since this library does not depend on `sorbet-runtime`, it cannot provide [`T::Enum`](https://sorbet.org/docs/tenum) instances. Instead, we provide "tagged symbols" instead, which is always a primitive at runtime:
+
+```ruby
+# :typescript
+puts(Stagehand::SessionActParams::XLanguage::TYPESCRIPT)
+
+# Revealed type: `T.all(Stagehand::SessionActParams::XLanguage, Symbol)`
+T.reveal_type(Stagehand::SessionActParams::XLanguage::TYPESCRIPT)
+```
+
+Enum parameters have a "relaxed" type, so you can either pass in enum constants or their literal value:
+
+```ruby
+# Using the enum constants preserves the tagged type information:
+stagehand.sessions.act(
+  x_language: Stagehand::SessionActParams::XLanguage::TYPESCRIPT,
+  # …
+)
+
+# Literal values are also permissible:
+stagehand.sessions.act(
+  x_language: :typescript,
+  # …
+)
+```
+
+## Versioning
+
+This package follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions. As the library is in initial development and has a major version of `0`, APIs may change at any time.
+
+This package considers improvements to the (non-runtime) `*.rbi` and `*.rbs` type definitions to be non-breaking changes.
+
+## Requirements
+
+Ruby 3.2.0 or higher.
+
+## Contributing
+
+See [the contributing documentation](https://github.com/browserbase/stagehand-ruby/tree/main/CONTRIBUTING.md).
\ No newline at end of file
diff --git a/packages/evals/CHANGELOG.md b/packages/evals/CHANGELOG.md
new file mode 100644
index 000000000..da8fa848d
--- /dev/null
+++ b/packages/evals/CHANGELOG.md
@@ -0,0 +1,126 @@
+# @browserbasehq/stagehand-evals
+
+## 1.1.8
+
+### Patch Changes
+
+- Updated dependencies [[`7584f3e`](https://github.com/browserbase/stagehand/commit/7584f3e92e60a557d2b3e0e0d2a2af04c3527523), [`1e1c9c1`](https://github.com/browserbase/stagehand/commit/1e1c9c15773e49d5c3cd36021dbc1d23495c1bce), [`6bef890`](https://github.com/browserbase/stagehand/commit/6bef89090ebd231e77d8092b2c32a0f06303d5a9), [`ffd4b33`](https://github.com/browserbase/stagehand/commit/ffd4b335a873d0f4dcd76ea22d44f47919bf8e49), [`677bff5`](https://github.com/browserbase/stagehand/commit/677bff5834c879a2d95f7dbff918b8e1510516b3), [`65ff464`](https://github.com/browserbase/stagehand/commit/65ff464bc13388eb109eba0a2cf533c1cc202854), [`101bcf2`](https://github.com/browserbase/stagehand/commit/101bcf2da8b527fd6ace6aa291ada5d0f2d90344), [`0a94301`](https://github.com/browserbase/stagehand/commit/0a94301caa991d1aa4cdade6e28a065b1aefb3e2), [`b27c04d`](https://github.com/browserbase/stagehand/commit/b27c04d278c290364347acd0c354a878ea9b7c2d), [`afbd08b`](https://github.com/browserbase/stagehand/commit/afbd08bb6367a9c9f65f67e453667987e4659918), [`e3db9aa`](https://github.com/browserbase/stagehand/commit/e3db9aa863f44270792215801fe6e3a02a1321aa), [`0e8d569`](https://github.com/browserbase/stagehand/commit/0e8d5695f662040f7384e64f46301152802e3c62), [`ff0f979`](https://github.com/browserbase/stagehand/commit/ff0f9795f3b2c1cf4f2610a80ebcb3341a24f987), [`2d89d2b`](https://github.com/browserbase/stagehand/commit/2d89d2b35ce812431956b28e0c8b52d32ddc7a27), [`aac9a19`](https://github.com/browserbase/stagehand/commit/aac9a19bdfbe62e4508631337ab0bfbcf8ae62b2), [`06de50f`](https://github.com/browserbase/stagehand/commit/06de50ff377fd31f1b0fcf79adb996d04562d2c0), [`aa4d981`](https://github.com/browserbase/stagehand/commit/aa4d981e440bdd0e3d3f42ccc310d5958aa25cc6), [`18b1e3b`](https://github.com/browserbase/stagehand/commit/18b1e3bd2b16b721845d52fcf1a45c6158e2403f), [`957d82b`](https://github.com/browserbase/stagehand/commit/957d82b9845b4413b123539e81a2e4a490e74a8a), [`b65756e`](https://github.com/browserbase/stagehand/commit/b65756e9e85643055446aa4a51956f7d6627c89f), [`22e371a`](https://github.com/browserbase/stagehand/commit/22e371ae4c25deb6350328fe02832bf2b2197b94), [`d29b91f`](https://github.com/browserbase/stagehand/commit/d29b91fa506636ca36f724fcf106320de54ec3f3), [`7b4f817`](https://github.com/browserbase/stagehand/commit/7b4f817cafb9829ac81c4b5890c318c7f9521fe4), [`176d420`](https://github.com/browserbase/stagehand/commit/176d42002cc0a2c7d13b4c0ffbbd56b70fdc49e8), [`3f9ca4d`](https://github.com/browserbase/stagehand/commit/3f9ca4d9acc109101357378d29cf969168991608), [`8a3c066`](https://github.com/browserbase/stagehand/commit/8a3c06600a9ba98485db7e9ed5c3cc43ea180334), [`49ead1e`](https://github.com/browserbase/stagehand/commit/49ead1e1e8678a8da0f87ad2042491dacc6b01d7), [`3673369`](https://github.com/browserbase/stagehand/commit/36733691f90c15386cf2a7b47d04ef429b7195ae), [`c465e87`](https://github.com/browserbase/stagehand/commit/c465e87ab41942435132c76338518fb3fa8e7896), [`ae533e4`](https://github.com/browserbase/stagehand/commit/ae533e40195181b53833f8055b1259fb360a927b), [`ea33052`](https://github.com/browserbase/stagehand/commit/ea330520a325583b71b87d85beb740df4bdb9b2d), [`5764ede`](https://github.com/browserbase/stagehand/commit/5764edee7aab00ef1aafafb68fc56eb26c0a70b2), [`f09b184`](https://github.com/browserbase/stagehand/commit/f09b184cc5e774736280ae8c94ba3f4f13adda80), [`a7d29de`](https://github.com/browserbase/stagehand/commit/a7d29decee0f7d12e2437267b9eef1795d3b4e3a), [`d334399`](https://github.com/browserbase/stagehand/commit/d3343990041bf9cd5613569840afb0c17131e33c), [`44416da`](https://github.com/browserbase/stagehand/commit/44416da7ff33301bb32d3811e6c3be8782a7d168), [`bdd8b4e`](https://github.com/browserbase/stagehand/commit/bdd8b4ee3c697a02728375510ab7fae764990576)]:
+  - @browserbasehq/stagehand@3.1.0
+
+## 1.1.7
+
+### Patch Changes
+
+- Updated dependencies [[`40ce5cc`](https://github.com/browserbase/stagehand/commit/40ce5cc83ec758f4e8c37132a7f4ac8eeea7ca34), [`5506f41`](https://github.com/browserbase/stagehand/commit/5506f416d2609d112b553263984e21d7a30e32b1), [`84c05ca`](https://github.com/browserbase/stagehand/commit/84c05ca8de4587181faf128e5c7464fd960caacc), [`692ffa0`](https://github.com/browserbase/stagehand/commit/692ffa0346ad3d121686aba503c0a22844293efa), [`1ef8901`](https://github.com/browserbase/stagehand/commit/1ef8901e1314e90f43b36be20192e652d3b5598f), [`72ac775`](https://github.com/browserbase/stagehand/commit/72ac775a831d6f0f376ceda4426525f93cc21452), [`3d5af07`](https://github.com/browserbase/stagehand/commit/3d5af07f66d6d26d1f5ac4bd9be7183c3381dd92), [`40e1d80`](https://github.com/browserbase/stagehand/commit/40e1d80776b9216422a25a81070ccb3105e56ec2), [`56c0d24`](https://github.com/browserbase/stagehand/commit/56c0d244f9b2431218bfa832ddfc0587930ae038), [`16d72fb`](https://github.com/browserbase/stagehand/commit/16d72fb4c4081dd33bf45605d75c27644ea4c00e), [`088c4cc`](https://github.com/browserbase/stagehand/commit/088c4cc31dc924bb232a9d5a09ab42cd961c2d36), [`4276f4a`](https://github.com/browserbase/stagehand/commit/4276f4abc8bbde215faac6c0321bf243484c376b), [`6005786`](https://github.com/browserbase/stagehand/commit/600578637e65f6fd18b0cdb322b9e0b857708b2f), [`6fbf5fc`](https://github.com/browserbase/stagehand/commit/6fbf5fc811e5e5d9d22f10c5309fbd336892263a), [`704cf18`](https://github.com/browserbase/stagehand/commit/704cf18cb2bdd187ba06c35f05ccb47317a7668c), [`091296e`](https://github.com/browserbase/stagehand/commit/091296e438bb2374c8bb10ef6c08283978145ebf), [`e56c6eb`](https://github.com/browserbase/stagehand/commit/e56c6eb139bf3aad37e98b16626fff13a6c671d0), [`2cb78d0`](https://github.com/browserbase/stagehand/commit/2cb78d0f5ddef9f7337a9a2fe3137f1421df700a), [`5dad639`](https://github.com/browserbase/stagehand/commit/5dad63938f08d968d434bb1ee2804f1e54fb836a), [`b7c2571`](https://github.com/browserbase/stagehand/commit/b7c2571ad4ac563f3ca0518e1f29a40da93e33bc), [`4c69117`](https://github.com/browserbase/stagehand/commit/4c6911748953199dc9aad3eabe98bcf325f871e4)]:
+  - @browserbasehq/stagehand@3.0.8
+
+## 1.1.6
+
+### Patch Changes
+
+- [#1373](https://github.com/browserbase/stagehand/pull/1373) [`cadd192`](https://github.com/browserbase/stagehand/commit/cadd192066c8aa5d19bb4d5daa630ed5981b5d7e) Thanks [@tkattkat](https://github.com/tkattkat)! - Update screenshot collector in agent evals cli
+
+- Updated dependencies [[`0f3991e`](https://github.com/browserbase/stagehand/commit/0f3991eedc0aaff72ef718dda3ddb0839cf4a464), [`e0e22e0`](https://github.com/browserbase/stagehand/commit/e0e22e06bc752a8ffde30f3dbfa58d91e24e6c09), [`f261051`](https://github.com/browserbase/stagehand/commit/f2610517d74774374de9ee93191e663439ef55e5), [`e021674`](https://github.com/browserbase/stagehand/commit/e021674f9641c1c5f9d0c1817c3fdf599eea124d), [`6a5496f`](https://github.com/browserbase/stagehand/commit/6a5496f17dbb716be1ee1aaa4e5ba9d8c723b30b), [`fea1700`](https://github.com/browserbase/stagehand/commit/fea1700552af3319052f463685752501c8e71de3), [`5b288d9`](https://github.com/browserbase/stagehand/commit/5b288d9ac37406ff22460ac8050bea26b87a378e), [`e822f5a`](https://github.com/browserbase/stagehand/commit/e822f5a8898df9eb48ca32c321025f0c74b638f0), [`638efc7`](https://github.com/browserbase/stagehand/commit/638efc7fea401bc43dd05dceedf4c13a3495a728), [`a890f16`](https://github.com/browserbase/stagehand/commit/a890f16fa3a752f308f858e5ab9c9a0faf6b3b34), [`934f492`](https://github.com/browserbase/stagehand/commit/934f492ec587bef81f0ce75b45a35b44ab545712), [`bd2db92`](https://github.com/browserbase/stagehand/commit/bd2db925f66a826d61d58be1611d55646cbdb560), [`51e0170`](https://github.com/browserbase/stagehand/commit/51e01709ce1c947c1947b4e2cb0b1f4f97b77182), [`05f5580`](https://github.com/browserbase/stagehand/commit/05f5580937c3c157550e3c25ae6671f44f562211), [`f56a9c2`](https://github.com/browserbase/stagehand/commit/f56a9c296d4ddce25a405358c66837f8ce4d679f), [`b40ae11`](https://github.com/browserbase/stagehand/commit/b40ae11391af49c3581fce27faa1b7483fc4a169), [`0d2b398`](https://github.com/browserbase/stagehand/commit/0d2b398cd40b32a9ecaf28ede70853036b7c91bd), [`cd01f29`](https://github.com/browserbase/stagehand/commit/cd01f290578eac703521f801ba3712f5332918f3), [`a734fca`](https://github.com/browserbase/stagehand/commit/a734fca0b4573753767d3ebc48ec414baf4f23e1), [`b342acf`](https://github.com/browserbase/stagehand/commit/b342acfaae058127fb57664644c5fd965db02bf2), [`2987cd1`](https://github.com/browserbase/stagehand/commit/2987cd1e5ffabefa9411936609635d4a638faed5), [`dfab1d5`](https://github.com/browserbase/stagehand/commit/dfab1d566299c8c5a63f20565a6da07dc8f61ccd), [`4d71162`](https://github.com/browserbase/stagehand/commit/4d71162beb119635b69b17637564a2bbd0e373e7)]:
+  - @browserbasehq/stagehand@3.0.7
+
+## 1.1.5
+
+### Patch Changes
+
+- [#1364](https://github.com/browserbase/stagehand/pull/1364) [`ca0630e`](https://github.com/browserbase/stagehand/commit/ca0630e4d96bf86708b9ff202ad8da0d0761bda8) Thanks [@tkattkat](https://github.com/tkattkat)! - Update model handling in agent evals cli
+
+- Updated dependencies [[`605ed6b`](https://github.com/browserbase/stagehand/commit/605ed6b81a3ff8f25d4022f1e5fce6b42aecfc19), [`34e7e5b`](https://github.com/browserbase/stagehand/commit/34e7e5b292f5e6af6efc0da60118663310c5f718), [`943d2d7`](https://github.com/browserbase/stagehand/commit/943d2d79d0f289ac41c9164578f2f1dd876058f2), [`0e95cd2`](https://github.com/browserbase/stagehand/commit/0e95cd2f67672f64f0017024fd47d8b3aef59a95), [`d4237e4`](https://github.com/browserbase/stagehand/commit/d4237e40951ecd10abfdbe766672d498f8806484), [`86975e7`](https://github.com/browserbase/stagehand/commit/86975e795db7505804949a267b20509bd16b5256), [`d5e119b`](https://github.com/browserbase/stagehand/commit/d5e119be5eec84915a79f8d611b6ba0546f48c99), [`4e051b2`](https://github.com/browserbase/stagehand/commit/4e051b23add7ae276b0dbead38b4587838cfc1c1), [`6b5a3c9`](https://github.com/browserbase/stagehand/commit/6b5a3c9035654caaed2da375085b465edda97de4), [`bb85ad9`](https://github.com/browserbase/stagehand/commit/bb85ad912738623a7a866f0cb6e8d5807c6c2738), [`88d28cc`](https://github.com/browserbase/stagehand/commit/88d28cc6f31058d1cf6ec6dc948a4ae77a926b3c), [`45bcef0`](https://github.com/browserbase/stagehand/commit/45bcef0e5788b083f9e38dfd7c3bc63afcd4b6dd), [`6aa9d45`](https://github.com/browserbase/stagehand/commit/6aa9d455aa5836ec2ee8ab2e8b9df3fb218e5381), [`d382084`](https://github.com/browserbase/stagehand/commit/d382084745fff98c3e71413371466394a2625429), [`1df08cc`](https://github.com/browserbase/stagehand/commit/1df08ccb0a2cf73b5c37a91c129721114ff6371c), [`2b56600`](https://github.com/browserbase/stagehand/commit/2b566009606fcbba987260f21b075b318690ce99)]:
+  - @browserbasehq/stagehand@3.0.6
+
+## 1.1.4
+
+### Patch Changes
+
+- Updated dependencies [[`fa18cfd`](https://github.com/browserbase/stagehand/commit/fa18cfdc45f28e35e6566587b54612396e6ece45), [`767d168`](https://github.com/browserbase/stagehand/commit/767d1686285cf9c57675595f553f8a891f13c63b), [`f27a99c`](https://github.com/browserbase/stagehand/commit/f27a99c11b020b33736fe67af8f7f0e663c6f45f), [`91a1ca0`](https://github.com/browserbase/stagehand/commit/91a1ca07d9178c46269bfb951abb20a215eb7c29), [`1dd7d43`](https://github.com/browserbase/stagehand/commit/1dd7d4330de9022dc6cd45a8b5c86cb9e1b575ec), [`c0f3b98`](https://github.com/browserbase/stagehand/commit/c0f3b98277c15c77b2b4c3f55503e61ef3d27cf3), [`44bb4f5`](https://github.com/browserbase/stagehand/commit/44bb4f51dcccbdca8df07e4d7f8d28a7e6e793ec), [`2b70347`](https://github.com/browserbase/stagehand/commit/2b7034771bc6d6b1fabb13deaa56c299881b3728)]:
+  - @browserbasehq/stagehand@3.0.4
+
+## 1.1.3
+
+### Patch Changes
+
+- Updated dependencies [[`ab51232`](https://github.com/browserbase/stagehand/commit/ab51232db428be048957c0f5d67f2176eb7a5194), [`c76ade0`](https://github.com/browserbase/stagehand/commit/c76ade009ef81208accae6475ec4707d3906e566), [`ffb5e5d`](https://github.com/browserbase/stagehand/commit/ffb5e5d2ab49adcb2efdfc9e5c76e8c96268b5b3), [`772e735`](https://github.com/browserbase/stagehand/commit/772e73543e45106d7fa0fafd95ade46ae11023bc)]:
+  - @browserbasehq/stagehand@3.0.3
+
+## 1.1.2
+
+### Patch Changes
+
+- Updated dependencies [[`a224b33`](https://github.com/browserbase/stagehand/commit/a224b3371b6c1470baf342742fb745c7192b52c6), [`6fc9de2`](https://github.com/browserbase/stagehand/commit/6fc9de2a1079e4f2fb0b1633d8df0bb7a9f7f89f), [`4935be7`](https://github.com/browserbase/stagehand/commit/4935be788b3431527f3d110864c0fd7060cfaf7c), [`bdd76fc`](https://github.com/browserbase/stagehand/commit/bdd76fcd1e48079fc5ab8cf040ebb5997dfc6c99), [`7ea18a4`](https://github.com/browserbase/stagehand/commit/7ea18a420fc033d1b72556db83a1f41735e5a022), [`d4de014`](https://github.com/browserbase/stagehand/commit/d4de014235a18f9e1089240bc72e28cbfe77ca1c), [`2d1b573`](https://github.com/browserbase/stagehand/commit/2d1b5732dc441a3331f5743cdfed3e1037d8b3b5), [`5556041`](https://github.com/browserbase/stagehand/commit/5556041e2deaed5012363303fd7a8ac00e3242cd), [`7e4b43e`](https://github.com/browserbase/stagehand/commit/7e4b43ed46fbdd2074827e87d9a245e2dc96456b), [`7e72adf`](https://github.com/browserbase/stagehand/commit/7e72adfd7e4af5ec49ac2f552e7f1f57c1acc554), [`9bf09d0`](https://github.com/browserbase/stagehand/commit/9bf09d041111870d71cb9ffcb3ac5fa2c4b1399d), [`92d32ea`](https://github.com/browserbase/stagehand/commit/92d32eafe91a4241615cc65501b8461c6074a02b), [`ebcf3a1`](https://github.com/browserbase/stagehand/commit/ebcf3a1ffa859374d71de4931c6a9b982a565e46), [`c29a4f2`](https://github.com/browserbase/stagehand/commit/c29a4f2eca91ae2902ed9d48b2385b4436f7b664), [`6d21efa`](https://github.com/browserbase/stagehand/commit/6d21efa8b30317aa3ce3e37ac6c2222af3b967b5), [`525ef0c`](https://github.com/browserbase/stagehand/commit/525ef0c1243aaf3452ee7e4ea81b4208f4c2efd1), [`9ddb872`](https://github.com/browserbase/stagehand/commit/9ddb872e350358214e12a91cf6a614fd2ec1f74c)]:
+  - @browserbasehq/stagehand@3.0.2
+
+## 1.1.1
+
+### Patch Changes
+
+- Updated dependencies [[`55da8c6`](https://github.com/browserbase/stagehand/commit/55da8c6e9575cbad3246c55b17650cf6b293ddbe), [`0a5ee63`](https://github.com/browserbase/stagehand/commit/0a5ee638bde051d109eb2266e665934a12f3dc31), [`ee76881`](https://github.com/browserbase/stagehand/commit/ee7688156cb67a9f0f90dfe0dbab77423693a332), [`9e95add`](https://github.com/browserbase/stagehand/commit/9e95add37eb30db4f85e73df7760c7e63fb4131e), [`98e212b`](https://github.com/browserbase/stagehand/commit/98e212b27887241879608c6c1b6c2524477a40d7), [`d5ecbfc`](https://github.com/browserbase/stagehand/commit/d5ecbfc8e419a59b91c2115fd7f984378381d3d0)]:
+  - @browserbasehq/stagehand@3.0.1
+
+## 1.0.9
+
+### Patch Changes
+
+- Updated dependencies [[`09b5e1e`](https://github.com/browserbase/stagehand/commit/09b5e1e9c23c845903686db6665cc968ac34efbb), [`e3734b9`](https://github.com/browserbase/stagehand/commit/e3734b9c98352d5f0a4eca49791b0bbf2130ab41), [`8244ab2`](https://github.com/browserbase/stagehand/commit/8244ab247cd679962685ae2f7c54e874ce1fa614), [`be85b19`](https://github.com/browserbase/stagehand/commit/be85b19679a826f19702e00f0aae72fce1118ec8), [`88d1565`](https://github.com/browserbase/stagehand/commit/88d1565c65bb65a104fea2d5f5e862bbbda69677), [`ab5d6ed`](https://github.com/browserbase/stagehand/commit/ab5d6ede19aabc059badc4247f1cb2c6c9e71bae)]:
+  - @browserbasehq/stagehand@2.5.0
+
+## 1.0.8
+
+### Patch Changes
+
+- Updated dependencies [[`9e8c173`](https://github.com/browserbase/stagehand/commit/9e8c17374fdc8fbe7f26e6cf802c36bd14f11039)]:
+  - @browserbasehq/stagehand@2.4.4
+
+## 1.0.7
+
+### Patch Changes
+
+- Updated dependencies [[`f45afdc`](https://github.com/browserbase/stagehand/commit/f45afdccc8680650755fee66ffbeac32b41e075d), [`261bba4`](https://github.com/browserbase/stagehand/commit/261bba43fa79ac3af95328e673ef3e9fced3279b), [`8de7bd8`](https://github.com/browserbase/stagehand/commit/8de7bd8635c2051cd8025e365c6c8aa83d81c7e7), [`3d80421`](https://github.com/browserbase/stagehand/commit/3d804210a106a6828c7fa50f8b765b10afd4cc6a), [`0ead63d`](https://github.com/browserbase/stagehand/commit/0ead63d6526f6c286362b74b6407c8bebc900e69), [`8422828`](https://github.com/browserbase/stagehand/commit/8422828c4cd5fd5ebcf348cfbdb40c768bb76dd9), [`b769206`](https://github.com/browserbase/stagehand/commit/b7692060f98a2f49aeeefb90d8789ed034b08ec2), [`72d2683`](https://github.com/browserbase/stagehand/commit/72d2683202af7e578d98367893964b33e0828de5)]:
+  - @browserbasehq/stagehand@2.4.3
+
+## 1.0.6
+
+### Patch Changes
+
+- Updated dependencies [[`6b4e6e3`](https://github.com/browserbase/stagehand/commit/6b4e6e3f31d5496cf15728e9018eddeb04839542), [`e77d018`](https://github.com/browserbase/stagehand/commit/e77d0188683ebf596dfb78dfafbbca1dc32993f0), [`c20adb9`](https://github.com/browserbase/stagehand/commit/c20adb95539fed8c56a4aa413262a9c65a8e6474), [`b86df93`](https://github.com/browserbase/stagehand/commit/b86df93b9136aae96292121a29c25f3d74d84bf7), [`023c2c2`](https://github.com/browserbase/stagehand/commit/023c2c273b46d3792d7e5d3c902089487b16b531), [`8c28647`](https://github.com/browserbase/stagehand/commit/8c2864755ecd05c8f7de235d4198deec0dd5f78e), [`87e09c6`](https://github.com/browserbase/stagehand/commit/87e09c618940f364ec8af00455a19a17ec63cbd3), [`a611115`](https://github.com/browserbase/stagehand/commit/a61111525d70b450bdfc43f112380f44899c9e97), [`69913fe`](https://github.com/browserbase/stagehand/commit/69913fe1dfb8201ae2aeffa5f049fb46ab02cbc2), [`b1b83a1`](https://github.com/browserbase/stagehand/commit/b1b83a1d334fe76e5f5f9dd32dc92c16b7d40ce6), [`be8497c`](https://github.com/browserbase/stagehand/commit/be8497cb6b142cc893cea9692b8c47bd19514c60), [`98704c9`](https://github.com/browserbase/stagehand/commit/98704c9ed225ca25bbde4bb3dc286936e9c54471), [`04978bd`](https://github.com/browserbase/stagehand/commit/04978bdd30d2edcbc69eb9fd91358a16975ea2eb)]:
+  - @browserbasehq/stagehand@2.4.2
+
+## 1.0.5
+
+### Patch Changes
+
+- Updated dependencies [[`8a43c5a`](https://github.com/browserbase/stagehand/commit/8a43c5a86d4da40cfaedd9cf2e42186928bdf946), [`890ffcc`](https://github.com/browserbase/stagehand/commit/890ffccac5e0a60ade64a46eb550c981ffb3e84a), [`64c1072`](https://github.com/browserbase/stagehand/commit/64c10727bda50470483a3eb175c02842db0923a1), [`b077d3f`](https://github.com/browserbase/stagehand/commit/b077d3f48a97f47a71ccc79ae39b41e7f07f9c04), [`8bcb5d7`](https://github.com/browserbase/stagehand/commit/8bcb5d77debf6bf7601fd5c090efd7fde75c5d5e), [`7bf10c5`](https://github.com/browserbase/stagehand/commit/7bf10c55b267078fe847c1d7f7a60d604f9c7c94)]:
+  - @browserbasehq/stagehand@2.4.1
+
+## 1.0.4
+
+### Patch Changes
+
+- [#831](https://github.com/browserbase/stagehand/pull/831) [`5812b02`](https://github.com/browserbase/stagehand/commit/5812b027e4919d005321cc00626b057e6e04074b) Thanks [@seanmcguire12](https://github.com/seanmcguire12)! - added -man & -h commands for explaining how to run evals
+
+- Updated dependencies [[`124e0d3`](https://github.com/browserbase/stagehand/commit/124e0d3bb54ddb6738ede6d7aa99a945ef1cacd1), [`6a18c1e`](https://github.com/browserbase/stagehand/commit/6a18c1ee1e46d55c6e90c4d5572e17ed8daa140c), [`1660751`](https://github.com/browserbase/stagehand/commit/1660751cd14cb5b27d44f8167216afb8d1c3c45c), [`cadac9d`](https://github.com/browserbase/stagehand/commit/cadac9da09123d12e5d496a0e8b12660964c1b33), [`759da55`](https://github.com/browserbase/stagehand/commit/759da55775eb2df81d56ae18c0f386fd9b02a9f0), [`a175a51`](https://github.com/browserbase/stagehand/commit/a175a519b8c14300db6f1ed30709e113d18e99db), [`8527a80`](https://github.com/browserbase/stagehand/commit/8527a80522c3eedb9516a6caa1a0e4e4be981a3d), [`55fca2f`](https://github.com/browserbase/stagehand/commit/55fca2f7da63cc0ef6e27b45a33f63c666cdce7e)]:
+  - @browserbasehq/stagehand@2.4.0
+
+## 1.0.3
+
+### Patch Changes
+
+- Updated dependencies [[`12a99b3`](https://github.com/browserbase/stagehand/commit/12a99b398d8a4c3eea3ca69a3cf793faaaf4aea3), [`2451797`](https://github.com/browserbase/stagehand/commit/2451797f64c0efa4a72fd70265110003c8d0a6cd), [`1d631a5`](https://github.com/browserbase/stagehand/commit/1d631a57a197390f672b718ae5199991ab27cfb1), [`9c398bb`](https://github.com/browserbase/stagehand/commit/9c398bb9ec2d10bdb53ad5aa7e3b58cce24fdb2b), [`c19ad7f`](https://github.com/browserbase/stagehand/commit/c19ad7f1e082e91fdeaa9c2ef63767a5a2b3a195)]:
+  - @browserbasehq/stagehand@2.3.1
+
+## 1.0.2
+
+### Patch Changes
+
+- Updated dependencies [[`5680d25`](https://github.com/browserbase/stagehand/commit/5680d2509352c383ad502c9f4fabde01fa638833), [`4de92a8`](https://github.com/browserbase/stagehand/commit/4de92a8af461fc95063faf39feee1d49259f58ba), [`6ef6073`](https://github.com/browserbase/stagehand/commit/6ef60730cab0ad9025f44b6eeb2c83751d1dcd35)]:
+  - @browserbasehq/stagehand@2.3.0
+
+## 1.0.1
+
+### Patch Changes
+
+- Updated dependencies [[`be8652e`](https://github.com/browserbase/stagehand/commit/be8652e770b57fdb3299fa0b2efa4eb0e816434e), [`6b413b7`](https://github.com/browserbase/stagehand/commit/6b413b7ad00b13ca0bd53ee2e7393023821408b6), [`7eafbd9`](https://github.com/browserbase/stagehand/commit/7eafbd9b1a73b37effa444929767df7c592caf02), [`1b50aa6`](https://github.com/browserbase/stagehand/commit/1b50aa61cf0a429dd6cb2760a08f7f698a50454b), [`f2b7f1f`](https://github.com/browserbase/stagehand/commit/f2b7f1f284eef1f96753319b66c7d0b273a6f8cd), [`c8d672f`](https://github.com/browserbase/stagehand/commit/c8d672f7c410c256defbc2e87ead99239837aa28), [`bebf204`](https://github.com/browserbase/stagehand/commit/bebf2044502333c694743078c5b0c9deae11fb79), [`37d6810`](https://github.com/browserbase/stagehand/commit/37d6810a704773d0383a86f98f5f17c7d5b21975)]:
+  - @browserbasehq/stagehand@2.2.1
diff --git a/packages/evals/README.md b/packages/evals/README.md
new file mode 100644
index 000000000..88b9f5182
--- /dev/null
+++ b/packages/evals/README.md
@@ -0,0 +1,223 @@
+# Stagehand Evals CLI
+
+A powerful command-line interface for running Stagehand evaluation suites and benchmarks.
+
+## Installation
+
+```bash
+# From the stagehand root directory
+pnpm install
+pnpm run build:cli
+```
+
+## Usage
+
+The evals CLI provides a clean, intuitive interface for running evaluations:
+
+```bash
+pnpm evals <command> <target> [options]
+```
+
+## Commands
+
+### `run` - Execute evaluations
+
+Run custom evals or external benchmarks.
+
+```bash
+# Run all custom evals
+pnpm evals run all
+
+# Run specific category
+pnpm evals run act
+pnpm evals run extract
+pnpm evals run observe
+
+# Run specific eval by name
+pnpm evals run extract/extract_text
+
+# Run external benchmarks
+pnpm evals run benchmark:gaia
+```
+
+### `list` - View available evals
+
+List all available evaluations and benchmarks.
+
+```bash
+# List all categories and benchmarks
+pnpm evals list
+
+# Show detailed task list
+pnpm evals list --detailed
+```
+
+### `config` - Manage defaults
+
+Configure default settings for all eval runs.
+
+```bash
+# View current configuration
+pnpm evals config
+
+# Set default values
+pnpm evals config set env browserbase
+pnpm evals config set trials 5
+pnpm evals config set concurrency 10
+
+# Reset to defaults
+pnpm evals config reset
+pnpm evals config reset trials  # Reset specific key
+```
+
+### `help` - Show help
+
+```bash
+pnpm evals help
+```
+
+## Options
+
+### Core Options
+
+- `-e, --env` - Environment: `local` or `browserbase` (default: local)
+- `-t, --trials` - Number of trials per eval (default: 3)
+- `-c, --concurrency` - Max parallel sessions (default: 3)
+- `-m, --model` - Model override (e.g., gpt-4o, claude-3.5)
+- `-p, --provider` - Provider override (openai, anthropic, etc.)
+- `--api` - Use Stagehand API instead of SDK
+
+### Benchmark-Specific Options
+
+- `-l, --limit` - Max tasks to run (default: 25)
+- `-s, --sample` - Random sample before limit
+- `-f, --filter` - Benchmark-specific filters (key=value)
+
+## Examples
+
+### Running Custom Evals
+
+```bash
+# Run with custom settings
+pnpm evals run act -e browserbase -t 5 -c 10
+
+# Run with specific model
+pnpm evals run observe -m gpt-4o -p openai
+
+# Run using API
+pnpm evals run extract --api
+```
+
+### Running Benchmarks
+
+```bash
+# WebBench with filters
+pnpm evals run b:webbench -l 10 -f difficulty=easy -f category=READ
+
+# GAIA with sampling
+pnpm evals run b:gaia -s 100 -l 25 -f level=1
+
+# WebVoyager with limit
+pnpm evals run b:webvoyager -l 50
+```
+
+## Available Benchmarks
+
+### OnlineMind2Web (`b:onlineMind2Web`)
+
+Real-world web interaction tasks for evaluating web agents.
+
+### GAIA (`b:gaia`)
+
+General AI Assistant benchmark for complex reasoning.
+
+**Filters:**
+
+- `level`: 1, 2, 3 (difficulty levels)
+
+### WebVoyager (`b:webvoyager`)
+
+Web navigation and task completion benchmark.
+
+### WebBench (`b:webbench`)
+
+Real-world web automation tasks across live websites.
+
+**Filters:**
+
+- `difficulty`: easy, hard
+- `category`: READ, CREATE, UPDATE, DELETE, FILE_MANIPULATION
+- `use_hitl`: true/false
+
+### OSWorld (`b:osworld`)
+
+Chrome browser automation tasks from the OSWorld benchmark.
+
+**Filters:**
+
+- `source`: Mind2Web, test_task_1, etc.
+- `evaluation_type`: url_match, string_match, dom_state, custom
+
+## Configuration
+
+The CLI uses a configuration file at `evals/evals.config.json` which contains:
+
+- **defaults**: Default values for CLI options
+- **benchmarks**: Metadata for external benchmarks
+- **tasks**: Registry of all evaluation tasks
+
+You can modify defaults either through the `config` command or by editing the file directly.
+
+## Environment Variables
+
+While the CLI reduces the need for environment variables, some are still supported for CI/CD:
+
+- `EVAL_ENV` - Override environment setting
+- `EVAL_TRIAL_COUNT` - Override trial count
+- `EVAL_MAX_CONCURRENCY` - Override concurrency
+- `EVAL_PROVIDER` - Override LLM provider
+- `USE_API` - Use Stagehand API
+
+## Development
+
+### Adding New Evals
+
+1. Create your eval file in `evals/tasks/<category>/`
+2. Add it to `evals.config.json` under the `tasks` array
+3. Run with: `pnpm evals run <category>/<eval_name>`
+
+## Troubleshooting
+
+### Command not found
+
+If `evals` command is not found, make sure you've:
+
+1. Run `pnpm install` from the project root
+2. Run `pnpm run build:cli` to compile the CLI
+
+### Build errors
+
+If you encounter build errors:
+
+```bash
+# Clean and rebuild
+rm -rf packages/evals/dist/cli
+pnpm run build:cli
+```
+
+### Permission errors
+
+If you get permission errors:
+
+```bash
+chmod +x packages/evals/dist/cli/cli.js
+```
+
+## Contributing
+
+When adding new features to the CLI:
+
+1. Update the command in `evals/cli.ts`
+2. Add new options to the help text
+3. Update this README with examples
+4. Test with various flag combinations
diff --git a/packages/evals/args.ts b/packages/evals/args.ts
new file mode 100644
index 000000000..cbb5ceba0
--- /dev/null
+++ b/packages/evals/args.ts
@@ -0,0 +1,346 @@
+import process from "process";
+import { EvalCategorySchema } from "./types/evals.js";
+import chalk from "chalk";
+import { dedent } from "./utils.js";
+
+const HELP_REGEX = /^(?:--?)?(?:h|help)$/i;
+const MAN_REGEX = /^(?:--?)?man$/i;
+
+const rawArgs = process.argv.slice(2);
+
+const parsedArgs: {
+  evalName?: string;
+  env?: string;
+  api?: string;
+  trials?: number;
+  concurrency?: number;
+  provider?: string;
+  dataset?: string;
+  max_k?: number;
+  leftover: string[];
+} = {
+  leftover: [],
+};
+
+for (const arg of rawArgs) {
+  if (arg.startsWith("env=")) {
+    parsedArgs.env = arg.split("=")[1]?.toLowerCase();
+  } else if (arg.startsWith("api=")) {
+    parsedArgs.api = arg.split("=")[1]?.toLowerCase();
+  } else if (arg.startsWith("name=")) {
+    parsedArgs.evalName = arg.split("=")[1];
+  } else if (arg.startsWith("trials=")) {
+    const val = parseInt(arg.split("=")[1], 10);
+    if (!isNaN(val)) {
+      parsedArgs.trials = val;
+    }
+  } else if (arg.startsWith("concurrency=")) {
+    const val = parseInt(arg.split("=")[1], 10);
+    if (!isNaN(val)) {
+      parsedArgs.concurrency = val;
+    }
+  } else if (arg.startsWith("provider=")) {
+    parsedArgs.provider = arg.split("=")[1]?.toLowerCase();
+  } else if (arg.startsWith("--dataset=")) {
+    parsedArgs.dataset = arg.split("=")[1]?.toLowerCase();
+  } else if (arg.startsWith("max_k=")) {
+    const val = parseInt(arg.split("=")[1], 10);
+    if (!isNaN(val)) {
+      parsedArgs.max_k = val;
+    }
+  } else {
+    parsedArgs.leftover.push(arg);
+  }
+}
+
+/** Apply environment defaults or overrides */
+if (parsedArgs.env === "browserbase") {
+  process.env.EVAL_ENV = "BROWSERBASE";
+} else if (parsedArgs.env === "local") {
+  process.env.EVAL_ENV = "LOCAL";
+}
+
+if (parsedArgs.api === "true") {
+  process.env.USE_API = "true";
+} else if (parsedArgs.api === "false") {
+  process.env.USE_API = "false";
+}
+
+if (parsedArgs.trials !== undefined) {
+  process.env.EVAL_TRIAL_COUNT = String(parsedArgs.trials);
+}
+if (parsedArgs.concurrency !== undefined) {
+  process.env.EVAL_MAX_CONCURRENCY = String(parsedArgs.concurrency);
+}
+if (parsedArgs.max_k !== undefined) {
+  process.env.EVAL_MAX_K = String(parsedArgs.max_k);
+}
+if (parsedArgs.dataset !== undefined) {
+  process.env.EVAL_DATASET = parsedArgs.dataset;
+}
+
+const DEFAULT_EVAL_CATEGORIES = process.env.EVAL_CATEGORIES
+  ? process.env.EVAL_CATEGORIES.split(",")
+  : [
+      "observe",
+      "act",
+      "combination",
+      "extract",
+      "experimental",
+      "targeted_extract",
+      "regression_llm_providers",
+      "regression",
+      "llm_clients",
+      "agent",
+      "external_agent_benchmarks",
+    ];
+
+const providerDefault = process.env.EVAL_PROVIDER ?? undefined;
+
+function buildUsage(detailed = false): string {
+  const header = chalk.blue.bold("Stagehand • Eval Runner");
+  const synopsis = chalk.cyan(
+    `pnpm run evals [key=value]… [category <name>] | name=<evalName>`,
+  );
+
+  const examplesSection = `
+      ${chalk.magenta.underline("Examples")}
+
+      ${chalk.dim("# Run every evaluation locally with default settings")}
+      ${chalk.green("pnpm run evals")}
+
+      ${chalk.dim("# Same as above but in Browserbase with three trials")}  
+      ${chalk.green("pnpm run evals")} ${chalk.cyan("env=")}${chalk.yellow("browserbase")} ${chalk.cyan("trials=")}${chalk.yellow("3")}
+
+      ${chalk.dim("# Run evals using the Stagehand API")}
+      ${chalk.green("pnpm run evals")} ${chalk.cyan("env=")}${chalk.yellow("browserbase")} ${chalk.cyan("api=")}${chalk.yellow("true")}
+
+      ${chalk.dim("# Run evals from only the 'act' category with a max of 4 running at any given time")}
+      ${chalk.green("pnpm run evals")} ${chalk.cyan("category")} ${chalk.yellow("act")} ${chalk.cyan("concurrency=")}${chalk.yellow("4")}
+
+      ${chalk.dim("# Execute a specific eval by filename")}
+      ${chalk.green("pnpm run evals")} ${chalk.cyan("name=")}${chalk.yellow("my_eval_name")}
+  `;
+
+  const body = dedent`
+    ${chalk.magenta.underline("Keys\n")}
+  ${chalk.cyan("env".padEnd(12))} ${"target environment".padEnd(24)}
+    (default ${chalk.dim("LOCAL")})                [${chalk.yellow("browserbase")}, ${chalk.yellow("local")}]
+
+  ${chalk.cyan("api".padEnd(12))} ${"use the Stagehand API".padEnd(24)}
+    (default ${chalk.dim("false")})                [${chalk.yellow("true")}, ${chalk.yellow("false")}]
+
+  ${chalk.cyan("trials".padEnd(12))} ${"number of trials per task".padEnd(24)}
+    (default ${chalk.dim("3")})
+
+  ${chalk.cyan("concurrency".padEnd(12))} ${"max parallel sessions".padEnd(24)}
+    (default ${chalk.dim("3")})
+
+  ${chalk.cyan("provider".padEnd(12))} ${"override LLM provider".padEnd(24)}
+    (default ${chalk.dim(providerDefault || "varies by model")})        [${chalk.yellow("openai")}, ${chalk.yellow("anthropic")}, ${chalk.yellow("google")}, ${chalk.yellow("together")}, ${chalk.yellow("groq")}, ${chalk.yellow("cerebras")}]
+
+  ${chalk.cyan("max_k".padEnd(12))} ${"max test cases per dataset".padEnd(24)}
+    (default ${chalk.dim("25")})
+
+  ${chalk.cyan("--dataset".padEnd(12))} ${"filter to specific benchmark".padEnd(24)}
+    (optional)              [${chalk.yellow("gaia")}, ${chalk.yellow("webvoyager")}, ${chalk.yellow("webbench")}, ${chalk.yellow("osworld")}, ${chalk.yellow("onlineMind2Web")}]
+
+
+    ${chalk.magenta.underline("Positional filters\n")}
+      
+      category <category_name>   
+      
+        ${chalk.gray("Available categories:")}
+        ${DEFAULT_EVAL_CATEGORIES.slice(0, 5)
+          .map((c) => chalk.yellow(c))
+          .join(", ")},
+        ${DEFAULT_EVAL_CATEGORIES.slice(5, 10)
+          .map((c) => chalk.yellow(c))
+          .join(", ")}${DEFAULT_EVAL_CATEGORIES.slice(10).length > 0 ? "," : ""}
+        ${DEFAULT_EVAL_CATEGORIES.slice(10)
+          .map((c) => chalk.yellow(c))
+          .join(", ")}
+  `;
+
+  if (!detailed)
+    return `${header}\n\n${synopsis}\n\nFor more details: ${chalk.bold(
+      "pnpm run evals -man\n",
+    )}`;
+
+  const externalBenchmarksSection = dedent`
+    ${chalk.magenta.underline("\nExternal Benchmarks\n")}
+    
+    ${chalk.cyan.bold("WebBench")} - 5,607 real-world web automation tasks across 452 live websites
+    
+      ${chalk.dim("Run:")} ${chalk.green("pnpm run evals")} ${chalk.cyan("name=")}${chalk.yellow("agent/webbench")}
+      
+      ${chalk.dim("Or:")}  ${chalk.green("EVAL_DATASET=webbench pnpm run evals")}
+      
+      ${chalk.gray("Environment Variables:")}
+      
+      EVAL_WEBBENCH_LIMIT       max tasks to run (default: 25)
+      EVAL_WEBBENCH_SAMPLE      random sample count before limit
+      EVAL_WEBBENCH_DIFFICULTY  filter: [${chalk.yellow("easy")}, ${chalk.yellow("hard")}] (254 easy, 61 hard tasks)
+      EVAL_WEBBENCH_CATEGORY    filter: [${chalk.yellow("READ")}, ${chalk.yellow("CREATE")}, ${chalk.yellow("UPDATE")}, ${chalk.yellow("DELETE")}, ${chalk.yellow("FILE_MANIPULATION")}]
+      EVAL_WEBBENCH_USE_HITL    use only HITL dataset with difficulty ratings (true/false)
+      
+      ${chalk.dim("Examples:")}
+      
+      ${chalk.green("EVAL_WEBBENCH_DIFFICULTY=easy EVAL_WEBBENCH_LIMIT=10 pnpm run evals name=agent/webbench")}
+      
+      ${chalk.green("EVAL_DATASET=webbench EVAL_WEBBENCH_CATEGORY=READ pnpm run evals")}
+    
+    
+    ${chalk.cyan.bold("GAIA")} - General AI Assistant benchmark for complex reasoning
+    
+      ${chalk.dim("Run:")} ${chalk.green("pnpm run evals")} ${chalk.cyan("name=")}${chalk.yellow("agent/gaia")}
+      
+      ${chalk.dim("Or:")}  ${chalk.green("EVAL_DATASET=gaia pnpm run evals")}
+      
+      ${chalk.gray("Environment Variables:")}
+      
+      EVAL_GAIA_LIMIT           max tasks to run (default: 25)
+      EVAL_GAIA_SAMPLE          random sample count before limit
+      EVAL_GAIA_LEVEL           filter by difficulty level [${chalk.yellow("1")}, ${chalk.yellow("2")}, ${chalk.yellow("3")}]
+      
+      ${chalk.dim("Example:")}
+      
+      ${chalk.green("EVAL_GAIA_LEVEL=1 EVAL_GAIA_LIMIT=10 pnpm run evals name=agent/gaia")}
+    
+    
+    ${chalk.cyan.bold("WebVoyager")} - Web navigation and task completion benchmark
+    
+      ${chalk.dim("Run:")} ${chalk.green("pnpm run evals")} ${chalk.cyan("name=")}${chalk.yellow("agent/webvoyager")}
+      
+      ${chalk.dim("Or:")}  ${chalk.green("EVAL_DATASET=webvoyager pnpm run evals")}
+      
+      ${chalk.gray("Environment Variables:")}
+      
+      EVAL_WEBVOYAGER_LIMIT     max tasks to run (default: 25)
+      EVAL_WEBVOYAGER_SAMPLE    random sample count before limit
+      
+      ${chalk.gray("Ground Truth Evaluation:")}
+      
+      WebVoyager uses ground truth answers for improved accuracy:
+      • Checks agent's "Final Answer:" against reference answers
+      • Supports golden (ideal) and possible (acceptable) answers
+      • Falls back to screenshot evaluation when uncertain
+      • Reference data: evals/datasets/webvoyager/reference-answers.json
+      
+      ${chalk.dim("Example:")}
+      
+      ${chalk.green("EVAL_WEBVOYAGER_SAMPLE=50 EVAL_WEBVOYAGER_LIMIT=10 pnpm run evals name=agent/webvoyager")}
+    
+    
+    ${chalk.cyan.bold("OSWorld")} - Chrome browser automation tasks from the OSWorld benchmark
+    
+      ${chalk.dim("Run:")} ${chalk.green("pnpm run evals")} ${chalk.cyan("name=")}${chalk.yellow("agent/osworld")}
+      
+      ${chalk.dim("Or:")}  ${chalk.green("EVAL_DATASET=osworld pnpm run evals")}
+      
+      ${chalk.gray("Environment Variables:")}
+      
+      EVAL_OSWORLD_LIMIT           max tasks to run (default: 25)
+      EVAL_OSWORLD_SAMPLE          random sample count before limit
+      EVAL_OSWORLD_SOURCE          filter by source: [${chalk.yellow("Mind2Web")}, ${chalk.yellow("test_task_1")}, ...]
+      EVAL_OSWORLD_EVALUATION_TYPE filter by eval type: [${chalk.yellow("url_match")}, ${chalk.yellow("string_match")}, ${chalk.yellow("dom_state")}, ${chalk.yellow("custom")}]
+      EVAL_OSWORLD_TIMEOUT         timeout per task in milliseconds (default: 60000)
+      
+      ${chalk.dim("Examples:")}
+      
+      ${chalk.green("EVAL_OSWORLD_SOURCE=Mind2Web EVAL_OSWORLD_LIMIT=10 pnpm run evals name=agent/osworld")}
+      
+      ${chalk.green("EVAL_DATASET=osworld EVAL_OSWORLD_EVALUATION_TYPE=url_match pnpm run evals")}
+    
+    
+    ${chalk.cyan.bold("Mind2Web")} - Real-world web interaction tasks for evaluating web agents
+    
+      ${chalk.dim("Run:")} ${chalk.green("pnpm run evals")} ${chalk.cyan("name=")}${chalk.yellow("agent/onlineMind2Web")}
+      
+      ${chalk.dim("Or:")}  ${chalk.green("EVAL_DATASET=onlineMind2Web pnpm run evals")}
+      
+      ${chalk.gray("Environment Variables:")}
+      
+      EVAL_ONLINEMIND2WEB_LIMIT     max tasks to run (default: 25)
+      EVAL_ONLINEMIND2WEB_SAMPLE    random sample count before limit
+      
+      ${chalk.dim("Example:")}
+      
+      ${chalk.green("EVAL_ONLINEMIND2WEB_SAMPLE=50 EVAL_ONLINEMIND2WEB_LIMIT=10 pnpm run evals name=agent/onlineMind2Web")}
+  `;
+
+  const envSection = dedent`
+    ${chalk.magenta.underline("\nGlobal Environment Variables\n")}
+      
+      EVAL_ENV              target environment, overridable via ${chalk.cyan("env=")}
+      
+      EVAL_TRIAL_COUNT      number of trials, overridable via ${chalk.cyan("trials=")}
+      
+      EVAL_MAX_CONCURRENCY  parallel sessions, overridable via ${chalk.cyan("concurrency=")}
+      
+      EVAL_PROVIDER         LLM provider, overridable via ${chalk.cyan("provider=")}
+      
+      EVAL_MAX_K            global limit for all benchmarks (overrides individual limits)
+      
+      EVAL_DATASET          filter to specific benchmark, overridable via ${chalk.cyan("--dataset=")}
+      
+      USE_API               use Stagehand API, overridable via ${chalk.cyan("api=")}
+      
+      EVAL_MODELS           comma-separated list of models to use
+      
+      AGENT_EVAL_MAX_STEPS  max steps for agent tasks (default: 50)
+  `;
+
+  return `${header}\n\n${synopsis}\n\n${body}\n${examplesSection}\n${externalBenchmarksSection}\n${envSection}\n`;
+}
+
+const wantsHelp = rawArgs.some((a) => HELP_REGEX.test(a));
+const wantsMan = rawArgs.some((a) => MAN_REGEX.test(a));
+
+if (wantsHelp || wantsMan) {
+  console.log(buildUsage(wantsMan));
+  process.exit(0);
+}
+
+let filterByCategory: string | null = null;
+let filterByEvalName: string | null = null;
+
+if (parsedArgs.evalName) {
+  filterByEvalName = parsedArgs.evalName;
+}
+
+if (!filterByEvalName && parsedArgs.leftover.length > 0) {
+  if (parsedArgs.leftover[0].toLowerCase() === "category") {
+    filterByCategory = parsedArgs.leftover[1];
+    if (!filterByCategory) {
+      console.error(chalk.red("Error: Category name not specified."));
+      process.exit(1);
+    }
+    try {
+      EvalCategorySchema.parse(filterByCategory);
+    } catch {
+      console.error(
+        chalk.red(
+          `Error: Invalid category "${filterByCategory}". Valid categories are: ${DEFAULT_EVAL_CATEGORIES.join(
+            ", ",
+          )}`,
+        ),
+      );
+      process.exit(1);
+    }
+  } else {
+    // If leftover[0] is not "category", interpret it as a task/eval name
+    filterByEvalName = parsedArgs.leftover[0];
+  }
+}
+
+if (parsedArgs.provider !== undefined) {
+  process.env.EVAL_PROVIDER = parsedArgs.provider;
+}
+
+export {
+  filterByCategory,
+  filterByEvalName,
+  DEFAULT_EVAL_CATEGORIES,
+  parsedArgs,
+};
diff --git a/evals/assets/cart.html b/packages/evals/assets/cart.html
similarity index 100%
rename from evals/assets/cart.html
rename to packages/evals/assets/cart.html
diff --git a/evals/assets/peeler.html b/packages/evals/assets/peeler.html
similarity index 100%
rename from evals/assets/peeler.html
rename to packages/evals/assets/peeler.html
diff --git a/packages/evals/browserbaseCleanup.ts b/packages/evals/browserbaseCleanup.ts
new file mode 100644
index 000000000..679fb7944
--- /dev/null
+++ b/packages/evals/browserbaseCleanup.ts
@@ -0,0 +1,32 @@
+import type { V3 } from "@browserbasehq/stagehand";
+
+const CLOSE_TIMEOUT_MS = 5_000;
+
+async function settleWithTimeout(
+  promise: Promise<unknown>,
+  timeoutMs: number,
+): Promise<void> {
+  let timeoutId: NodeJS.Timeout | undefined;
+  const timeout = new Promise<void>((resolve) => {
+    timeoutId = setTimeout(resolve, timeoutMs);
+  });
+  try {
+    await Promise.race([promise.catch(() => {}), timeout]);
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
+  }
+}
+
+export async function endBrowserbaseSession(v3?: V3 | null): Promise<void> {
+  if (!v3?.isBrowserbase) return;
+  if ((process.env.USE_API ?? "").toLowerCase() === "true") return;
+
+  try {
+    await settleWithTimeout(
+      v3.context.conn.send("Browser.close"),
+      CLOSE_TIMEOUT_MS,
+    );
+  } catch {
+    // best-effort cleanup
+  }
+}
diff --git a/packages/evals/cli.ts b/packages/evals/cli.ts
new file mode 100644
index 000000000..aa238df43
--- /dev/null
+++ b/packages/evals/cli.ts
@@ -0,0 +1,586 @@
+import process from "process";
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import { spawn } from "child_process";
+import { getCurrentDirPath } from "./runtimePaths.js";
+
+const moduleDir = getCurrentDirPath();
+const CONFIG_PATH = path.join(moduleDir, "evals.config.json");
+
+interface Config {
+  defaults: {
+    env: string;
+    trials: number;
+    concurrency: number;
+    provider: string | null;
+    model: string | null;
+    api: boolean;
+  };
+  benchmarks: Record<
+    string,
+    {
+      limit: number;
+      filters?: string[];
+      timeout?: number;
+    }
+  >;
+  tasks: Array<{ name: string; categories: string[] }>;
+}
+
+function loadConfig(): Config {
+  return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+}
+
+function saveConfig(config: Config): void {
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+function printHelp(): void {
+  console.log(
+    chalk.yellow(`⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡾⠻⣶⡀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⢠⡶⠛⢳⡆⠀⠀⠀⠀⢸⡇⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠀⢸⣷⠶⣦⣴⠶⣾⡇⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠀⢸⡇⠀⢸⡇⠀⢸⡇⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠀⠘⠷⣤⢾⡏⠉⠉⠉⠙⣾⡇⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠀⠀⠀⠀⠈⣻⡿⠟⠂⠀⣿⠃⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠈⣷⠀⠀⠀⠀⢰⡏⠀⠀⠀⢀⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⣷⡀⠀⠀⠀⠀⠀⠀⢀⡾⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠷⣦⣤⣤⣴⠾⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀`),
+  );
+  console.log(chalk.yellow.bold("\nStagehand Evals CLI"));
+  console.log(chalk.cyan("\nevals <command> <target> [options]\n"));
+
+  console.log(chalk.magenta.underline("Commands"));
+  console.log("  run       Execute evals or benchmarks");
+  console.log("  list      List available evals/benchmarks");
+  console.log("  config    Get/set default configuration");
+  console.log("  help      Show this help message\n");
+
+  console.log(chalk.magenta.underline("Examples"));
+  console.log(chalk.dim("  # Run all custom evals"));
+  console.log(chalk.green("  evals run all\n"));
+
+  console.log(chalk.dim("  # Run specific category"));
+  console.log(
+    chalk.green("  evals run act") + chalk.cyan(" -e browserbase -t 5\n"),
+  );
+
+  console.log(chalk.dim("  # Run specific eval"));
+  console.log(chalk.green("  evals run login\n"));
+
+  console.log(chalk.dim("  # Run benchmark"));
+  console.log(
+    chalk.green("  evals run benchmark:onlineMind2Web") +
+      chalk.cyan(" -l 10 -f difficulty=easy\n"),
+  );
+
+  console.log(chalk.dim("  # Configure defaults"));
+  console.log(chalk.green("  evals config set env browserbase"));
+  console.log(chalk.green("  evals config set trials 5\n"));
+
+  console.log(chalk.magenta.underline("Options"));
+  console.log(
+    chalk.cyan("  -e, --env".padEnd(20)) + "Environment: local|browserbase",
+  );
+  console.log(
+    chalk.cyan("  -t, --trials".padEnd(20)) + "Number of trials per eval",
+  );
+  console.log(
+    chalk.cyan("  -c, --concurrency".padEnd(20)) + "Max parallel sessions",
+  );
+  console.log(chalk.cyan("  -m, --model".padEnd(20)) + "Model override");
+  console.log(chalk.cyan("  -p, --provider".padEnd(20)) + "Provider override");
+  console.log(chalk.cyan("  --api".padEnd(20)) + "Use Stagehand API\n");
+
+  console.log(chalk.dim("  Benchmark-specific:"));
+  console.log(chalk.cyan("  -l, --limit".padEnd(20)) + "Max tasks to run");
+  console.log(
+    chalk.cyan("  -s, --sample".padEnd(20)) + "Random sample before limit",
+  );
+  console.log(
+    chalk.cyan("  -f, --filter".padEnd(20)) + "Benchmark filters (key=value)\n",
+  );
+}
+
+function handleConfig(args: string[]): void {
+  const config = loadConfig();
+
+  if (args.length === 0) {
+    // Show current config
+    console.log(chalk.blue.bold("\nCurrent Configuration"));
+    console.log(chalk.cyan("\nDefaults:"));
+    Object.entries(config.defaults).forEach(([key, value]) => {
+      console.log(`  ${key}: ${chalk.yellow(value ?? "not set")}`);
+    });
+    return;
+  }
+
+  if (args[0] === "set" && args.length >= 3) {
+    const [, key, ...valueParts] = args;
+    const value = valueParts.join(" ");
+
+    if (!(key in config.defaults)) {
+      console.error(chalk.red(`Error: Unknown config key "${key}"`));
+      console.log(
+        chalk.dim(`Valid keys: ${Object.keys(config.defaults).join(", ")}`),
+      );
+      process.exit(1);
+    }
+
+    // Parse value based on type
+    let parsedValue: string | number | boolean | null = value;
+    if (key === "trials" || key === "concurrency") {
+      parsedValue = parseInt(value, 10);
+      if (isNaN(parsedValue)) {
+        console.error(chalk.red(`Error: ${key} must be a number`));
+        process.exit(1);
+      }
+    } else if (key === "api") {
+      parsedValue = value === "true";
+    } else if (value === "null" || value === "none") {
+      parsedValue = null;
+    }
+
+    // Type-safe assignment
+    if (key === "env") {
+      config.defaults.env = parsedValue as string;
+    } else if (key === "trials") {
+      config.defaults.trials = parsedValue as number;
+    } else if (key === "concurrency") {
+      config.defaults.concurrency = parsedValue as number;
+    } else if (key === "provider") {
+      config.defaults.provider = parsedValue as string | null;
+    } else if (key === "model") {
+      config.defaults.model = parsedValue as string | null;
+    } else if (key === "api") {
+      config.defaults.api = parsedValue as boolean;
+    }
+    saveConfig(config);
+    console.log(chalk.green(`✓ Set ${key} to ${parsedValue}`));
+  } else if (args[0] === "reset") {
+    const defaultConfig: Config["defaults"] = {
+      env: "local",
+      trials: 3,
+      concurrency: 3,
+      provider: null,
+      model: null,
+      api: false,
+    };
+
+    if (args[1] && args[1] in config.defaults) {
+      const key = args[1];
+      // Type-safe reset by key
+      if (key === "env") {
+        config.defaults.env = defaultConfig.env;
+      } else if (key === "trials") {
+        config.defaults.trials = defaultConfig.trials;
+      } else if (key === "concurrency") {
+        config.defaults.concurrency = defaultConfig.concurrency;
+      } else if (key === "provider") {
+        config.defaults.provider = defaultConfig.provider;
+      } else if (key === "model") {
+        config.defaults.model = defaultConfig.model;
+      } else if (key === "api") {
+        config.defaults.api = defaultConfig.api;
+      }
+      saveConfig(config);
+      console.log(chalk.green(`✓ Reset ${args[1]} to default`));
+    } else if (!args[1]) {
+      config.defaults = defaultConfig;
+      saveConfig(config);
+      console.log(chalk.green("✓ Reset all settings to defaults"));
+    } else {
+      console.error(chalk.red(`Error: Unknown config key "${args[1]}"`));
+      process.exit(1);
+    }
+  } else if (args[0] === "path") {
+    console.log(CONFIG_PATH);
+  } else {
+    console.error(chalk.red("Error: Invalid config command"));
+    console.log(
+      chalk.dim("Usage: evals config [set <key> <value> | reset [key] | path]"),
+    );
+    process.exit(1);
+  }
+}
+
+function handleList(args: string[]): void {
+  const config = loadConfig();
+
+  console.log(chalk.blue.bold("\nAvailable Evals\n"));
+
+  // Group tasks by category
+  const categories = new Map<string, string[]>();
+  config.tasks.forEach((task) => {
+    task.categories.forEach((cat) => {
+      if (!categories.has(cat)) {
+        categories.set(cat, []);
+      }
+      categories.get(cat)!.push(task.name);
+    });
+  });
+
+  // Show custom eval categories
+  console.log(chalk.magenta.underline("Custom Eval Categories"));
+  Array.from(categories.entries())
+    .filter(([cat]) => !cat.includes("external_agent_benchmarks"))
+    .forEach(([category, tasks]) => {
+      console.log(
+        `  ${chalk.cyan(category)} ${chalk.dim(`(${tasks.length} evals)`)}`,
+      );
+    });
+
+  console.log(chalk.magenta.underline("\nBenchmarks"));
+  Object.keys(config.benchmarks).forEach((name) => {
+    const shorthand = `b:${name}`;
+    console.log(
+      `  ${chalk.cyan(shorthand.padEnd(20))} ${chalk.dim(`benchmark:${name}`)}`,
+    );
+  });
+
+  if (args.includes("--detailed") || args.includes("-d")) {
+    console.log(chalk.magenta.underline("\n\nDetailed Task List"));
+    categories.forEach((tasks, category) => {
+      if (!category.includes("external_agent_benchmarks")) {
+        console.log(chalk.cyan(`\n${category}:`));
+        tasks.forEach((task) => {
+          console.log(`  - ${task}`);
+        });
+      }
+    });
+  } else {
+    console.log(
+      chalk.yellow(
+        "\n💡 Tip: Use 'evals list --detailed' to see all individual tasks",
+      ),
+    );
+  }
+}
+
+function parseArgs(rawArgs: string[]): {
+  options: Record<string, string | number | boolean>;
+  target?: string;
+  filters: Array<[string, string]>;
+} {
+  const options: Record<string, string | number | boolean> = {};
+  const filters: Array<[string, string]> = [];
+  let target: string | undefined;
+
+  for (let i = 0; i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+
+    if (arg.startsWith("-")) {
+      // Handle options
+      const flagName = arg.replace(/^--?/, "");
+
+      // Map short flags to long names
+      const flagMap: Record<string, string> = {
+        e: "env",
+        t: "trials",
+        c: "concurrency",
+        m: "model",
+        p: "provider",
+        l: "limit",
+        s: "sample",
+        f: "filter",
+      };
+
+      const optionName = flagMap[flagName] || flagName;
+
+      if (optionName === "api") {
+        options.api = true;
+      } else if (optionName === "filter") {
+        // Parse filter as key=value
+        const filterValue = rawArgs[++i];
+        if (filterValue && filterValue.includes("=")) {
+          const [key, value] = filterValue.split("=");
+          filters.push([key, value]);
+        }
+      } else {
+        // Get next value
+        const value = rawArgs[++i];
+        if (value && !value.startsWith("-")) {
+          // Parse numbers
+          if (
+            ["trials", "concurrency", "limit", "sample"].includes(optionName)
+          ) {
+            options[optionName] = parseInt(value, 10);
+          } else {
+            options[optionName] = value;
+          }
+        }
+      }
+    } else if (!target) {
+      target = arg;
+    }
+  }
+
+  return { options, target, filters };
+}
+
+function handleRun(args: string[]): void {
+  const config = loadConfig();
+  const { options, target, filters } = parseArgs(args);
+
+  // Merge with defaults
+  const stagehandTarget = (process.env.STAGEHAND_BROWSER_TARGET ?? "")
+    .toLowerCase()
+    .trim();
+  if (
+    !options.env &&
+    (stagehandTarget === "local" || stagehandTarget === "browserbase")
+  ) {
+    options.env = stagehandTarget;
+  }
+  const finalOptions = { ...config.defaults, ...options };
+
+  // Build environment variables
+  const env = { ...process.env };
+
+  // Set core environment variables
+  if (finalOptions.env === "browserbase") {
+    env.EVAL_ENV = "BROWSERBASE";
+  } else {
+    env.EVAL_ENV = "LOCAL";
+  }
+
+  if (finalOptions.api) {
+    env.USE_API = "true";
+  }
+
+  if (finalOptions.trials) {
+    env.EVAL_TRIAL_COUNT = String(finalOptions.trials);
+  }
+
+  if (finalOptions.concurrency) {
+    env.EVAL_MAX_CONCURRENCY = String(finalOptions.concurrency);
+  }
+
+  if (finalOptions.provider) {
+    env.EVAL_PROVIDER = finalOptions.provider;
+  }
+
+  if (finalOptions.model) {
+    env.EVAL_MODEL_OVERRIDE = finalOptions.model;
+  }
+
+  // Handle benchmark-specific options
+  let evalName: string | undefined;
+  let categoryFilter: string | undefined;
+
+  if (target) {
+    if (target.startsWith("b:") || target.startsWith("benchmark:")) {
+      // Running a benchmark
+      const benchmarkName = target.replace(/^(b:|benchmark:)/, "");
+
+      if (!config.benchmarks[benchmarkName]) {
+        console.error(chalk.red(`Error: Unknown benchmark "${benchmarkName}"`));
+        console.log(
+          chalk.dim(
+            `Available benchmarks: ${Object.keys(config.benchmarks).join(", ")}`,
+          ),
+        );
+        process.exit(1);
+      }
+
+      // Map to the actual eval name
+      const benchmarkMap: Record<string, string> = {
+        webbench: "agent/webbench",
+        gaia: "agent/gaia",
+        webvoyager: "agent/webvoyager",
+        osworld: "agent/osworld",
+        onlineMind2Web: "agent/onlineMind2Web",
+        webtailbench: "agent/webtailbench",
+      };
+
+      evalName = benchmarkMap[benchmarkName];
+      env.EVAL_DATASET = benchmarkName;
+
+      // Set benchmark-specific options
+      if (options.limit) {
+        env.EVAL_MAX_K = String(options.limit);
+        env[`EVAL_${benchmarkName.toUpperCase()}_LIMIT`] = String(
+          options.limit,
+        );
+      }
+
+      if (options.sample) {
+        env[`EVAL_${benchmarkName.toUpperCase()}_SAMPLE`] = String(
+          options.sample,
+        );
+      }
+
+      // Apply filters
+      filters.forEach(([key, value]) => {
+        const envKey = `EVAL_${benchmarkName.toUpperCase()}_${key.toUpperCase()}`;
+        env[envKey] = value;
+      });
+    } else if (target === "all") {
+      // Run all evals (no filter)
+    } else if (target.includes("/") || target.includes("*")) {
+      // Pattern matching - treat as eval name
+      evalName = target;
+    } else {
+      // Check if it's a category
+      const categories = new Set<string>();
+      config.tasks.forEach((task) => {
+        task.categories.forEach((cat) => categories.add(cat));
+      });
+
+      if (categories.has(target)) {
+        categoryFilter = target;
+      } else {
+        // Assume it's a specific eval name
+        evalName = target;
+      }
+    }
+  }
+
+  // Build the legacy command
+  const legacyArgs: string[] = [];
+
+  if (evalName) {
+    legacyArgs.push(`name=${evalName}`);
+  } else if (categoryFilter) {
+    legacyArgs.push("category", categoryFilter);
+  }
+
+  // Run the existing eval system with our environment
+  console.log(chalk.blue.bold("\nRunning evals...\n"));
+
+  // Build first if needed
+  const buildChild = spawn("pnpm", ["run", "build"], {
+    stdio: "inherit",
+    shell: true,
+  });
+
+  buildChild.on("exit", (buildCode) => {
+    if (buildCode !== 0) {
+      process.exit(buildCode || 1);
+    }
+
+    const compiledEvalPath = path.resolve(
+      moduleDir,
+      "..",
+      "esm",
+      "index.eval.js",
+    );
+    // When built to packages/evals/dist/cli/cli.js, moduleDir is packages/evals/dist/cli/
+    // Source is at packages/evals/index.eval.ts from repo root
+    const sourceEvalPath = path.resolve(
+      moduleDir,
+      "..",
+      "..",
+      "packages",
+      "evals",
+      "index.eval.ts",
+    );
+
+    let child;
+
+    if (fs.existsSync(compiledEvalPath)) {
+      child = spawn(process.execPath, [compiledEvalPath, ...legacyArgs], {
+        env,
+        stdio: "inherit",
+        shell: true,
+      });
+    } else {
+      let tsxCliPath: string | undefined;
+      try {
+        // Resolve the local tsx CLI entry within this package installation
+        // This avoids requiring a globally installed tsx binary
+        tsxCliPath = require.resolve("tsx/dist/cli.js");
+      } catch {
+        // no-op; will fall back to shell-resolved "tsx" if not found
+      }
+
+      const tsxArgs = [sourceEvalPath, ...legacyArgs];
+
+      if (tsxCliPath) {
+        child = spawn(process.execPath, [tsxCliPath, ...tsxArgs], {
+          env,
+          stdio: "inherit",
+          shell: true,
+        });
+      } else {
+        child = spawn("tsx", tsxArgs, {
+          env,
+          stdio: "inherit",
+          shell: true,
+        });
+      }
+    }
+
+    child.on("exit", (code) => {
+      process.exit(code || 0);
+    });
+
+    // Forward SIGINT (Ctrl+C) and SIGTERM to child process
+    process.on("SIGINT", () => {
+      console.log("\n\nReceived SIGINT, killing child process...");
+      child.kill("SIGINT");
+      setTimeout(() => {
+        child.kill("SIGKILL");
+        process.exit(130);
+      }, 1000);
+    });
+
+    process.on("SIGTERM", () => {
+      console.log("\n\nReceived SIGTERM, killing child process...");
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        child.kill("SIGKILL");
+        process.exit(143);
+      }, 1000);
+    });
+  });
+}
+
+// Main CLI logic
+function main(): void {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const commandArgs = args.slice(1);
+
+  switch (command) {
+    case "run":
+      handleRun(commandArgs);
+      break;
+
+    case "list":
+      handleList(commandArgs);
+      break;
+
+    case "config":
+      handleConfig(commandArgs);
+      break;
+
+    case "help":
+    case "--help":
+    case "-h":
+      printHelp();
+      break;
+
+    case undefined:
+      console.error(chalk.red("Error: No command specified"));
+      printHelp();
+      process.exit(1);
+      break;
+
+    default:
+      // Check if it's a direct target (backward compatibility)
+      if (!command.startsWith("-")) {
+        handleRun(args);
+      } else {
+        console.error(chalk.red(`Error: Unknown command "${command}"`));
+        printHelp();
+        process.exit(1);
+      }
+  }
+}
+
+// Run the CLI
+main();
diff --git a/packages/evals/datasets/gaia/GAIA_web.jsonl b/packages/evals/datasets/gaia/GAIA_web.jsonl
new file mode 100644
index 000000000..b6f122b69
--- /dev/null
+++ b/packages/evals/datasets/gaia/GAIA_web.jsonl
@@ -0,0 +1,90 @@
+{"task_id": "e1fc63a2-da7a-432f-be78-7c4a95598703", "Level": 1, "Final answer": "17", "id": "level1-0", "web": "https://www.google.com/", "ques": "If Eliud Kipchoge could maintain his record-making marathon pace indefinitely, how many thousand hours would it take him to run the distance between the Earth and the Moon its closest approach? Please use the minimum perigee value on the Wikipedia page for the Moon when carrying out your calculation. Round your result to the nearest 1000 hours and do not use any comma separators if necessary."}
+{"task_id": "8e867cd7-cff9-4e6c-867a-ff5ddc2550be", "Level": 1, "Final answer": "3", "id": "level1-1", "web": "https://www.google.com/", "ques": "How many studio albums were published by Mercedes Sosa between 2000 and 2009 (included)? You can use the latest 2022 version of english wikipedia."}
+{"task_id": "5d0080cb-90d7-4712-bc33-848150e917d3", "Level": 1, "Final answer": "0.1777", "id": "level1-2", "web": "https://www.google.com/", "ques": "What was the volume in m^3 of the fish bag that was calculated in the University of Leicester paper \"Can Hiccup Supply Enough Fish to Maintain a Dragon\u2019s Diet?\""}
+{"task_id": "a1e91b78-d3d8-4675-bb8d-62741b4b68a6", "Level": 1, "Final answer": "3", "id": "level1-3", "web": "https://www.google.com/", "ques": "In the video https://www.youtube.com/watch?v=L1vXCYZAYYM, what is the highest number of bird species to be on camera simultaneously?"}
+{"task_id": "46719c30-f4c3-4cad-be07-d5cb21eee6bb", "Level": 1, "Final answer": "Mapping Human Oriented Information to Software Agents for Online Systems Usage", "id": "level1-4", "web": "https://www.google.com/", "ques": "Of the authors (First M. Last) that worked on the paper \"Pie Menus or Linear Menus, Which Is Better?\" in 2015, what was the title of the first paper authored by the one that had authored prior papers?"}
+{"task_id": "4b6bb5f7-f634-410e-815d-e673ab7f8632", "Level": 1, "Final answer": "THE CASTLE", "id": "level1-5", "web": "https://www.google.com/", "ques": "In Series 9, Episode 11 of Doctor Who, the Doctor is trapped inside an ever-shifting maze. What is this location called in the official script for the episode? Give the setting exactly as it appears in the first scene heading."}
+{"task_id": "b816bfce-3d80-4913-a07d-69b752ce6377", "Level": 1, "Final answer": "fluffy", "id": "level1-6", "web": "https://www.google.com/", "ques": "In Emily Midkiff's June 2014 article in a journal named for the one of Hreidmar's sons that guarded his house, what word was quoted from two different authors in distaste for the nature of dragon depictions?"}
+{"task_id": "72e110e7-464c-453c-a309-90a95aed6538", "Level": 1, "Final answer": "Guatemala", "id": "level1-7", "web": "https://www.google.com/", "ques": "Under DDC 633 on Bielefeld University Library's BASE, as of 2020, from what country was the unknown language article with a flag unique from the others?"}
+{"task_id": "b415aba4-4b68-4fc6-9b89-2c812e55a3e1", "Level": 1, "Final answer": "diamond", "id": "level1-8", "web": "https://www.google.com/", "ques": "In Nature journal's Scientific Reports conference proceedings from 2012, in the article that did not mention plasmons or plasmonics, what nano-compound is studied? Don't use the prefix nano in your answer if there is one."}
+{"task_id": "935e2cff-ae78-4218-b3f5-115589b19dae", "Level": 1, "Final answer": "research", "id": "level1-9", "web": "https://www.google.com/", "ques": "In the year 2022, and before December, what does \"R\" stand for in the three core policies of the type of content that was violated in the public logs on the Legume Wikipedia page?"}
+{"task_id": "4fc2f1ae-8625-45b5-ab34-ad4433bc21f8", "Level": 1, "Final answer": "FunkMonk", "id": "level1-10", "web": "https://www.google.com/", "ques": "Who nominated the only Featured Article on English Wikipedia about a dinosaur that was promoted in November 2016?"}
+{"task_id": "5188369a-3bbe-43d8-8b94-11558f909a08", "Level": 1, "Final answer": "Annie Levin", "id": "level1-11", "web": "https://www.google.com/", "ques": "What writer is quoted by Merriam-Webster for the Word of the Day from June 27, 2022?"}
+{"task_id": "9d191bce-651d-4746-be2d-7ef8ecadb9c2", "Level": 1, "Final answer": "Extremely", "id": "level1-12", "web": "https://www.google.com/", "ques": "Examine the video at https://www.youtube.com/watch?v=1htKBjuUWec.\n\nWhat does Teal'c say in response to the question \"Isn't that hot?\""}
+{"task_id": "cabe07ed-9eca-40ea-8ead-410ef5e83f91", "Level": 1, "Final answer": "Louvrier", "id": "level1-13", "web": "https://www.google.com/", "ques": "What is the surname of the equine veterinarian mentioned in 1.E Exercises from the chemistry materials licensed by Marisa Alviar-Agnew & Henry Agnew under the CK-12 license in LibreText's Introductory Chemistry materials as compiled 08/21/2023?"}
+{"task_id": "d0633230-7067-47a9-9dbf-ee11e0a2cdd6", "Level": 1, "Final answer": "BaseLabelPropagation", "id": "level1-14", "web": "https://www.google.com/", "ques": "In the Scikit-Learn July 2017 changelog, what other predictor base command received a bug fix? Just give the name, not a path."}
+{"task_id": "0383a3ee-47a7-41a4-b493-519bdefe0488", "Level": 1, "Final answer": "Rockhopper penguin", "id": "level1-15", "web": "https://www.google.com/", "ques": "On the BBC Earth YouTube video of the Top 5 Silliest Animal Moments, what species of bird is featured?"}
+{"task_id": "11af4e1a-5f45-467d-9aeb-46f4bb0bf034", "Level": 1, "Final answer": "6", "id": "level1-16", "web": "https://www.google.com/", "ques": "How many more blocks (also denoted as layers) in BERT base encoder than the encoder from the architecture proposed in Attention is All You Need?"}
+{"task_id": "7673d772-ef80-4f0f-a602-1bf4485c9b43", "Level": 1, "Final answer": "inference", "id": "level1-17", "web": "https://www.google.com/", "ques": "On Cornell Law School website's legal information institute, under the fifth section of federal rules alphabetically, what word was deleted in the last amendment to the first rule in the article that has \"witnesses\" in the most titles as of 2021?"}
+{"task_id": "c365c1c7-a3db-4d5e-a9a1-66f56eae7865", "Level": 1, "Final answer": "Braintree, Honolulu", "id": "level1-18", "web": "https://www.google.com/", "ques": "Of the cities within the United States where U.S. presidents were born, which two are the farthest apart from the westernmost to the easternmost going east, giving the city names only? Give them to me in alphabetical order, in a comma-separated list"}
+{"task_id": "7d4a7d1d-cac6-44a8-96e8-ea9584a70825", "Level": 1, "Final answer": "22", "id": "level1-19", "web": "https://www.google.com/", "ques": "According to Girls Who Code, how long did it take in years for the percentage of computer scientists that were women to change by 13% from a starting point of 37%?"}
+{"task_id": "dc22a632-937f-4e6a-b72f-ba0ff3f5ff97", "Level": 1, "Final answer": "Five Hundred Things To Eat Before It's Too Late: and the Very Best Places to Eat Them", "id": "level1-20", "web": "https://www.google.com/", "ques": "What was the complete title of the book in which two James Beard Award winners recommended the restaurant where Ali Khan enjoyed a New Mexican staple in his cost-conscious TV show that started in 2015? Write the numbers in plain text if there are some in the title."}
+{"task_id": "3f57289b-8c60-48be-bd80-01f8099ca449", "Level": 1, "Final answer": "519", "id": "level1-21", "web": "https://www.google.com/", "ques": "How many at bats did the Yankee with the most walks in the 1977 regular season have that same season?"}
+{"task_id": "23dd907f-1261-4488-b21c-e9185af91d5e", "Level": 1, "Final answer": "2", "id": "level1-22", "web": "https://www.google.com/", "ques": "In Audre Lorde\u2019s poem \u201cFather Son and Holy Ghost\u201d, what is the number of the stanza in which some lines are indented?"}
+{"task_id": "840bfca7-4f7b-481a-8794-c560c340185d", "Level": 1, "Final answer": "80GSFC21M0002", "id": "level1-23", "web": "https://www.google.com/", "ques": "On June 6, 2023, an article by Carolyn Collins Petersen was published in Universe Today. This article mentions a team that produced a paper about their observations, linked at the bottom of the article. Find this paper. Under what NASA award number was the work performed by R. G. Arendt supported by?"}
+{"task_id": "a0068077-79f4-461a-adfe-75c1a4148545", "Level": 1, "Final answer": "90", "id": "level1-24", "web": "https://www.google.com/", "ques": "What was the actual enrollment count of the clinical trial on H. pylori in acne vulgaris patients from Jan-May 2018 as listed on the NIH website?"}
+{"task_id": "bda648d7-d618-4883-88f4-3466eabd860e", "Level": 1, "Final answer": "Saint Petersburg", "id": "level1-25", "web": "https://www.google.com/", "ques": "Where were the Vietnamese specimens described by Kuznetzov in Nedoshivina's 2010 paper eventually deposited? Just give me the city name without abbreviations."}
+{"task_id": "c61d22de-5f6c-4958-a7f6-5e9707bd3466", "Level": 2, "Final answer": "egalitarian", "id": "level2-0", "web": "https://www.google.com/", "ques": "A paper about AI regulation that was originally submitted to arXiv.org in June 2022 shows a figure with three axes, where each axis has a label word at both ends. Which of these words is used to describe a type of society in a Physics and Society article submitted to arXiv.org on August 11, 2016?"}
+{"task_id": "17b5a6a3-bc87-42e8-b0fb-6ab0781ef2cc", "Level": 2, "Final answer": "34689", "id": "level2-1", "web": "https://www.google.com/", "ques": "I\u2019m researching species that became invasive after people who kept them as pets released them. There\u2019s a certain species of fish that was popularized as a pet by being the main character of the movie Finding Nemo. According to the USGS, where was this fish found as a nonnative species, before the year 2020? I need the answer formatted as the five-digit zip codes of the places the species was found, separated by commas if there is more than one place."}
+{"task_id": "04a04a9b-226c-43fd-b319-d5e89743676f", "Level": 2, "Final answer": "41", "id": "level2-2", "web": "https://www.google.com/", "ques": "If we assume all articles published by Nature in 2020 (articles, only, not book reviews/columns, etc) relied on statistical significance to justify their findings and they on average came to a p-value of 0.04, how many papers would be incorrect as to their claims of statistical significance? Round the value up to the next integer."}
+{"task_id": "14569e28-c88c-43e4-8c32-097d35b9a67d", "Level": 2, "Final answer": "backtick", "id": "level2-3", "web": "https://www.google.com/", "ques": "In Unlambda, what exact charcter or text needs to be added to correct the following code to output \"For penguins\"? If what is needed is a character, answer with the name of the character. If there are different names for the character, use the shortest. The text location is not needed. Code:\n\n`r```````````.F.o.r. .p.e.n.g.u.i.n.si"}
+{"task_id": "3627a8be-a77f-41bb-b807-7e1bd4c0ebdf", "Level": 2, "Final answer": "142", "id": "level2-4", "web": "https://www.google.com/", "ques": "The object in the British Museum's collection with a museum number of 2012,5015.17 is the shell of a particular mollusk species. According to the abstract of a research article published in Science Advances in 2021, beads made from the shells of this species were found that are at least how many thousands of years old?"}
+{"task_id": "7619a514-5fa8-43ef-9143-83b66a43d7a4", "Level": 2, "Final answer": "04/15/18", "id": "level2-5", "web": "https://www.google.com/", "ques": "According to github, when was Regression added to the oldest closed numpy.polynomial issue that has the Regression label in MM/DD/YY?"}
+{"task_id": "2a649bb1-795f-4a01-b3be-9a01868dae73", "Level": 2, "Final answer": "3.1.3.1; 1.11.1.7", "id": "level2-6", "web": "https://www.google.com/", "ques": "What are the EC numbers of the two most commonly used chemicals for the virus testing method in the paper about SPFMV and SPCSV in the Pearl Of Africa from 2016? Return the semicolon-separated numbers in the order of the alphabetized chemicals."}
+{"task_id": "87c610df-bef7-4932-b950-1d83ef4e282b", "Level": 2, "Final answer": "Morarji Desai", "id": "level2-7", "web": "https://www.google.com/", "ques": "In April of 1977, who was the Prime Minister of the first place mentioned by name in the Book of Esther (in the New International Version)?"}
+{"task_id": "624cbf11-6a41-4692-af9c-36b3e5ca3130", "Level": 2, "Final answer": "So we had to let it die.", "id": "level2-8", "web": "https://www.google.com/", "ques": "What's the last line of the rhyme under the flavor name on the headstone visible in the background of the photo of the oldest flavor's headstone in the Ben & Jerry's online flavor graveyard as of the end of 2022?"}
+{"task_id": "dd3c7503-f62a-4bd0-9f67-1b63b94194cc", "Level": 2, "Final answer": "6", "id": "level2-9", "web": "https://www.google.com/", "ques": "Use density measures from the chemistry materials licensed by Marisa Alviar-Agnew & Henry Agnew under the CK-12 license in LibreText's Introductory Chemistry materials as compiled 08/21/2023.\n\nI have a gallon of honey and a gallon of mayonnaise at 25C. I remove one cup of honey at a time from the gallon of honey. How many times will I need to remove a cup to have the honey weigh less than the mayonaise? Assume the containers themselves weigh the same."}
+{"task_id": "f0f46385-fc03-4599-b5d3-f56496c3e69f", "Level": 2, "Final answer": "Indonesia, Myanmar", "id": "level2-10", "web": "https://www.google.com/", "ques": "In terms of geographical distance between capital cities, which 2 countries are the furthest from each other within the ASEAN bloc according to wikipedia? Answer using a comma separated list, ordering the countries by alphabetical order."}
+{"task_id": "e4e91f1c-1dcd-439e-9fdd-cb976f5293fd", "Level": 2, "Final answer": "cloak", "id": "level2-11", "web": "https://www.google.com/", "ques": "I need to fact-check a citation. This is the citation from the bibliography:\n\nGreetham, David. \"Uncoupled: OR, How I Lost My Author(s).\" Textual Cultures: Texts, Contexts, Interpretation, vol. 3 no. 1, 2008, p. 45-46. Project MUSE, doi:10.2979/tex.2008.3.1.44.\n\nAnd this is the in-line citation:\n\nOur relationship with the authors of the works we read can often be \u201cobscured not by a \"cloak of print\" but by the veil of scribal confusion and mis-transmission\u201d (Greetham 45-46).\n\nDoes the quoted text match what is actually in the article? If Yes, answer Yes, otherwise, give me the word in my citation that does not match with the correct one (without any article)."}
+{"task_id": "56137764-b4e0-45b8-9c52-1866420c3df5", "Level": 2, "Final answer": "Li Peng", "id": "level2-12", "web": "https://www.google.com/", "ques": "Which contributor to the version of OpenCV where support was added for the Mask-RCNN model has the same name as a former Chinese head of government when the names are transliterated to the Latin alphabet?"}
+{"task_id": "8b3379c0-0981-4f5b-8407-6444610cb212", "Level": 2, "Final answer": "1.8", "id": "level2-13", "web": "https://www.google.com/", "ques": "What is the maximum length in meters of #9 in the first National Geographic short on YouTube that was ever released according to the Monterey Bay Aquarium website? Just give the number."}
+{"task_id": "0ff53813-3367-4f43-bcbd-3fd725c1bf4b", "Level": 2, "Final answer": "beta geometric", "id": "level2-14", "web": "https://www.google.com/", "ques": "What two-word type of model did Manash Pratim Kashyap's and PS Fader's studies in customer retention studies published during 2018-2019 have in common (no punctuation)?"}
+{"task_id": "a7feb290-76bb-4cb7-8800-7edaf7954f2f", "Level": 2, "Final answer": "31", "id": "level2-15", "web": "https://www.google.com/", "ques": "How many High Energy Physics - Lattice articles listed in January 2020 on Arxiv had ps versions available?"}
+{"task_id": "b4cc024b-3f5e-480e-b96a-6656493255b5", "Level": 2, "Final answer": "Russian-German Legion", "id": "level2-16", "web": "https://www.google.com/", "ques": "The photograph in the Whitney Museum of American Art's collection with accession number 2022.128 shows a person holding a book. Which military unit did the author of this book join in 1813? Answer without using articles."}
+{"task_id": "33d8ea3b-6c6b-4ff1-803d-7e270dea8a57", "Level": 2, "Final answer": "2", "id": "level2-17", "web": "https://www.google.com/", "ques": "What is the minimum number of page links a person must click on to go from the english Wikipedia page on The Lord of the Rings (the book) to the english Wikipedia page on A Song of Ice and Fire (the book series)? In your count, include each link you would click on to get to the page. Use the pages as they appeared at the end of the day on July 3, 2023."}
+{"task_id": "e8cb5b03-41e0-4086-99e5-f6806cd97211", "Level": 2, "Final answer": "shrimp", "id": "level2-18", "web": "https://www.google.com/", "ques": "I went to Virtue restaurant & bar in Chicago for my birthday on March 22, 2021 and the main course I had was delicious!  Unfortunately, when I went back about a month later on April 21, it was no longer on the dinner menu.  Using the Wayback Machine, can you help me figure out which main course was on the dinner menu for Virtue on March 22, 2021 but not April 21, 2021? Answer using the singular form, without articles."}
+{"task_id": "f46b4380-207e-4434-820b-f32ce04ae2a4", "Level": 2, "Final answer": "Harbinger, Tidal", "id": "level2-19", "web": "https://www.google.com/", "ques": "It is 1999. Before you party like it is 1999, please assist me in settling a bet.\n\nFiona Apple and Paula Cole released albums prior to 1999. Of these albums, which didn't receive a letter grade from Robert Christgau? Provide your answer as a comma delimited list of album titles, sorted alphabetically."}
+{"task_id": "05407167-39ec-4d3a-a234-73a9120c325d", "Level": 2, "Final answer": "Format Document", "id": "level2-20", "web": "https://www.google.com/", "ques": "In the 2018 VSCode blog post on replit.com, what was the command they clicked on in the last video to remove extra lines?"}
+{"task_id": "b9763138-c053-4832-9f55-86200cb1f99c", "Level": 2, "Final answer": "3", "id": "level2-21", "web": "https://www.google.com/", "ques": "Compute the check digit the Tropicos ID for the Order Helotiales would have if it were an ISBN-10 number."}
+{"task_id": "16d825ff-1623-4176-a5b5-42e0f5c2b0ac", "Level": 2, "Final answer": "6:41 PM", "id": "level2-22", "web": "https://www.google.com/", "ques": "What time was the Tri-Rail train that carried the most passengers on May 27, 2019 scheduled to arrive in Pompano Beach? Express your answer in the 12-hour digital clock format without leading zero if any, and include whether it is AM or PM."}
+{"task_id": "544b7f0c-173a-4377-8d56-57b36eb26ddf", "Level": 2, "Final answer": "A Nightmare on Elm Street", "id": "level2-23", "web": "https://www.google.com/", "ques": "In Valentina Re\u2019s contribution to the 2017 book \u201cWorld Building: Transmedia, Fans, Industries\u201d, what horror movie does the author cite as having popularized metalepsis between a dream world and reality? Use the complete name with article if any."}
+{"task_id": "6b078778-0b90-464d-83f6-59511c811b01", "Level": 2, "Final answer": "Alfonso Visconti", "id": "level2-24", "web": "https://www.google.com/", "ques": "The Metropolitan Museum of Art has a portrait in its collection with an accession number of 29.100.5. Of the consecrators and co-consecrators of this portrait's subject as a bishop, what is the name of the one who never became pope?"}
+{"task_id": "08cae58d-4084-4616-b6dd-dd6534e4825b", "Level": 2, "Final answer": "2018", "id": "level2-25", "web": "https://www.google.com/", "ques": "According to Google Finance, when was the first year the Apple stock went above $50 (without adjusting for stock split)?"}
+{"task_id": "2dfc4c37-fec1-4518-84a7-10095d30ad75", "Level": 2, "Final answer": "6", "id": "level2-26", "web": "https://www.google.com/", "ques": "According to Box Office Mojo's 2020 Worldwide Box Office list, how many of the top 10 highest-grossing worldwide movies are also on the top 10 highest-grossing domestic movies? Your answer should be a numerical integer value."}
+{"task_id": "9f41b083-683e-4dcf-9185-ccfeaa88fa45", "Level": 2, "Final answer": "0", "id": "level2-27", "web": "https://www.google.com/", "ques": "How many pages if the 2023 IPCC report (85 pages version) mentions nuclear energy?"}
+{"task_id": "ecbc4f94-95a3-4cc7-b255-6741a458a625", "Level": 2, "Final answer": "13", "id": "level2-28", "web": "https://www.google.com/", "ques": "How many images are there in the latest 2022 Lego english wikipedia article?"}
+{"task_id": "71345b0a-9c7d-4b50-b2bf-937ec5879845", "Level": 2, "Final answer": "Here be dragons", "id": "level2-29", "web": "https://www.google.com/", "ques": "On a leap day before the year 2008, a joke was removed from the Wikipedia page for \u201cDragon\u201d. What was the phrase that was removed? Give the phrase as it appeared on the page, but without punctuation."}
+{"task_id": "7b5377b0-3f38-4103-8ad2-90fe89864c04", "Level": 2, "Final answer": "563.9", "id": "level2-30", "web": "https://www.google.com/", "ques": "Find the value of x to the nearest tenth: Lx = (d/dx * (A * x-squared)) + 4-thousand'n'ninety-7 minus C\nWhere L is the last two digits of the year of the Venezuelan Declaration of Independence,\nA is the number of colors in the TikTok logo as of July 2023, excluding black and white,\nand C is the height of the average woman in the Philippines according to a July 2023 Business Insider article, rounded to the nearest whole centimeter"}
+{"task_id": "114d5fd0-e2ae-4b6d-a65a-870da2d19c08", "Level": 2, "Final answer": "4", "id": "level2-31", "web": "https://www.google.com/", "ques": "In the endnote found in the second-to-last paragraph of page 11 of the book with the doi 10.2307/j.ctv9b2xdv, what date in November was the Wikipedia article accessed? Just give the day of the month."}
+{"task_id": "ad37a656-079a-49f9-a493-7b739c9167d1", "Level": 2, "Final answer": "Bravo", "id": "level2-32", "web": "https://www.google.com/", "ques": "On July 15, 2008, Phys.org published an article about a catastrophe. Find the explosive force of this catastrophe according to Encyclopedia Britannica, then find the name of the US nuclear test that had the same yield. Your answer should only be the last word of the name of the test."}
+{"task_id": "f3917a3d-1d17-4ee2-90c5-683b072218fe", "Level": 2, "Final answer": "2732", "id": "level2-33", "web": "https://www.google.com/", "ques": "How many edits were made to the Wikipedia page on Antidisestablishmentarianism from its inception until June of 2023?"}
+{"task_id": "48eb8242-1099-4c26-95d4-ef22b002457a", "Level": 2, "Final answer": "6", "id": "level2-34", "web": "https://www.google.com/", "ques": "How many nonindigenous crocodiles were found in Florida from the year 2000 through 2020? You can get the data from the USGS Nonindigenous Aquatic Species database."}
+{"task_id": "c8b7e059-c60d-472e-ad64-3b04ae1166dc", "Level": 2, "Final answer": "8", "id": "level2-35", "web": "https://www.google.com/", "ques": "The work referenced in footnote 397 of Federico Lauria's 2014 dissertation is also the source for the titles of two paintings in the Smithsonian American Art Museum's collection, as of August 2023. What is the absolute difference between the chapter numbers of the chapters that the titles of these two paintings quote?"}
+{"task_id": "d1af70ea-a9a4-421a-b9cc-94b5e02f1788", "Level": 2, "Final answer": "736455", "id": "level2-36", "web": "https://www.google.com/", "ques": "As of the 2020 census, what was the population difference between the largest county seat and smallest county seat, by land area of the county seat, in Washington state? For population figures, please use the official data from data.census.gov. Please report the integer difference."}
+{"task_id": "ded28325-3447-4c56-860f-e497d6fb3577", "Level": 2, "Final answer": "Picnic is in Ploybius Plaza.", "id": "level2-37", "web": "https://www.google.com/", "ques": "This is a secret message my friend gave me. It says where we should meet for our picnic on Friday. The only problem is, it\u2019s encrypted in the Caesar cipher, so I can\u2019t read it. Can you tell me what it says? This is the message:\n\nZsmxsm sc sx Zyvilsec Zvkjk."}
+{"task_id": "d700d50d-c707-4dca-90dc-4528cddd0c80", "Level": 2, "Final answer": "Roger Miller", "id": "level2-38", "web": "https://www.google.com/", "ques": "Who composed the song that was performed by a rooster and a hamster in separate animated videos at separate tempos with different lyrics? Answer using the format First name Last name."}
+{"task_id": "0a3cd321-3e76-4622-911b-0fda2e5d6b1a", "Level": 2, "Final answer": "Brunei, China, Morocco, Singapore", "id": "level2-39", "web": "https://www.google.com/", "ques": "According to the World Bank, which countries had gross savings of over 35% of GDP for every year in the period 2001-2010? Give your answer as a comma-separated list of countries in alphabetical order. Use the countries most common names in english when answering."}
+{"task_id": "f2feb6a4-363c-4c09-a804-0db564eafd68", "Level": 2, "Final answer": "900000", "id": "level2-40", "web": "https://www.google.com/", "ques": "I\u2019m thinking about selling my home, so I want to learn more about how homes in my area sold recently. I live in Pearl City, Hawaii, which is on the island of Oahu. I know two homes near me that sold in 2022 were 2072 Akaikai Loop, and 2017 Komo Mai Drive. Find which of those homes sold for more in 2022, and tell me how much it sold for. Don\u2019t put commas or decimal places in the answer."}
+{"task_id": "0b260a57-3f3a-4405-9f29-6d7a1012dbfb", "Level": 2, "Final answer": "0.269", "id": "level2-41", "web": "https://www.google.com/", "ques": "On ScienceDirect, what is the difference to 3 decimal places in the sample standard deviations of the number of Reference Works in each Life Science domain compared to Health Sciences as of 2022?"}
+{"task_id": "ed58682d-bc52-4baa-9eb0-4eb81e1edacc", "Level": 2, "Final answer": "stare", "id": "level2-42", "web": "https://www.google.com/", "ques": "What is the last word before the second chorus of the King of Pop's fifth single from his sixth studio album?"}
+{"task_id": "023e9d44-96ae-4eed-b912-244ee8c3b994", "Level": 2, "Final answer": "8", "id": "level2-43", "web": "https://www.google.com/", "ques": "It's May 2023, and I'm about to drive across the U.S. from California to Maine. I always recycle my water bottles at the end of a trip, and I drink 5 12-ounce water bottles for every 100 miles I travel, rounded to the nearest 100. Assuming I follow I-40 from Los Angeles to Cincinnati, then take I-90 from Cincinnati to Augusta, how many dollars will I get back according to Wikipedia?"}
+{"task_id": "0e9e85b8-52b9-4de4-b402-5f635ab9631f", "Level": 2, "Final answer": "1927", "id": "level2-44", "web": "https://www.google.com/", "ques": "What is the latest chronological year date written in the image on the webpage found when following the first citation reference link on the latest version of Carl Nebel's Wikipedia page as of August 2023?"}
+{"task_id": "20194330-9976-4043-8632-f8485c6c71b2", "Level": 2, "Final answer": "4", "id": "level2-45", "web": "https://www.google.com/", "ques": "The YouTube channel Game Grumps began a Let\u2019s Play of the game Sonic the Hedgehog (2006) in the year 2012. Thirty seconds into the first episode, a phrase is shown on the screen in white letters on a red background. How many times does the letter \"E\" appear in this phrase?"}
+{"task_id": "65638e28-7f37-4fa7-b7b9-8c19bb609879", "Level": 2, "Final answer": "Kleinpaul", "id": "level2-46", "web": "https://www.google.com/", "ques": "The book with the doi 10.1353/book.24372 concerns a certain neurologist. According to chapter 2 of the book, what author influenced this neurologist\u2019s belief in \u201cendopsychic myths\u201d? Give the last name only."}
+{"task_id": "3ff6b7a9-a5bd-4412-ad92-0cd0d45c0fee", "Level": 2, "Final answer": "56000", "id": "level2-47", "web": "https://www.google.com/", "ques": "The longest-lived vertebrate is named after an island.  According to Wikipedia as of January 1, 2021, what is the 2020 estimated population of that island, to the nearest thousand?"}
+{"task_id": "708b99c5-e4a7-49cb-a5cf-933c8d46470d", "Level": 2, "Final answer": "Citations", "id": "level2-48", "web": "https://www.google.com/", "ques": "On the DeepFruits fruit detection graph on Connected Papers from 2016, what feature caused the largest bubble to be the size it is?"}
+{"task_id": "0a65cb96-cb6e-4a6a-8aae-c1084f613456", "Level": 2, "Final answer": "Holabird", "id": "level2-49", "web": "https://www.google.com/", "ques": "During the first week of August 2015, one of the NASA Astronomy Pictures of the Day shows the lights of a city on the horizon. The namesake of this city also has a landmark building in Chicago named after him. What is the name of the architectural firm that designed this landmark building? Give the first name appearing in the name of the firm as of June 2023."}
+{"task_id": "65da0822-a48a-4a68-bbad-8ed1b835a834", "Level": 2, "Final answer": "Santa Clara, Boston", "id": "level2-50", "web": "https://www.google.com/", "ques": "All of the individuals who formally held the position of United States secretary of homeland security prior to April 2019, excluding those who held the position in an acting capacity, have a bachelor's degree. Of the universities that these bachelor's degrees were from, which is the westernmost university and which is the easternmost university? Give them to me as a comma-separated list, I only want the name of the cities where the universities are located, with the westernmost city listed first."}
+{"task_id": "73c1b9fe-ee1d-4cf4-96ca-35c08f97b054", "Level": 2, "Final answer": "1954", "id": "level2-51", "web": "https://www.google.com/", "ques": "According to the USGS, in what year was the American Alligator first found west of Texas (not including Texas)?"}
+{"task_id": "e2d69698-bc99-4e85-9880-67eaccd66e6c", "Level": 2, "Final answer": "Michele Fitzgerald", "id": "level2-52", "web": "https://www.google.com/", "ques": "As of August 2023, who is the only winner of the US version of Survivor to be born in the month of May?"}
+{"task_id": "a56f1527-3abf-41d6-91f8-7296d6336c3f", "Level": 2, "Final answer": "185", "id": "level2-53", "web": "https://www.google.com/", "ques": "The cover of the August 2021 issue of Vogue shows a famous landmark in the background behind some trees. How tall is this monument in yards, rounded to the nearest yard? Give the number only."}
+{"task_id": "42d4198c-5895-4f0a-b0c0-424a66465d83", "Level": 2, "Final answer": "60", "id": "level2-54", "web": "https://www.google.com/", "ques": "I'm curious about how much information is available for popular video games before their release. Find the Wikipedia page for the 2019 game that won the British Academy Games Awards. How many revisions did that page have before the month listed as the game's release date on that Wikipedia page (as of the most recent entry from 2022)?"}
+{"task_id": "a26649c6-1cb2-470a-871e-6910c64c3e53", "Level": 2, "Final answer": "116", "id": "level2-55", "web": "https://www.google.com/", "ques": "What is the absolute difference in tens of thousands between the population of chinstrap penguins on the Wikipedia page for penguin species populations as of the end of 2018 and the population recorded in the Nature.com \"global population assessment of the Chinstrap penguin\" article from 2020, assuming two penguins per breeding pair?"}
+{"task_id": "d5141ca5-e7a0-469f-bf3e-e773507c86e2", "Level": 2, "Final answer": "19/02/2009", "id": "level2-56", "web": "https://www.google.com/", "ques": "When was a picture of St. Thomas Aquinas first added to the Wikipedia page on the Principle of double effect? Answer using the format DD/MM/YYYY."}
+{"task_id": "1dcc160f-c187-48c2-b68e-319bd4354f3d", "Level": 2, "Final answer": "3", "id": "level2-57", "web": "https://www.google.com/", "ques": "According to Openreview.net, at the NeurIPS 2022 Conference, how many papers by an author named Yuri were accepted with a \"certain\" recommendation?"}
+{"task_id": "e0c10771-d627-4fd7-9694-05348e54ee36", "Level": 2, "Final answer": "234.9", "id": "level2-58", "web": "https://www.google.com/", "ques": "Take the gender split from the 2011 Bulgarian census about those who have completed tertiary education. Subtract the smaller number from the larger number, then return the difference in thousands of women. So if there were 30.1 thousand more men, you'd give \"30.1\""}
+{"task_id": "e29834fd-413a-455c-a33e-c3915b07401c", "Level": 2, "Final answer": "21", "id": "level2-59", "web": "https://www.google.com/", "ques": "I'd like to learn more about some popular reality television competition shows. As of the end of the 44th season of the American version of Survivor, how many more unique winners have there been compared to the number of winners of American Idol?"}
+{"task_id": "08c0b6e9-1b43-4c2e-ae55-4e3fce2c2715", "Level": 2, "Final answer": "orange, white", "id": "level2-60", "web": "https://www.google.com/", "ques": "In the film Goldfinger, what color was the object that James Bond concealed himself and his companion Pussy Galore at the end of the film? If there are multiple colors, put them in a comma-separated list in alphabetical order."}
+{"task_id": "db4fd70a-2d37-40ea-873f-9433dc5e301f", "Level": 2, "Final answer": "10", "id": "level2-61", "web": "https://www.google.com/", "ques": "As of May 2023, how many stops are between South Station and Windsor Gardens on MBTA\u2019s Franklin-Foxboro line (not included)?"}
+{"task_id": "853c8244-429e-46ca-89f2-addf40dfb2bd", "Level": 2, "Final answer": "11", "id": "level2-62", "web": "https://www.google.com/", "ques": "In the 2015 Metropolitan Museum of Art exhibition titled after the Chinese zodiac animal of 2015, how many of the \"twelve animals of the Chinese zodiac\" have a hand visible?"}
+{"task_id": "7a4a336d-dcfa-45a0-b014-824c7619e8de", "Level": 2, "Final answer": "1:41.614", "id": "level2-63", "web": "https://www.google.com/", "ques": "At the two-minute mark in the YouTube video uploaded by the channel \u201cGameGrumps\u201d on May 14, 2017 as part of their playthrough of the game Mario Kart 8 Deluxe, the shows\u2019 hosts are competing on one of the game\u2019s racetracks. What was the world record time for that track in the game\u2019s 150cc mode as of June 7, 2023? Express your answer in minutes and seconds, rounding the seconds to the nearest hundredth, e.g. 1:01.001."}
diff --git a/packages/evals/datasets/onlineMind2Web/onlineMind2Web.jsonl b/packages/evals/datasets/onlineMind2Web/onlineMind2Web.jsonl
new file mode 100644
index 000000000..58b3dfd0f
--- /dev/null
+++ b/packages/evals/datasets/onlineMind2Web/onlineMind2Web.jsonl
@@ -0,0 +1,300 @@
+{"task_id": "b7258ee05d75e6c50673a59914db412e", "confirmed_task": "Find the store location and hours of the closest Gamestop to zip code 90028 and set it as the home store on Gamestop.", "website": "https://www.gamestop.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "ade4c09ad3fdb1607209750924cd232f", "confirmed_task": "Compare available plans for the AeroAPI on Flightaware.", "website": "https://www.flightaware.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "fb7b4f784cfde003e2548fdf4e8d6b4f", "confirmed_task": "Open the page with an overview of the submission of releases on Discogs.", "website": "https://www.discogs.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "824eb7bb0ef1ce40bfd49c12182d9428", "confirmed_task": "Get the lowest priced women's plus size one piece swimsuit in color black with a customer rating of at least 5 on Kohls.", "website": "https://www.kohls.com/", "reference_length": 13, "level": "hard"}
+{"task_id": "046138801a05ddf56ad94e8672942496", "confirmed_task": "Find discussions of the community and open one with the most replies on Flightaware.", "website": "https://www.flightaware.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "92a3d4236f167af4afdc08876a902ba6", "confirmed_task": "Find a 2022 Tesla Model 3 on CarMax.", "website": "https://www.carmax.com/", "reference_length": 10, "level": "medium"}
+{"task_id": "48c73f3f53e2611c4a1052457c1033db", "confirmed_task": "Get the report from the final environmental impact statement for the Jamaica Bus Depot expansion on new.mta.info.", "website": "https://new.mta.info/", "reference_length": 10, "level": "medium"}
+{"task_id": "8f2611047de227a2ca8bda13f6e2e5fb", "confirmed_task": "Find the used 2012-2013 Honda Crosstour with the lowest mileage for under $25,000 near zip code 49102 on CarGurus.", "website": "https://www.cargurus.com/", "reference_length": 17, "level": "hard"}
+{"task_id": "b320c68bffc1f3c7f2a8dc9d5478fb27", "confirmed_task": "Find a walkthrough for the game \"The Legend of Zelda: Breath of the Wild\" on ign.", "website": "https://www.ign.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "aa4b5cb7114fcc138ade82b4b9716d24", "confirmed_task": "Find an editor's choice review with a score of 10 in the boardgame category on ign.", "website": "https://www.ign.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "005be9dd91c95669d6ddde9ae667125c", "confirmed_task": "Find the weight of baggage allowance for economy class on Qatar Airways.", "website": "https://www.qatarairways.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "323bd85e3559655d89e5496b951a25e8", "confirmed_task": "Tell me information about what identification I need to bring on my trip on Amtrak.", "website": "https://www.amtrak.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "123e8c2fc453f55fadd1d0b9aaf94df4", "confirmed_task": "Browse used Audi cars made before 2015 and sort by lowest price on KBB.", "website": "https://www.kbb.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "56f8890a837c49f7df766b9c981646f3", "confirmed_task": "Show crazy credits for the movie \" Prometheus\" on IMDb.", "website": "https://www.imdb.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "644a856c3897665e475e0dce50bf217d", "confirmed_task": "Find a pair of wireless headphones on Amazon with active noise canceling for $100 or less and add them to the cart.", "website": "https://www.amazon.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "62f1626ce249c31098854f8b38bdd6cf", "confirmed_task": "Find Playstation 5 digital edition on gamestop.", "website": "https://www.gamestop.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "561693d6eec7bbfba3fefe9e4b26decb", "confirmed_task": "Browse Marriott Bonvoy credit cards on Marriott.", "website": "https://www.marriott.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "b7a9a6b5d451164c09bbd27b670bc2ae", "confirmed_task": "Show me the list of Men's Blazers, Black, Size M on Uniqlo.", "website": "https://www.uniqlo.com/", "reference_length": 11, "level": "hard"}
+{"task_id": "bfa2de159be6978acf2702be31a2eeeb", "confirmed_task": "Show me the options for a roundtrip leaving from Las Vegas on flexible dates on the interactive map on united.", "website": "https://www.united.com/", "reference_length": 12, "level": "hard"}
+{"task_id": "4091bdd3fa64a5b0d912bc08eaf9c824", "confirmed_task": "Find the list of neighborhood maps for Brooklyn on new.mta.info.", "website": "https://new.mta.info/", "reference_length": 5, "level": "easy"}
+{"task_id": "79f0bd7df6e685f30f20025cc6755c0a", "confirmed_task": "Find me the cheapest external Hard Drive for an Xbox One on GameStop.", "website": "https://www.gamestop.com/", "reference_length": 13, "level": "hard"}
+{"task_id": "6ebde509dca8f15c0fa1bd74f071e8d6", "confirmed_task": "Search for a job in Miami, Florida, in Human Resources on target.", "website": "https://www.target.com/", "reference_length": 14, "level": "hard"}
+{"task_id": "34ccd15a8ea8fd3895af83f5ccf62369", "confirmed_task": "Find out what to do when I lose an item on a bus on us.megabus.", "website": "https://us.megabus.com/", "reference_length": 3, "level": "easy"}
+{"task_id": "c698ff3fc0f6cbce39947c597ab5749b", "confirmed_task": "Browse the page with event planning tips on Eventbrite.", "website": "https://www.eventbrite.com/", "reference_length": 5, "level": "easy"}
+{"task_id": "b6d10e9bd19b4009a02dea0e98f4e1ae", "confirmed_task": "Check the current standings for MLS on Fox Sports.", "website": "https://www.foxsports.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "d71be72aa25c3eab8eea47a0e60382e2", "confirmed_task": "Find technical specs for the latest Macbook Air on Apple.", "website": "https://www.apple.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "0b51b4fa0295ae80ccd176ebdad6fff6", "confirmed_task": "Search for a red Toyota Corolla from model years 2018 to 2023 on CarMax.", "website": "https://www.carmax.com/", "reference_length": 13, "level": "hard"}
+{"task_id": "3f312ae3efc3c3e90ababe050dd4e7ae", "confirmed_task": "Find the current NFL standings for the AFC East division on NFL.com and go to the page on which team is in first place.", "website": "https://www.nfl.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "95cad96f2e43f3c0d8efad1331c77c8c", "confirmed_task": "View the list of the Most Popular TV on rotten tomatoes.", "website": "https://www.rottentomatoes.com/", "reference_length": 3, "level": "easy"}
+{"task_id": "bf3b311cc8dce16d3de844f4b5875dfd", "confirmed_task": "Compare Apple watches and  learn more about the ultra version on apple.", "website": "https://www.apple.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "b64f938af842f6a1b4489d0e49a785a7", "confirmed_task": "Get the frozen vegan cheese pizza between 5 to 10 USD on Target.", "website": "https://www.target.com/", "reference_length": 17, "level": "hard"}
+{"task_id": "5e1b8254c123c80178cc28e0afdb14f0", "confirmed_task": "Find a help page about buying tickets on seatgeek.", "website": "https://seatgeek.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "f27c0a7b8b0bb33d37698dff227fc8d7", "confirmed_task": "Browse used Mercedes-Benz cars from model years 2004 to 2012 on KBB and sort by highest price.", "website": "https://www.kbb.com/", "reference_length": 11, "level": "hard"}
+{"task_id": "8fdec8eeffd3491e6526cc78c028120b", "confirmed_task": "See Nissan and Honda cars for sale near Kentwood, MI 49512 on CarMax.", "website": "https://www.carmax.com/", "reference_length": 12, "level": "hard"}
+{"task_id": "7b182a5087347d494b48a29dbc0f1d3e", "confirmed_task": "Find a shelter or rescue group near zip code 90011.", "website": "https://www.adoptapet.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "828c2d98616a9478d5864d847d5a1b28", "confirmed_task": "Browse the list of Civil Division forms.", "website": "https://www.justice.gov/", "reference_length": 4, "level": "easy"}
+{"task_id": "608c595eec271fa5dc03506923519994", "confirmed_task": "Calculate a FedEx Ground shipping rate for a 3-pound package from zip code 10019 to zip code 90028.", "website": "https://www.fedex.com/en-us/home.html", "reference_length": 9, "level": "medium"}
+{"task_id": "a7a73c8fa75441fc76df9746c327bdd6", "confirmed_task": "Estimate the cost of a photographer in 07055 for a 4-hour project.", "website": "https://www.thumbtack.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "cfafe3771369d1d261e9f7ecd44c296d", "confirmed_task": "Find the highest-rated dealer for Cadillac with a rating above 4 stars within 20 miles of zip 60606.", "website": "https://www.cars.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "bbbc243b4f18a7a897f0bc84e11d293f", "confirmed_task": "Find out how many assists Chris Paul has been averaging in the current season.", "website": "https://www.nba.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "816851ff92ff0219acf4364dcc2c4692", "confirmed_task": "Search for boys' infant pajamas below $40.", "website": "https://www.macys.com/", "reference_length": 10, "level": "medium"}
+{"task_id": "8244409b2c82043f966cad05f9afe132", "confirmed_task": "Find the best Audiologist within 50 miles of New York, NY, with a rating of 4 and above.", "website": "https://doctor.webmd.com/", "reference_length": 13, "level": "hard"}
+{"task_id": "e7301bb694871429bf2eb36c3a72186c", "confirmed_task": "Find baby shoes priced under $20 with a 5-star rating.", "website": "https://www.macys.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "905cb53061c33aa2d77e485fe1fca516", "confirmed_task": "Browse dermatologists within 10 miles of zip code 10019 and filter by only those who accept Blue Medicare Advantage.", "website": "https://www.healthgrades.com/", "reference_length": 11, "level": "hard"}
+{"task_id": "fcf4952d2a1d80ea505c555c3c3b54e7", "confirmed_task": "Find the cheapest used  8-cylinder bmw made between 2005-2015 and priced from 25,000 to  50,000 dollars with mileage less than 50,000 miles or less.", "website": "https://www.cars.com/", "reference_length": 11, "level": "hard"}
+{"task_id": "3c1ffc3f494e423b3c434c79e35da8f3", "confirmed_task": "Find 12 Monkeys community and view the latest posts mentioning James Cole.", "website": "https://www.reddit.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "26a0e5c21c145dd8448aa92f35bec5ea", "confirmed_task": "Browse optometrists who offer telehealth services in Columbus, OH.", "website": "https://www.healthgrades.com/", "reference_length": 3, "level": "easy"}
+{"task_id": "070c907d34a4ce71dfdbea38f9c5d4d8", "confirmed_task": "Find a dentist who specializes in pediatric dentistry and is located near zip code 90210 (within 5-mile distance).", "website": "https://www.healthgrades.com/", "reference_length": 7, "level": "medium"}
+{"task_id": "43a1ca251f11c6b0bdd0379766cc49e6", "confirmed_task": "Find a neurosurgeon who is over 50 years old and has an appointment available tomorrow.", "website": "https://www.healthgrades.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "b3f8bd9198d9d157e0848109563c4b23", "confirmed_task": "Find a permanent job in Logistics within 20 miles of New York, zip 11005, in the middle-income range for a high school diploma holder.", "website": "https://ohiomeansjobs.ohio.gov/", "reference_length": 15, "level": "hard"}
+{"task_id": "20a460a8fe1971b84411c5b1e6ac4186", "confirmed_task": "Show theatre events for Las Vegas and select one.", "website": "https://www.stubhub.com/", "reference_length": 3, "level": "easy"}
+{"task_id": "db1ffb5e60578597d1c3aa3c389ac7b1", "confirmed_task": "Search for smart TVs with a screen size of 55 to 65 inches and filter the results to show only those that have an LED display.", "website": "https://www.google.com/shopping?udm=28", "reference_length": 5, "level": "easy"}
+{"task_id": "7be8cd8dba885cddd9af5320f49bc41b", "confirmed_task": "Find roofing contractors within 5 miles of zip code 10002.", "website": "https://www.bbb.org/", "reference_length": 9, "level": "medium"}
+{"task_id": "239a29bde438fe44fe17fe1390ef1634", "confirmed_task": "Find me a gluten-free diet to lose weight for a pregnant woman.", "website": "https://www.healthline.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "9f1cba613830ca1c6a58f9498c06e679", "confirmed_task": "Find a premier real estate agent in St Augustine, FL.", "website": "https://www.redfin.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "75146b7b67388b9244e0f21a1527c022", "confirmed_task": "Find a male senior boxer near zip code 90028.", "website": "https://www.adoptapet.com/", "reference_length": 10, "level": "medium"}
+{"task_id": "59b7b990b4828bc305ab0d7ed6071b55", "confirmed_task": "Get owner-financing homesite land for sale in New Mexico, Luna County,  listed in the last 30 days, and contact the cheapest per acre land seller.", "website": "https://www.landwatch.com/", "reference_length": 9, "level": "medium"}
+{"task_id": "9c97bab9c2abfb90a426cbe9addae8d0", "confirmed_task": "Check the details of order 12345 with email 12345@gmail.com.", "website": "https://www.macys.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "871e7771cecb989972f138ecc373107b", "confirmed_task": "Find the weather for Vancouver, British Columbia for the next seven days.", "website": "https://www.theweathernetwork.com/", "reference_length": 3, "level": "easy"}
+{"task_id": "b69eb4de621e9e265676daac44938f3f", "confirmed_task": "Find an adult husky near zip code 10019.", "website": "https://www.adoptapet.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "9bb63ad0e38d5691a618932a8b31c05a", "confirmed_task": "Look for reviews of a Nest Hello Video Doorbell and filter by 1-star ratings.", "website": "https://www.google.com/shopping?udm=28", "reference_length": 5, "level": "easy"}
+{"task_id": "8ae510355d978424f490798f900bfa2c", "confirmed_task": "Show me the shared rooms in any university in Melbourne that has a private bathroom wifi, and gas included in the bills.", "website": "https://www.student.com/", "reference_length": 9, "level": "medium"}
+{"task_id": "4c186c6ed888d0c8d4cf4adb39443080", "confirmed_task": "Find a medium Devin Booker jersey and add it to the shopping cart.", "website": "https://www.nba.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "2fc51dd3febd447f0fdcdabca8d944ce", "confirmed_task": "Locate a self-storage unit near zip code 60538 that can fit about a dorm room full of items and is climate-controlled.", "website": "https://www.extraspace.com/", "reference_length": 9, "level": "medium"}
+{"task_id": "eb323dc584156d0eb3a2b90bb8c4b791", "confirmed_task": "Find the latest 2 bed and 1.5+ bath apartment listing for rent in New York.", "website": "https://www.redfin.com/", "reference_length": 12, "level": "hard"}
+{"task_id": "87f4c5128e36cdb9366a138a7b61bb00", "confirmed_task": "View the speakers that are bluetooth and wireless and filter the results to only show models that are on sale and cost less than $50.", "website": "https://www.bestbuy.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "354b4ddf048815f8fd4163d0d7e1aaa3", "confirmed_task": "Browse marketing jobs and filter by Bachelor's Degree education level.", "website": "https://ohiomeansjobs.ohio.gov/", "reference_length": 6, "level": "medium"}
+{"task_id": "e4e097222d13a2560db6f6892612dab6", "confirmed_task": "Search for a young spayed male dog cared for by a private owner within 50 miles of zip 33109.", "website": "https://www.adoptapet.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "f389398d2eeb29e5571e00439c57eb76", "confirmed_task": "Find the latest climate news.", "website": "https://www.theweathernetwork.com/", "reference_length": 3, "level": "easy"}
+{"task_id": "8ea6c3a2ea3f59150619935261a76d19", "confirmed_task": "Find a staffed FedEx location near zip code 10019 to return a package.", "website": "https://www.fedex.com/en-us/home.html", "reference_length": 7, "level": "medium"}
+{"task_id": "c1d6ea6f2196d25782cc3646ff3090db", "confirmed_task": "Create a list of drip coffee makers that are on sale and within $25-60 and have a black finish.", "website": "https://www.google.com/shopping?udm=28", "reference_length": 7, "level": "medium"}
+{"task_id": "2dd41b1d0e8f389d0683f4a4627abfe6", "confirmed_task": "Show houses for sale in Maryland with a maximum price of $60,000.", "website": "https://www.landwatch.com/", "reference_length": 7, "level": "medium"}
+{"task_id": "f2097f92a10d42a842c14179f422311e", "confirmed_task": "Add a $50 Uber gift card to the cart.", "website": "https://www.bestbuy.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "85b284c18d7e78c9b5a9e074e7aa3b98", "confirmed_task": "View the cheapest apartment available for students at the University of Leeds with bills that include WIFI and cleaning services.", "website": "https://www.student.com/", "reference_length": 10, "level": "medium"}
+{"task_id": "853afd530c72f4b00ffc32ae854efaf8", "confirmed_task": "Show me the wind flow map for Belo Horizonte.", "website": "https://www.accuweather.com/", "reference_length": 5, "level": "easy"}
+{"task_id": "c09721cc937d4dcfb391a0bc2c574b28", "confirmed_task": "Find the next available date for Albion Basin.", "website": "https://www.recreation.gov/", "reference_length": 3, "level": "easy"}
+{"task_id": "4c572a627b53b0f9a734ab37f21819b8", "confirmed_task": "Browse apartments with at least 2 bedrooms and 2 bathrooms and a max price of $4000 per month.", "website": "https://craigslist.org/", "reference_length": 5, "level": "easy"}
+{"task_id": "301f267f421b93045874726183e8f722", "confirmed_task": "Find healthy savory vegan snack recipes which can be cooked within 5 minutes and contain a high level of protein.", "website": "https://www.healthline.com/", "reference_length": 10, "level": "medium"}
+{"task_id": "4f903626f632586fe4728d6664947bab", "confirmed_task": "Find press releases by the antitrust division in 2022.", "website": "https://www.justice.gov/", "reference_length": 4, "level": "easy"}
+{"task_id": "3ec0f6138d37fadcb989347a6088ec45", "confirmed_task": "Open the page to learn more about how to get accredited.", "website": "https://www.bbb.org/", "reference_length": 2, "level": "easy"}
+{"task_id": "2207bb4f21786690cfed20b37253fb8b", "confirmed_task": "Check the current wind speed in Calgary, Alberta.", "website": "https://www.theweathernetwork.com/", "reference_length": 2, "level": "easy"}
+{"task_id": "9c04b71bb8db6cf8e743b2290cbc8797", "confirmed_task": "Find a UPS drop-off point near Miami Florida.", "website": "https://www.ups.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "4e0f5561a76478da87995dee00b09572", "confirmed_task": "Show me the monthly weather forecast for Florida City.", "website": "https://www.accuweather.com/", "reference_length": 3, "level": "easy"}
+{"task_id": "7562d9b4e4829a44245aafce2e1f62db", "confirmed_task": "Find the nearest location to zip code 54620 that offers size 4 P.O. Boxes.", "website": "https://www.usps.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "bd1e3770b7181f6fce9c35e18caa9785", "confirmed_task": "Browse service listings for a solar panel installer and hide duplicates.", "website": "https://craigslist.org/", "reference_length": 3, "level": "easy"}
+{"task_id": "330cd04c773ac498f51afa4665461ec8", "confirmed_task": "Browse couches for sale, sort by cheapest, and search in titles only.", "website": "https://craigslist.org/", "reference_length": 6, "level": "medium"}
+{"task_id": "ec78d3a635e417bc2a80d03ca93d7165", "confirmed_task": "What are the benefits and financial support a single person living in England, over the state pension age, unemployed, with no health conditions, or caring for someone with one, can get?", "website": "https://www.gov.uk/", "reference_length": 16, "level": "hard"}
+{"task_id": "a0a18ca6a3529f3e97c771aadd42d3a0", "confirmed_task": "Add a men's T-shirt that is in large size with a stripe pattern, short sleeve, and under the Best Sellers group to the cart.", "website": "https://www.macys.com/", "reference_length": 7, "level": "medium"}
+{"task_id": "82eb3bfedd78456a0230b389f4e7a938", "confirmed_task": "Open the XRP yearly chart.", "website": "https://coinmarketcap.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "e7f6cca9a8875f98fee3b711ead3a444", "confirmed_task": "Find the comments made by the user Separate-Camp7202.", "website": "https://www.reddit.com/", "reference_length": 5, "level": "easy"}
+{"task_id": "75a1b5dcd2c28508a971d98d51fe5767", "confirmed_task": "Open the reviews of a recipe with beef sirloin.", "website": "https://www.allrecipes.com/", "reference_length": 5, "level": "easy"}
+{"task_id": "c03ee2be3d73556ab789c0ad1cbd3451", "confirmed_task": "Find a dog groomer for nail trimming within 100 miles of zip code 10005 and check the detailed service prices of the first one.", "website": "https://www.akc.org/", "reference_length": 11, "level": "hard"}
+{"task_id": "05483c50cc9b04c8ac44c574758fb2bd", "confirmed_task": "Look for the best rated BBB accredited charity near 12023.", "website": "https://www.bbb.org/", "reference_length": 8, "level": "medium"}
+{"task_id": "a172a5d9ffaf5ef02bd550ec4fe24e6d", "confirmed_task": "Browse the natural products database.", "website": "https://www.drugs.com/", "reference_length": 2, "level": "easy"}
+{"task_id": "7e1047f4803237f319c004f7a7f6bccb", "confirmed_task": "Discover the trade-in value of my Intel 7th generation i3 Windows 10, HP laptop in fair condition,  which has 8 GB memory and can be powered on, proceed for the in-store trade-in.", "website": "https://www.bestbuy.com/", "reference_length": 13, "level": "hard"}
+{"task_id": "f2be37a9a60fbc25b6b11cf622d17352", "confirmed_task": "Find obedience trials in state of New York during the month of May.", "website": "https://www.akc.org/", "reference_length": 14, "level": "hard"}
+{"task_id": "e24662008c3be5d56f986f232fcec447", "confirmed_task": "Find the stock price for WWE over the last month.", "website": "https://www.google.com/finance/", "reference_length": 4, "level": "easy"}
+{"task_id": "0170ca95038b05fa58d463fe627ac605", "confirmed_task": "Check if a visa is required to work in the UK for longer than 6 months in Healthcare as an American citizen.", "website": "https://www.gov.uk/", "reference_length": 12, "level": "hard"}
+{"task_id": "b3a7da968de13bbdcaed12ffe4993df6", "confirmed_task": "Compare the breeds Afghan Hound, Akita and Azawakh.", "website": "https://www.akc.org/", "reference_length": 9, "level": "medium"}
+{"task_id": "515f2e5811cfdd5e0e669e40f17886d8", "confirmed_task": "Search for a new internal M2 Samsung SSD drive between $25 and $200.", "website": "https://www.bestbuy.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "4d3157aab34b54e5f0c4b965dfe930f3", "confirmed_task": "Show me community posts about pregnancy fever from the past 30 days.", "website": "https://www.babycenter.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "e4e19e04286f644d747d8c5a79d17fac", "confirmed_task": "Find the Drug Interaction Report for Viagra and alcohol.", "website": "https://www.drugs.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "cad62d2be0c53f08a416457486b3db23", "confirmed_task": "Search for adoptable dogs near 21122 zip code.", "website": "https://www.adoptapet.com/", "reference_length": 5, "level": "easy"}
+{"task_id": "9ef1a8972f375db59c0e6329e11b7939", "confirmed_task": "Find Farms land in Wilkes County, NC with the lowest price.", "website": "https://www.landwatch.com/", "reference_length": 5, "level": "easy"}
+{"task_id": "a11ecdff735b51372d536c866011af6f", "confirmed_task": "Explore courses related to Psychology.", "website": "https://www.coursera.org/", "reference_length": 4, "level": "easy"}
+{"task_id": "7fff82864f21ddeccf4104a220892824", "confirmed_task": "Find the lowest 27\"-32\" Samsung or LG computer monitors nearby which have 4k, IPS display.", "website": "https://www.google.com/shopping?udm=28", "reference_length": 10, "level": "medium"}
+{"task_id": "50d91eabde542906937ab4c5b6f8f23a", "confirmed_task": "Calculate Pregnancy Weight Gain for a 5-week pregnancy with a 169lb weight before pregnancy and a 175lb after pregnancy with a 5.6ft height.", "website": "https://www.babycenter.com/", "reference_length": 9, "level": "medium"}
+{"task_id": "dcd26e662a616d373ddd339747c6ce5b", "confirmed_task": "Take a weight management quiz to find a motivating article for a non-exercising, mostly eating out and can't control portions and cravings, and who has a strong support system, enjoys traveling, loves family time and cooking.", "website": "https://www.healthline.com/", "reference_length": 22, "level": "hard"}
+{"task_id": "eb2db4b769c145dbe6ba4f74f3e0de98", "confirmed_task": "Find an energetic hairless dog with medium barking.", "website": "https://www.akc.org/", "reference_length": 10, "level": "medium"}
+{"task_id": "c0fa2c0e622971955cabf5bcf7b777e8", "confirmed_task": "Search for rentals in Corning, CA with a maximum price of $1500.", "website": "https://www.apartments.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "ce616721ce9aeda69890fbccb29677a6", "confirmed_task": "Calculate the price to ship a large flat-rate box from 77449 to 77084 at the first available date and time.", "website": "https://www.usps.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "9d09bc948462db032bac98968b11b008", "confirmed_task": "Find NHL events occurring in Boston.", "website": "https://www.stubhub.com/", "reference_length": 7, "level": "medium"}
+{"task_id": "29526b17a32485742b5ab63507e99417", "confirmed_task": "Browse Humira dosage information.", "website": "https://www.drugs.com/", "reference_length": 3, "level": "easy"}
+{"task_id": "d7c955b47af68e01766fa86d0bee08a7", "confirmed_task": "Add Elevate at Chicago, IL, to favorites and show a virtual tour.", "website": "https://www.apartments.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "9d090a15c214eb070d9caa8a034d03c1", "confirmed_task": "Find the lowest-priced Student housing near Liverpool International College which has been priced between 100 to 300 pounds and has a private bathroom.", "website": "https://www.student.com/", "reference_length": 14, "level": "hard"}
+{"task_id": "5916018d1cad999881018cac1216a692", "confirmed_task": "Find a personal trainer service at 10040 for a 25-year-old client aiming to build muscle.", "website": "https://www.thumbtack.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "0059adc6b12a3822305deb68929b2de8", "confirmed_task": "Find support services jobs in Bentonville, in the state of Arkansas.", "website": "https://careers.walmart.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "07bdc595306729a028ba06cc7451a80a", "confirmed_task": "Select a high speed train ticket with a departure time before 23:00  from Shanghai to Beijing.", "website": "https://us.trip.com/", "reference_length": 7, "level": "medium"}
+{"task_id": "64b76158720a69e4a5c31a55d54928bf", "confirmed_task": "Compare two pescatarian diets for eating healthier.", "website": "https://www.healthline.com/", "reference_length": 10, "level": "medium"}
+{"task_id": "e3ab665e01e7632ce33ac1aeca14aff6", "confirmed_task": "Find the next available dates for Alley Creek Camp.", "website": "https://www.recreation.gov/", "reference_length": 3, "level": "easy"}
+{"task_id": "2d5a7f95f951a26838289dfd629ae850", "confirmed_task": "Find a list of houses for sale in zip code 85747 with a private pool.", "website": "https://www.redfin.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "26810ed9c123a62992e3eed31db3c5ee", "confirmed_task": "Show daily weather for New York City.", "website": "https://www.accuweather.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "c181f903ec1107b850032c17cad88393", "confirmed_task": "Help me identify a pink round pill with 150 written on it.", "website": "https://www.webmd.com/", "reference_length": 7, "level": "medium"}
+{"task_id": "ef289e34a2f59a707cb07e2a6229ff03", "confirmed_task": "Compare the Acura CL 2003 with the ILX 2022.", "website": "https://www.cars.com/", "reference_length": 9, "level": "medium"}
+{"task_id": "84f806c7fc15576673915f195efa72df", "confirmed_task": "Find a nationwide nearest animal shelter for birds around zip 10012.", "website": "https://www.adoptapet.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "be9e7dca1222714571ef3d7d59d2a41c", "confirmed_task": "Find out the cold and flu forecast and today's air quality in Champaign, IL.", "website": "https://weather.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "11abb668c751dd56bb41f296a8bb3a13", "confirmed_task": "Find a store near zip 30010 that provides authorized Apple services for imacs and make this one my store.", "website": "https://www.bestbuy.com/", "reference_length": 10, "level": "medium"}
+{"task_id": "207e933d1bba815bcb58664b5d82c085", "confirmed_task": "Find Ohio City apartments with parking, a fitness center, and an elevator.", "website": "https://www.apartments.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "29b7372d5a3884a2ba831af2d117af3c", "confirmed_task": "Browse the first top news of Microsoft stock on Google Finance.", "website": "https://www.google.com/finance/", "reference_length": 3, "level": "easy"}
+{"task_id": "5c00e9561eae94789443f405525a5869", "confirmed_task": "Find the recommended dosage for Vivitrol.", "website": "https://www.healthline.com/", "reference_length": 5, "level": "easy"}
+{"task_id": "2532fd402d3c741b79894e6ff2269f53", "confirmed_task": "find electricians near 10203.", "website": "https://www.thumbtack.com/", "reference_length": 3, "level": "easy"}
+{"task_id": "9829f3087ab1f9c8eba6b6dd2b831d25", "confirmed_task": "Play the latest video from NBA TV.", "website": "https://www.nba.com/", "reference_length": 3, "level": "easy"}
+{"task_id": "783ce6a3499fa7cf25bc12f8f0ecbbbb", "confirmed_task": "Find Florida internship programs in the Mayo Clinic College of Medicine and Science.", "website": "https://www.mayoclinic.org/", "reference_length": 5, "level": "easy"}
+{"task_id": "6db4a0e346976f2729ba9afcd3208941", "confirmed_task": "Look up tracking information for shipment #3023858502.", "website": "https://www.fedex.com/en-us/home.html", "reference_length": 2, "level": "easy"}
+{"task_id": "1fc28d91d25ccd1c6ba268101326a654", "confirmed_task": "Find the 5-day price chart for Bitcoin.", "website": "https://www.google.com/finance/", "reference_length": 3, "level": "easy"}
+{"task_id": "255bf27c43fd3f9254d6b81a5f36d3a9", "confirmed_task": "Look for the largest hunting land for auction in Kansas high plain region with mineral rights posted in the last seven days.", "website": "https://www.landwatch.com/", "reference_length": 9, "level": "medium"}
+{"task_id": "a8b9edd598561d2de901864d5f40fe67", "confirmed_task": "Calculate the shipping cost for 4 pound package from Texas to New York.", "website": "https://www.fedex.com/en-us/home.html", "reference_length": 9, "level": "medium"}
+{"task_id": "a6f0434ce6aff5f9b03681241b03ad82", "confirmed_task": "Find the closing stock price for Tesla on March 17, 2023.", "website": "https://finance.yahoo.com/", "reference_length": 3, "level": "easy"}
+{"task_id": "415bf9da6f3db3a735ecbba3b0c76c15", "confirmed_task": "Find the nearest vet within 50 miles of zip 75228.", "website": "https://www.akc.org/", "reference_length": 9, "level": "medium"}
+{"task_id": "8103786e0e5976ebf961bd062d5f39cd", "confirmed_task": "Find possible causes for the symptoms of chest pain which is sharp which is accompanied by anxiety.", "website": "https://www.mayoclinic.org/", "reference_length": 9, "level": "medium"}
+{"task_id": "92160852a6bbbc165cee4e14ab0b1d59", "confirmed_task": "Find the shipping cost of a Common medium-sized box in flat-rate shipping and compare it with other parcel services.", "website": "https://www.ups.com/", "reference_length": 5, "level": "easy"}
+{"task_id": "502e864440283214e0180645015f568b", "confirmed_task": "Check permit availability for a group of 4 in Brooks Camp, Katmai National Park on May 22.", "website": "https://www.recreation.gov/", "reference_length": 8, "level": "medium"}
+{"task_id": "7680a920359cb1a508fbddb001b98167", "confirmed_task": "See the prediction about the girl child's height, whose current height at seven years is 4 feet and whose weight is 55 lbs, her mother is 5 feet 2, and her father is 5 feet 8.", "website": "https://www.babycenter.com/", "reference_length": 11, "level": "hard"}
+{"task_id": "07ec4a12cba8090e2dc524d558ac7675", "confirmed_task": "Check drug interaction for melatonin and Folate Forte.", "website": "https://www.drugs.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "987bad7c6d4726d64232a8a1c3386888", "confirmed_task": "Find the seller info and seller's notes about the used car model 2011 BMW 135 with a max price of $30000.", "website": "https://www.cars.com/", "reference_length": 11, "level": "hard"}
+{"task_id": "15be05973fba714e490cd9c884e4f072", "confirmed_task": "Find the procedure to get the license for Athletic Trainer.", "website": "https://ohio.gov/", "reference_length": 6, "level": "medium"}
+{"task_id": "3adeea7627f4343069f38adae40f73d0", "confirmed_task": "Within 25 Miles of 96817, find a nursing home that accepts medicare.", "website": "https://health.usnews.com/", "reference_length": 7, "level": "medium"}
+{"task_id": "c94551d2b18f9ad0ab31b0bd98ca42e3", "confirmed_task": "Find cats available for adoption within 10 miles of zip code 94587, Young or adult-age cats, sorted by Oldest Addition.", "website": "https://www.petfinder.com/", "reference_length": 10, "level": "medium"}
+{"task_id": "4e801ba102dfaf22c7cf7a126b107609", "confirmed_task": "Find Linux platform software developers in 10080 who master the Python language and Java language with web interface project type.", "website": "https://www.thumbtack.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "39c388cdc468688c8139cc2bb5157c13", "confirmed_task": "Calculate the estimated car loan payment amount for an average credit-rated person for a 15,000-dollar car with a down payment of 2000 dollars and loan tenure of 48 months in zip 65215 and shop for the lowest-priced car.", "website": "https://www.cars.com/", "reference_length": 9, "level": "medium"}
+{"task_id": "c8d7f2aa7eb5dd074c48c9f76f8659ad", "confirmed_task": "Show Teen Driver Safety program information.", "website": "https://www.dmv.virginia.gov/", "reference_length": 2, "level": "easy"}
+{"task_id": "fd787623166785d84093565bf945fd24", "confirmed_task": "Check the interaction between Novolin N and Novolin R.", "website": "https://www.drugs.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "c3307a70bb12ebf56cc9ec926b368f15", "confirmed_task": "Find the interactions between Eulexin and hepatic dysfunction.", "website": "https://www.drugs.com/", "reference_length": 5, "level": "easy"}
+{"task_id": "9586827ad04ee2362f4f0076bf0f0468", "confirmed_task": "Find the side effects of taking Montelukast.", "website": "https://www.drugs.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "34992feb69eb8e788faa06868b365c49", "confirmed_task": "Submit a request for vehicle registration renewal with title number X123456 and last 4 digits of VIN is 1234.", "website": "https://www.dmv.virginia.gov/", "reference_length": 5, "level": "easy"}
+{"task_id": "47b93b9e649eadeb8d96a6e3df715c2d", "confirmed_task": "Show me Diagnoses & Treatment for Female infertility.", "website": "https://www.mayoclinic.org/", "reference_length": 4, "level": "easy"}
+{"task_id": "3443e9c3151fef19a3c3a45eb2c13640", "confirmed_task": "Search for the ovulation calculator and enter Mar 1 as the first date of the period and calculate the date of ovulation and pregnancy test day.", "website": "https://www.webmd.com/", "reference_length": 12, "level": "hard"}
+{"task_id": "6b5be1764692d1dc8f17dc4375b2daa8", "confirmed_task": "Show me historical data for EUR/USD.", "website": "https://finance.yahoo.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "16200f51d63f0a47a58fa17acd49e368", "confirmed_task": "Find a recipe that includes eggplant and mushrooms.", "website": "https://cookpad.com/", "reference_length": 3, "level": "easy"}
+{"task_id": "c2153fc053112e89c2f103869c4d6890", "confirmed_task": "Find a house cleaning service in 10001 on a weekly basis.", "website": "https://www.thumbtack.com/", "reference_length": 5, "level": "easy"}
+{"task_id": "5e4e89c9b6fdaee7a41aca5601b82e04", "confirmed_task": "Identify a pill with a pink color and oval shape with 894 5 number on it.", "website": "https://www.drugs.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "60cbbbd58eb9d28b053aef945f464228", "confirmed_task": "Look up if the phone number 555555555 is a scam.", "website": "https://www.bbb.org/", "reference_length": 6, "level": "medium"}
+{"task_id": "8f80e64e44e1fada018997b2fe869683", "confirmed_task": "What are the top posts of all time on Reddit?", "website": "https://www.reddit.com/", "reference_length": 3, "level": "easy"}
+{"task_id": "65c4030f22fb6eb101acfee4825f1318", "confirmed_task": "Find a female MD Cardiologist in Jacksonville, Florida.", "website": "https://www.mayoclinic.org/", "reference_length": 8, "level": "medium"}
+{"task_id": "6ca20f1da01edeb49a7a42c816d8c6fe", "confirmed_task": "Find the Eligibility to get the child benefit and How it works and how to claim", "website": "https://www.gov.uk/", "reference_length": 8, "level": "medium"}
+{"task_id": "2e4e21cf1449c6894b17d571c47b77ea", "confirmed_task": "Find an English bulldog near zip code 90028 that was cared for by a private owner.", "website": "https://www.adoptapet.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "1df24ec81137386d6476bcf343a79012", "confirmed_task": "Search for NordicTrack with the lowest price.", "website": "https://www.bestbuy.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "4639a54f3ab549864fd8d60b7398b1e1", "confirmed_task": "Find a white female kitten within 35 miles of zip 77494.", "website": "https://www.adoptapet.com/", "reference_length": 10, "level": "medium"}
+{"task_id": "9af05e392cf3f5a8ff17aa764ba5bda6", "confirmed_task": "Get a quote from C and above-rated solar energy equipment company within 10 miles of Miami, Florida.", "website": "https://www.bbb.org/", "reference_length": 16, "level": "hard"}
+{"task_id": "627f7a18d85f29a687234f1ade4585c2", "confirmed_task": "Find the current league leader in total blocked shots.", "website": "https://www.nba.com/", "reference_length": 5, "level": "easy"}
+{"task_id": "0b838cd54f826c59c71f600c56b89a11", "confirmed_task": "Find all the locations for the second-best-rated used car dealer less than 5 miles from New York.", "website": "https://www.bbb.org/", "reference_length": 11, "level": "hard"}
+{"task_id": "5dec0e6620849459f29e6465982c597e", "confirmed_task": "Search for 33 to 49inch Qled gaming monitor with a 240hz refresh rate that is within $1000 to $2000.", "website": "https://www.bestbuy.com/", "reference_length": 11, "level": "hard"}
+{"task_id": "52efbab520734ef9bf7c09ba0f62cdc8", "confirmed_task": "Find the app for iOS.", "website": "https://www.recreation.gov/", "reference_length": 2, "level": "easy"}
+{"task_id": "b1ce968a361e1088ce8d2ade6c2c9af0", "confirmed_task": "Find young cats in Seattle and show off the newest additions.", "website": "https://www.petfinder.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "23204728192da9f73197a613d9681c18", "confirmed_task": "What are the Symptoms and causes of fever?", "website": "https://www.mayoclinic.org/", "reference_length": 3, "level": "easy"}
+{"task_id": "a69d2934fe54fef165490a5a2d95bf38", "confirmed_task": "Show me recipes for pancakes with wheat and without beetroot.", "website": "https://cookpad.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "e9f4dfc67e0e6aa37f05f7cc5aa7428c", "confirmed_task": "Browse pediatricians near zip code 90028 who specialize in Internal Medicine and have a rating of at least 4 stars.", "website": "https://www.healthgrades.com/", "reference_length": 9, "level": "medium"}
+{"task_id": "2218042362d8fae73756eb309848c2b2", "confirmed_task": "Compare Audi A7 with Audi A6, both made in 2023, and hide similarities.", "website": "https://www.cars.com/", "reference_length": 9, "level": "medium"}
+{"task_id": "ba2a469af584f16da93ce6a7430cf7e5", "confirmed_task": "Search for a beginner\u2019s course in computer science that includes advertisement skills.", "website": "https://www.coursera.org/", "reference_length": 7, "level": "medium"}
+{"task_id": "26784156ae9859a0dd6c5920eb106f91", "confirmed_task": "calculate and search rent for a $6000 monthly income with 30% rent budget near 90012 area.", "website": "https://www.apartments.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "47e314cc452c540524ffb7cf520285a3", "confirmed_task": "Find the park that offers the cheapest paddling permits.", "website": "https://www.recreation.gov/", "reference_length": 6, "level": "medium"}
+{"task_id": "271b36efd4346721b5542488ff997042", "confirmed_task": "Browse 8K Samsung TVs that are open box.", "website": "https://www.bestbuy.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "6b2cfae0ef25c73d1224b6ab74cb8b63", "confirmed_task": "Find Devin Booker's highest-scoring points per game playoff run.", "website": "https://www.nba.com/", "reference_length": 7, "level": "medium"}
+{"task_id": "0a54069a0ef542e571d1fee7f39c93d5", "confirmed_task": "Browse senior spayed/neutered dogs near zip code 90028.", "website": "https://www.adoptapet.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "4e3f6a538cc1f7321cfc50260db9545d", "confirmed_task": "Look up the current temperature for zip code 10019.", "website": "https://www.theweathernetwork.com/", "reference_length": 2, "level": "easy"}
+{"task_id": "f00e7accfb4a5e09680bdb326e6274ad", "confirmed_task": "Check the hourly forecast for Boston.", "website": "https://www.accuweather.com/", "reference_length": 3, "level": "easy"}
+{"task_id": "6174e5ddd40cfbdc33ee1502f40bac39", "confirmed_task": "Find a day-use park that offers horseback riding near Nashville.", "website": "https://www.recreation.gov/", "reference_length": 6, "level": "medium"}
+{"task_id": "547f5729c59d5d12a457a3ebb74c31c6", "confirmed_task": "Search for 3 bedroom condos with 2 bathrooms within $1500- $2500 range in NYC.", "website": "https://www.apartments.com/", "reference_length": 14, "level": "hard"}
+{"task_id": "0b2623e9fa5cea997f76490bcbc5220f", "confirmed_task": "Find a list of shorthaired dogs available for adoption within 100 miles of zip code 94587 that are good with kids and cats, and have been on Petfinder for over 30 days.", "website": "https://www.petfinder.com/", "reference_length": 13, "level": "hard"}
+{"task_id": "3ae28b3c440efe87dc700480b78ac608", "confirmed_task": "Find the closest 5-star rated dentist to zip code 98011.", "website": "https://www.healthgrades.com/", "reference_length": 9, "level": "medium"}
+{"task_id": "0632e496d37badee0350dad358f047c5", "confirmed_task": "Browse recipes for gluten-free chocolate chip cookies that can be made without nuts.", "website": "https://cookpad.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "aafd1fddea1558466ac6133934d35156", "confirmed_task": "Find a Single-Family House for Rent in Houston, TX with 1 bed.", "website": "https://www.apartments.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "246d654fab7c31d9651007e39e75f74f", "confirmed_task": "Open the most helpful 5-star reviews of Alpine Ridge.", "website": "https://www.recreation.gov/", "reference_length": 5, "level": "easy"}
+{"task_id": "690d7b4a285fdb1e9dabf973bf46ae4d", "confirmed_task": "Browse iPhone X for sale that is in good condition, has a max price of 400, and searches in titles only.", "website": "https://craigslist.org/", "reference_length": 8, "level": "medium"}
+{"task_id": "c43a7dccf5c44f7b45a821e712dd1970", "confirmed_task": "Take a newsletter subscription with my email id (buckeye.foobar@gmail.com) for Allergies and asthma, Anxiety and depression, nutrition, diabetes, breast cancer, and migraine with email id.", "website": "https://www.healthline.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "d5c34bf39eb6096ae5d439325cde4d32", "confirmed_task": "Find a DMV center in Richmond.", "website": "https://www.dmv.virginia.gov/", "reference_length": 5, "level": "easy"}
+{"task_id": "180ed2ec377ef3a4af9035a21522091a", "confirmed_task": "Find the way to give a gift to UM-Dearborn.", "website": "https://umich.edu/", "reference_length": 5, "level": "easy"}
+{"task_id": "c521933dad9c0ef9f1dfa2f38b8e4405", "confirmed_task": "See the monthly forecast for Atlanta, GA.", "website": "https://www.accuweather.com/", "reference_length": 3, "level": "easy"}
+{"task_id": "9b5dfe54a1c14c5c6336bae7374c3bb5", "confirmed_task": "Find a UPS Access Point near SPRING, TX and services provided by them.", "website": "https://www.ups.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "c073ac1bcf40f84c599affc97edbc396", "confirmed_task": "Search for the cheapest apartment in Detroit for a student.", "website": "https://www.apartments.com/", "reference_length": 9, "level": "medium"}
+{"task_id": "73d08420706ae205a9c5be28b6d4e80f", "confirmed_task": "Show me the rules and cancellation for Alley Spring.", "website": "https://www.recreation.gov/", "reference_length": 3, "level": "easy"}
+{"task_id": "0a0fa834ce41b5297c6474293383759d", "confirmed_task": "What are the onboard activities of the highest-rated Regent Seven Seas Cruise ship based on Costco member reviews?", "website": "https://www.costco.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "a13e4231a3d6a7000c622c56448d97ba", "confirmed_task": "Find an Airbnb in Cleveland for three nights. The check-in date is the day after tomorrow. We have 2 adults, 2 kids, and 1 pet. The budget is $100 to $300 per night. Essential amenities include free parking, a washer, and a gym.", "website": "https://www.airbnb.com/", "reference_length": 19, "level": "hard"}
+{"task_id": "bb518416a786fdb9b9bbf0c78515595e", "confirmed_task": "Browse the class schedule of graduate-level computer science courses.", "website": "https://www.osu.edu/", "reference_length": 4, "level": "easy"}
+{"task_id": "b99c02965196d51e80ac7539e33f335b", "confirmed_task": "Please find graduate-level computer science courses scheduled on Tuesdays starting time from 2:00 to 6:00 PM in the Fall 2023 semester.", "website": "https://www.berkeley.edu/", "reference_length": 9, "level": "medium"}
+{"task_id": "27fa3ac20745d3d35e89fae157f63069", "confirmed_task": "Browse the class schedule of graduate-level chemistry courses on Monday afternoons in the winter of 2023.", "website": "https://www.stanford.edu/", "reference_length": 11, "level": "hard"}
+{"task_id": "b4aa7315e31dfcdc52baf7771be260c9", "confirmed_task": "Find the HGX H100 driver for Ubuntu 22.04 on AMD64 CPU.", "website": "https://www.nvidia.com/", "reference_length": 11, "level": "hard"}
+{"task_id": "442a450e696a96085257db6297891a4d", "confirmed_task": "Using a calculator to determine how much I can have in my 401(k) account at retirement, if I work from age 22 to 65, with an annual rate of return of 3%, annual employee contributions of $8,000, and annual employer contributions of $8,000.", "website": "https://www.chase.com/", "reference_length": 11, "level": "hard"}
+{"task_id": "9ed3827266b3b804f485859c3d00401e", "confirmed_task": "If I'm 30, plan to retire at 65, and can save $300/month, with a 3% annual return, 13% current tax rate, and 24% retirement tax rate, show the comparison chart between Traditional and Roth IRA.", "website": "https://www.chase.com/", "reference_length": 12, "level": "hard"}
+{"task_id": "c801d1c951f59297f526bab84fa86c6e", "confirmed_task": "Browse the latest negative reviews from players with over 100 hours of playtime for the game that won the 2023 VR Game of the Year Award.", "website": "https://store.steampowered.com/", "reference_length": 11, "level": "hard"}
+{"task_id": "7c09c2c7c87cf6bb1138701eb54284ea", "confirmed_task": "Find the comments for the most popular news in the past month under the Quantum Physics topic.", "website": "https://phys.org/", "reference_length": 8, "level": "medium"}
+{"task_id": "afcebfed28bea091d58f49ea6cb8194b", "confirmed_task": "Find the most reviewed gluten-free multivitamins from CVS Health Brand under $15.", "website": "https://www.cvs.com/", "reference_length": 12, "level": "hard"}
+{"task_id": "64345c365f544375357c7b67917f08a0", "confirmed_task": "Look for the newest refrigerator that is 34-36 inches wide, priced between $1,000 and $2,000, and has a customer review rating of 4 stars or higher.", "website": "https://www.costco.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "ab6ee3b83aab6cd283320f5e01003cff", "confirmed_task": "Find the tech specs of the MacBook Pro 16-inch introduced in November 2023.", "website": "https://www.apple.com/", "reference_length": 7, "level": "medium"}
+{"task_id": "33bd2cdcea4fcc42a09a8a1e4e5841c6", "confirmed_task": "Add a 5-piece Tenders Combo to my bag with Sweet Corn as the side, Sweet Tea as the drink, and both Honey BBQ and Honey Mustard sauces. Select the store closest to Zip code 10001 for pick-up tomorrow at 12:00 PM.", "website": "https://www.kfc.com/", "reference_length": 23, "level": "hard"}
+{"task_id": "47186fac8e7c7277af01144644eb4e0b", "confirmed_task": "What is the ownership cost of the first car in the list \"top buys 2025\"?", "website": "https://www.parkers.co.uk/", "reference_length": 3, "level": "easy"}
+{"task_id": "fa9adb815b85d259f943d81874a052e5", "confirmed_task": "Browse a user homepage that reposted the top song from the Top 50 Rock chart.", "website": "https://soundcloud.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "b922508886ded315c9835457a6eb43ea", "confirmed_task": "Browse tenured/tenure-track faculty positions in Computer Sciences & Technology in California.", "website": "https://jobs.chronicle.com", "reference_length": 6, "level": "medium"}
+{"task_id": "5d542a7ec1fa142ba73cc87d970caf39", "confirmed_task": "Find the most cited publication at the 2022 CVPR main conference.", "website": "https://dblp.org/", "reference_length": 6, "level": "medium"}
+{"task_id": "864244b6969e0f8733b0eb1ca06cd51f", "confirmed_task": "Find the race time for who wins the first place in the last race of the 2023 Formula 1 (F1).", "website": "https://www.espn.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "01abae9608f2d8752a83e08f136f720c", "confirmed_task": "Show me the code for the company that is the top mover in the Cboe Europe Technology Sector Index (BEPTEC) as of the latest market close.", "website": "https://www.cboe.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "da8f3823a827c7d3a492f383808e7912", "confirmed_task": "Find and open the earliest press release.", "website": "https://www.instructure.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "8689af4d33ce00bf2cdd8987d3bbfd86", "confirmed_task": "Add the cheapest certified refurbished iPad Air with 256GB of storage in any shade of blue to my bag.", "website": "https://www.apple.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "78f397336b6fd1cbba0127db7a8cd502", "confirmed_task": "Browse the upcoming SuperBike events taking place in Italy.", "website": "https://www.redbull.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "3dca7cbe7d086619d837ff9f5312cebc", "confirmed_task": "Can you show me products under the category path 'Automotive' -> 'Car Jack', with an additional filter for the color pink?", "website": "https://us.shein.com/", "reference_length": 4, "level": "easy"}
+{"task_id": "b962927dfe03bf2274a54381127ed433", "confirmed_task": "Find the best-selling vinyl record by an artist from New York City in the classical music genre.", "website": "https://bandcamp.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "78baf9dbe7c3532f7d7ef4cc22a7f065", "confirmed_task": "Find the most popular digital trends report in the Finance & Insurance industry within the region of China.", "website": "https://www.statista.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "c7c07ec10c668625a21ba64165d719bb", "confirmed_task": "Find the total monthly price for four prepaid unlimited lines without autopay discounts.", "website": "https://www.verizon.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "512fd4deab099b8dc0dcfc0ec48a3c63", "confirmed_task": "Identify the open issue with the most comments in the first trending open-source repository this week.", "website": "https://github.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "d9d8b7d84a3f8d057e368254fe8d65e2", "confirmed_task": "Find the first commit submitted by NielsRogge to the official repository of the SAM2 model.", "website": "https://github.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "157f4a79d55e8fa3fd55ba772ba40fbc", "confirmed_task": "Find the most popular blue Lilo & Stitch toys.", "website": "https://www.disney.com/", "reference_length": 9, "level": "medium"}
+{"task_id": "62c8d970b3d13891f355911e5a8f4030", "confirmed_task": "Find the top game listed in the Steam Deck's top-played list over the past year. Then, browse reviews for that game from players who have played over 100 hours and primarily use a Steam Deck.", "website": "https://store.steampowered.com/", "reference_length": 9, "level": "medium"}
+{"task_id": "11857213ca01510f12813740afd59918", "confirmed_task": "Add the most top-selling Adidas men's basketball shoe in red, size 10 to my cart.", "website": "https://www.adidas.com/", "reference_length": 10, "level": "medium"}
+{"task_id": "47bfe8a7e0e4e7efc837287b407fbe90", "confirmed_task": "Compare the first and second most popular smartphones manufactured by Xiaomi and show the comparison chart.", "website": "https://versus.com/", "reference_length": 10, "level": "medium"}
+{"task_id": "bb314cb80f0f8489135cbf59074d11e2", "confirmed_task": "Open the page for the first Best Paper Award video recording of talks from ICLR 2016.", "website": "https://iclr.cc/", "reference_length": 4, "level": "easy"}
+{"task_id": "1aeca99e6a60b0e3aefb3ef212bdce79", "confirmed_task": "Find full-time legal occupation jobs in San Diego County with a minimum salary of $4,000+ per month.", "website": "https://www.ca.gov/", "reference_length": 10, "level": "medium"}
+{"task_id": "d730f4ff450da1bd60a836163736ef6a", "confirmed_task": "Find the best-selling GORE-TEX men's hiking shoe priced between $100.00 and $199.99 with a rating of 4 stars or higher, and show its most helpful comment.", "website": "https://www.rei.com/", "reference_length": 10, "level": "medium"}
+{"task_id": "fe33894188d20d7469f37a9fd855e7ff", "confirmed_task": "Find me Python 3.9 packages on PyPI that are designed for the Web Environment, licensed under MIT, have a stable production status, and are intended for developers.", "website": "https://pypi.org/", "reference_length": 11, "level": "hard"}
+{"task_id": "71f8de1834599fba443f40dbbfab8edd", "confirmed_task": "Search for papers related to reinforcement learning under the topics of computer science and mathematics on arxiv, with recent submission dates between September 2024 and January 2025.", "website": "https://arxiv.org/", "reference_length": 11, "level": "hard"}
+{"task_id": "c8c1ff115879b3afd14280beb1559b13", "confirmed_task": "Find the latest Doraemon video in MP4 format that is over 20 minutes long and has a medium file size.", "website": "https://www.4shared.com/", "reference_length": 12, "level": "hard"}
+{"task_id": "d4fb78b7e74508cd3b33f01cf9200997", "confirmed_task": "Show the figure comparing Occupational Fatalities Trends between Ohio and New York.", "website": "https://www.americashealthrankings.org/", "reference_length": 12, "level": "hard"}
+{"task_id": "0e42c3a73f2aece1f854e0ba55b7c8b0", "confirmed_task": "Find a gas station in Manhattan, NY with a rating above 4.0, and sort the user reviews by the lowest rating.", "website": "https://www.google.com/maps/", "reference_length": 7, "level": "medium"}
+{"task_id": "96afb3c51146b0c2a9c55f039a5ea6d6", "confirmed_task": "Find the most frequent word that rhymes with \"thought\" and has three syllables.", "website": "https://www.merriam-webster.com/", "reference_length": 5, "level": "easy"}
+{"task_id": "59912927c1fddee6ded8a49986896bc2", "confirmed_task": "Look for the most useful reviews of the highest-rated anti-reflective TVs with screen sizes from 55\" to 64\" and prices ranging from $300 to $1500.", "website": "https://www.samsung.com/", "reference_length": 14, "level": "hard"}
+{"task_id": "e43cbc8a0bf9e999884928d11006f894", "confirmed_task": "Browse the list of things to do in Miami that have a rating of 9+ (wonderful), last between 1 to 4 hours per session, cost under $100 per person, and are available for booking between next Monday and next Friday.", "website": "https://www.expedia.com/", "reference_length": 15, "level": "hard"}
+{"task_id": "1b867afecf072cb877ebfa4069263746", "confirmed_task": "Display the figure comparing unemployment trends among women in Illinois and Michigan.", "website": "https://www.americashealthrankings.org/", "reference_length": 15, "level": "hard"}
+{"task_id": "c3a333968fc3c43d7f2688f425a0d633", "confirmed_task": "Find the cheapest certified pre-owned Porsche 911 with a model year of 2019 or newer, within a 200-mile radius of ZIP code 97007.", "website": "https://www.porsche.com/", "reference_length": 15, "level": "hard"}
+{"task_id": "bb5d90e6f2fbc0ae146f7c1998c2b4a1", "confirmed_task": "Find the most viewed TED talk on the topic of robots that lasts between 12 and 18 minutes.", "website": "https://www.ted.com/", "reference_length": 15, "level": "hard"}
+{"task_id": "c577a14301a725e09ccd269a3e0b271e", "confirmed_task": "Return the page for the highest-rated red wine from Oregon under $40 that pairs well with either mushrooms or veal.", "website": "https://www.vivino.com/", "reference_length": 15, "level": "hard"}
+{"task_id": "c6c9dc6079677cef594cec2fa6b16602", "confirmed_task": "Add the cheapest black sofa with at least three seats, a leather finish, and at least four stars to my cart.", "website": "https://www.ikea.com/", "reference_length": 16, "level": "hard"}
+{"task_id": "c39d6c245f8243993e707d54d2f4acec", "confirmed_task": "Browse the final skin in the list for the champion Ahri.", "website": "https://www.leagueoflegends.com/", "reference_length": 18, "level": "hard"}
+{"task_id": "b2f4fde2fce122a93c7b578086cb0585", "confirmed_task": "Find the cheapest hotel + flight + car package from New York to San Francisco, departing tomorrow and returning on the fourth day from departure, for two adults and a six-year-old child. The package should be one room with free breakfast and spa access.", "website": "https://www.booking.com/", "reference_length": 19, "level": "hard"}
+{"task_id": "d02d236836924919f35f2438d9ed2374", "confirmed_task": "Browse the top 250 movies and find one movie that is available on AMC+.", "website": "https://www.imdb.com/", "reference_length": 22, "level": "hard"}
+{"task_id": "3621b099326c7aebd2e2dac6be3b52d1", "confirmed_task": "Open the profile page of the leader of the Nvidia Learning and Perception Lab.", "website": "https://www.nvidia.com/", "reference_length": 5, "level": "easy"}
+{"task_id": "f27b393bbd2082f92b566270c4b74fe6", "confirmed_task": "Find a large van for sale from the year 2024 or newer with up to 10,000 miles.", "website": "https://www.parkers.co.uk/", "reference_length": 7, "level": "medium"}
+{"task_id": "ba01ea557b73f864c35ebba0dd6f3cb2", "confirmed_task": "Find the top-rated hotel in Manhattan, NY, suitable for 4 guests, and identify the fastest public transportation option from the hotel to LGA airport.", "website": "https://www.google.com/maps/", "reference_length": 14, "level": "hard"}
+{"task_id": "662ae0f2d3ac851dbcdd245f908277e3", "confirmed_task": "What is the second stop among the best stops along the road trip from Yellowstone National Park to Las Vegas?", "website": "https://wanderlog.com/", "reference_length": 5, "level": "easy"}
+{"task_id": "461ab9b0c7b20ac5f912704480979c65", "confirmed_task": "Find the NYSE Rule 605 Market Center Files data for July 2024.", "website": "https://www.nyse.com/", "reference_length": 5, "level": "easy"}
+{"task_id": "a96fca87a17d792644e736d1d10d3cbe", "confirmed_task": "View the pricing plan for 'Business'. Specifically, we have 100 users. We need a 1PB storage quota and a 50 TB transfer quota.", "website": "https://mega.io/", "reference_length": 5, "level": "easy"}
+{"task_id": "2c8ef01a92c71ba9ef2e59bb17eea2b3", "confirmed_task": "If there are any discounts on the Apple Mac Studio, add the one with the largest absolute discount to my cart; otherwise, add the cheapest one.", "website": "https://www.costco.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "3084bc225219fcb73dc1cb0f97276c1c", "confirmed_task": "Get quotes for a package weighing 10 lbs with dimensions of 2 inches in length, width, and height, being shipped from Long Beach, 90802 to Portland, 97201.", "website": "https://www.ups.com/", "reference_length": 7, "level": "medium"}
+{"task_id": "949dc965a6c23a95663b3bc2ca2c3a8a", "confirmed_task": "Find UA or AA flights from London to New York that arrive between 8:00 PM and 11:00 PM on FlightAware.", "website": "https://www.flightaware.com/", "reference_length": 13, "level": "hard"}
+{"task_id": "636b07af4dd97c1793733db1fd1b90b8", "confirmed_task": "Filter handbags to evening bags that are blue, and polyester and cost less than $100.", "website": "https://www.macys.com/", "reference_length": 9, "level": "medium"}
+{"task_id": "38203be65401943aea2179c4c680059a", "confirmed_task": "Check the status of bus S92 for any disruptions on new.mta.info.", "website": "https://new.mta.info/", "reference_length": 6, "level": "medium"}
+{"task_id": "cf757a775fa1224acfc7998489e199a8", "confirmed_task": "Find a flight from Dublin to anywhere under $100 tomorrow on Ryanair.", "website": "https://www.ryanair.com/", "reference_length": 13, "level": "hard"}
+{"task_id": "d8e2a81fa621ce4737e5ea85671b630e", "confirmed_task": "Search for regular weekday jobs around 14810 that I can start within two weeks or three.", "website": "https://hiring.amazon.com/", "reference_length": 13, "level": "hard"}
+{"task_id": "63d6866fc000fcb1f153e07604bd1395", "confirmed_task": "What are the Nearby Attractions from the most popular attraction in Hong Kong?", "website": "https://us.trip.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "199be0b54a436daee74247971fc684ee", "confirmed_task": "Add a Macy's Happy Birthday E-Gift Card worth $50 from Shak to my cart, with the birthday wish message \"Happy birthday, wish you many more years to come\", addressed to christene (christenson@gmail.com).", "website": "https://www.macys.com/", "reference_length": 11, "level": "hard"}
+{"task_id": "c00437fd76a7a83b57f3dc4e5dbc41f8", "confirmed_task": "Check the most recent full-time medical health and safety jobs, requiring 1-3 years of industry experience available in the US.", "website": "https://www.amazon.jobs/", "reference_length": 8, "level": "medium"}
+{"task_id": "fc53ddd3421411a41c1020a3fdc84ec4", "confirmed_task": "I want to purchase an open-box Samsung Galaxy S25 Plus in excellent condition and trade in a gray Galaxy S20 5G (Verizon), with a perfect screen, in good condition. How much would it cost?", "website": "https://www.bestbuy.com/", "reference_length": 17, "level": "hard"}
+{"task_id": "9d46ccb915eff39ee1ae1e7328f5f20d", "confirmed_task": "Get a quote for the fastest shipping available for 5 lbs with dimensions of 4 inches in length, width, and height from New York, NY 10001, USA to Truckee, California 96162, USA.", "website": "https://www.ups.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "d1970c16271496cbbe166ecbecc0a1d8", "confirmed_task": "I'm 25 and located in Texas. Shop for 2020 made dry red wine made in United States priced between 15-20 dollars and add 5 bottles to the cart.", "website": "https://macyswineshop.com/", "reference_length": 13, "level": "hard"}
+{"task_id": "7211af65d266402f99499053924262e9", "confirmed_task": "View the most recent job posting for a full-time pharmacy position in the US.", "website": "https://www.amazon.jobs/", "reference_length": 8, "level": "medium"}
+{"task_id": "4464a8421f8bc8786524a499258dfad3", "confirmed_task": "Check the specifications of the best-selling HP FHD laptop with 16 GB RAM and core i7 running on Windows 11.", "website": "https://www.bestbuy.com/", "reference_length": 12, "level": "hard"}
+{"task_id": "f707d765bca668830745d20807d7bee6", "confirmed_task": "Show me the list of young female English Spot rabbits available for adoption in Chicago, IL, within 50 miles.", "website": "https://www.petfinder.com/", "reference_length": 14, "level": "hard"}
+{"task_id": "d392e154c1c6ffbb26e2331c3afafc67", "confirmed_task": "Add a $100 Best Buy gift card for a birthday to my cart.", "website": "https://www.bestbuy.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "a5c87cc1c94a090c9a8dc2c8b6a125d0", "confirmed_task": "Find the SO2 air quality over the past hour for Maine North, County Cork, Ireland.", "website": "https://www.accuweather.com/", "reference_length": 15, "level": "hard"}
+{"task_id": "367d843c640637745e8fafa741cca13b", "confirmed_task": "Find a condo for rent in Houston, TX, with a monthly rent of no more than 30% of an income of $8000. The condo should have a minimum area of 600 square feet, and the move-in date is the 1st of next month.", "website": "https://www.apartments.com/", "reference_length": 15, "level": "hard"}
+{"task_id": "84ef883a37af638c3bcf7561f28ce80a", "confirmed_task": "Find the cheapest used hatchback car listing in Madison which has black interiors with a heated seat option and premium sound system.", "website": "https://www.cars.com/", "reference_length": 12, "level": "hard"}
+{"task_id": "d9a8689393effeed75ea0866e44e1def", "confirmed_task": "Find the address and phone of the Office of the Inspector General (OIG).", "website": "https://www.justice.gov/", "reference_length": 8, "level": "medium"}
+{"task_id": "1bc154377120ec15b18dbabdba49c741", "confirmed_task": "Book 4 tickets in the upper for any Kevin Hart show in New York in the next three months and view ticket prices with estimated fees.", "website": "https://www.stubhub.com/", "reference_length": 12, "level": "hard"}
+{"task_id": "28e7574e7bd6d14f36d2988a5ef2bd23", "confirmed_task": "Get a part-time job within 5 miles of Moscow, Idaho in the accommodation and food services industry, as a chef, and show jobs for corporate only.", "website": "https://ohiomeansjobs.ohio.gov/", "reference_length": 12, "level": "hard"}
+{"task_id": "1c3b747ae12ccee895745f82e3f2ef8a", "confirmed_task": "Identify the ongoing competition that offers the highest prize and find the code that received the most votes in that competition.", "website": "https://www.kaggle.com/", "reference_length": 11, "level": "hard"}
+{"task_id": "d1807551297ac60ecaaabbd2a2ed301a", "confirmed_task": "Find the No.1 children's hospital in the California that specializes in Neonatology.", "website": "https://health.usnews.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "7abdceee212151f187ee1a1744c57606", "confirmed_task": "Can you show me the page with the filing fee for a self-petitioned I-140 application?", "website": "https://www.uscis.gov/", "reference_length": 6, "level": "medium"}
+{"task_id": "0e5536aaad9d3462b06cf725e6ed535a", "confirmed_task": "Show me the page with average wait times for U.S. citizens arriving at Raleigh-Durham International Airport on 2025-03-12.", "website": "https://www.cbp.gov/", "reference_length": 11, "level": "hard"}
+{"task_id": "bc2ce7f206045dd2d322e5695a947219", "confirmed_task": "Estimate the federal income tax I would owe on $158,500 of taxable income in ZIP code 97007, filing as single.", "website": "https://smartasset.com/", "reference_length": 6, "level": "medium"}
+{"task_id": "7e6993f2c5cd72c44809024f0bc85dc1", "confirmed_task": "Create a meme with a frog as the background and leave the only text with \"Enjoy your life\".", "website": "https://imgur.com/", "reference_length": 8, "level": "medium"}
+{"task_id": "a48e2f1ee8d87eaeea56fe5e730427e6", "confirmed_task": "Pass the first trending chess puzzle.", "website": "https://www.chess.com/", "reference_length": 7, "level": "medium"}
+{"task_id": "dd44c665cec1e9c929a4c5f074e7844a", "confirmed_task": "Find parking near the San Francisco Museum of Modern Art from June 18, 1:00 PM to 5:00 PM. I'm driving a Ford F-150 and need a garage that allows in-and-out privileges. If there are multiple options, show me the details of the one with the lowest price.", "website": "https://spothero.com/", "reference_length": 17, "level": "hard"}
+{"task_id": "99daaed9a83c266341d28aa40067d376", "confirmed_task": "Find the most popular board game on the 'The Hotness' list that has a rating above 7.5 and is suitable for 2 players.", "website": "https://boardgamegeek.com/", "reference_length": 5, "level": "easy"}
+{"task_id": "7072d09436972a5d5fe7476e3e9f1559", "confirmed_task": "Show me the comparison of the first two personal credit cards that do not charge foreign transaction fees.", "website": "https://www.americanexpress.com/", "reference_length": 10, "level": "medium"}
+{"task_id": "2c20d87a046fadcb6ff07ee877bfbf37", "confirmed_task": "Open the form 8843 for tax year 2022.", "website": "https://www.irs.gov/", "reference_length": 8, "level": "medium"}
+{"task_id": "753f372c189d3b306623cb0c65b50320", "confirmed_task": "Compare the U.S. ETP Odd Lot Rate (%) between Quartile 1 and Quartile 4, viewing quartiles by price, and display the chart with a logarithmic scale on the vertical axis.", "website": "https://www.sec.gov/", "reference_length": 9, "level": "medium"}
+{"task_id": "733f1d8bf79d5bc2240c5357f928ffff", "confirmed_task": "Find the cheapest travel deal or discount to Thailand that lasts more than 10 days, departs in next month, and show the total price.", "website": "https://www.tourradar.com/", "reference_length": 10, "level": "medium"}
+{"task_id": "f05e87c5b92d9869e08806103c1c15a1", "confirmed_task": "Find all startup companies from the 2022 and 2023 Y Combinator batches that are based in France and currently have job openings.", "website": "https://www.ycombinator.com/", "reference_length": 12, "level": "hard"}
+{"task_id": "3ef64f34eae59c9fac7ee9a4f18b4a0c", "confirmed_task": "Find and open an animal learning course on YouTube Kids for my 6-year-old without login in. As a parent born in 1992, I would prefer not to enable search.", "website": "https://www.youtube.com/", "reference_length": 16, "level": "hard"}
+{"task_id": "f158345f8489e0d1d91e28768c39bca1", "confirmed_task": "Estimate the total cost (with basic support) of using 5 million input tokens and 5 million output tokens each for GPT-4o and GPT-4o Mini, both deployed in the US/EU Data Zones under Standard (On-Demand) in the East US region.", "website": "https://azure.microsoft.com/", "reference_length": 13, "level": "hard"}
+{"task_id": "1ab384fb3a791edfb410213cc6b82151", "confirmed_task": "Show me the result of a proton emission decay for a Beryllium nucleus with 6 protons and 4 neutrons in the simulation.", "website": "https://phet.colorado.edu/", "reference_length": 13, "level": "hard"}
+{"task_id": "1223b07536a87e0170ff87cbbebd1d3c", "confirmed_task": "Complete a multiplication quiz on https://www.coolmath4kids.com/, covering multiplication facts for 11-12. The quiz should consist of 10 questions, with unlimited time allowed for each. The goal is to achieve a perfect score of 10 out of 10.", "website": "https://www.coolmath4kids.com/", "reference_length": 24, "level": "hard"}
diff --git a/packages/evals/datasets/webtailbench/WebTailBench_data.jsonl b/packages/evals/datasets/webtailbench/WebTailBench_data.jsonl
new file mode 100644
index 000000000..987ef525d
--- /dev/null
+++ b/packages/evals/datasets/webtailbench/WebTailBench_data.jsonl
@@ -0,0 +1,609 @@
+{"id":"united_13","category":"flights","ques":"What is the price difference between economy and business class on United Airlines direct flights from Chicago to São Paulo from 11/24/2025 to 12/14/2025? If there are no available flights for those dates, please indicate that in your answer\r","web":""}
+{"id":"ryanair_55","category":"flights","ques":"How many seats with extra legroom are available on Ryanair from Birmingham, UK to Porto, Portugal flying out 11/23/2025 and coming back 11/18/2025? If there are no available flights for those dates or this is not possible, please indicate that in your answer\r","web":""}
+{"id":"westjet_47","category":"flights","ques":"What is the checked baggage allowance and any associated fees for WestJet flights from Waterloo, Ontario to Calgary, Alberta September 10, 2026 - September 27, 2026 round trip? If there are no available flights for those dates, please indicate that in your answer\r","web":""}
+{"id":"airasia_88","category":"flights","ques":"How much does it cost to select a window seat on a direct AirAsia flight from Singapore to Langkawi from November 24 to November 27? If there are no available flights for those dates, please indicate that in your answer\r","web":""}
+{"id":"jal_61","category":"flights","ques":"What meal options are available in premium economy on Japan Airlines from Dallas/Fort Worth to Singapore leaving on April 23 returning May 3? If there are no available flights for those dates, please indicate that in your answer\r","web":""}
+{"id":"cathaypacific_59","category":"flights","ques":"How much would it cost to upgrade from economy to business class on Cathay Pacific from Manila to Hong Kong November 17 - December 12? If there are no available flights for those dates, please indicate that in your answer\r","web":""}
+{"id":"alitalia_37","category":"flights","ques":"What are the flight duration and number of daily flights with ITA from Rome to Naples leaving on February 23 returning March 18? If there are no available flights for those dates, please indicate that in your answer\r","web":""}
+{"id":"jetstar_22","category":"flights","ques":"What is the cancellation and change fee policy for Jetstar from Darwin to Adelaide in a month for a two week trip? If there are no available flights for those dates, please indicate that in your answer\r","web":""}
+{"id":"alaskaair_6","category":"flights","ques":"How many exit row seats are still available on Alaska Airlines flights from Seattle, WA to Honolulu, HI 11/29/2025 - 12/03/2025? If there are no available flights for those dates, please indicate that in your answer\r","web":""}
+{"id":"easyjet_87","category":"flights","ques":"What is the total cost including all fees and taxes for the cheapest EasyJet flight from Palma de Mallorca to Newcastle December 3 - December 23? If there are no available flights for those dates, please indicate that in your answer\r","web":""}
+{"id":"jetstar_10","category":"flights","ques":"Does Jetstar offer any bundle deals or packages for flights from Adelaide to Sunshine Coast November 18 - November 25 round trip? If there are no available flights for those dates, please indicate that in your answer\r","web":""}
+{"id":"singaporeair_9","category":"flights","ques":"Can you help me find just the flight numbers of a Singapore Airlines flight from London (LHR) to Sydney (SYD) via Singapore (SIN) leaving July 2 and coming back July 28? If there are no available flights for those dates, please indicate that in your answer\r","web":""}
+{"id":"spirit_9","category":"flights","ques":"How much more expensive is a \"Big Front Seat\" compared to standard economy on Spirit Airlines from Houston to Los Angeles beginning March 5 till March 20? If there are no available flights for those dates, please indicate that in your answer\r","web":""}
+{"id":"goindigo_52","category":"flights","ques":"How much are business class seats on IndiGo from Sharjah (SHJ) to Delhi (DEL) outbound on January 13 returning January 19, if available? If there are no available flights for those dates or business class is not available, please indicate that in your answer\r","web":""}
+{"id":"thaiairways_13","category":"flights","ques":"Book a flight with Thai Airways from Bangkok, Thailand to Singapore. outbound on November 19 returning December 4. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"vueling_15","category":"flights","ques":"Book a flight with Vueling from Birmingham, UK to Barcelona, Spain departing November 28 and returning December 16. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"turkishairlines_11","category":"flights","ques":"Book a round-trip flight with Turkish Airlines from Istanbul Airport (IST) to John F. Kennedy International Airport (JFK) for a two week trip starting the upcoming Saturday. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"airasia_50","category":"flights","ques":"Book a flight with AirAsia from Hong Kong to Manila leaving December 2 and coming back December 8. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"britishairways_11","category":"flights","ques":"Book a round-trip flight with British Airways from Manchester Airport to London Heathrow from the upcoming Friday for four days. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"suncountry_2","category":"flights","ques":"Book a flight with Sun Country Airlines from Duluth, MN to Phoenix, AZ from January 17 to January 31. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"thaiairways_9","category":"flights","ques":"Book a flight with Thai Airways from Bangkok to London departing November 16 and returning November 26. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"lufthansa_39","category":"flights","ques":"Book a flight with Lufthansa from Frankfurt, Germany to Tel Aviv, Israel beginning November 18 till November 30. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"suncountry_9","category":"flights","ques":"Book a flight with Sun Country Airlines from Tampa, FL to Dallas, TX outbound on February 9 returning February 28. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"klm_9","category":"flights","ques":"Book a flight with KLM from Lagos, Nigeria to Frankfurt, Germany flying out 11/18/2025 → coming back 11/25/2025. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"jetstar_82","category":"flights","ques":"Book a flight with Jetstar from Brisbane to Perth from 03/20/2026 → 04/03/2026. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"aircanada_54","category":"flights","ques":"Book a flight with Air Canada from Vancouver to Penticton June 9 - July 4. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"southwest_18","category":"flights","ques":"Book a flight with Southwest Airlines from Portland, OR to Salt Lake City, UT flying out 05/15/2026 → coming back 05/17/2026. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"allegiantair_18","category":"flights","ques":"Book a flight with United Airlines from Houston to Newark, NJ February 11 - March 2. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"airasia_7","category":"flights","ques":"Book a round-trip flight with Delta from Boston, MA to San Francisco, CA outbound in the Saturday after next week. Make the round-trip be two weeks length. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"philippineairlines_45","category":"flights","ques":"Book a flight with Philippine Airlines from Manila to Singapore from November 16 to December 15. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"aircanada_27","category":"flights","ques":"Book a flight with Air Canada from Toronto, ON to New York City, NY leaving on December 10 returning January 7. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"singaporeair_41","category":"flights","ques":"Book a flight with Singapore Airlines from Singapore to Naha, Japan beginning February 10 till February 17. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"suncountry_12","category":"flights","ques":"Book a flight with Sun Country Airlines from San Francisco (SFO) to Minneapolis (MSP) December 18- January 3 round trip. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"lot_5","category":"flights","ques":"Book a flight with LOT Polish Airlines from Warsaw, Poland to New York City, USA March 25 - April 22 round trip. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"allegiantair_53","category":"flights","ques":"Book a flight with Allegiant Air from Asheville, NC to Boston, MA leaving on November 22 returning December 12. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"spirit_5","category":"flights","ques":"Book a Spirit Airlines flight from BWI airport to Newark Liberty International Airport (EWR) beginning May 2 till June 2. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"malaysiaairlines_95","category":"flights","ques":"Book a flight with Malaysia Airlines from Kuala Lumpur to Kathmandu outbound on March 4 returning March 21. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"swiss_48","category":"flights","ques":"Book a Swiss Airlines flight to Mumbai from Zurich outbound on November 22 returning December 12. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"iberia_41","category":"flights","ques":"Book a flight for two people with Iberia from Madrid, Spain to Santiago, Chile beginning July 17 till August 11. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"vueling_28","category":"flights","ques":"Book a flight with Vueling from London to Asturias Airport (OVD) from May 22 to  June 17. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"ana_22","category":"flights","ques":"Book a flight with ANA from Singapore to Fukuoka March 24 - March 27. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"thaiairways_11","category":"flights","ques":"Book a flight with Thai Airways from Thailand to Sydney, Australia from November 16 through December 11. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"wizzair_96","category":"flights","ques":"Book a flight with Wizz Air from Larnaca, Cyprus to Athens, Greece outbound on February 9 returning February 21. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"jetstar_66","category":"flights","ques":"Book a cheap flight with Jetstar from Sydney to Hobart outbound on December 20 returning January 6. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"klm_21","category":"flights","ques":"Book a flight with KLM from Geneva, Switzerland to Osaka, Japan from 11/22/2025 → 11/28/2025. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"iberia_27","category":"flights","ques":"Book a flight with Iberia from Alicante to Funchal leaving on March 11 returning March 25. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"koreanair_0","category":"flights","ques":"Book a cheap flight with Korean Air from Los Angeles, CA to Seoul, South Korea from November 30 to December 30. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"thaiairways_18","category":"flights","ques":"Book a VTL flight with Thai Airways from Bangkok to Singapore leaving on May 1 returning May 21. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"jetblue_48","category":"flights","ques":"Book a flight with JetBlue from Orlando, FL to Denver, CO from December 19 through January12. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"goindigo_24","category":"flights","ques":"Book a flight with IndiGo from Bhubaneswar (BBSR) to Delhi (DEL) from February 20 to March 3. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"aerlingus_93","category":"flights","ques":"Book a direct flight with Aer Lingus from Dublin to Orlando outbound on December 7 returning December 22. If there are no available flights for those dates or the booking is not possible, please indicate that in your answer\r","web":""}
+{"id":"samsung_9702","category":"shopping_head","ques":"I want to buy the Samsung Galaxy Tab S11+ 256GB Wi-Fi from Samsung.\r","web":""}
+{"id":"amazon_8235","category":"shopping_head","ques":"Can you help me purchase the Electrosport ESR 150 from Amazon?\r","web":""}
+{"id":"amazon_9969","category":"shopping_head","ques":"I'm looking to buy Disney Grumpy stuffed plush toy from Amazon.\r","web":""}
+{"id":"underarmour_6889","category":"shopping_head","ques":"I need to purchase Under Armour Men's Project Rock BSR size 8 training shoes from Under Armour.\r","web":""}
+{"id":"publix_9146","category":"shopping_head","ques":"Could you help me order Febreze Air Freshener from publix for delivery (use 32204 zip code for the store)?\r","web":""}
+{"id":"rockauto_4460","category":"shopping_head","ques":"I'd like to get an E450 parking brake rotor and brake pad kit from RockAuto.\r","web":""}
+{"id":"underarmour_3963","category":"shopping_head","ques":"Can you order Under Armour kids' lunch boxes from Under Armour for me?\r","web":""}
+{"id":"rockauto_6656","category":"shopping_head","ques":"Help me buy a radiator for a 1995 Ford F-350 Powerstroke 7.3 from RockAuto.\r","web":""}
+{"id":"hobbylobby_351","category":"shopping_head","ques":"I'm trying to purchase 1/4-inch square hardwood dowels from Hobby Lobby.\r","web":""}
+{"id":"overstock_8717","category":"shopping_head","ques":"I want to order a wall-hung bathroom sink (14\" x 12\") from Overstock.\r","web":""}
+{"id":"publix_2256","category":"shopping_head","ques":"Can you help me buy a pack of organic broccoli florets from publix for delivery? (use 32204 zip code for the store)\r","web":""}
+{"id":"amazon_1934","category":"shopping_head","ques":"I need to get The Witches movie (widescreen edition) from Amazon.\r","web":""}
+{"id":"bestbuy_5569","category":"shopping_head","ques":"I'm looking for a refrigerator with a built-in water dispenser from Best Buy.\r","web":""}
+{"id":"ebay_1007","category":"shopping_head","ques":"I'd like to purchase the Ninco BMW Amprex from eBay.\r","web":""}
+{"id":"sears_4887","category":"shopping_head","ques":"Can you help me order a 30-inch Café induction cooktop on sale from Sears?\r","web":""}
+{"id":"ebay_8268","category":"shopping_head","ques":"I want to buy a 1939 issue of Adventure magazine from eBay.\r","web":""}
+{"id":"bestbuy_8406","category":"shopping_head","ques":"I need to order a 20-foot printer cable from Best Buy.\r","web":""}
+{"id":"westelm_7538","category":"shopping_head","ques":"I'm looking to get a green rug of size 8'x10' or something close from West Elm.\r","web":""}
+{"id":"amazon_7859","category":"shopping_head","ques":"Could you help me buy Storm Fury Book 1 from Amazon?\r","web":""}
+{"id":"rei_4150","category":"shopping_head","ques":"I want to purchase the Currex Insole M size from REI.\r","web":""}
+{"id":"ikea_4872","category":"shopping_head","ques":"I'm looking for the cheapest queen size mattress from Ikea\r","web":""}
+{"id":"gap_3164","category":"shopping_head","ques":"I need to buy white Modern V-Neck T-Shirt m size from Gap\r","web":""}
+{"id":"sears_6088","category":"shopping_head","ques":"Can you help me get the cheapest 18 cu ft freezer from Sears?\r","web":""}
+{"id":"homedepot_7304","category":"shopping_head","ques":"Purchase the DeWalt Atomic Sawzall from Home Depot.\r","web":""}
+{"id":"amazon_4045","category":"shopping_head","ques":"Purchase the book \"El vuelo de una abeja\" from Amazon.\r","web":""}
+{"id":"amazon_970","category":"shopping_head","ques":"Purchase 20 disposable plastic bowls on amazon\r","web":""}
+{"id":"hobbylobby_299","category":"shopping_head","ques":"Buy some metal cake stand from Hobby Lobby\r","web":""}
+{"id":"zappos_9900","category":"shopping_head","ques":"Purchase navy Clarks shoes for women size 8 from Zappos.\r","web":""}
+{"id":"publix_4839","category":"shopping_head","ques":"Buy a Jimmy Dean pork sausages from Publix for delivery (use 32204 zip code for the store).\r","web":""}
+{"id":"overstock_9388","category":"shopping_head","ques":"Purchase Steve Madden tall women's boots 9 size\r","web":""}
+{"id":"underarmour_7483","category":"shopping_head","ques":"Purchase the Under Armour mens beanie from Under Armour.\r","web":""}
+{"id":"potterybarn_7344","category":"shopping_head","ques":"Purchase a light color around 90' long Chesterfield-style sectional sofa from Pottery Barn.\r","web":""}
+{"id":"potterybarn_1237    ","category":"shopping_head","ques":"Help me purchase a rectangular drop leaf dining table from Pottery Barn that's at least 54\" long.\r","web":""}
+{"id":"kohls_8946","category":"shopping_head","ques":"Purchase pink Skechers girls’ slip-on shoes size 13 from Kohl’s.\r","web":""}
+{"id":"rockauto_1225","category":"shopping_head","ques":"Purchase intake coolant hoses (molded, silicone) from RockAuto.\r","web":""}
+{"id":"wholefoodsmarket_5324","category":"shopping_head","ques":"Purchase 6 fcans of zero-sugar cola from Whole Foods Market.\r","web":""}
+{"id":"overstock_9756","category":"shopping_head","ques":"Purchase ~20\" wide by ~30\" high medicine cabinets from Overstock.\r","web":""}
+{"id":"amazon_1230","category":"shopping_head","ques":"Purchase configuration of RT81 Turntable with AT95E Cartridge (no more than 350$ configuration) from Amazon\r","web":""}
+{"id":"lowes_8758","category":"shopping_head","ques":"Purchase a cotoneaster plant from Lowe's\r","web":""}
+{"id":"ikea_2219","category":"shopping_head","ques":"Purchase a hammock chair with stand from IKEA.\r","web":""}
+{"id":"westelm_19","category":"shopping_head","ques":"Purchase the Gemini Bed from West Elm.\r","web":""}
+{"id":"target_4231","category":"shopping_head","ques":"Purchase 12 cups of Snack Pack sugar-free pudding from Target.\r","web":""}
+{"id":"sears_4759","category":"shopping_head","ques":"Purchase Lush Decor Bohemian Stripe window curtains in turquoise and orange from Sears.\r","web":""}
+{"id":"ulta_1473","category":"shopping_head","ques":"Purchase the Dashing Dive Glaze Starter Kit from Ulta.\r","web":""}
+{"id":"overstock_2959","category":"shopping_head","ques":"Purchase a cheapest Costway dog bed from Overstock with shipping to Canada.\r","web":""}
+{"id":"underarmour_784","category":"shopping_head","ques":"Purchase the Under Armour Men's UA Base 4 long sleeve M size from Under Armour.\r","web":""}
+{"id":"wholefoodsmarket_4455","category":"shopping_head","ques":"Purchase 4 bottles of Belvoir Lemonade from Whole Foods.\r","web":""}
+{"id":"lowes_6063","category":"shopping_head","ques":"Purchase 4 tier chrome shelving from Lowe’s approximately 35 inches width and 50 inches height.\r","web":""}
+{"id":"target_6682","category":"shopping_head","ques":"Purchase Aveeno sunscreen lotion with 60 spf from Target.\r","web":""}
+{"id":"michaels_2250","category":"shopping_head","ques":"Purchase baby fabric sold by the half yard from Michaels.\r","web":""}
+{"id":"publix_8722","category":"shopping_head","ques":"Have Publix deliver Heinz Apple Cider Vinegar (use 32204 zip code for the store).\r","web":""}
+{"id":"crateandbarrel_2072","category":"shopping_head","ques":"Purchase a ceramic photo frame from Crate & Barrel.\r","web":""}
+{"id":"nordstrom_5374","category":"shopping_head","ques":"Purchase women's full-length leather coat S size less than 200$ from Nordstrom.\r","web":""}
+{"id":"publix_3096","category":"shopping_head","ques":"Find prepared pasta salads from publix for delivery (use 32204 zip code for the store).\r","web":""}
+{"id":"petsmart_5650","category":"shopping_head","ques":"Purchase a 20-gallon fish tank from PetSmart.\r","web":""}
+{"id":"kohls_7716","category":"shopping_head","ques":"Purchase a Starter Pittsburgh Steelers hoodie from Kohl's.\r","web":""}
+{"id":"eventbrite_tickets_book_93","category":"things_to_do","ques":"Submit a request form to book a tasting tour at St. Michaels Winery in maryland (but don't hit \"send\"). Then give me their phone number to confirm.\r","web":""}
+{"id":"eventbrite_tickets_book_97","category":"things_to_do","ques":"Book tickets for the next murder mystery dinner event for me and my wife in Ocala, Florida and tell me the total price\r","web":""}
+{"id":"eventbrite_tickets_book_110","category":"things_to_do","ques":"What is the next recreational event (like cherry blossom festival) coming up on the City of Monterey Park, California municipal calendar?\r","web":""}
+{"id":"tripadvisor_find_128","category":"things_to_do","ques":"Find 2 ziplining places in Marylan, and provide their address. Which is closer to Baltimore?\r","web":""}
+{"id":"tripadvisor_find_162","category":"things_to_do","ques":"Find a deep sea fishing tour option on Viator in Moorea, Society Islands and give me the total cost and start time of the tour\r","web":""}
+{"id":"eventbrite_tickets_book_126","category":"things_to_do","ques":"Find the next board of commissioners meeting for the city of Covington, Kentucky and tell me where I can livestream it at\r","web":""}
+{"id":"alltrails_plan_a_trip_13","category":"things_to_do","ques":"Buy a one day MONT BLANC MultiPass for hiking for the next available date and tell me the price, for one adult\r","web":""}
+{"id":"alltrails_find_243","category":"things_to_do","ques":"What is the top rated hiking trail in Creekside Park, Salinas, California and provide details on the length and difficulty\r","web":""}
+{"id":"eventbrite_tickets_book_92","category":"things_to_do","ques":"Register me for the turkey trot event coming up in Coppell, Texas, tell me how much it costs and when it is.\r","web":""}
+{"id":"hipcamp_find_111","category":"things_to_do","ques":"I want to book a camping spot at Bridge Bay in Yellowstone for the next available slot; how much is the nightly rate?\r","web":""}
+{"id":"tripadvisor_question_answering_148","category":"things_to_do","ques":"help me register for the new years day 5k in chesapeake city, MD on raceroster.com. Then tell me who is the event contact.\r","web":""}
+{"id":"eventbrite_tickets_book_51","category":"things_to_do","ques":"help me plan a weekend going to events with my kids on discover baltimore county websites\r","web":""}
+{"id":"tripadvisor_question_answering_185","category":"things_to_do","ques":"Write a review on tripadvisor giving the NCL excursion to Volcano Winery on the Island of Hawaii a 4 start review\r","web":""}
+{"id":"sixflags_find_71","category":"things_to_do","ques":"What is the price of a military discount ticket for Six Flags at Darien Lake, New York and then try to book a ticket. Stop once I am asked to login to verify my military membership.\r","web":""}
+{"id":"tripadvisor_recommend_158","category":"things_to_do","ques":"Reserve an airboat ride with more than 500 reviews in Kissimmee, Florida on tripadvisor\r","web":""}
+{"id":"tripadvisor_general_activity_20","category":"things_to_do","ques":"Provide information on visiting historic sites in Camden, Maine, including one must-see landmark or site\r","web":""}
+{"id":"disneyworld.disney.go_find_180","category":"things_to_do","ques":"Find out the opening hours and ticket prices for Disney's Animal Kingdom Theme Park in Orlando, Florida.\r","web":""}
+{"id":"eventbrite_tickets_book_118","category":"things_to_do","ques":"book tickets for the next Greater Haitian-American Chamber of Commerce event near tampa, FL\r","web":""}
+{"id":"alltrails_find_206","category":"things_to_do","ques":"What are the alerts, if any, for the petrified forest loop trail on alltrails.com\r","web":""}
+{"id":"tripadvisor_recommend_9","category":"things_to_do","ques":"Submit a form to plan a safari trip in johannesburg  on jacadatravel.com for a family of 4 with 2 kids, including a private dinner with a budget of $15000\r","web":""}
+{"id":"tripadvisor_find_153","category":"things_to_do","ques":"Buy tickets for the St. Petersburg Pirate Museum in Florida, and inform me of the including visiting hours and total price for 2 adults.\r","web":""}
+{"id":"metmuseum_find_24","category":"things_to_do","ques":"Buy tickets for the Met on the next available day, using 11201 as the zipcode for discounts and pay only the ticket price.\r","web":""}
+{"id":"smithsonianmag_question_answering_24","category":"things_to_do","ques":"Find the oldest Nez Perce site on the Salmon River and then tell me what road I would take to get there from Cottonwood, ID\r","web":""}
+{"id":"eventbrite_tickets_book_37","category":"things_to_do","ques":"Find and book a kayaking event in Winter Haven, Florida.\r","web":""}
+{"id":"eventbrite_tickets_book_71","category":"things_to_do","ques":"what are the next three events happening at miami beach convention center\r","web":""}
+{"id":"tripadvisor_find_286","category":"things_to_do","ques":"book tickets for the next dinner show at Pigeon Forge, Tennessee and tell me the price\r","web":""}
+{"id":"eventbrite_tickets_book_109","category":"things_to_do","ques":"buy tickets for a sumo wrestling event in tokyo\r","web":""}
+{"id":"eventbrite_tickets_book_66","category":"things_to_do","ques":"Book tickets for a murder mystery dinner in Chambersburg, Pennsylvania\r","web":""}
+{"id":"sixflags_question_answering_79","category":"things_to_do","ques":"Find out operating hours and ticket prices for Six Flags New England\r","web":""}
+{"id":"tripadvisor_general_activity_194","category":"things_to_do","ques":"Plan an airboat tour at Lake Trafford in Florida and check if alligator sightings are guaranteed\r","web":""}
+{"id":"eventbrite_tickets_book_81","category":"things_to_do","ques":"tell me when daffodil day at the garden club of virginia is and add it to my calendar if you can\r","web":""}
+{"id":"tripadvisor_find_250","category":"things_to_do","ques":"Locate and provide options for ziplining in Bavaria, Germany.\r","web":""}
+{"id":"hipcamp_question_answering_4","category":"things_to_do","ques":"order a nonresident Annual Park Pass from new jersey state park service\r","web":""}
+{"id":"alltrails_find_223","category":"things_to_do","ques":"Find the best hiking trails in Pendleton, Oregon and include details such as trail length and difficulty\r","web":""}
+{"id":"eventbrite_tickets_book_102","category":"things_to_do","ques":"Find a cooking class in Bethesda, Maryland and book a session if available\r","web":""}
+{"id":"eventbrite_tickets_book_174","category":"things_to_do","ques":"Find the price and availability for tours of Waverly Hills Sanatorium in Kentucky, and help me book tickets if possible.\r","web":""}
+{"id":"disneyworld.disney.go_plan_a_trip_2","category":"things_to_do","ques":"Plan a visit to Disney World in Orlando, Florida, including ticket options and must-see attractions\r","web":""}
+{"id":"sixflags_general_activity_11","category":"things_to_do","ques":"Check for opening hours and ticket prices for the Wild Safari at Six Flags in New Jersey\r","web":""}
+{"id":"eventbrite_tickets_book_45","category":"things_to_do","ques":"what are the upcoming events at pershing square, LA on bandsintown websites\r","web":""}
+{"id":"eventbrite_recommend_220","category":"things_to_do","ques":"What free events or activities are happening in Ithaca, New York this weekend?\r","web":""}
+{"id":"alltrails_find_232","category":"things_to_do","ques":"buy a backcountry permit for Thunder River and Deer Creek trail at the grand canyon, or tell me when I can apply if not available.\r","web":""}
+{"id":"metmuseum_question_answering_49","category":"things_to_do","ques":"What are the current exhibits at the Metropolitan Museum of Art in New York City, New York?\r","web":""}
+{"id":"eventbrite_tickets_book_95","category":"things_to_do","ques":"tell me the date and time of the next event at Fort Gibson historic site in Oklahoma, and what to expect at the event.\r","web":""}
+{"id":"eventbrite_tickets_book_1","category":"things_to_do","ques":"sign up for a family membership for the oklahoma historical society\r","web":""}
+{"id":"sixflags_general_activity_16","category":"things_to_do","ques":"buy a season pass to hurricane harbor in arlington tx and tell me the price\r","web":""}
+{"id":"tiqets_tickets_book_4","category":"things_to_do","ques":"purchase tickets to the Azulejo Tile Museum directly from their website\r","web":""}
+{"id":"trailforks_question_answering_3","category":"things_to_do","ques":"Check the current conditions of the Lake Eiler Trail and report any closures or hazards.\r","web":""}
+{"id":"eventbrite_tickets_book_136","category":"things_to_do","ques":"buy tickets for the next upcoming Edgar Allan Poe speakeasy event (in whichever city)\r","web":""}
+{"id":"alltrails_find_282","category":"things_to_do","ques":"Find the top 3 hiking trails in Pike National Forest and provide a table detailing their difficulty level, number of reviews, and length in miles.\r","web":""}
+{"id":"eventbrite_tickets_book_112","category":"things_to_do","ques":"Book tickets for the underground NYC tour known as 'Empire Beneath the Streets' in New York City, New York\r","web":""}
+{"id":"recreation.gov_question_answering_26","category":"things_to_do","ques":"Find the hours of operation and available activities at Colter Bay Visitor Center in Wyoming.\r","web":""}
+{"id":"tripadvisor_recommend_275","category":"things_to_do","ques":"Recommend activities or attractions to visit near Yankee Stadium in Bronx, New York before a Yankee game\r","web":""}
+{"id":"tripadvisor_find_101","category":"things_to_do","ques":"buy tickets for family of 4 (2 kids) at the denver museum of nature and science\r","web":""}
+{"id":"tripadvisor_question_answering_278","category":"things_to_do","ques":"which time slot in the next upcoming Saturday has the most availability at the denver museum of nature and science\r","web":""}
+{"id":"tripadvisor_find_190","category":"things_to_do","ques":"book a ziplining tour at fox fire adventure park in Sevierville, TN\r","web":""}
+{"id":"hipcamp_recommend_5","category":"things_to_do","ques":"What are the best camping parks in Languedoc-Roussillon, France, and what amenities do they offer?\r","web":""}
+{"id":"eventbrite_tickets_book_77","category":"things_to_do","ques":"buy 1 colorado resident and another non-resident ticket to the denver art museum on the next available Tuesday\r","web":""}
+{"id":"tripadvisor_plan_a_trip_118","category":"things_to_do","ques":"buy tickets a tour of teatro colon and then dinner/tango show in La Ventana, Buenos Aires\r","web":""}
+{"id":"eventbrite_tickets_book_83","category":"things_to_do","ques":"buy tickets to the next wine festival anywhere in the US -- I really need more wine\r","web":""}
+{"id":"tripadvisor_plan_a_trip_162","category":"things_to_do","ques":"Plan a road trip itinerary with interesting places to stop between Glacier National Park and Red Lodge, Montana\r","web":""}
+{"id":"eventbrite_find_40","category":"things_to_do","ques":"rsvp to an event involving food at visitlakegeneva.com\r","web":""}
+{"id":"eventbrite_tickets_book_128","category":"things_to_do","ques":"buy tickets for the next weekend show at the Barrymore Theatre in Fort Lee, New Jersey\r","web":""}
+{"id":"tiqets_tickets_book_9","category":"things_to_do","ques":"buy next available tickets for La Lonja de la Seda in Valencia, Spain\r","web":""}
+{"id":"eventbrite_tickets_book_2","category":"things_to_do","ques":"book tickets for the next event in Grapevine, TX on eventbrite so I can plan my weekend\r","web":""}
+{"id":"tripadvisor_plan_a_trip_226","category":"things_to_do","ques":"Help me plan a trip with recommendations for hotels, day tours, and attractions in Palawan, Philippines\r","web":""}
+{"id":"eventbrite_tickets_book_170","category":"things_to_do","ques":"book tickets to visit the chrysler building observation deck in NYC\r","web":""}
+{"id":"tiqets_tickets_book_15","category":"things_to_do","ques":"book tickets to the Pinacoteca di Brera in Milan, Italy on their official site\r","web":""}
+{"id":"alltrails_find_23","category":"things_to_do","ques":"Identify the best waterfalls to see while hiking in the Superstition Mountains, Arizona\r","web":""}
+{"id":"sixflags_find_48","category":"things_to_do","ques":"Find the operational hours and entry prices for Sky Harbor Waterpark in Phoenix, Arizona\r","web":""}
+{"id":"hipcamp_find_90","category":"things_to_do","ques":"Locate the available campgrounds near Little Bighorn Battlefield National Monument in Montana and provide details about the amenities they offer.\r","web":""}
+{"id":"eventbrite_tickets_book_57","category":"things_to_do","ques":"which day in the upcoming month is cheapest to buy admission tickets to chicago botanic garden and what is the price?\r","web":""}
+{"id":"eventbrite_tickets_book_73","category":"things_to_do","ques":"register for the next open house at the NY campus of the culinary institute of america\r","web":""}
+{"id":"disneyworld.disney.go_question_answering_147","category":"things_to_do","ques":"when is the next available day to schedule a divequest at sea base aquarium at epcot and what is the price? Then proceed to book.\r","web":""}
+{"id":"eventbrite_tickets_book_67","category":"things_to_do","ques":"sign up for a guided tour at the Leland Stanford mansion for the next available Saturday\r","web":""}
+{"id":"tiqets_tickets_book_5","category":"things_to_do","ques":"purchase a ticket to visit the The Odeon of Herodes Atticus in Athens, Greece\r","web":""}
+{"id":"eventbrite_tickets_book_76","category":"things_to_do","ques":"book tickets to the next event at the African-American Research Library and Cultural Center, Ft lauderdale FL\r","web":""}
+{"id":"alltrails_find_237","category":"things_to_do","ques":"Find the starting point and trail length for hiking Mount Oxford in New Zealand\r","web":""}
+{"id":"tripadvisor_find_41","category":"things_to_do","ques":"Find 2 museums located in Iowa City, Iowa, and provide the addresses or websites for them.\r","web":""}
+{"id":"eventbrite_tickets_book_74","category":"things_to_do","ques":"Find and book tickets to a dinner show happening this weekend in Memphis, Tennessee\r","web":""}
+{"id":"eventbrite_find_279","category":"things_to_do","ques":"Find upcoming Indian or Hindu festivals taking place in Pittsburgh, Pennsylvania and provide details about the events.\r","web":""}
+{"id":"mgmgrand.mgmresorts_1","category":"hotels_head","ques":"I need to reserve a room at MGM Grand in Las Vegas, Nevada, this weekend at mgmgrand.mgmresorts.com checking in November 27 until December 9. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"kayak_256","category":"hotels_head","ques":"What's the cheapest room price at Red Roof Inn in St. Louis, Missouri with kayak.com staying from November 23 to December 4? If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"caesars_313","category":"hotels_head","ques":"Can you help me book a stay at Harrah's Cherokee in Cherokee, North Carolina using caesars.com 11/25/2025 - 11/27/2025? If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"holidayinnclub_211","category":"hotels_head","ques":"How many rooms are available at Holiday Inn Club Scottsdale in Scottsdale, Arizona using holidayinnclub.com from December 6 through December 19? If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"hilton_248","category":"hotels_head","ques":"I'm looking to get a room at DoubleTree by Hilton Rapid City Downtown Convention Center in Rapid City, South Dakota using hilton.com staying from December 17 to December 30. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"airbnb_437","category":"hotels_head","ques":"What do the taxes and fees amount to for a stay at Bella's House from Twilight in St. Helens, Oregon through airbnb.com 11/13/2025 - 11/25/2025? If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"orbitz_8","category":"hotels_head","ques":"I'd like to reserve a room at Legoland Hotel in Carlsbad, California using orbitz.com checking in November 19 - November 21. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"resortsandlodges_43","category":"hotels_head","ques":"Can you help me find a pet-friendly resort in New Jersey for my vacation at resortsandlodges.com from December 18 to January 1? If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"hotels_131","category":"hotels_head","ques":"What's the price for the cheapest hotel in Edisto Beach, South Carolina at hotels.com 12/18/2025 - 12/28/2025? If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"uniquehotels.me_13","category":"hotels_head","ques":"I'm trying to book a unique accommodation in Havelock North, New Zealand through uniquehotels.me from 11/17/2025 → 11/19/2025. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"tripadvisor_347","category":"hotels_head","ques":"How many hotels are available near the Grand Canyon in Las Vegas, Nevada through tripadvisor.com February 3 checking out February 8? If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"choicehotels_52","category":"hotels_head","ques":"I need to get a room at Clarion Inn in Idaho Falls, Idaho with choicehotels.com from January 18 through January 31. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"choicehotels_25","category":"hotels_head","ques":"What are the total taxes and fees for a room at Radisson Resort in Miami Beach, Florida at choicehotels.com January 8 checking out January 13? If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"motel6_76","category":"hotels_head","ques":"Can you book me a room at Motel 6 in Lenexa, Kansas with motel6.com November 26 - November 30? If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"hostelworld_27","category":"hotels_head","ques":"I'm looking for a cheap hostel in Mykonos, Greece through hostelworld.com checking in on November 24 and leaving December 6. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"holidayinnclub_103","category":"hotels_head","ques":"Help me reserve a room at Orange Lake Resort by Holiday Inn in Kissimmee, Florida with holidayinnclub.com from December 11 to December 15. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"hilton_150","category":"hotels_head","ques":"What's the cheapest available room at Hampton Inn and Suites Albany in Albany, Georgia at hilton.com from 12/10/2025 → 12/15/2025? If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"agoda_121","category":"hotels_head","ques":"I want to book a room at SO Sofitel Hua Hin in Hua Hin, Cha-Am, Thailand on Agoda using agoda.com checking in on December 18 and leaving December 23. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"travelocity_36","category":"hotels_head","ques":"How many rooms are still available in Lauderdale-by-the-Sea, Florida using travelocity.com February 4 checking out February 11? If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"oyster_72","category":"hotels_head","ques":"I'd like to get a 2-bedroom suite at Ocean Lodge in St. Simons Island using oyster.com checking in January 4 - January 15. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"vrbo_282","category":"hotels_head","ques":"What do the total fees and taxes come to for Harbor House in Treasure Island, Florida through vrbo.com from December 14 to December 16? If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"motel6_83","category":"hotels_head","ques":"Book a room at Motel 6 in Shartlesville, Pennsylvania through motel6.com December 12 checking out December 16.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"ihg_11","category":"hotels_head","ques":"Book a hotel in Green River, Utah at ihg.com January 5 checking out January 17.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"marriott_20","category":"hotels_head","ques":"Book a room at Gaylord Opryland Resort and Convention Center in Nashville, Tennessee with marriott.com from 01/13/2025 → 01/15/2025.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"bestwestern_370","category":"hotels_head","ques":"Book a room at Best Western Wapakoneta Inn in Wapakoneta, Ohio using bestwestern.com staying from December 18 to December 22.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"bluegreenvacations_23","category":"hotels_head","ques":"Book a room at Bluegreen at Tradewinds in Florida with bluegreenvacations.com from December 3 through December 5.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"marriott_490","category":"hotels_head","ques":"Book a room at Courtyard by Marriott Anchorage Airport in Anchorage, Alaska at marriott.com checking in on January 25 and leaving January 31.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"hyattinclusivecollection_265","category":"hotels_head","ques":"Book a room at Dreams Onyx Resort & Spa - All Inclusive in the Dominican Republic with hyattinclusivecollection.com checking in December 16, checking out December 27.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"premierinn_26","category":"hotels_head","ques":"Book a Premier Inn hotel Edinburgh City Centre in Scotland using premierinn.com checking in December 3, checking out December 8.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"planethollywoodhotels_25","category":"hotels_head","ques":"Book a room at Planet Hollywood Cancun Resort with Star Class in Cancun, Mexico at planethollywoodhotels.com from December 19 through December 24.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"motel6_32","category":"hotels_head","ques":"Book a room at Motel 6 in Branford, Connecticut using motel6.com staying from November 25 to November 29.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"druryhotels_224","category":"hotels_head","ques":"Book a room at Drury Inn and Suites Columbus Polaris in Columbus, Ohio at druryhotels.com from February 9 through February 22.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"hyatt_305","category":"hotels_head","ques":"Book a room at Hyatt Regency Hotel at Orlando International Airport in Orlando, Florida through hyatt.com from 12/06/2025 → 12/19/2025.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"bestwestern_409","category":"hotels_head","ques":"Book a room at Best Western Plus Capitola By-the-Sea Inn & Suites in Capitola, California using bestwestern.com checking in on January 23 and leaving January 25.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"airbnb_192","category":"hotels_head","ques":"Book a place to stay in Plainfield Township, Michigan with airbnb.com checking in December 12 until December 16.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"hyatt_115","category":"hotels_head","ques":"Book a room at Hyatt Vacation Club at the Ranahan in Colorado with hyatt.com checking in January 15 - January 25.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"motel6_59","category":"hotels_head","ques":"Book a room at Motel 6 in Harrisburg, Pennsylvania with motel6.com checking in December 4, checking out December 16.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"hiltongrandvacations_128","category":"hotels_head","ques":"Book a room at Hilton Grand Vacations in South Lake Tahoe, California through hiltongrandvacations.com arriving 11/20/2025 to 11/25/2025.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"ihg_236","category":"hotels_head","ques":"Book a room at Holiday Inn in Toronto, Ontario, Canada at ihg.com checking in on February 14 and leaving February 16.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"tripadvisor_280","category":"hotels_head","ques":"Book a hotel in Concord, New Hampshire using tripadvisor.com checking in November 19 - November 27.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"hilton_312","category":"hotels_head","ques":"Book a room at Homewood Suites in Wallingford, Connecticut with hilton.com checking in January 9 - January 13.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"marriott-hotels.marriott_9","category":"hotels_head","ques":"Book a Marriott hotel with a lounge in Orlando, Florida at marriott-hotels.marriott.com November 19 checking out November 29.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"sandals_14","category":"hotels_head","ques":"Book an all-inclusive stay at Sandals Turks and Caicos through sandals.com staying from Jan 27 to Feb 4.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"kempinski_30","category":"hotels_head","ques":"Book a room at Kempinski Budapest Hotel in Budapest, Hungary at kempinski.com from November 29 through December 6.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"caesars_162","category":"hotels_head","ques":"Book a room at Harrah's Lake Tahoe in Lake Tahoe, Nevada through caesars.com February 6 checking out on the 13.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"bestwestern_354","category":"hotels_head","ques":"Book a room at Best Western Venice Mestre Hotel in Mestre, Italy through bestwestern.com checking in January 17, checking out January 30.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"airbnb_161","category":"hotels_head","ques":"Book a bed and breakfast in Leadville, Colorado using airbnb.com January 4 - January 15.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"bluegreenvacations_66","category":"hotels_head","ques":"Book a stay at Bluegreen Odyssey Dells in Wisconsin Dells, Wisconsin through bluegreenvacations.com checking in February 11 until February 22.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"bestwestern_467","category":"hotels_head","ques":"Book a room at SureStay by Best Western Glendive Yellowstone River in Glendive, Montana with bestwestern.com from November 22 to November 27.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"holidayinnclub_277","category":"hotels_head","ques":"Book a stay at Holiday Inn Vacation Club Orange Lake Resort in Orlando, Florida using holidayinnclub.com December 12 checking out December 18.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"hilton_262","category":"hotels_head","ques":"Book a room at Home2 Suites by Hilton in St. Louis, Missouri using hilton.com December 13 - December 20.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"hyatt_335","category":"hotels_head","ques":"Book a room at Hyatt Place Pasadena in California at hyatt.com checking in December 22, checking out December 27.. If the hotel doesn't take reservations for that date or there are no available rooms for that time, please indicate that in your answer\r","web":""}
+{"id":"gardenofeatn_1","category":"restaurants_tail","ques":"Find some vegan options at Garden of Eatin in Sacramento, CA.\r","web":""}
+{"id":"eatleven_2","category":"restaurants_tail","ques":"Find me a deli in Downtown Denver and its most meat-filled option at the deli.\r","web":""}
+{"id":"thekafeneo_1","category":"restaurants_tail","ques":"Find a vegetarian item on the menu for Kafe Neo in Bainbridge\r","web":""}
+{"id":"indytoday.6amcity_8","category":"restaurants_tail","ques":"Book a reservation at Yazsh Cafe and Bistro in Indianapolis on Thursday for brunch time.. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"antioch.eatatanastasias_1","category":"restaurants_tail","ques":"Book a reservation for two at Anastasia Restaurant in Antioch on November 20 at 11:15 AM.. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"queensyardnyc_1","category":"restaurants_tail","ques":"Book a reservation at Rose Room in New York at 10 PM. If it doesn't take reservations or is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"ronskenosha_1","category":"restaurants_tail","ques":"Book a reservation at Ron's Place in Kenosha for the soonest available time.. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"portofinoutica_1","category":"restaurants_tail","ques":"Book a brunch reservationfor three at 11 AM on the upcoming Sunday for Mother's Day at Portofino in Utica, NY. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"ophchicagoland_2","category":"restaurants_tail","ques":"What are some famous pancakes on the menu at The Original Pancake House in Hyde Park.\r","web":""}
+{"id":"firebowlcafe_1","category":"restaurants_tail","ques":"What are the cheapest rice/noodle dishes featuring meat at Fire Bowl Cafe in McKinney, TX?\r","web":""}
+{"id":"theshopsatcolumbuscircle_1","category":"restaurants_tail","ques":"Book a reservation at a restaurant in Time Warner Center at 7 pm on 11/30/25. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"gillhouseny_2","category":"restaurants_tail","ques":"What specials do they have featured at Gill House in Henderson Harbor, NY.\r","web":""}
+{"id":"greatwoksecaucus_1","category":"restaurants_tail","ques":"Do they have any spicy beef or chicken dishes available for takeout at Great Wok in Secaucus, NJ\r","web":""}
+{"id":"mauihawaii_3","category":"restaurants_tail","ques":"Book a reservation at a restaurant in Lahaina, Maui for the earliest available reservation this week.. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"brunchpubcenterville_2","category":"restaurants_tail","ques":"Book a reservation at The Brunch Pub in Centerville for the upcoming Friday at 7 pm. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"aubergeresorts_8","category":"restaurants_tail","ques":"Book a reservation at The Conservatory Restaurant in Newport for Novemeber 26 at 11:15 AM.. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"reysolcoffee_1","category":"restaurants_tail","ques":"What is the most expensive dish on the menu for Rey Sol Coffee in Morristown, NJ\r","web":""}
+{"id":"duffystavernlg_1","category":"restaurants_tail","ques":"What kinda chicken wings and drinks they got at Duffy's Tavern in Lake George.\r","web":""}
+{"id":"restaurantsinsarasota_9","category":"restaurants_tail","ques":"Book a reservation at Gen Korean restaurant in UTC Mall, Sarasota, FL for Tuesday at 6:30 PM. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"tallahasseetimes_1","category":"restaurants_tail","ques":"Book a reservation with outdoor setaing at a 347 Grille in Tallahassee, FL any day over the next three weeknds between 5:30 and 8 pm. Let them know that I have peanut allergies too. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"ritual.co_4","category":"restaurants_tail","ques":"What is the most popular dish on the menu for Java Java Coffee on Fleet Street, London\r","web":""}
+{"id":"brennanssportsbar_1","category":"restaurants_tail","ques":"Book a reservation at Brennan's Sports Bar in the Phoenix area on December 2 for the next free slot. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"thecapitalburger_3","category":"restaurants_tail","ques":"Find a vegetarian item on the menu and prices for The Capital Burger in Washington, DC\r","web":""}
+{"id":"carinos_2","category":"restaurants_tail","ques":"List some types of lasagna featured at Johnny Carino's in Downey, CA during lunchtime.\r","web":""}
+{"id":"gazette_5","category":"restaurants_tail","ques":"What chicken dishes are available at  Masala Mingle Indian Bistro and Bar in Colorado Springs\r","web":""}
+{"id":"bestnewyork.us_5","category":"restaurants_tail","ques":"In the upcoming Friday or Saturday, book a reservation for four people at Buffet House in Queens, NY.\r","web":""}
+{"id":"mounthorebchamber_1","category":"restaurants_tail","ques":"Make a reservation for four people at Campo Di Bella in Mt Horeb, WI on Nov. 22. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer.\r","web":""}
+{"id":"mallsinamerica_7","category":"restaurants_tail","ques":"Book a reservation at SkyDome restaurant for two in Pentagon Row for Novemeber 22nd at 6:00 PM.. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"utcsarasota_6","category":"restaurants_tail","ques":"Make a reservation at Isan Thai Restaurant in Sarastoa, FL for a party of 3 at at around 6 PM.  If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"rockawave_1","category":"restaurants_tail","ques":"What are some special drinks or cuisine found at Fitzgerald's Bar in Rockaway, NY ?\r","web":""}
+{"id":"sloansrestaurant_1","category":"restaurants_tail","ques":"What are some common American breakfast foods found at Sloan's Restaurant in Indio during its breakfast/lunch time?\r","web":""}
+{"id":"mainkitchenma_1","category":"restaurants_tail","ques":"Are there any duck dishes served at Peking House on Carew St in Springfield, MA.\r","web":""}
+{"id":"longshots-bar_1","category":"restaurants_tail","ques":"Book a reservation for 6 people at Longshots Bar and Grill in Fairmount Park, IL for Saturday, Novebmer 22 at 7:00 PM.. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"wearetravelgirls_3","category":"restaurants_tail","ques":"Book a reservation for a party of 12 at Magnolias in Charleston, SC for a bachelorette party on 12/12/2025 at 8 PM. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"local.starmarket_1","category":"restaurants_tail","ques":"Order two birthday cakes from Star Market Bakery in Quincy, MA. The budget is capped at $100. If there are no two birthday cakes that exceed $100, do not order a cake.\r","web":""}
+{"id":"grilledcheeseandcrabcakeco_1","category":"restaurants_tail","ques":"Find a vegetarian item on the menu for The Grilled Cheese and Crab Cake Company in Cocoa Beach\r","web":""}
+{"id":"epicureantravelerblog_2","category":"restaurants_tail","ques":"Is Marro's Italian Restaurant in Saugatuck, MI a romantic restaurant? If so, book a reservation for two on November 18 at 7:00 PM.  If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"gulelerestaurant_1","category":"restaurants_tail","ques":"Book a reservation at Gulele Restaurant in Gaithersburg, MD on the upcoming Sunday for weekend brunch at 11:00 AM. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"sinners.co_1","category":"restaurants_tail","ques":"Book a reservation at Sinners Restaurant in Bloomington for lunchtime on 12/19.. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"nothingbundtcakes_6","category":"restaurants_tail","ques":"Order a cake from Nothing Bundt Cakes in Lincoln, NE.\r","web":""}
+{"id":"sawasdeethaicuisine-asheville_1","category":"restaurants_tail","ques":"Book a reservation at Sawasdee Thai in Asheville, NC on November 21 at 1:00 PM. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"mammamaria_3","category":"restaurants_tail","ques":"Book a reservation at Mamma Maria in the North End, Boston for the upcoming Monday dinnretime.. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"foodieflashpacker_1","category":"restaurants_tail","ques":"Book a reservation at one of the best restaurants in Laramie, WY for an early dinner at around 5 PM on 11/20/2025. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"skny.io_2","category":"restaurants_tail","ques":"Book a private room for 20 people at Dead Rabbit Grocery and Grog in New York  City on 12/18/25. If there are no bookings availble for a party of such size, please indicate that in your answer.\r","web":""}
+{"id":"restaurants_6","category":"restaurants_tail","ques":"Find soul food hidden gem restaurants in Towaco, New Jersey that are open during lunchtime on 11/21/2025.\r","web":""}
+{"id":"theplacearizona_1","category":"restaurants_tail","ques":"What are some specialty cocktails featured at The Place Restaurant in Arizona.\r","web":""}
+{"id":"uptown-pizza2.website.spoton_1","category":"restaurants_tail","ques":"List all healthy options available at Uptown Pizza in Tomah, WI. Then, put together an order that would satiate a party of 4.\r","web":""}
+{"id":"birchsonthelake_1","category":"restaurants_tail","ques":"Book a reservation for a party of two at a restaurant along a body of water in Long Lake, WI on November 19 at 7:00 PM. Let the staff know that this is a date. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"refugeinthewoodlands_3","category":"restaurants_tail","ques":"Book a reservation at Refuge Restaurant in The Woodlands for a party of four on 12/02/2025 for 9:-0 PM.. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"weatherfordbar_1","category":"restaurants_tail","ques":"Can you help me book a reservation for a party of 5 at Fire Oak Grill in Weatherford, TX on November 22 for the first available table of that day. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"hamadaya-bakery_1","category":"restaurants_tail","ques":"Looking at Hamadaya Bakery in Irvine, compile an order featuring cakes, pastries, and sandwiches to feed a family of three for a meal.\r","web":""}
+{"id":"valerienewyorkcity_2","category":"restaurants_tail","ques":"Book a reservation for the next available Sunday brunch at Valerie's in NYC. If the restaurant doesn't take reservations or it is unavailable for that time, please indicate that in your answer\r","web":""}
+{"id":"kelty_2","category":"shopping_lists_tail","ques":"Purchase a 65-liter capacity internal frame backpack from Kelty and a rain cover to protect it\r","web":""}
+{"id":"kancanusa_3","category":"shopping_lists_tail","ques":"Purchase mid-rise denim bermuda shorts, size 26, from KancanUSA and a blue top, size M, to go with them.\r","web":""}
+{"id":"goat_7","category":"shopping_lists_tail","ques":"Purchase Reebok pump sneakers for men in size 10 from Goat and athletic socks to pair with the sneakers, doesn't matter the color.\r","web":""}
+{"id":"medline_14","category":"shopping_lists_tail","ques":"Purchase replacement wheels for the Guardian K3 wheelchair from Medline and a tire repair kit for the wheelchair wheels.\r","web":""}
+{"id":"irishsetterboots_3","category":"shopping_lists_tail","ques":"Purchase Irish Setter Kasota 6-inch work boots in size 9.5 regular width from irishsetterboots.com, and a pair of brown chukka boots in the same size.\r","web":""}
+{"id":"agwheelexpress_5","category":"shopping_lists_tail","ques":"Purchase 14 x 38 double bevel rims in JD yellow from AgWheelExpress, and include a mount hub as well.\r","web":""}
+{"id":"birkenstock_11","category":"shopping_lists_tail","ques":"Purchase Birkenstocks Arizona style in black for women from Birkenstock's website and a shoe care kit to keep them in good condition\r","web":""}
+{"id":"acrylux_1","category":"shopping_lists_tail","ques":"Add semi-gloss Acrylux Exterior Paint to my cart Acrylux.com and also add brushes or rollers for painting to my cart on Amazon.\r","web":""}
+{"id":"colgate_1","category":"shopping_lists_tail","ques":"Purchase 5000 ppm fluoride toothpaste in regular mint flavor from Colgate and a soft bristle toothbrush to use with it.\r","web":""}
+{"id":"tcl_11","category":"shopping_lists_tail","ques":"Purchase a 27-inch monitor from TCL.com and a pair of headphones.\r","web":""}
+{"id":"shop.rolltide_3","category":"shopping_lists_tail","ques":"Purchase an Alabama vintage t-shirt from the official Alabama Crimson Tide shop and a matching Alabama Crimson Tide cap.\r","web":""}
+{"id":"americanstandard-us_23","category":"shopping_lists_tail","ques":"Purchase American Standard 19-inch high toilet in white from American Standard's official website and a electric bidet seat to go with it.\r","web":""}
+{"id":"ronellclock_2","category":"shopping_lists_tail","ques":"Purchase 8-inch extra fancy large clock hands from Ronell Clock and a brass brush to help keep it clean\r","web":""}
+{"id":"vevor_23","category":"shopping_lists_tail","ques":"Purchase Vevor food process that is at least 10Quarts from Vevor.com and 7.5in meat slicer.\r","web":""}
+{"id":"oceanstatejoblot_4","category":"shopping_lists_tail","ques":"Purchase a 9'x12' rectangular indoor/outdoor rug from Ocean State Job Lot and a 18in by 30in kitchen mat.\r","web":""}
+{"id":"golfpride_7","category":"shopping_lists_tail","ques":"Purchase Golf Pride tour classic putter grip from Golf Pride and a grip tape to install the putter grip.\r","web":""}
+{"id":"craftsman_9","category":"shopping_lists_tail","ques":"Purchase Craftsman 6-gallon portable air compressor from Craftsman.com and a 16 gauge nailer.\r","web":""}
+{"id":"m2motorsportinc_2","category":"shopping_lists_tail","ques":"Purchase 22-inch IROC wheels from M2 Motorsport Inc., along with lug nuts suitable for the wheels.\r","web":""}
+{"id":"catholicshop_1","category":"shopping_lists_tail","ques":"Purchase a cheap wood rosary from Catholic Shop along with a rosary holder.\r","web":""}
+{"id":"beatsbydre_5","category":"shopping_lists_tail","ques":"Purchase studio headphones from Beats by Dre and an extra usb-c charging cable for them.\r","web":""}
+{"id":"tagwoodbbq_1","category":"shopping_lists_tail","ques":"Purchase a medium-sized Argentinian charcoal grill from Tagwood BBQ and a cover to go with it.\r","web":""}
+{"id":"spreadshirt_3","category":"shopping_lists_tail","ques":"Purchase a black classic rock sweatshirt from Spreadshirt and a hat to go with it.\r","web":""}
+{"id":"extremerate_3","category":"shopping_lists_tail","ques":"Purchase 3rd party Switch Joy-Con shells in black or blue from ExtremeRate and a screen protector for my Switch.\r","web":""}
+{"id":"surfboards_2","category":"shopping_lists_tail","ques":"Purchase a 9ft longboard surfboard in white, black, blue or green from Surfboards.com and a surfboard leash for it.\r","web":""}
+{"id":"tomsstudio_1","category":"shopping_lists_tail","ques":"Purchase a Fountain Pen in any color from Tom's Studio along with a bottle of fountain pen ink for refills.\r","web":""}
+{"id":"bacteriostaticwater_1","category":"shopping_lists_tail","ques":"Purchase a 30 mL vial of bacteriostatic water for injection from BacteriostaticWater.com, along with sterile syringes or needles for use with it.\r","web":""}
+{"id":"fiestafactorydirect_1","category":"shopping_lists_tail","ques":"Purchase a 12 piece mixed dinnerware set and blue (or green) luncheon plate.\r","web":""}
+{"id":"mcfeelys_2","category":"shopping_lists_tail","ques":"Purchase a pack (less than 100) 1/4-20 T-nuts from McFeely's and also a pack of 1/4-20 softwood threaded inserts.\r","web":""}
+{"id":"housebeautiful_2","category":"shopping_lists_tail","ques":"Purchase an outdoor smoker online and some wood chips to use with it.\r","web":""}
+{"id":"whitemountainshoes_2","category":"shopping_lists_tail","ques":"Purchase heeled sandals for women as well as some winter boots, size 8, from WhiteMountainShoes.com\r","web":""}
+{"id":"eyeglasses_16","category":"shopping_lists_tail","ques":"Purchase Swarovski SK1011 frames in black from Eyeglasses.com and then a pair of Guess sunglasses to go with them\r","web":""}
+{"id":"frandenim_1","category":"shopping_lists_tail","ques":"Purchase size 30 athletic cut jeans for women from Fran Denim and then another pair of medium wash straight cut jeans.\r","web":""}
+{"id":"recwatches_1","category":"shopping_lists_tail","ques":"Preorder a DNA edition Lotus 98T-4 watch and a 24mm strap for it from REC Watches\r","web":""}
+{"id":"awaytravel_1","category":"shopping_lists_tail","ques":"Purchase Away \"carry-on\" and \"The bigger carry on\"  luggages from AwayTravel.com\r","web":""}
+{"id":"replacementkeys_1","category":"shopping_lists_tail","ques":"Purchase a replacement 703 Yale lock key from EasyKeys and a graphite lubricant for the lock\r","web":""}
+{"id":"skipsgarage_1","category":"shopping_lists_tail","ques":"Purchase a professional regulation-size wooden cornhole set from Skip's Garage and cornhole bags to go with it.\r","web":""}
+{"id":"gymshark_12","category":"shopping_lists_tail","ques":"Purchase Gymshark Arrival 7\" shorts in navy, size medium, from Gymshark, and a matching regular fit Arrival t-shirt.\r","web":""}
+{"id":"computers.microsoft_1","category":"shopping_lists_tail","ques":"Purchase a black Surface Pro 13 tablet with snapdragon X Elite processor and 16GB RAM with a matching keyboard on the official Microsoft store\r","web":""}
+{"id":"walgreens_10","category":"shopping_lists_tail","ques":"Purchase a heated foot spa from Walgreens, and Epsom salt to enhance the foot spa experience\r","web":""}
+{"id":"vogue-eyewear_2","category":"shopping_lists_tail","ques":"Purchase a pair of pink cat eye sunglasses and a pair of black metal framed sunglasses from Vogue Eyewear\r","web":""}
+{"id":"simpletire_5","category":"shopping_lists_tail","ques":"Purchase 4 BFGoodrich 35x10R17 Jeep tires and another 4 Continental ExtremeContact DW tires SimpleTire\r","web":""}
+{"id":"picktrampoline_1","category":"shopping_lists_tail","ques":"Purchase 8.5 inch 14ft trampoline replacement springs (pack of 84) from Trampoline Parts And Supply and a heavy duty safety pad cover.\r","web":""}
+{"id":"uniqlo_8","category":"shopping_lists_tail","ques":"Purchase a men's jacket in size Medium and a matching pair of gloves from Uniqlo.\r","web":""}
+{"id":"rvusa_11","category":"shopping_lists_tail","ques":"Purchase the new Aliner 2025 Evolution from RVUSA, and also buy a towing cover for the RV.\r","web":""}
+{"id":"frederickbuechner_1","category":"shopping_lists_tail","ques":"Purchase 'Wishful Thinking: A Seeker's ABC' by Frederick Buechner (1993) and \"Godric: A Novel\" from Amazon\r","web":""}
+{"id":"saraschildrensbtq_1","category":"shopping_lists_tail","ques":"Purchase boys' size 10 communion suit and a matching tie from Sara's Children's Boutique in Jamison, PA.\r","web":""}
+{"id":"everythingarcticcatoffroad_2","category":"shopping_lists_tail","ques":"Purchase any appropriate black Arctic Cat Prowler Pro side mirrors and review mirros from Everything Arctic Cat Off-Road.\r","web":""}
+{"id":"polaroid_1","category":"shopping_lists_tail","ques":"Purchase a Polaroid Now Gen 3 Memories Set from Polaroid's website and extra Color I-type film to go with it.\r","web":""}
+{"id":"birdbgone_1","category":"shopping_lists_tail","ques":"Purchase silicone adhesive and a dripless caulking gun to apply it from Bird BGone.\r","web":""}
+{"id":"vintagesingerparts_2","category":"shopping_lists_tail","ques":"Purchase Singer Sewhandy Model 50 machine needles, Size 14, from Vintage Singer Parts, and extra bobbins for the sewing machine.\r","web":""}
+{"id":"landsend_23","category":"shopping_lists_tail","ques":"Purchase men's knit nightshirt in size Large and a pair of slippers to complement it, both from Lands' End.\r","web":""}
+{"id":"amazon_comparison_shopping_41","category":"price_comparison","ques":"help me compare the price of the red George Foreman Indoor/Outdoor Electric Grill that can make 12 servings at both walmart and target. Make sure to check the actual product pages; which one is cheaper?\r","web":""}
+{"id":"samsclub_comparison_shopping_2","category":"price_comparison","ques":"help me compare the price of the yellow/navy women's adidas Originals Samba sneaker at both amazon and foot locker. Output a table of the price of each after you check their respective product pages.\r","web":""}
+{"id":"amazon_comparison_shopping_297","category":"price_comparison","ques":"can you compare the price and dimensions of outdoor drop box mailboxes on uline and home depot? Which one is bigger and which one is cheaper?\r","web":""}
+{"id":"homedepot_comparison_shopping_421","category":"price_comparison","ques":"what standard length of vinyl outside corner trim does homedepot sell vs Southeastern Building Products, and what is the price per unit they sell? Make sure to confirm the product details on the webpages.\r","web":""}
+{"id":"napaonline_comparison_shopping_8","category":"price_comparison","ques":"help me compare coil spring boosters/spacers (front) from rock auto and napa. What are the part numbers and prices from each website?\r","web":""}
+{"id":"lowes_comparison_shopping_216","category":"price_comparison","ques":"I want to know where to buy a 3-arm wall-mounted pivoting Towel Bar between homedepot and wayfair. Figure out which one is cheaper and which one has more reviews by visiting the product pages.\r","web":""}
+{"id":"lowes_comparison_shopping_231","category":"price_comparison","ques":"please help compare the price of the CRAFTSMAN Cmmt45305 mechanic tool set at both walmart and acmetools, which is cheaper and how many pieces are in the set?\r","web":""}
+{"id":"ebay_comparison_shopping_154","category":"price_comparison","ques":"can you look up the prices of the 40v Kobalt Cordless 15-inch String trimmer on both amazon and walmart (it's blue) and tell me which one is cheaper and how much a 2-year warranty add-on would be for each?\r","web":""}
+{"id":"kohls_comparison_shopping_1","category":"price_comparison","ques":"can you compare the IZOD Men's Golf Swing Flex Cargo Short on kohls and amazon and tell me the price and level of sun protection they offer for each?\r","web":""}
+{"id":"autozone_comparison_shopping_61","category":"price_comparison","ques":"compare the price of a replacement 2016 Hyundai Genesis Grille from carparts.com and amazon. What is the price and Partslinks number from each websites?\r","web":""}
+{"id":"ebay_comparison_shopping_90","category":"price_comparison","ques":"Can you compare the pricing and package sizes for the Rockshark 36V e-bike battery charger between eBay and Amazon? Please check the actual product pages to confirm prices and package details.\r","web":""}
+{"id":"basspro_comparison_shopping_2","category":"price_comparison","ques":"Compare the pricing and package sizes for dog beds between Bass Pro Shops and Chewy to find the best value—make sure to check the actual product pages for each bed’s price and dimensions.\r","web":""}
+{"id":"aliexpress_comparison_shopping_11","category":"price_comparison","ques":"can you compare the price and length of a dual 8Pin-to-16Pin Graphics Card Power Adapter Cable (it is a Y-shaped cord) on both ebay and newegg.\r","web":""}
+{"id":"amazon_comparison_shopping_98","category":"price_comparison","ques":"I want you to compare the price of Regis Rossi's \"Intelligence émotionnelle\" book between Amazon and Apple books?\r","web":""}
+{"id":"homedepot_comparison_shopping_440","category":"price_comparison","ques":"Help me compare the price of the Direct Drive wireless keypad garage door opener at Home Depot and Amazon\r","web":""}
+{"id":"homedepot_comparison_shopping_482","category":"price_comparison","ques":"Can you help me compare the features and specifications of Terro Indoor Liquid Ant Killer Baits at both home depot and uline, what the price and number of baits per box sold at each?\r","web":""}
+{"id":"ebay_comparison_shopping_454","category":"price_comparison","ques":"what is the price of a dozen Vital Farms Pasture Raised Eggs at Whole Foods and Walmart?\r","web":""}
+{"id":"wholefoodsmarket_comparison_shopping_7","category":"price_comparison","ques":"what is the price of a dozen Vital Farms Pasture Raised Eggs at Target and Giant?\r","web":""}
+{"id":"dickssportinggoods_comparison_shopping_6","category":"price_comparison","ques":"Compare the prices of boys' black swim trunks between Dick's Sporting Goods and Amazon by checking the actual product pages for shipping costs and estimated delivery windows.\r","web":""}
+{"id":"bestbuy_comparison_shopping_74","category":"price_comparison","ques":"Help me compare the price of the iBUYPOWER Scale gaming desktop PC (Intel Core i5-14400F, NVIDIA GeForce RTX 4060, 16GB DDR5, 1TB NVMe) at Best Buy and Walmart to determine which is cheaper. Make sure to check the actual product pages to confirm current pricing.\r","web":""}
+{"id":"homedepot_comparison_shopping_13","category":"price_comparison","ques":"Does Home Depot or Amazon offer more color options for the Samsung 27-inch laundry pedestal storage drawer? What are the color options available from each retailer? Make sure to check the actual product pages to confirm available finishes.\r","web":""}
+{"id":"amazon_comparison_shopping_77","category":"price_comparison","ques":"Can you help me compare the price and dimensions of the NECA Dungeons & Dragons Ultimate Strongheart action figure available at Target  vs Walmart formatted as a table? Make sure to check the actual product pages to confirm details.\r","web":""}
+{"id":"bestbuy_comparison_shopping_45","category":"price_comparison","ques":"I would like you to compare the price of Xbox Series X black console at Best Buy vs Microsoft's websites, format your output as a table including the url, retailer, and price.\r","web":""}
+{"id":"heb_comparison_shopping_1","category":"price_comparison","ques":"Compare the price and brands for  cherry flavored night time cold & flu relief liquid between H-E-B and Amazon by checking the actual product pages. Specifically, output a table of the product name, price, and price per ounce for each.\r","web":""}
+{"id":"ebay_comparison_shopping_230","category":"price_comparison","ques":"which store sells the Nitecore EDC31 Compact Tactical EDC Flashlight for less -- Amazon or walmart?\r","web":""}
+{"id":"lowes_comparison_shopping_227","category":"price_comparison","ques":"which retailer sells the marey 2.0 GPM Electric Tankless Water Heater for less homedepot or lowes?\r","web":""}
+{"id":"samsclub_comparison_shopping_16","category":"price_comparison","ques":"Help me compare the price of ribeye steak at target and walmart, noting how many steaks per tray.\r","web":""}
+{"id":"ebay_comparison_shopping_450","category":"price_comparison","ques":"Help me compare the price of Super Mario 3D All-Stars for Nintendo Switch at eBay and Amazon, which is cheaper? Make sure to check the actual product pages to confirm the price.\r","web":""}
+{"id":"walmart_comparison_shopping_270","category":"price_comparison","ques":"Compare the shipping options and delivery times for a Pro Lift  lawn mower jack between Walmart and Amazon. Make sure to check the actual product pages for available shipping methods and estimated delivery windows.\r","web":""}
+{"id":"walmart_comparison_shopping_245","category":"price_comparison","ques":"Compare options and prices for buying sports whistles between Walmart and Amazon, checking the actual product pages to confirm details.\r","web":""}
+{"id":"walmart_comparison_shopping_22","category":"price_comparison","ques":"Compare the bulk pricing and package sizes for top soil between Walmart and Home Depot to find the best value per unit. Please check the actual product pages to confirm package weights and prices.\r","web":""}
+{"id":"nordstrom_comparison_shopping_46","category":"price_comparison","ques":"Compare the pricing for women's navy blazers between Nordstrom and Macy's to find which retailer offers the best value—make sure to check the actual product pages for current prices and size availability.\r","web":""}
+{"id":"walmart_comparison_shopping_375","category":"price_comparison","ques":"Can you help me compare the price and dimensions of kids bumper cars at Walmart vs Amazon formatted as a table? Please check the actual product pages to confirm each spec.\r","web":""}
+{"id":"walmart_comparison_shopping_424","category":"price_comparison","ques":"compare the price of the Dyson V11 cordless vacuum from their official website vs bestbuy, how much are the monthly payments with each of their suggested buy now, pay later options?\r","web":""}
+{"id":"ebay_comparison_shopping_58","category":"price_comparison","ques":"how much more is the The Enforcer Blue-ray than the DVD on amazon? How much is the DVD at BestBuy?\r","web":""}
+{"id":"target_comparison_shopping_112","category":"price_comparison","ques":"how much is a 6 pack of white undershirts at target vs at walmart?\r","web":""}
+{"id":"homedepot_comparison_shopping_18","category":"price_comparison","ques":"how many different options of 3-way coaxial cable splitters does HomeDepot sell and what is the difference between the cheapest and most expensive option\r","web":""}
+{"id":"walmart_comparison_shopping_220","category":"price_comparison","ques":"Help me compare the price of Food For Life Baking Co. Organic Ezekiel 4:9 Sprouted Whole Grain Cereal (16 oz) at Walmart and Amazon to determine which is more cost-effective. Please check the actual product pages to confirm the prices.\r","web":""}
+{"id":"ebay_comparison_shopping_436","category":"price_comparison","ques":"How much more is the Elephant Terry 33 cm than the Miffy ECO Tiny Teddy - 23 cm on bontontoys.com\r","web":""}
+{"id":"sephora_comparison_shopping_8","category":"price_comparison","ques":"how much is Giorgio Men's Acqua di Giò Eau de Toilette Spray, 1.6 oz at Macy's vs at Sephora?\r","web":""}
+{"id":"dickssportinggoods_comparison_shopping_28","category":"price_comparison","ques":"I’m thinking of getting my son a Justin Jefferson jersey for his birthday, how much more is a small on the vikings' official website than on Dick's sporting goods?\r","web":""}
+{"id":"ulta_comparison_shopping_4","category":"price_comparison","ques":"Look at the price and number of reviews of Ouai Hair and Body Mist Travel size on their official site vs on Ulta, and output a table with the price, retailer, and number of reviews.\r","web":""}
+{"id":"walmart_comparison_shopping_285","category":"price_comparison","ques":"what are the all the different colors men's 7\" sweat shorts are available in on Old Navy, and is that less or more than the equivalent product on Target's website?\r","web":""}
+{"id":"rockauto_comparison_shopping_4","category":"price_comparison","ques":"what is the MSRP for a GM Genuine 84440529 Side Object Sensor Module on gmparts.com, and how much more is that than on gmpartscenter.net\r","web":""}
+{"id":"dickssportinggoods_comparison_shopping_40","category":"price_comparison","ques":"find three different online retailers that sell GM part number 84440529 and list their prices from lowest to highest\r","web":""}
+{"id":"walmart_comparison_shopping_147","category":"price_comparison","ques":"Help me compare the price of the FRAM CV10134 TrueAir Premium cabin air filter for a 2012 Honda Civic at Walmart and AutoZone, which is cheaper? Make sure to check the actual product pages to confirm the price.\r","web":""}
+{"id":"homedepot_comparison_shopping_97","category":"price_comparison","ques":"how much more is the 4-in x 6-in x 12-ft pressure-treated ground-contact southern pine timber on homedepot than their 4 x 4 x 10 ft?\r","web":""}
+{"id":"walmart_comparison_shopping_125","category":"price_comparison","ques":"can you find three options of where to buy Smino Luv 4 Rent translucent green 2-LP explicit vinyl and list their prices and urls\r","web":""}
+{"id":"ebay_comparison_shopping_118","category":"price_comparison","ques":"create a table of three retailers where you can buy  For Whom the Bell Tolls and in the columns put the price for the paperback and hardcover separately\r","web":""}
+{"id":"homedepot_comparison_shopping_20","category":"price_comparison","ques":"help me research where to buy A Tale of Two Cities and output a table of retailers in the rows, and in the columns put the price for the paperback and hardcover separately\r","web":""}
+{"id":"homedepot_comparison_shopping_165","category":"price_comparison","ques":"I need to buy a 6-pack of ankle athletic socks, please find 2 different retailers and the price at which they offer the product\r","web":""}
+{"id":"ebay_comparison_shopping_113","category":"price_comparison","ques":"find three different options of where to buy purple leather paisley pants and output a list of the prices for each site.\r","web":""}
+{"id":"tractorsupply_comparison_shopping_19","category":"price_comparison","ques":"Could you compare the pricing and capacity (in gallons) of steel water troughs between Tractor Supply Co and Amazon to see which offers the best value per gallon? Please check the actual product pages to confirm prices and tank sizes.\r","web":""}
+{"id":"zappos_comparison_shopping_1","category":"price_comparison","ques":"Can you help me compare the price of the cheapest men's Adidas Stan Smith sneakers at Zappos vs Foot Locker and tell me which site is cheaper overall?\r","web":""}
+{"id":"target_comparison_shopping_27","category":"price_comparison","ques":"find the pack of papermate rainbow pens at target that has the most colors, and tell me how many more or less colors it has in it than the most colorful pack at walmart?\r","web":""}
+{"id":"wayfair_comparison_shopping_3","category":"price_comparison","ques":"Can you help me compare the features and specifications (material, fill weight, care instructions, dimensions) of California King burgundy bedspreads available at Wayfair vs Amazon formatted as a table? Please check the actual product pages to confirm the details.\r","web":""}
+{"id":"amazon_comparison_shopping_456","category":"price_comparison","ques":"Can you help me compare the type of rope and length it is sold in of clothesline rope available at Amazon vs Home Depot. Please check the actual product pages to confirm details like material, length, diameter, and weight capacity.\r","web":""}
+{"id":"composite_116","category":"compositional_tasks_v2","ques":"Check Steam for the first  top-selling game today that has a TV series adaptation if any, then use JustWatch.com to find streaming services for the series adaptation.\r","web":""}
+{"id":"composite_23","category":"compositional_tasks_v2","ques":"On Eventbrite.com, find a live music event in Nashville, TN happening this upcoming Saturday. Then on Spotify.com, find a songs by any of the performing artists from that event, if any. \r","web":""}
+{"id":"composite_78","category":"compositional_tasks_v2","ques":"Look at the amazon page for \"The Innovator's Dilemma\", see what it ranks in books overall, and then find a repair service anywhere in the US whose phone number contains that rank as a sub-string. Output the name and phone number of that repair service.\r","web":""}
+{"id":"composite_121","category":"compositional_tasks_v2","ques":"On Wikipedia.org, look up Harvard University to find its location; then on Google Maps, get walking directions to Boston City Hall from this location.\r","web":""}
+{"id":"composite_62","category":"compositional_tasks_v2","ques":"Locate a coding bootcamp company in brooklyn, NYC, and tell me how much full-time tuition would cost there. Then use Google Maps to tel lme which bus I can take from Grand Army Plaza to reach there. Output the name of the bootcamp, the tuition cost, and the bus service name.\r","web":""}
+{"id":"composite_89","category":"compositional_tasks_v2","ques":"Go to lettuce.com and find the first restaurant after filtering their portfolio for spanish cuisine, then go their website to order, and add the 4 most commonly-ordered items to the cart and proceed to checkout. Also output and the prices of those 4 items.\r","web":""}
+{"id":"composite_6","category":"compositional_tasks_v2","ques":"On Booking.com, find the cheapest available 8/10+ scored hotel room for a three-night stay starting December 15, 2025, in Jakarta for 2 adults. Use the hotel's address to search for the closest coffee shop, output it's name and address.\r","web":""}
+{"id":"composite_87","category":"compositional_tasks_v2","ques":"on bklynlibrary.org find the northern-most library branch that has a teen tech help center, then find the year that branch opened to the public, how many square feet of space it has, and who the managing librarian is.\r","web":""}
+{"id":"composite_81","category":"compositional_tasks_v2","ques":"Retrieve the lowest-price round-trip flight from Dallas (DFW) to Miami (MIA) on Jan 20, 2026, to Jan 25, 2026, using Google Flights. Noting the flight's arrival timestamp in miami, book the cheapest compact car from Miami International on Rentalcars.com beginning no less than one hour after the flight arrives. For the first result output the price per day, make/model, and number of seats.\r","web":""}
+{"id":"composite_56","category":"compositional_tasks_v2","ques":"find what xbox.com says is a  top-selling xbox game; note who it was published by and the release date. Then tell me how many years have elapsed since when the CEO or head of that gaming studio was born and the release date.\r","web":""}
+{"id":"composite_99","category":"compositional_tasks_v2","ques":"Search for a \"applied scientist\" position on careers.microsoft.com in redmond, WA and for the first result, extract what the team or group name the job posting is for, and then search externally for what that group does and who it is led by.\r","web":""}
+{"id":"composite_51","category":"compositional_tasks_v2","ques":"at the denver museum of nature and science, find the next show held at the Infinity Theater, and find out who the producer is, and furthermore the names of up to three other films/movies they produced.\r","web":""}
+{"id":"composite_50","category":"compositional_tasks_v2","ques":"List all the members of the bands Nsync and BackStreet Boys. Find the net worth of the one with the longest last name.\r","web":""}
+{"id":"composite_40","category":"compositional_tasks_v2","ques":"Search for women's clothes on sale at zara, take the first result that is marked down, find out what materials it is composed of, and then tell me at what temperature the primary material ignites.\r","web":""}
+{"id":"composite_79","category":"compositional_tasks_v2","ques":"on amazon, find the #3 best selling pantry staple item, and then on AllRecipes, find a recipe which contains that item as an ingredient. Output the full ingredients list along with the recipe name.\r","web":""}
+{"id":"composite_120","category":"compositional_tasks_v2","ques":"Please help me find the first news article published on universityofcalifornia.edu websites, then tell me two other articles published by the same author.\r","web":""}
+{"id":"composite_67","category":"compositional_tasks_v2","ques":"find the next upcoming exhibit at the George H.W. Bush library and tell me what dates it will be available. Tell me whether any total solar eclipse will occur at all within that time frame.\r","web":""}
+{"id":"composite_38","category":"compositional_tasks_v2","ques":"Find a vegetarian restaurant in San Francisco with a rating ≥4.5 and ≥100 reviews; use its address to book a compact car nearest to that location on Rentalcars.com from December 15 to December 18, 2025.\r","web":""}
+{"id":"composite_100","category":"compositional_tasks_v2","ques":"find a reddit post in r/golf talking about how golf courses take up \"3000 sq miles\" of land in the USA. Summarize the top upvoted comment for that post, and then find another website that substantiates any major claim that comment makes.\r","web":""}
+{"id":"composite_123","category":"compositional_tasks_v2","ques":"On Eventbrite.com, find an art exhibition happening this month in Portland and extract the exact date and venue; then check Google Flights for the cheapest same-day round-trip tickets from Seattle (SEA) to Portland (PDX), completing the task before purchase.\r","web":""}
+{"id":"composite_5","category":"compositional_tasks_v2","ques":"From Google Flights, record the least expensive one-way flight from Edinburgh (EDI) to Manchester (MAN) on December 28, 2025, then figure out what aircraft type the flight is on, and how many fewer passengers that aircraft type can carry compared to a 747-8 all-economy configuration.\r","web":""}
+{"id":"composite_68","category":"compositional_tasks_v2","ques":"Plan an itinerary of getting from central park, manhattan, to miami by taking trains only!\r","web":""}
+{"id":"composite_111","category":"compositional_tasks_v2","ques":"find out how many views Adele's \"Rolling in the Deep (Official Music Video)\" has, and then determine what percent of the worlds population that is using a calculator or equivalent search tool.\r","web":""}
+{"id":"composite_21","category":"compositional_tasks_v2","ques":"On Wikipedia.org, look up the first Sister City of the city in which Massachusetts Institute of Technology (MIT) resides, and retrieve the 5-day weather forecast for that sister city.\r","web":""}
+{"id":"composite_61","category":"compositional_tasks_v2","ques":"find the location of the first race listed on raceroster.com, and then find the address of a café or coffee shop nearby that I can wait for my husband at while he finishes the race.\r","web":""}
+{"id":"composite_22","category":"compositional_tasks_v2","ques":"Locate the location of the upcoming NeurIPS conference in 2025 and then find the best local food near the event venue\r","web":""}
+{"id":"composite_114","category":"compositional_tasks_v2","ques":"Locate the top-seller RPG game on Steam and identify its matching game controller. On Amazon, find this controller and add it to the cart, stopping at the review page.\r","web":""}
+{"id":"composite_106","category":"compositional_tasks_v2","ques":"use a mortgage rate calculator tool online to see what my estimated monthly payment will be (including only principal and interest) for a $500,000 home with a down payment of $80,000 over 30 years at an interest rate of 6.0% in 98101.\r","web":""}
+{"id":"composite_94","category":"compositional_tasks_v2","ques":"I want to learn how much I should save for my 2-year olds college fund. Use the Office of Financial Rediness college savings calculator and input the following fields: 3% education cost inflation, $50,000 in current savings, $250 in monthly contributions with 6% rate of return. If their tuition is going to be $50,000 per year and room/board $12,000, how much more per month do i need to save according to the tool? (Hint: do not use the sliders)\r","web":""}
+{"id":"composite_75","category":"compositional_tasks_v2","ques":"go to investor.gov and compute how much money I will have with an initial principle of $10000, to which I make monthly contributions of $200 over 10 years. Assume an interest rate of 5.0 compounded quarterly. Additionally, tell me the colors of the lines it plots in the results.\r","web":""}
+{"id":"composite_96","category":"compositional_tasks_v2","ques":"can you go the latest news release from the US Dept. of Labor, and tell me who the media contact is and how many other contacts there are in their department?\r","web":""}
+{"id":"composite_31","category":"compositional_tasks_v2","ques":"Find one of Beyonce's favorite soul food restaurants in houston, go to their website, and find out when they opened. How much older are they than Beyonce herself?\r","web":""}
+{"id":"composite_58","category":"compositional_tasks_v2","ques":"On Wikipedia.org, find the city containing the oldest university in the US,  use this location to find the lowest priced compact car rental for November 17-19, 2025, on Rentalcars.com.\r","web":""}
+{"id":"composite_82","category":"compositional_tasks_v2","ques":"can you find a quote from Dario Amodei saying that AI will take a lot of jobs. What did he predict the unemployment rate would be, and how many percentage points higher is that than the maximum unemployment the US experienced in 2001?\r","web":""}
+{"id":"composite_74","category":"compositional_tasks_v2","ques":"Find a job on USA jobs in the 10003 area code, and tell me whether the salary of the first listing is above or below the median for that role nationally on salary.com\r","web":""}
+{"id":"composite_25","category":"compositional_tasks_v2","ques":"find an official microsoft support page showing a tutorial about pivot tables. Somewhere on that page, they must have an example spreadsheet or screenshot of one. What is the first row of that example table?\r","web":""}
+{"id":"composite_55","category":"compositional_tasks_v2","ques":"On Steam, find the top-selling horror game and note its associated guidebook. On Amazon, search for this guidebook and add it to the cart, stopping at the cart review page.\r","web":""}
+{"id":"composite_7","category":"compositional_tasks_v2","ques":"On Booking.com, find the cheapest hotel available for a four-night stay from November 20–14, 2025, in San Francisco, California, for 1 adult. Use the hotel's address to identify the closest grocery store and tell me its name and address.\r","web":""}
+{"id":"composite_60","category":"compositional_tasks_v2","ques":"Search for any AI  conferences or workshops in San Francisco this month, noting the date and location; then on Google Flights, secure a viable round-trip flight from Toronto (YYZ) to San Francisco  on the summit date, stopping before booking.\r","web":""}
+{"id":"composite_91","category":"compositional_tasks_v2","ques":"I need to find a job with Secret security clearance on USAjobs.com, can you find the first job in the list that has an annual salary, and then use another tool to compute what my after tax takehome pay would be for that job?\r","web":""}
+{"id":"composite_42","category":"compositional_tasks_v2","ques":"On LinkedIn.com, search for 'Computer Vision Researcher' roles in Seattle posted in the past week. Find me the latest computer vision course from stanford available for free online to prep.\r","web":""}
+{"id":"composite_29","category":"compositional_tasks_v2","ques":"look at the first article published on searchengineland.com, summarize the key takeaway, and then find another article from a different site that supports / verifies it.\r","web":""}
+{"id":"composite_112","category":"compositional_tasks_v2","ques":"Locate a headline jazz event in Los Angeles featuring multiple artists in the near future, select the headline artist, and subsequently find and play a song from this artist on Spotify.com.\r","web":""}
+{"id":"composite_4","category":"compositional_tasks_v2","ques":"Using Google Maps, tell me how many miles it is to drive from Manchester Airport to Etihad Stadium, and whether that is longer or shorter than the distance from the george washington bridge to the NYSE.\r","web":""}
+{"id":"composite_53","category":"compositional_tasks_v2","ques":"Identify three jazz clubs in Chicago, and determine their neighborhoods; afterward, use Booking.com to find the least expensive hotel for a one-night stay in the first of those neighborhoods (sorted alphabetically) on December 28, 2025, for 2 adults.\r","web":""}
+{"id":"composite_27","category":"compositional_tasks_v2","ques":"find the best mens face wash according to GQ or mens health, then buy it from amazon.com\r","web":""}
+{"id":"composite_85","category":"compositional_tasks_v2","ques":"Find the address for the office of 'Bright Future Forever' based in Seattle, WA; and then tell me the name of one of the DDS that works at the dental office across the street and where they graduated from undergrad.\r","web":""}
+{"id":"composite_63","category":"compositional_tasks_v2","ques":"I want to find a Compliance Specialist job on NYC jobs for the city of new york and calculate my takehome pay if I were to get it. Assume the maximum end of the salary range and use smartasset.com tell me both what the take-home pay would be and effective tax rate.\r","web":""}
+{"id":"composite_52","category":"compositional_tasks_v2","ques":"On reddit, search for blues club in New Orleans and take the first one mentioned in the comments. What was the most recent comment that user made according to their reddit profile, and does it appear from their comments they actually live in Louisiana?\r","web":""}
+{"id":"composite_16","category":"compositional_tasks_v2","ques":"Find the names of the three \"dynasties\" that preside over broadway theater houses, and find out how many theaters each owns.\r","web":""}
+{"id":"composite_84","category":"compositional_tasks_v2","ques":"during the first week of December, find the cheapest hotel in New York in times square then find tickets for the lion king or MJ the musical that week\r","web":""}
+{"id":"composite_124","category":"compositional_tasks_v2","ques":"Can you tell me the cost structure of a one-year certificate program in New York City at the International Center of Photography and how it is different than the same program at the New York Film Academy.\r","web":""}
+{"id":"composite_57","category":"compositional_tasks_v2","ques":"I'm deciding between enrolling in stanford vs johns hopkins as a freshman, can you tell me how much a full-year (2 semester or 3 quarter) meal plan costs at each university (assuming I will eat the maximum number allowed or unlimited meals).\r","web":""}
+{"id":"composite_43","category":"compositional_tasks_v2","ques":"On genentech's website, first tell me how many open roles there are in the regulatory & quality department at each job level, and secondly filter to the most senior job level and tell me what it's salary range is.\r","web":""}
+{"id":"composite_98","category":"compositional_tasks_v2","ques":"Find top 'Software Engineer' roles in Seattle for an established big-tech company on LinkedIn.com and retrieve the associated company name; use the company name on Wikipedia.org to find the year it was founded.\r","web":""}
+{"id":"tripadvisor_other_event_5","category":"ticketing","ques":"I plan on going to Fantastic Caverns in Springfield, MO on 12/2/2025 with my wife and two kids under 12. See if there are any discounts available online, either for a group discount or an age discount, and book tickets if any tickets are available at 3:00 PM.\r","web":""}
+{"id":"discounts.aaa_theme_park_16","category":"ticketing","ques":"Can you help me buy Walt Disney World theme park tickets for two in Florida from AAA online for any day over 12/11-12/15 ? Please let me know if they're not available.\r","web":""}
+{"id":"vacourts.gov_citation_13","category":"ticketing","ques":"Can you help me pay my Virginia traffic ticket online via the Virginia Courts website? Please let me know if there are any issues with completing the payment.\r","web":""}
+{"id":"palaciodemafra.pt_other_event_1","category":"ticketing","ques":"Can you help me buya  Mafra Museum visit ticket online from the Palácio de Mafra website on December 20th? Please let me know if they aren't available.\r","web":""}
+{"id":"universalorlando_theme_park_16","category":"ticketing","ques":"I plan on going to Universal Orlando Resort in Orlando, FL around Christmastime with my family of four. Could you please assist me in securing tickets? Please let me know if there are any issues or if they're not available.\r","web":""}
+{"id":"pacificbonsaimuseum_other_event_1","category":"ticketing","ques":"I really want to see the Weyerhaeuser Company Bonsai Exhibit at the Pacific Bonsai Museum in Federal Way, WA with my boyfriend. Would it be possible to book tickets online for November 28th? Let me know if they're not available anymore.\r","web":""}
+{"id":"americasriverroots_music_event_1","category":"ticketing","ques":"Can you help me buy the soonest Celebration Belle Riverfest 2025 tickets for me and my parents? Let me know if they're no longer available.\r","web":""}
+{"id":"ludlowgaragecincinnati_music_event_1","category":"ticketing","ques":"Can you help me the upcoming buy Barrington Levy concert tickets online within a 50 mile radius of Cincinnati, OH? Please let me know if they aren't available anymore.\r","web":""}
+{"id":"eventbrite_other_event_36","category":"ticketing","ques":"I am based in thie Chicago, IL. Can you help me buy the next Marriott bridal show tickets at a Marriott Hotel in the greater Chicago area on Eventbrite? Please let me know if the tickets aren't available.\r","web":""}
+{"id":"romehacks_music_event_1","category":"ticketing","ques":"Can you help me get two tickets for the Vatican museums on January 9th at 1 PM? Let me know if they're not available anymore.\r","web":""}
+{"id":"caminitodelrey.info_other_event_2","category":"ticketing","ques":"Can you help me buy 5 Caminito del Rey tickets online in Malaga, Spain from the official Caminito del Rey website in two wees? Please let me know if they aren't available anymore.\r","web":""}
+{"id":"ticketmaster_music_event_192","category":"ticketing","ques":"Can you help me buy a ticket at an upcoming event at Shoreline Amphitheatre in Mountain View, CA on Ticketmaster? Please let me know if they're not available.\r","web":""}
+{"id":"fandango_movie_87","category":"ticketing","ques":"Can you help me buy 12 Superman 2025 movie tickets online on Fandango next Wednesday? We have four youth in our group. Please let me know if they aren't available.\r","web":""}
+{"id":"anaheim_citation_3","category":"ticketing","ques":"Can you help me pay my City of Anaheim Police Department traffic ticket online? Please let me know if there are any issues with completing the payment.\r","web":""}
+{"id":"bahn.de_transportation_3","category":"ticketing","ques":"Can you help me buy Deutsche Bahn train tickets from Munich to Vienna online on bahn.de on February 3rd? Please let me know if the tickets aren't available.\r","web":""}
+{"id":"amazon_lottery_2","category":"ticketing","ques":"Can you help me buy pre-numbered blank raffle tickets on Amazon? Please let me know if they're not available for purchase.\r","web":""}
+{"id":"portalnjmcdirect-cloud.njcourts.gov_citation_35","category":"ticketing","ques":"Can you help me pay my New Jersey municipal court ticket online via NJMCDirect? Please let me know if there are any issues with completing the payment.\r","web":""}
+{"id":"showtimes_movie_44","category":"ticketing","ques":"Can you help me buy a Downton Abbey movie tickets online for Dietrich Theater in Tunkhannock, PA? I would prefer seats in the center back. Let me know if they're not available.\r","web":""}
+{"id":"morgancountyutah.gov_citation_1","category":"ticketing","ques":"Could you help me pay my ticket online at the Morgan County, Utah District Court? Please let me know if there are any issues with the payment process.\r","web":""}
+{"id":"confirmtkt_transportation_1","category":"ticketing","ques":"Can you help me book six round-trip railway tickets online on ConfirmTkt from New Dehli to Mumbai Central?  I would like to travel over March 1st-14th. Let me know if there aren't any tickets available.\r","web":""}
+{"id":"buckeyecountrysuperfest_music_event_1","category":"ticketing","ques":"Can you help me buy Buckeye Countryfest tickets from the Buckeye Country Superfest website? Please let me know if they're not available.\r","web":""}
+{"id":"united_transportation_10","category":"ticketing","ques":"Could you help me book a United Airlines direct flight ticket on January 7th from Little Rock, Arl to Providence, RI online through United.com? Let me know if there are any issues or if the tickets aren’t available.\r","web":""}
+{"id":"costco_theme_park_12","category":"ticketing","ques":"Can you help me buy Universal Studios theme park tickets online from Costco from December 20th to January 2nd for two people? Please let me know if they're not available.\r","web":""}
+{"id":"ticketmaster_sporting_event_31","category":"ticketing","ques":"Can you help me buy  three Toronto Maple Leafs game tickets in Toronto, ON  for the upcoming game on NHL.com? Please let me know if they're not available anymore.\r","web":""}
+{"id":"lacourt.ca.gov_citation_13","category":"ticketing","ques":"Can you help me pay my Los Angeles County speeding ticket online on the LA Court website? Please let me know if there are any issues with the payment process.\r","web":""}
+{"id":"regmovies_movie_58","category":"ticketing","ques":"Can you help me buy three tickets for the any PG-13 movie online at Regal Cinemas near Fairbanks, AK? Please let me know if they aren't available.\r","web":""}
+{"id":"thesphere_other_event_20","category":"ticketing","ques":"Can you help me purchase four The Wizard of Oz Experience tickets online on The Sphere website in Las Vegas on December 1st at 5:00 PM? Please let me know if they aren't available.\r","web":""}
+{"id":"albemarle.edu_music_event_1","category":"ticketing","ques":"Could you help me reserve two tickets for any event online from the College of the Albemarle Performing Arts Center in Elizabeth City, NC? Please let me know if they're not available.\r","web":""}
+{"id":"koobit_music_event_2","category":"ticketing","ques":"Can you help me purchase Florence + The Machine Everybody Scream Tour tickets on StubHUb? Please let me know if they are sold out.\r","web":""}
+{"id":"azfamily_citation_1","category":"ticketing","ques":"Can you please help me pay my photo radar traffic ticket online in Paradise Valley, AZ? Let me know if there are any issues processing the payment.\r","web":""}
+{"id":"sanbernardino.courts.ca.gov_citation_3","category":"ticketing","ques":"Can you help me pay my San Bernardino County traffic ticket online via the San Bernardino County Superior Court website? Please let me know if there are any issues completing the payment.\r","web":""}
+{"id":"flyontario_transportation_1","category":"ticketing","ques":"Could you help me book the first available flight tickets from Ontario International Airport  to New York City using FlyOntario? Please let me know if there are any issues with availability.\r","web":""}
+{"id":"stpaul.gov_citation_1","category":"ticketing","ques":"Could you please pay my City of St. Paul parking ticket online for me? Let me know if there are any issues with completing the payment.\r","web":""}
+{"id":"mncourts.gov_citation_3","category":"ticketing","ques":"Could you please pay my St. Louis County, MN speeding ticket online through the Minnesota Courts website? Let me know if there are any issues or if you can't complete the payment.\r","web":""}
+{"id":"ges.wcs.edu_other_event_1","category":"ticketing","ques":"Can you help me buy the next GES Fest tickets online in Dallas, TX? Please let me know if they're not available.\r","web":""}
+{"id":"nerdwallet_theme_park_9","category":"ticketing","ques":"Can you help me buy discounted Epic Universe theme park tickets in Orlando, FL online around Christmastime? Consider looking at blogposts for resources, as well as AAA, Undercover tourist, and other sites with discounted websites. Please let me know if they aren't available.\r","web":""}
+{"id":"seattlegreatwheel_theme_park_1","category":"ticketing","ques":"Could you assist me with purchasing Seattle Great Wheel tickets online from the Seattle Great Wheel website on the upcoming Sunday at around 7 PM? Please let me know if they're not available.\r","web":""}
+{"id":"aquarionwater_theme_park_1","category":"ticketing","ques":"Can you help me buy discounted Mystic Aquarium tickets online in Mystic, CT for me and my veteran father? I plan on going the upcoming Saturday morning. Let me know if they aren't available anymore.\r","web":""}
+{"id":"ticketmaster_music_event_25","category":"ticketing","ques":"Can you help me buy the upcoming Malcolm Todd concert tickets on Ticketmaster? I can travel anywhere in the world. Please let me know if they're no longer available.\r","web":""}
+{"id":"pay.baltimorecity.gov_citation_3","category":"ticketing","ques":"Could you help me pay my Baltimore parking tickets online through the Baltimore City website? Please let me know if there are any issues with the payment process.\r","web":""}
+{"id":"etickets_sporting_event_1","category":"ticketing","ques":"Could you help me buy Calgary Stampede 2026 tickets online from eTickets.com in Calgary, AB on July 6? Please let me know if they're not available.\r","web":""}
+{"id":"quickcourt.biz_citation_4","category":"ticketing","ques":"Can you help me pay my Henderson, LA traffic ticket online using QuickCourt? Please let me know if there are any issues processing the payment.\r","web":""}
+{"id":"expedia_transportation_67","category":"ticketing","ques":"Can you help me find cheap plane tickets from New Orleans, LA to El Paso, TX on Expedia? Let me know if there aren't any available flights.\r","web":""}
+{"id":"transact2.dmv.ny.gov_citation_3","category":"ticketing","ques":"Can you help me pay a New York traffic ticket online through the NY DMV? Please let me know if there are any issues with completing the payment.\r","web":""}
+{"id":"arlandaexpress_transportation_1","category":"ticketing","ques":"Can you help me buy two round-trip Arlanda Express train tickets from Arlanda Express online? I plan on traveling leaving anytime next Friday and staying there for a week. Find discounts if possible. Let me know if they're not available.\r","web":""}
+{"id":"stagepittsburgh_music_event_1","category":"ticketing","ques":"Can you help me buy tickets for any upcoming Stage AE 2026 music event at Stage AE in Pittsburgh, PA online? Let me know if they aren't available.\r","web":""}
+{"id":"wetzeltaxpiled-technologies_citation_1","category":"ticketing","ques":"Can you help me pay my Wetzel County Sheriff's current tax ticket online? Please let me know if there are any issues with completing the payment.\r","web":""}
+{"id":"ticketmaster_music_event_162","category":"ticketing","ques":"Can you help me buy Lady Gaga Mayhem 2026 concert tickets in California on Ticketmaster? Please let me know if they're sold out.\r","web":""}
+{"id":"cityofvancouver.us_citation_1","category":"ticketing","ques":"Can you help me pay my City of Vancouver, WA parking ticket online? Please let me know if there are any issues with the payment process.\r","web":""}
+{"id":"sugarbowl_other_event_1","category":"ticketing","ques":"Can you help me buy Sugar Bowl ski resort tickets online at SugarBowl.com for Lake Tahoe? I want to go with my family of 5, with 3 young kids. Let me know if it's not available anymore.\r","web":""}
+{"id":"reddit_sporting_event_1","category":"ticketing","ques":"Can you help me buy Giants football tickets online the next time they play a home game? Please let me know if they're unavailable.\r","web":""}
+{"id":"help.ticketmaster_music_event_10","category":"ticketing","ques":"Can you help me buy two Ariana Grande 2026 tour tickets on Ticketmaster in Los Angeles, CA? Let me know if they're not available anymore.\r","web":""}
+{"id":"alltrippers_other_event_1","category":"ticketing","ques":"Can you help me buy London New Year's Eve tickets online? Please let me know if they're not available anymore.\r","web":""}
+{"id":"whichmuseum_other_event_21","category":"ticketing","ques":"Can you help me buy five discounted tickets for the upcoming Sunday at 1 PM to the Greater Cleveland Aquarium in Cleveland, OH online? I have three cihldren, ages 7, 10, 13, and I'm traveling with my husband. Let me know if they're not available.\r","web":""}
+{"id":"seaworld_theme_park_10","category":"ticketing","ques":"Can you help me buy SeaWorld Orlando theme park tickets online using the ID.me military discount? Please let me know if tickets aren't available.\r","web":""}
+{"id":"artic.edu_other_event_1","category":"ticketing","ques":"Could you assist me in getting Art Institute of Chicago college student admission tickets online from the Art Institute of Chicago website? Please let me know if they're not available.\r","web":""}
+{"id":"plandisney.disney.go_theme_park_6","category":"ticketing","ques":"Can you help me buy Disneyland theme park tickets online from Sam’s Club in Anaheim, CA? I plan on going during Christmastime with my fiance. Please let me know if they aren't available.\r","web":""}
+{"id":"buy_condo_port_aransas__tx_11146","category":"realestate_complex","ques":"I'm looking to buy a condominium in Sea Gull, Port Aransas, TX, that's under $900k, with 2 or more bedrooms, a water view, and low HOA fees. Can you help me find one?\r","web":""}
+{"id":"buy_land_naples__fl_13486","category":"realestate_complex","ques":"I'm interested in buying land in Naples, FL. I'd like some options with over 0.5 acres, that are new listings, have no HOA, and preferably offer a water view. Can you help me find something that fits these criteria?\r","web":""}
+{"id":"buy_condo_titusville__fl_7914","category":"realestate_complex","ques":"I'm looking for a condo for sale in Titusville, Florida that’s under $500k, has 2 or more bathrooms, offers a water view, and has low HOA fees. Can you help me find something that matches these criteria?\r","web":""}
+{"id":"buy_other_alice__tx_18179","category":"realestate_complex","ques":"Can you help me find a commercial property for sale in Alice, Texas that is new to the market, priced between $300k-$600k, and has central AC?\r","web":""}
+{"id":"buy_house_amherst__nh_2032","category":"realestate_complex","ques":"Can you help me find a home for sale in Amherst, NH? I'm looking for something between $300k-$600k, with 4 or more bedrooms, over 2000 square feet, and in an area with top-rated schools.\r","web":""}
+{"id":"buy_house_madison__wi_6412","category":"realestate_complex","ques":"I'm looking to buy a home in Madison, WI near Sunfield Street. Ideally, I'd like it to have at least 3 bedrooms, 2 bathrooms, central AC, and be located in a walkable neighborhood. Can you help me find something that fits these criteria?\r","web":""}
+{"id":"buy_land_lake_county__in_4991","category":"realestate_complex","ques":"I'm looking to buy land for sale by owner in Lake County, Indiana, under $500k, over 0.5 acres, with active listings. Can you show me options that meet my criteria?\r","web":""}
+{"id":"buy_house_gallatin__tn_11755","category":"realestate_complex","ques":"I'm interested in buying a home in Gallatin, TN, ideally on Duncan Ave. My budget is between $300k-$600k, and I'm looking for a place with at least 3 bedrooms, a 2-car garage, and access to top-rated schools. Could you help me find listings that meet these criteria?\r","web":""}
+{"id":"rent_other_arcata__ca_7137","category":"realestate_complex","ques":"I'm looking to rent a property in Arcata, CA with 2+ bedrooms and in-unit laundry in a walkable neighborhood.\r","web":""}
+{"id":"buy_house_provo__ut_15202","category":"realestate_complex","ques":"Can you help me find a house for sale in Provo, UT with 3 or more bedrooms, that's new to the market and has a mountain view?\r","web":""}
+{"id":"buy_house_westfield__chatham_hills_5479","category":"realestate_complex","ques":"I'm interested in buying a home in Chatham Hills, Westfield that has 4 or more bedrooms, was built after 2000, and is near top-rated schools. Can you help me find a listing that meets these criteria?\r","web":""}
+{"id":"buy_house_chambers_county__tx_2343","category":"realestate_complex","ques":"I'm looking to buy a house in Chambers County, Texas with 3+ bedrooms, 2+ bathrooms, on a large lot, and under $500k. Can you show me listings that meet these criteria?\r","web":""}
+{"id":"buy_house_pittsburgh__pa_13147","category":"realestate_complex","ques":"I'm looking to buy a home with a river view in a walkable neighborhood in Pittsburgh, PA. Ideally, it should have 3+ bedrooms, 2+ bathrooms, and be built after 2000. Can you help me find something that fits these criteria?\r","web":""}
+{"id":"buy_house_heath__tx_3681","category":"realestate_complex","ques":"Can you help me find new homes for sale in Heath, TX with pools, built after 2000, that have 4+ bedrooms, are new listings, and sit on large lots?\r","web":""}
+{"id":"buy_house_houston__tx_15257","category":"realestate_complex","ques":"Can you help me find a move-in ready mobile home to buy in Houston, TX? I'm looking for something under $500k with 3 bedrooms and 2+ bathrooms. You can check listings for me online.\r","web":""}
+{"id":"buy_house_florida_18531","category":"realestate_complex","ques":"Can you help me find homes for sale in Florida that are between $300k-$600k, have 3 or more bedrooms, central AC, and are near transit?\r","web":""}
+{"id":"buy_land_gun_barrel_city__tx_4916","category":"realestate_complex","ques":"I'm interested in buying land near Gun Barrel City, TX. Can you find active listings over 0.5 acres and under $500k?\r","web":""}
+{"id":"buy_house_jackson__tn_2638","category":"realestate_complex","ques":"I'm looking to buy a move-in ready home with 3 bedrooms and central AC in Jackson, TN, priced between $300k and $600k. Can you help me find one that meets these criteria?\r","web":""}
+{"id":"buy_townhouse_bolingbrook__il_3053","category":"realestate_complex","ques":"Can you help me find townhomes for sale in Bolingbrook, Illinois with 3 or more bedrooms, at least 2 bathrooms, priced under $400k, and that are new to the market?\r","web":""}
+{"id":"buy_house_bossier_city__la_20568","category":"realestate_complex","ques":"I'm looking to buy a small house with 3 bedrooms and 2+ bathrooms under $300k in Bossier City, LA. Can you help me find one that fits these criteria?\r","web":""}
+{"id":"buy_house_denton__tx_732","category":"realestate_complex","ques":"I'm looking to buy a home in Robson Ranch, Denton with 3 bedrooms, 2+ bathrooms, an active listing, and a 2-car garage. Can you help me find something that meets these criteria?\r","web":""}
+{"id":"rent_apartment_sayville__ny_10236","category":"realestate_complex","ques":"I'm searching for an apartment to rent in Sayville, NY with 2 or more bedrooms, in-unit laundry, and a walkable neighborhood. Can you help me find one?\r","web":""}
+{"id":"buy_house_highland__mi_2862","category":"realestate_complex","ques":"Can you help me find homes for sale in Highland, MI with at least 3 bedrooms, 2+ bathrooms, and a large lot?\r","web":""}
+{"id":"buy_house_bartlett__tn_12368","category":"realestate_complex","ques":"I'm looking to buy a home in Bartlett, TN with 4+ bedrooms, 2+ bathrooms, a large lot, and central AC. Can you find a listing that meets my criteria?\r","web":""}
+{"id":"buy_house_staten_island__ny_2532","category":"realestate_complex","ques":"I'm looking to buy a house in Staten Island, NY that has 4 or more bedrooms, a large lot, and access to top-rated schools. Can you help me find a listing that meets these criteria?\r","web":""}
+{"id":"buy_house_columbus__ga_10335","category":"realestate_complex","ques":"Can you show me the latest listings of homes for sale in Columbus, GA with 4+ bedrooms, 2+ bathrooms, under $400k, and central AC?\r","web":""}
+{"id":"buy_house_montesano__wa_7329","category":"realestate_complex","ques":"Can you help me find houses for sale in Montesano, WA with 3 or more bedrooms, at least 2 bathrooms, on over 0.5 acres, and that are new to the market?\r","web":""}
+{"id":"buy_house_jenks__ok_10654","category":"realestate_complex","ques":"I'm looking to buy a home in Jenks, Oklahoma with 3+ bedrooms, central AC, and a large lot. Can you show me listings?\r","web":""}
+{"id":"buy_house_lambertville__mi_20673","category":"realestate_complex","ques":"Could you help me find homes for sale in Lambertville, MI with 3 or more bedrooms, 2 or more bathrooms, a large lot, and central AC?\r","web":""}
+{"id":"buy_house_little_rock__ar_17955","category":"realestate_complex","ques":"I'm looking to buy a move-in ready small house in Little Rock, Arkansas. Ideally, it should be under $500k, have 3 bedrooms, and include a 2-car garage. Can you show me options?\r","web":""}
+{"id":"rent_house_nashville__tn_8900","category":"realestate_complex","ques":"I'm looking to rent a 3-bedroom, pet-friendly house with central AC in the Morrow Rd area of Nashville, TN. Could you find listings that meet these criteria?\r","web":""}
+{"id":"buy_house_the_villages__fl_14171","category":"realestate_complex","ques":"Can you help me find move-in ready homes for sale in The Villages, FL with 3+ bedrooms, 2+ bathrooms, priced between $300k-$600k?\r","web":""}
+{"id":"buy_other_lafayette__co_19861","category":"realestate_complex","ques":"I'm looking for condominiums or townhouses for sale in Lafayette, CO with 2+ bathrooms, central AC, and low HOA fees. Could you find me some options?\r","web":""}
+{"id":"buy_house_aiken__sc_20679","category":"realestate_complex","ques":"I'm interested in buying a home on Equinox Loop in Aiken, SC with 4+ bedrooms, 2.5+ bathrooms, a large lot, and central AC. Can you find a listing that meets these criteria?\r","web":""}
+{"id":"buy_house_temperance__mi_11916","category":"realestate_complex","ques":"Can you help me find homes for sale in Temperance, Michigan with 3 or more bedrooms, at least 2 bathrooms, and priced under $500k?\r","web":""}
+{"id":"buy_house_tacoma__wa_12334","category":"realestate_complex","ques":"I'm looking for homes for sale in Tacoma, WA that have 3 bedrooms, 2 or more bathrooms, and are under $500k. Can you show me some options?\r","web":""}
+{"id":"rent_land_brodheadsville__pa_12988","category":"realestate_complex","ques":"I'm looking for a commercial lot for rent near Brodheadsville, PA that's under $500k, over 0.5 acres, and new to market. Can you help me find one?\r","web":""}
+{"id":"buy_house_lorain__oh_13583","category":"realestate_complex","ques":"I'm looking to buy a move-in ready split level home in Lorain, Ohio with 3 bedrooms, 2+ bathrooms, and over 2000 sq ft. Could you find a listing that meets these criteria?\r","web":""}
+{"id":"buy_house_hillsboro__oh_5688","category":"realestate_complex","ques":"I'm interested in buying a house with 3 or more bedrooms, a 2-car garage, a large lot, and central AC in the Hillsboro, Ohio area. Could you show me listings that meet these criteria?\r","web":""}
+{"id":"buy_house_oviedo__fl_3554","category":"realestate_complex","ques":"Can you help me find a 3 bedroom house with at least 2 bathrooms in Oviedo, Florida, located near top-rated schools?\r","web":""}
+{"id":"buy_house_williamstown__nj_14447","category":"realestate_complex","ques":"Could you assist me in finding move-in ready, new listings with 4 or more bedrooms for sale in Williamstown, NJ?\r","web":""}
+{"id":"buy_condo_cranston__ri_16769","category":"realestate_complex","ques":"I'm looking for a condo for sale in Cranston, RI that meets the following criteria: under $500k, 2 bedrooms, low HOA fees, and located in a walkable neighborhood. Can you help me find an option that fits these requirements?\r","web":""}
+{"id":"buy_house_lapeer_county__mi_19012","category":"realestate_complex","ques":"I'm searching for a home in Lapeer County, MI that's under $330k. Ideally, it should have 3 bedrooms, 2+ bathrooms, a large lot, and be move-in ready. Can you find options for me?\r","web":""}
+{"id":"buy_house_omaha__ne_11006","category":"realestate_complex","ques":"I'm looking to buy a house in Omaha, NE with 4 or more bedrooms, a large lot, and near top-rated schools. Can you find a listing that meets these criteria?\r","web":""}
+{"id":"buy_other_minnesota_2733","category":"realestate_complex","ques":"Can you help me find farms for sale in Minnesota that are over 0.5 acres, have central AC, are recently reduced in price, and are move-in ready?\r","web":""}
+{"id":"buy_other__13924","category":"realestate_complex","ques":"I'm looking to buy an oceanfront property that is under $500k, has 4 or more bedrooms, offers a water view, and is a new construction. Can you help me find something that fits these criteria?\r","web":""}
+{"id":"buy_house_4059_10th_avenue_dr_sw__nc_19159","category":"realestate_complex","ques":"Can you help me find homes with at least 3 bedrooms, 2 or more bathrooms, and built after 2000 in the SW area of North Carolina? Please show me listings that meet these criteria.\r","web":""}
+{"id":"buy_house_wyoming__mi_17426","category":"realestate_complex","ques":"I'm looking to buy a home in Wyoming, MI with 3 bedrooms, 2+ bathrooms, and central AC in a walkable neighborhood. Can you show me listings that meet these criteria?\r","web":""}
+{"id":"apply_apply_1239","category":"jobs","ques":"Help me apply for an administrative position listed on CareerBuilder and name at least three employers hiring for it according to CareerBuilder's listings\r","web":""}
+{"id":"wildcard_wildcard_1969","category":"jobs","ques":"How many remote full time fullfillment center warehouse associate positions are available at Amazon according to their latest job listings?\r","web":""}
+{"id":"apply_apply_2864","category":"jobs","ques":"Help me apply for an accounting position in Los Angeles listed on Robert Half's website and output all permanent senior accounting and  accounting manager positions according to Robert Half's listings\r","web":""}
+{"id":"apply_apply_1219","category":"jobs","ques":"Help me apply for a chemistry research scientist position in Madison, WI found on LinkedIn and output five listings that would have me be an early application according to the listings. If there are less than five such listings, output them all.\r","web":""}
+{"id":"pay_grades_pay_grades_1238","category":"jobs","ques":"I have a CDL. Find 3 entry-level driving jobs in Houston, TX on SimplyHired. What is the guaranteed minimum salary for each of these jobs according to the listings?\r","web":""}
+{"id":"employer_landscape_employer_landscape_1359","category":"jobs","ques":"List at least three customer support specialist positions available on the Apple Careers site in New York.\r","web":""}
+{"id":"job_id_job_id_127","category":"jobs","ques":"What are the locations for the motorcoach driver positions listed in Iowa on GoWindstar according to GoWindstar's job listings?\r","web":""}
+{"id":"salary_range_salary_range_982","category":"jobs","ques":"What is the salary range for at least three available positions that are hiring immediately in McDonough, GA, according to the McDonough job openings page?\r","web":""}
+{"id":"benefits_benefits_1624","category":"jobs","ques":"What some benefits are offered for positions listed on RL Carriers Careers?\r","web":""}
+{"id":"company_size_company_size_661","category":"jobs","ques":"Tell me how many vacancies there are for Physical Scientist at NOAA on usajobs.gov and where the vacancies are located\r","web":""}
+{"id":"apply_apply_2979","category":"jobs","ques":"I'm looking for a cook position that pays at least $18/hr within 25 miles of Cumming, GA. Help me apply for 5 cook positions that meet such criteria on SimpliyHired.\r","web":""}
+{"id":"apply_apply_353","category":"jobs","ques":"Help me apply for an economist position in Washington, D.C. listed on USAJobs. Output at least two agencies hiring according to the listings if at least two agencies exist.\r","web":""}
+{"id":"apply_apply_2635","category":"jobs","ques":"I'm looking for Home Infusion Nurse positions at the Cigna Group. How many open positions are there in California for this role?\r","web":""}
+{"id":"apply_apply_2473","category":"jobs","ques":"I'm seeking a job in Charlotte, NC with Spectrum. Through the Spectrum Jobs website, find me 3 cusomter service jobs\r","web":""}
+{"id":"job_titles_job_titles_139","category":"jobs","ques":"how many open opportunities are there at Howard Brown Health careers page in Chicago? What is the first position listed and its Requisition Number?\r","web":""}
+{"id":"responsibilities_responsibilities_1537","category":"jobs","ques":"what are the first three \"essential functions\" of a driver with Fedex Freight as listed on one of their job postings?\r","web":""}
+{"id":"apply_apply_1546","category":"jobs","ques":"Help me apply for 3 retail sales associate positions near Glen Burnie, MD  that are friendly to veternas\r","web":""}
+{"id":"job_id_job_id_253","category":"jobs","ques":"What is the requisition number, salary range, and posting closing date of the first \"comptroller\" job listed on https://jobs.myflorida.com/? And who is the office contact?\r","web":""}
+{"id":"apply_apply_2317","category":"jobs","ques":"Help me apply for a customer support position at Thermo Fisher Scientific on their career page. I am looking for a position that only requires a high school diploma, and I would prefer it to be remote.\r","web":""}
+{"id":"wording_wording_163","category":"jobs","ques":"What is the exact wording of the first sentence of the job description for a paralegal position on the Nevada Bar Jobs site? Output the job ID as well for my later reference.\r","web":""}
+{"id":"wording_wording_2464","category":"jobs","ques":"Find  the exact wording of the first sentence of a job description on The Bair Foundation's Careers page based in Pennsylvania. Also return the ID of the job.\r","web":""}
+{"id":"apply_apply_2810","category":"jobs","ques":"I have experience with the Microsoft Office Suite and covers medical insurance. Help me apply for a logistics coordinator position that meets such requirements in Miami, FL using CareerBuilder.\r","web":""}
+{"id":"employer_landscape_employer_landscape_961","category":"jobs","ques":"Help me apply for a police officer position in Soldotna, AK  on their government jobs portal if it still exists, and tell me which form I need to fill out and what the hourly wage is.\r","web":""}
+{"id":"apply_apply_2022","category":"jobs","ques":"Help me apply for an anthropologist (i.e. researcher, scientist, or professor) position in Washington, D.C. listed on Careers in Anthropology, if available, with a minimum salary of $60,000. Output three organiziations, univerisites, or companies hiring that meets these constraints according to these listings\r","web":""}
+{"id":"apply_apply_1003","category":"jobs","ques":"Help me apply for a full-time sales position at Farmers Insurance by navigating their careers page in the US, and let me know if none exist. List the three closest listings to Boston, MA if at least three exist.\r","web":""}
+{"id":"salary_range_salary_range_1277","category":"jobs","ques":"What is the salary range for finance positions available at Bank of Texas in Dallas, TX as listed on BOK Financial's career site, specifically for full-time roles? Output at least three of the job listings and the required years of experience for those positions.\r","web":""}
+{"id":"apply_apply_174","category":"jobs","ques":"Help me apply for a computer science position located in Rancho Cucamonga, CA, with a minimum salary of $80,000 if available, using LinkedIn. Provide 5  URLs to forms for me to fill out myself.\r","web":""}
+{"id":"benefits_benefits_2600","category":"jobs","ques":"Output at least three psychologist positions and their benefits in Kentucky found on LinkedIn that require a Master's degree, if available? Provide links to their forms for job application as well in your output\r","web":""}
+{"id":"salary_range_salary_range_1684","category":"jobs","ques":"What is the salary range for any job opening listed on the SSENSE Careers page requiring a Bachelor's degree, if available? Provide a URL for such a job if it exists.\r","web":""}
+{"id":"responsibilities_responsibilities_1471","category":"jobs","ques":"What are the main responsibilities listed in a production operations job posting at Grande Cheese from their careers page, specifically for positions that require a minimum of three years of relevant experience?\r","web":""}
+{"id":"qualifications_qualifications_724","category":"jobs","ques":"What are the qualifications for environmental scientist positions listed on the South Florida Water Management District careers page open to the public? How do the qualifications vary across listings?\r","web":""}
+{"id":"wildcard_wildcard_2597","category":"jobs","ques":"List the salary or salary ranges for five different filing tax consultant positions based in Chicago, IL on Robert Half that require a CPA certification? Output pairs of (employers, salary) in decreasing order of salary.\r","web":""}
+{"id":"responsibilities_responsibilities_2088","category":"jobs","ques":"What are the main responsibilities listed in the first administrative position post in Mililani, Hawaii that offers health insurance, if available? Output a link to the job listing as well.\r","web":""}
+{"id":"salary_range_salary_range_633","category":"jobs","ques":"What is the salary range for the first logistics coordinator job posting in Miami, FL on LinkedIn, if any exist? Does the job require full-time on-site? How many people does it indicate have already applied?\r","web":""}
+{"id":"apply_apply_2722","category":"jobs","ques":"Help me apply for a mid-level software development position at Amazon by reviewing available job postings on their official careers site that offer have a six-figure salary and require proficiency in JavaScript, if any exist. Provide a link to the form for the job.\r","web":""}
+{"id":"employer_landscape_employer_landscape_624","category":"jobs","ques":"Can you find any roles for equipment operator positions in Houston, prefereably but not necessarily from Waste Management, offering a minimum salary of $50,000 and at least three years of experience, if available.\r","web":""}
+{"id":"apply_apply_2720","category":"jobs","ques":"Help me apply for a finance position at Veritas Partners by exploring opportunities available on HireVeritas. I have five years of work experience and a bachelors in finance, which role would be most appropriate for me?\r","web":""}
+{"id":"apply_apply_1288","category":"jobs","ques":"Help me apply for a dentist position in Kentucky on the ADA CareerCenter with at least 401 (k) benefits and effective pay of at least $100/hr, if any exist.\r","web":""}
+{"id":"wording_wording_2838","category":"jobs","ques":"What is the exact wording of the first sentence of the job description for the first airline job opening listed in Atlanta on ATL Careers that offers a minimum salary of $50,000 and requires a Bachelor's degree, if any exist? Direct me to a form to the job from the listing as well. Pre-fill the form with the city and state being Atlanta and Georiga, respectively.\r","web":""}
+{"id":"apply_apply_1737","category":"jobs","ques":"Help me apply for a firefighter position in Orange County, CA on GovernmentJobs that offers a minimum salary of $50,000 and is open to applicants with a Bachelor's degree, if any exist. List at least three such job postings and summarize how they differ at a high level.\r","web":""}
+{"id":"apply_apply_410","category":"jobs","ques":"Help me apply for a maintenance job located in Chicago, IL, that offers a minimum salary of $50,000 and requires at least two years of experience, if any exist. What's a suitable option that can hire immediately?\r","web":""}
+{"id":"requirements_requirements_7","category":"jobs","ques":"What are the in-person requirements listed for Kroger jobs available in Atlanta, GA on Kroger Family Careers that are full-time positions and offer health insurance, if any exist? What are the hours like for such positions based on the listings?\r","web":""}
+{"id":"apply_apply_2","category":"jobs","ques":"Help me apply for three administrative position in Minnesota listed on GovernmentJobs that pays at least $18/hr and requires a high school diploma, if any exist.\r","web":""}
+{"id":"job_titles_job_titles_2726","category":"jobs","ques":"List the titles of available cashier positions at Walmart on their careers page that are full-time and within 10 miles of Chicago, if any exist. What are the 401(k) benefits and salary range?\r","web":""}
+{"id":"job_id_job_id_1431","category":"jobs","ques":"What are the job numbers/ID s of three full-time warehouse supervisor positions in the greater Chicago area listed on SimplyHired that offers at least a $60,000 annual salary and requires a bachelor's degree, if any exist? What are the benefits of each of the positions? How many years of experience are required for each one?\r","web":""}
+{"id":"employer_landscape_employer_landscape_2701","category":"jobs","ques":"find a store manager or assistant store manager position at dollar general close to new york, NY and tell me the location of the first such listing\r","web":""}
+{"id":"salary_range_salary_range_2829","category":"jobs","ques":"is Triomics hiring? Can you tell me the job that has the highest salary that they are hiring for, and would I qualify for it given that I have a masters in clinical biology?\r","web":""}
+{"id":"wildcard_wildcard_542","category":"jobs","ques":"What are the 3 most recent job openings shown on The Lash Lounge Careers site and what locations are they for?\r","web":""}
+{"id":"qualifications_qualifications_2504","category":"jobs","ques":"I want to apply for a position at Bluegrass Chiro in kentucky; how many positions do they have open and what roles are they for?\r","web":""}
+{"id":"apply_apply_50","category":"jobs","ques":"Help me apply for a full-time security position in Florida with allied universal, let me know the requisition id.","web":""}
\ No newline at end of file
diff --git a/packages/evals/datasets/webvoyager/WebVoyager_data.jsonl b/packages/evals/datasets/webvoyager/WebVoyager_data.jsonl
new file mode 100644
index 000000000..7ba2ebd2e
--- /dev/null
+++ b/packages/evals/datasets/webvoyager/WebVoyager_data.jsonl
@@ -0,0 +1,643 @@
+{"web_name": "Allrecipes", "id": "Allrecipes--0", "ques": "Provide a recipe for vegetarian lasagna with more than 100 reviews and a rating of at least 4.5 stars suitable for 6 people.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--1", "ques": "Find a recipe for a vegetarian lasagna that has at least a four-star rating and uses zucchini.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--2", "ques": "Find a recipe for a vegetarian lasagna under 600 calories per serving that has a prep time of less than 1 hour.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--3", "ques": "Locate a recipe for vegan chocolate chip cookies with over 60 reviews and a rating of at least 4.5 stars on Allrecipes.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--4", "ques": "Find a recipe for Baked Salmon that takes less than 30 minutes to prepare and has at least a 4 star rating based on user reviews.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--5", "ques": "Search for a popular Pasta Sauce with more than 1000 reviews and a rating above 4 stars. Create a shopping list of ingredients for this recipe.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--6", "ques": "Search for a vegetarian lasagna recipe that has at least a four-star rating and over 500 reviews.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--7", "ques": "Find a popular recipe for a chocolate chip cookie and list the ingredients and preparation steps.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--8", "ques": "Search for a recipe for Beef Wellington on Allrecipes that has at least 200 reviews and an average rating of 4.5 stars or higher. List the main ingredients required for the dish.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--9", "ques": "Find a high-rated recipe for vegetarian lasagna, list the key ingredients required, and include the total preparation and cook time stated on the recipe.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--10", "ques": "Find The Most Popular Recipes of the 1960s, noting the recipe name, preparation time and total time of the second recipe in this collection.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--11", "ques": "Discover a suitable chocolate cupcake recipe on Allrecipes that has a preparation time of under 1 hour and at least 100 user reviews.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--12", "ques": "Search for a popular cookie recipe on Allrecipes with more than 1000 reviews and a rating of 4.5 stars or better. Provide the list of ingredients needed.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--13", "ques": "Find a recipe with over 100 reviews for Fried Fish on Allrecipes, list the Full Nutrition Label and tell me the amount of Iron per Serving.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--14", "ques": "Search for a recipe that includes \"chicken breast\" and \"quinoa\" with preparation time under 30 minutes on Allrecipes.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--15", "ques": "Choose a dessert recipe on Allrecipes with a prep time of less than 30 minutes, has chocolate as an ingredient, and has a user rating of 4 stars or higher. Provide the name of the recipe, ingredients list, and step-by-step instructions.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--16", "ques": "Find a five-star rated chocolate chip cookie recipe that takes less than 1 hour to make on Allrecipes. Note how many reviews the recipe has and the main ingredients required.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--17", "ques": "Find the Easy Vegetarian Spinach Lasagna recipe on Allrecipes and tell me what the latest review says.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--18", "ques": "Find a recipe for a vegetarian lasagna that has over 300 reviews and an average rating of 4.5 or higher on Allrecipes.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--19", "ques": "Find a vegan lasagna recipe on Allrecipes that requires 10 ingredients or less and has feedback of more than 200 reviews. Provide a brief overview of the ingredient list and the total prep and cook time.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--20", "ques": "Find a recipe for a cauliflower pizza crust that has a preparation time of under 30 minutes and a rating of at least 4 stars on Allrecipes. Include the number of calories per serving.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--21", "ques": "Locate a high-rated recipe for gluten-free brownies on Allrecipes with at least 50 reviews. List the main ingredients and the total time required for preparation and cooking.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--22", "ques": "Find a recipe for a healthy avocado salad on Allrecipes that has a preparation time of less than 20 minutes and more than 30 user reviews. Include the nutritional information per serving.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--23", "ques": "Search Allrecipes for a baked lemon chicken recipe that has a prep time under 45 minutes, with at least a 4.5-star rating based on user reviews, and over 200 reviews. List the primary ingredients required.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--24", "ques": "Locate a recipe for an eggplant Parmesan on Allrecipes with a rating of at least 4.5 stars and over 50 reviews. Include the preparation time and the number of servings provided by the recipe.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--25", "ques": "Find a popular quinoa salad recipe on Allrecipes with more than 500 reviews and a rating above 4 stars. Create a shopping list of ingredients for this recipe and include the total cooking and preparation time.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--26", "ques": "Search for a high-protein vegetarian chili recipe on Allrecipes that has at least 50 reviews and a rating of 4 stars or higher. Provide the ingredient list, cooking time, and a brief description of the cooking steps.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--27", "ques": "Locate a chicken curry recipe on Allrecipes that has been reviewed more than 30 times and has a rating of at least 4 stars. Provide a summary of the recipe including ingredients, preparation time, and cooking instructions.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--28", "ques": "On Allrecipes, find a vegan brownie recipe that has at least 40 reviews and a rating of 4.5 or higher. Include the list of ingredients, total prep and cook time, and a brief overview of the preparation steps.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--29", "ques": "Search for a Mediterranean-style grilled fish recipe on Allrecipes that includes ingredients like olives, has at least a 4-star rating, and more than 25 reviews. Detail the ingredients, cooking method, and total time required for preparation and cooking.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--30", "ques": "Find a recipe for a vegan smoothie bowl on Allrecipes that includes bananas and leaves, has more than 20 reviews, and a rating of at least 4 stars. Provide a list of ingredients, preparation time, and a summary of the recipe steps.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--31", "ques": "Search for a seafood paella recipe on Allrecipes with a minimum of 4.5 stars rating and at least 50 reviews. The recipe should include shrimp and mussels. Provide the ingredients, total time, and an overview of the preparation steps.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--32", "ques": "Find a high-rated beef stew recipe on Allrecipes that requires a slow cooker and has at least 30 reviews. Detail the cooking time and the first five ingredients listed in the recipe.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--33", "ques": "Find a recipe for a low-carb breakfast on Allrecipes with at least 25 reviews. Show the Nutrition Facts and the total carbohydrate content per serving.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--34", "ques": "Locate a baked salmon recipe on Allrecipes that has at least 50 reviews and a rating of 4.5 stars or higher. Note the primary seasoning or herb used and the estimated cooking time.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--35", "ques": "Search for an Italian-style meatball recipe on Allrecipes that has more than 100 reviews. Detail the type of meat used and the overall cooking time required.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--36", "ques": "Locate a recipe for an American apple pie on Allrecipes with a rating of at least 4 stars and more than 50 reviews. Note the maximum temperature mentioned in the Directions.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--37", "ques": "Search for a Greek salad recipe on Allrecipes that has a prep time of under 25 minutes and more than 15 reviews. Include the primary cheese used and the type of dressing recommended.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--38", "ques": "Find a French ratatouille recipe on Allrecipes with a 4-star rating or higher and at least 15 reviews. Note the variety of vegetables included and the overall cooking time.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--39", "ques": "Locate a recipe for sushi rolls on Allrecipes with a minimum of 20 reviews. Show the Nutrition Facts and the main ingredients. Tell me how to store these rolls.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--40", "ques": "Browse the about us section of Allrecipes for a brief introduction to The Allrecipes Allstars.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--41", "ques": "List 3 recommended dinner recipes in the Allrecipes Dinners section.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--42", "ques": "Find a recipe for banana bread with more than 200 reviews and a rating of at least 4.0 stars on Allrecipes.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--43", "ques": "Find a recipe for a vegan pumpkin pie on Allrecipes with a minimum four-star rating and a total cook time exceeding 1 hour.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Allrecipes", "id": "Allrecipes--44", "ques": "List at least 6 holiday recipes sections mentioned in the Occasions section of Allrecipes.", "web": "https://www.allrecipes.com/"}
+{"web_name": "Amazon", "id": "Amazon--0", "ques": "Search an Xbox Wireless controller with green color and rated above 4 stars.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--1", "ques": "Search for women's golf polos in m size, priced between 50 to 75 dollars, and save the lowest priced among results.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--2", "ques": "Find a gaming desktop with Windows 11 Home, and the disk size should be 1TB.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--3", "ques": "Find climbing gears and sort the results by price high to low. Answer the first 3 results after sorting.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--4", "ques": "Find the used Nintendo Switch Lite on Amazon then filter by 'Used - Good', tell me the cheapest one that is 'Used - Good'.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--5", "ques": "Find a Blue iPhone 12 Pro 128gb and add to cart.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--6", "ques": "Browse black strollers within $100 to $200 on Amazon. Then find one Among these black strollers with over 20,000 reviews and a rating greater than 4 star.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--7", "ques": "Browse the women's hiking boots on Amazon and filter the results to show only those that are waterproof and have a rating of at least 4 stars and size 6.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--8", "ques": "Find the cheapest Samsung-made Android tablet with screen between 10-10.9 inches on Amazon. Only answer the cheapest one.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--9", "ques": "Find a dog bed on Amazon that is washable and has a length of at least 30 inches.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--10", "ques": "Find the cost of a 2-year protection for PS4 on Amazon.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--11", "ques": "Find a stainless steel kitchen sink with double bowls on Amazon. Sort the results and find the cheapest one with FREE delivery.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--12", "ques": "Check reviews for a Ride On Car with 100+ reviews & 4+ stars rating on Amazon. Give me the top review about this Ride On Car.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--13", "ques": "Browse best selling black hoodies in mens size Big and Tall that is between $25 and $50 on Amazon.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--14", "ques": "Find the new surge protector on Amazon with 6 to 8 outlets under 25 dollars with customer reviews above 4+ stars.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--15", "ques": "Find a pair of mens running shoes in black, size 7, 4+ stars and under $50 and add them to my cart on Amazon.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--16", "ques": "Find the Return Policy for Mens Rhinestone Skull Graphic Shirt on Amazon. Color: Black, Size: XX-Large. If Free return is avaliable, tell me how to return this item.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--17", "ques": "Show me the list of baby products that are on sale and under 10 dollars on Amazon. Provide at least 2 on sale products", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--18", "ques": "Open Amazon's home page and tell me what the deal is that is going on at the moment, list the names of at least 2 items that are on offer and tell me what percent off they are.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--19", "ques": "Look for an English language book on roman empire history in the Amazon Kindle store. Sort by newests arrivals and look for a title that will be released within a month.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--20", "ques": "Search for a wireless ergonomic keyboard with backlighting and a rating of at least 4 stars. The price should be between $40 to $60. Save the product with the 500+ customer reviews.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--21", "ques": "Find a stainless steel, 12-cup programmable coffee maker on Amazon. The price range should be between $100 to $200. Report the one with the 4+ customer rating.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--22", "ques": "Search for a set of non-stick, oven-safe cookware on Amazon. The set should include at least 10 pieces and be priced under $150.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--23", "ques": "Look for a men's waterproof digital sports watch with a heart rate monitor on Amazon. It should be priced between $50 to $100.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--24", "ques": "Browse for a compact air fryer on Amazon with a capacity of 2 to 3 quarts. It should have a digital display, auto shutoff and be priced under $100.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--25", "ques": "Search for a queen-sized, hypoallergenic mattress topper on Amazon. It should have a memory foam material and be priced between $50 to $100.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--26", "ques": "Find a portable Bluetooth speaker on Amazon with a water-resistant design, under $50. It should have a minimum battery life of 10 hours.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--27", "ques": "Look for a USB-C hub on Amazon compatible with MacBook Pro, featuring at least 4 ports, including HDMI and SD card reader. The price should be under $50. Select the one after sorting by Best Sellers.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--28", "ques": "Search for a yoga mat on Amazon that is at least 6mm thick, non-slip, and eco-friendly. The price should be under $50.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--29", "ques": "Find a set of solar-powered garden lights on Amazon with a minimum pack of 10 lights. They should be LED and priced under $50.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--30", "ques": "Locate the highest-rated fiction book released in 2024 on Amazon, with a minimum of 50 customer reviews.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--31", "ques": "Find a compact digital camera on Amazon with a zoom capability of at least 10x, rated 4 stars or higher, and priced between $100 to $300.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--32", "ques": "Search for an electric kettle on Amazon with a capacity of at least 1.5 liters, made of stainless steel, and with a customer rating of 4 stars or above.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--33", "ques": "Search for a portable air conditioner on Amazon suitable for a room size of 300 sq ft, with energy efficiency rating, and compare the prices of the top three search results.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--34", "ques": "Find a beginner's acrylic paint set on Amazon, with at least 24 colors, suitable for canvas painting, and priced under $40.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--35", "ques": "Find a men's leather wallet on Amazon with RFID blocking, at least 6 card slots, and priced below $50. Check if it's available for FREE delivery.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--36", "ques": "Search for a children's science experiment kit on Amazon suitable for ages 8-13, with at least a 4-star rating and priced under $30.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--37", "ques": "Locate a queen-sized bedspread on Amazon with a floral pattern, and check if it's available in blue color.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--38", "ques": "Find a bird feeder on Amazon suitable for small birds, with an anti-squirrel mechanism, and check if it's available with free shipping.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--39", "ques": "Locate a travel guide book on Amazon for Japan, published in 2024, with at least 20 customer reviews.", "web": "https://www.amazon.com/"}
+{"web_name": "Amazon", "id": "Amazon--40", "ques": "Locate a women's yoga mat in purple, with a thickness of at least 5mm, rated 4+ stars, and priced under $30 on Amazon. Check how many colors are available in total, and what is the return and delivery policy.", "web": "https://www.amazon.com/"}
+{"web_name": "Apple", "id": "Apple--0", "ques": "Compare the prices of the latest models of MacBook Air available on Apple's website.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--1", "ques": "Research the new features of the iOS 17 on Apple support and check its compatibility with the iPhone 12.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--2", "ques": "Compare the prices and chips for the iPhone 14 Pro and iPhone 15 Pro models directly from Apple's website.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--3", "ques": "Find the latest model of the iPhone and compare the price and screen size between the pro and pro max.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--4", "ques": "How much does it cost to buy a Macbook pro, 16-inch, Apple M3 Max chip with 16-core CPU, 40-core GPU, 64GB unified memory, 1TB SSD.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--5", "ques": "Check the release date and price for the latest version of the iPhone.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--6", "ques": "Find AirPods on Apple and how many types are currently available.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--7", "ques": "When and where the Apple Vision Pro will be released.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--8", "ques": "Identify and list the specifications of the latest iPad model released by Apple, including its storage options, processor type, and display features.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--9", "ques": "Check the Apple Store for the availability of the latest iPhone model and schedule an in-store pickup at the nearest Apple Store for January 10, 2024.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--10", "ques": "Find information on the latest (as of today's date) MacBook model, including its key features such as processor type, memory size, and storage capacity.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--11", "ques": "Get information about the latest iPad model released by Apple, including its release date, base storage capacity, and starting price available on Apple's official website.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--12", "ques": "What Apple Repair ways are mentioned on apple website, answer 2 of them.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--13", "ques": "How many colors does the latest MacBook Air come in?", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--14", "ques": "Identify the upgrade options available for the cheapest base model of the MacBook Pro 14-inch with M3 chip, and calculate the total price difference from the base model to the maximum upgrade (no Pre-Installed Software) offered by Apple.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--15", "ques": "On Apple's website, how many different types of keyboards are available when customizing your 14-inch MacBook Pro?", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--16", "ques": "Find on Apple website how many types of AirPods (3rd generation) are available and what is the price difference.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--17", "ques": "Search Apple for the accessory Smart Folio for iPad and check the closest pickup availability next to zip code 90038.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--18", "ques": "Check if there are trade-in offers for the latest model of iPhone.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--19", "ques": "On Apple's website, what is the slogan for the Mac and what is the slogan for the Macbook pro.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--20", "ques": "Check the price for an Apple iPhone 14 Plus with 256GB storage in Purple color.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--21", "ques": "Identify the available storage options for the latest iPad Pro on the Apple website.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--22", "ques": "Find out the trade-in value for an iPhone 13 Pro Max in good condition on the Apple website.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--23", "ques": "Determine the price difference between the latest series of Apple Watch and Apple Watch SE on the Apple website.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--24", "ques": "Find out the starting price for the most recent model of the iMac on the Apple website.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--25", "ques": "On the Apple website, look up the processor for the latest model of the Apple TV.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--26", "ques": "Find the maximum video recording resolution supported by the latest iPad mini on the Apple website.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--27", "ques": "On Apple's website, check if the HomePod mini in store is available in multiple colors and list them.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--28", "ques": "On the Apple website, find out if the Mac Mini can be configured with a GPU larger than 16-core.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--29", "ques": "On Apple's website, check the estimated battery life of the latest MacBook Air during web browsing in Tech Specs.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--30", "ques": "Check the storage options and prices for the latest iPad Pro models on Apple's website.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--31", "ques": "On Apple's website, what is the slogan for the latest Apple Watch Series.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--32", "ques": "Investigate the trade-in value for an iPhone 11 Pro Max on Apple's website.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--33", "ques": "Look for the color options available for the newest iMac.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--34", "ques": "Identify the size and weight for the Apple TV 4K and list the Siri Remote features introduced.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--35", "ques": "How many types of Apple Pencil are currently available on the Apple's website? Which one supports Wireless pairing and charging.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--36", "ques": "Browse Apple Music on the entertainment section of the Apple's website, and see which singers' names are included in the pictures on this page.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--37", "ques": "Compare the color options of iPhone 13 Pro, iPhone 14 Pro and iPhone 15 Pro.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--38", "ques": "Explore accessories for Apple Vision Pro, list at least three accessories.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--39", "ques": "Find solutions on Apple's website if you forgot your Apple ID password.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--40", "ques": "Find information on Apple website, and tell me the device weight of Apple Vision Pro and list 5 Built-in Apps it supports.", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--41", "ques": "How much does it cost to buy an ipad mini with 64GB storage and Wi-Fi + Cellular connectivity? (no engraving, no apple pencil, no smart folio, no apple trade-in).", "web": "https://www.apple.com/"}
+{"web_name": "Apple", "id": "Apple--42", "ques": "Find updates for Apple Watch Series 7,8,9 on Apple's website.", "web": "https://www.apple.com/"}
+{"web_name": "ArXiv", "id": "ArXiv--0", "ques": "Search for the latest preprints about 'quantum computing'.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--1", "ques": "Search for the latest research papers on quantum computing submitted to ArXiv within the last two days.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--2", "ques": "Look up the most recent papers related to 'cs.CL', select one and show its abstract.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--3", "ques": "Locate the most recent research paper about 'Algebraic Topology' under Mathematics published on ArXiv. Provide the title of the paper, the name of the authors, and the abstract.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--4", "ques": "Find the most recent research papers in Astrophysics of Galaxies. How many papers have been announced in the last day?", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--5", "ques": "Search papers about \"quantum computing\" which has been submitted to the Quantum Physics category on ArXiv. How many results in total. What if search in all archives?", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--6", "ques": "How many figures and tables are in the paper \"On the Sentence Embeddings from Pre-trained Language Models\"?", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--7", "ques": "Find the most recent paper submitted on machine learning in the Computer Science category posted on ArXiv.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--8", "ques": "What is the latest news on ArXiv?", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--9", "ques": "Find the latest research paper about neural networks published on ArXiv which has been submitted within the last week.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--10", "ques": "Visit ArXiv Help on how to withdraw an article if the submission is not yet announced.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--11", "ques": "For Non-English submissions, do I need to provide a multi-language abstract, if need, answer the separator between the multiple abstracts.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--12", "ques": "Find store in arXiv Help, tell me how many styles of arXiv Logo Shirt are available?", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--13", "ques": "How many articles on ArXiv with 'SimCSE' in the title?", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--14", "ques": "On ArXiv, how many articles have 'SimCSE' in the article and are originally announced in October 2023?", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--15", "ques": "Searching Chinese Benchmark on ArXiv, how many papers announced in December 2023 mention being accepted for AAAI 2024?", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--16", "ques": "Locate the latest research about gravitational waves that were uploaded to ArXiv this week and provide a brief summary of one article's main findings.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--17", "ques": "Find the paper 'GPT-4 Technical Report', when was v3 submitted?", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--18", "ques": "Download the paper 'Dense Passage Retrieval for Open-Domain Question Answering'. How many formulas are in the article and which one is the loss function?", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--19", "ques": "Which university maintains and manages ArXiv. Accessing the university's website from ArXiv, how many underegraduate students are currently at the university.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--20", "ques": "Find the latest paper on 'machine learning in the Statistics section of ArXiv and provide its abstract.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--21", "ques": "Search for papers on 'neural networks for image processing' in the Computer Science category on ArXiv and report how many were submitted in the last week.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--22", "ques": "Locate the ArXiv Help section and find instructions on how to subscribe to daily listing emails for new submissions in a specific category.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--23", "ques": "Determine how many articles with the keyword 'autonomous vehicles' were published in the 'Electrical Engineering and Systems Science' section of ArXiv yesterday.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--24", "ques": "Identify the most recent paper related to 'graph neural networks' on ArXiv and determine the affiliation of the first author.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--25", "ques": "Browse the ArXiv store and let me know how many different types of merchandise are available.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--26", "ques": "Search for papers related to 'climate change modeling' on ArXiv and find out how many have been published in the Earth and Planetary Astrophysics (astro-ph.EP) category in the last week.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--27", "ques": "On ArXiv, what categories does Economics include, and what are their abbreviations?", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--28", "ques": "Search 'Poly encoder' by title on ArXiv and check whether the articles in the search results provide HTML access.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--29", "ques": "On ArXiv, search for papers with 'Neural Network Optimization' in the title published in 2023, and provide the number of such papers.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--30", "ques": "Look up the submission guidelines on ArXiv for submitting a paper and tell me the formats for figures.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--31", "ques": "Search ArXiv for papers with 'Graph Neural Networks' in the abstract that were submitted between Jan 1, 2024, and Jan 3, 2024, and determine how many of these papers have more than five authors.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--32", "ques": "Locate the latest paper on ArXiv within the 'Nonlinear Sciences - Chaotic Dynamics' category, summarize the abstract and note the submission date.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--33", "ques": "Query ArXiv for the latest research article in the category of Systems and Control under Computer Science. Summarize the main objective or hypothesis presented in the paper and provide the names of the authors.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--34", "ques": "Search for the most recent paper related to non-commutative geometry submitted by an author with the first name John. Provide the title and the abstract.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--35", "ques": "Retrieve the latest research paper in Quantum Physics from ArXiv and provide the title, author(s), and date of submission.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--36", "ques": "Search 'CVPR 2023' and 'CVPR2023' through journal ref on ArXiv to see how many results there are respectively.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--37", "ques": "Find the names of people in ArXiv's Leadership Team.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--38", "ques": "Find the ArXiv Blog on the ArXiv website and summarize the content of its latest article.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--39", "ques": "Search the title 'GPT-4 Technical Report' and access this paper through HTML format. Read the paper on this page and tell me what is 'one of the main goals of developing such models' mentioned in the Introduction.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--40", "ques": "How many articles are there on each of the three most recent announce days in the Solar and Stellar Astrophysics section of ArXiv. Choose one at random and answer its title and when the first version was uploaded?", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--41", "ques": "Find the button to share arxiv non-profit store and follow the QR code to share the shop. Then add arXiv Forever short sleeve (XL) to your cart.", "web": "https://arxiv.org/"}
+{"web_name": "ArXiv", "id": "ArXiv--42", "ques": "Find an article published between 1 January 2000 and 1 January 2005 that requires Support Vector Machines in the title and its Journey ref is ACL Workshop.", "web": "https://arxiv.org/"}
+{"web_name": "BBC News", "id": "BBC News--0", "ques": "Find a report on the BBC News website about recent developments in renewable energy technologies in the UK.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--1", "ques": "Read the latest health-related news article published on BBC News and summarize the key points discussed.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--2", "ques": "Read the latest article regarding the environmental impacts of deforestation published within the last two days.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--3", "ques": "Check the leaderboard for Golf's DP World Tour in the SPORT section, what was the name of the most recent tournament, and how many teams have a Total of -10 strokes.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--4", "ques": "Find the latest article regarding the economic implications of climate change in Europe as reported by BBC News and summarize the central points.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--5", "ques": "Find the article \"What is climate change? A really simple guide\" and use it to answer what human activities are causing climate change.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--6", "ques": "Find the top story from BBC News in the technology section for today.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--7", "ques": "Find a AI-related story under Technology of Business. What is in the first picture in the story?", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--8", "ques": "Get a brief overview of the economic implications of the UK's latest trade deal posted on BBC News and the date when the article was published.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--9", "ques": "Find out which musician made the headlines in Music News.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--10", "ques": "Identify the main headlines covering the UK's plan to tackle climate change on BBC News.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--11", "ques": "Find out how many teams are in the Scottish Premiership of the Football Tournament and when did the Hibernian team's most recent match start?", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--12", "ques": "Find a picture in the travel section that contains food, tell me what the food is called and what region it comes from.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--13", "ques": "Search for recent news related to Trump and summarize the main points.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--14", "ques": "Find a news article on BBC News about the impact of the recent tech industry layoffs on the global economy. Summarize the key points and the name of the author, and provide the date of publication.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--15", "ques": "What does the current headline in Natural Wonders tell about.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--16", "ques": "Identify the most recent development or update in Brexit negotiations as reported on BBC News and report the key points and any stated impacts on European economies.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--17", "ques": "How many War related sections are currently in BBC News.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--18", "ques": "Visit BBC News Audio, What are the best PodCasts for 2023? List 2 of them.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--19", "ques": "Visit the Athletics calendar for the date of the next earliest game.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--20", "ques": "Find the latest article in the Green Living section on BBC News and provide a summary of its main points.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--21", "ques": "Identify the top headline in the World News section on BBC News and describe the region it is related to.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--22", "ques": "Determine the current top business story on BBC News and give a brief overview of its economic implications.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--23", "ques": "Identify the latest health-related news on BBC News and summarize the main findings or recommendations.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--24", "ques": "Search the latest article about space exploration on BBC News and summarize its key points.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--25", "ques": "Find the most recent sports analysis article on BBC News related to the English Premier League and summarize its key insights.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--26", "ques": "Locate the latest report on BBC News about the impact of recent natural disasters in Asia and summarize the key points and areas affected.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--27", "ques": "Find the most recent article on BBC News about archaeological discoveries and summarize the main findings and their significance.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--28", "ques": "Find the Market Data section on BBC News and tell me which company the data comes from.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--29", "ques": "Visit BBC News Audio and find out which podcast episode is currently featured as the \"New Releases\".", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--30", "ques": "In the Culture section, identify the latest film release reviewed and provide a brief summary of the review.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--31", "ques": "Check the Sports section for the result of the most recent Manchester United football match.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--32", "ques": "Find the artificial intelligence section, what is the top headline at this time, and which companies are involved?", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--33", "ques": "In the World News section, find the latest war situations of Middle East and provide a brief summary.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--34", "ques": "Find The SpeciaList section in Travel and browse the page to see which cities are mentioned.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--35", "ques": "In the Asia section, browse and identify the most recent report about technological advancements and summarize its content.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--36", "ques": "Look up recent articles in the Africa news section in World, summarize what topics most of these news are about", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--37", "ques": "Identify the latest book review featured in the Culture section and provide the title and author of the book.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--38", "ques": "Find news related to the storm in Weather section and indicate where and when the severe weather occurred.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--39", "ques": "Check the Horse Racing results in Sport section, browse all the games that took place yesterday and see which one had the highest number of runners.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--40", "ques": "Read and summarise a recent story on BBC News about people being injured or killed in wars.", "web": "https://www.bbc.com/news/"}
+{"web_name": "BBC News", "id": "BBC News--41", "ques": "Find Golf in BBC News, check the Leaderboard at this point in Women's Majors and count which country has the most players in the top 20? Which player has the best score amongst the Australian players and in what place.", "web": "https://www.bbc.com/news/"}
+{"web_name": "Booking", "id": "Booking--0", "ques": "Find a Mexico hotel with deals for December 25-26.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--1", "ques": "Find the cheapest available hotel room for a three night stay from 1st Jan in Jakarta. The room is for 2 adults, just answer the cheapest hotel room and the price.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--2", "ques": "Find a hotel in Ohio From December 20th to December 23th for 3 adults and 2 rooms.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--3", "ques": "Find a hotel with 4 star and above rating in Los Angeles for 3 days from Dec 18th.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--4", "ques": "Search for the cheapest Hotel near Kashi Vishwanath Temple that offer breakfast from Dec 25th - Dec 26th.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--5", "ques": "Search a hotel with free WiFi and air conditioning in Bali from Jan 1 to Jan 4, 2024.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--6", "ques": "Book one room which provides breakfast, and airport shuttle from Jan 22 to 25 in Los Angeles.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--7", "ques": "Find a hotel room on January 3-6 that is closest to National University of Singapore and costs less than $500", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--8", "ques": "Get the hotel with highest review score and free cancelation in Chennai for 20/12/2023 - 21/12/2023.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--9", "ques": "Find hotels for 2 adults in London with a price less than 250 dollars for four days starting from December 25. You must browse the page and offer at least 3 options.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--10", "ques": "Find a well-reviewed hotel in Paris with available bookings suitable for a couple (2 adults) on Valentine's Day week, February 14-21, 2024, that offers free cancellation options.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--11", "ques": "Reserve a hotel in downtown Chicago with a rating of 9 or higher for a stay from March 20-27, 2024, which offers free cancellation and includes a fitness center.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--12", "ques": "Find a hotel in Paris with a customer review score of 8 or higher, free Wi-Fi, and available for a 5-night stay starting on January 5th, 2024.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--13", "ques": "Find and book a hotel in Paris with suitable accommodations for a family of four (two adults and two children) offering free cancellation for the dates of February 14-21, 2024.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--14", "ques": "Book a highly-rated hotel with a swimming pool and free WiFi near the Louvre Museum in Paris for the weekend of March 3-5, 2024.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--15", "ques": "Find the highest-rated luxury hotel in Rome available for booking from January 10, 2024, to January 20, 2024, for 2 adults. Include the cost, amenities offered, and customer rating.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--16", "ques": "Look for a hotel in Paris with a user rating of 9 or higher and available for a 5-night stay starting January 15, 2024. The hotel should also offer free Wi-Fi and breakfast included in the price. Provide the name, location, and price per night.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--17", "ques": "Find a hotel in Paris with a fitness center and a rating of 8 or higher available for a 5-night stay starting from February 14, 2024, and sort the results by best reviewed.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--18", "ques": "Search a hotel in London with a user rating of 8 or higher for a stay between February 14th, 2024, and February 21st, 2024, suitable for a couple. Provide the name and a short description of the hotel.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--19", "ques": "Look for a hotel with customer ratings above an 8.0 in Paris, France for a weekend stay from March 18, 2024, to March 20, 2024, and list top three suggestions based on user reviews.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--20", "ques": "Locate a hotel in Rome with a good rating (7 or above) that offers free cancellation and breakfast included, for a three-night stay from February 28 to March 2, 2024, for two adults.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--21", "ques": "Find a hotel in Sydney with a rating of 8 or higher, providing free Wi-Fi and parking, available for a four-night stay starting on March 10, 2024.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--22", "ques": "Search for a hotel in Amsterdam with a customer review score of 9 or higher, offering bicycle rentals, for a week-long stay from March 15 to March 22, 2024, for two adults.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--23", "ques": "Identify a hotel in Tokyo with a spa and wellness center, rated 9 or above, with availability for a five-night stay starting on February 20, 2024. Check if free cancellation is offered.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--24", "ques": "Find a hotel in Barcelona for a stay from February 25-28, 2024. Please sort the results by distance from the beach and make sure they offer free Wi-Fi and breakfast.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--25", "ques": "Search for a hotel in Lisbon with airport shuttle, rated 8.5 or above, available for a six-night stay from March 1 to March 7, 2024, for two adults, breakfast included.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--26", "ques": "Check Booking.com for a 3-star hotel or higher in Paris with a guest rating above 8.0 and available parking for dates February 20-23, 2024.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--27", "ques": "Locate a hotel in Melbourne offering free parking and free WiFi, for a stay from February 28 to March 4, 2024.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--28", "ques": "Find a hotel in Dubai with a swimming pool, for a week-long stay from February 22 to February 29, 2024.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--29", "ques": "Search for a hotel in Toronto with a fitness center and a rating of 8+, available for a two-night stay from March 5 to March 7, 2024.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--30", "ques": "Search for hotels in London from March 20 to March 23, 2024, on Booking. How many hotels are left after applying the Breakfast included and Fitness center filters?", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--31", "ques": "Search for hotels in Rio de Janeiro from March 1-7, 2024, check the Brands filter to see which brand has the most hotels and which brand has the fewest.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--32", "ques": "Look for hotels in Sydney from February 24 to February 27, 2024, on Booking. Once the Swimming Pool and Airport Shuttle filters are applied, what is the total number of hotels available?", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--33", "ques": "Find the Customer Service on the Booking website, browse the questions about cancellation, and tell me 'how do I know whether my booking has been cancelled'.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--34", "ques": "Search for a hotel in Berlin available for a three-night stay from March 15 to March 18, 2024, for one adult. Tell me the price in USD and CNY for the three-night stay.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--35", "ques": "Browse the booking website to get inspiration for your next trip, and summarize at least three places mentioned in one of the travel articles.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--36", "ques": "Search for a budget hotel in Rome under $100 per night for one adult from March 20 to March 23, 2024. Sort the results by price, identify if any of top three results offer breakfast.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--37", "ques": "Search for a resort (not hotel) in Bali, detailing the available dates between March 20, 2024, and March 25, 2024, and checking any provided tour or cultural experiences.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--38", "ques": "Look up Vienna hotel options with availability for a 4-night stay from February 28 to March 4, 2024, with amenities that include a Parking, breakfast included, and a rating of 8+ on Booking.com.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--39", "ques": "Find a pet-friendly hotel with parking available in downtown Toronto for the stay of February 24-26, 2024.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--40", "ques": "I need to choose a hotel in Shenzhen, please select date (6 March to 8 March 2024) and click the search button. How much it costs when convert the price to Chinese Yuan on the page.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--41", "ques": "Browse Booking's homepage to find out which company it belongs to.", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--42", "ques": "Search for a hotel in Hokkaido for the period March 1 to March 7, 2024, with a rating of 9+, check out its user reviews, which categories are greater than 9 and which are less than 9?", "web": "https://www.booking.com/"}
+{"web_name": "Booking", "id": "Booking--43", "ques": "Search for properties in Los Angeles, browse the results page to see what filters are available, list some of them.", "web": "https://www.booking.com/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--0", "ques": "Look up the pronunciation and definition of the word \"sustainability\" on the Cambridge Dictionary.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--1", "ques": "Find the pronunciation, definition, and a sample sentence for the word 'serendipity'.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--2", "ques": "Look up the pronunciation, definition, and example sentence for the word \"ubiquitous\" in UK and US English.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--3", "ques": "Look up the definition, pronunciation, and examples of the word \"zeitgeist.\"", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--4", "ques": "Look for the British English pronunciation of the word \"innovate\" and write down the International Phonetic Alphabet (IPA) notation, then find one example sentence provided in the Cambridge Dictionary that uses this word.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--5", "ques": "Learn the UK and US pronunciation of the word \"procrastination\", and find one example sentence that reflects its use in context.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--6", "ques": "Search for the word \"sustainability\" on the Cambridge Dictionary, what is the translation of sustainability into Chinese and French in the dictionary.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--7", "ques": "Look up the meaning, pronunciation, and an example sentence of the word \"gestalt\" using the Cambridge Dictionary.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--8", "ques": "Find three different meanings of \"dog\" in Cambridge Dictionary.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--9", "ques": "Look up the British pronunciation of the word \"euphoria\" and find an example sentence using that word on the Cambridge Dictionary.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--10", "ques": "Look up the definition and pronunciation of the word \"impeccable\" and also find an example sentence using that word.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--11", "ques": "Look up the pronunciation and definition of the word \"ameliorate,\" and provide an example sentence using the word.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--12", "ques": "Find the pronunciation, definition, and a sample sentence for the word \"resilience\" in the Cambridge Dictionary.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--13", "ques": "Find one word, one phase and one idiom related to euphoria in Cambridge Dictionary.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--14", "ques": "Use the Cambridge Dictionary to find the pronunciation, definition, and one example sentence for the word \"concatenate\".", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--15", "ques": "Find the pronunciation and a sample sentence for the word \"pandemic.\"", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--16", "ques": "Look up the definition of \"cryptocurrency\" on Cambridge Dictionary, provide the pronunciation, and use it in two example sentences that illustrate different contexts.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--17", "ques": "How many meanings of \"unblemished\" are given in Cambridge Dictionary? Please browse the page and give the number directly.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--18", "ques": "Search for \"to behave well\" in Cambridge Dictionary's Thesaurus and see which synonyms the dictionary gives.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--19", "ques": "Try a Cambridge Dictionary translation and tell me which company provided the translation.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--20", "ques": "Look up the definition, pronunciation (both UK and US), and find one example sentence for the word \"altruism\" in the Cambridge Dictionary.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--21", "ques": "Search for the word \"ephemeral\" on Cambridge Dictionary and find its translation into Spanish.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--22", "ques": "Use the Cambridge Dictionary to find the definition, UK pronunciation, and an example sentence for the word \"quintessential.\"", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--23", "ques": "Find the US English pronunciation of the word \"meticulous\" using the Cambridge Dictionary and note the International Phonetic Alphabet (IPA) notation, then find one example sentence provided in the dictionary using this word.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--24", "ques": "Look up the definition and both UK and US pronunciation of the word \"reverie,\" and provide an example sentence using the word from Cambridge Dictionary.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--25", "ques": "Find two different meanings of the word \"harmony\" in the Cambridge Dictionary.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--26", "ques": "Search for the word \"nostalgia\" in the Cambridge Dictionary and report the translation of this word into Chinese.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--27", "ques": "Look up the meaning, pronunciation, and an example sentence of the word \"solitude\" using the Cambridge Dictionary.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--28", "ques": "Search for \"feel giddy\" in Cambridge Dictionary's Thesaurus and list the synonyms the dictionary provides.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--29", "ques": "Go to the Plus section of Cambridge Dictionary, find Image quizzes and do an easy quiz about Animals and tell me your final score.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--30", "ques": "Find the grammar for present perfect simple uses in English, including examples of affirmative, negative, and interrogative sentences, on the Cambridge Dictionary website.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--31", "ques": "Look up the use of modal verbs in grammar section for expressing possibility (e.g., 'might', 'could', 'may') and find examples of their usage in sentences on the Cambridge Dictionary.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--32", "ques": "Search for the differences between \"fewer\" and \"less\" in grammar section, and provide examples illustrating their correct usage from the Cambridge Dictionary.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--33", "ques": "Find explanations and examples of the passive voice in Grammar on the Cambridge Dictionary website.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--34", "ques": "Use the Cambridge Dictionary to understand the rules for forming and using comparative and superlative adjectives in English Grammar, including example sentences.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--35", "ques": "Find the most common prepositions that consist of groups of words on the Cambridge Dictionary.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--36", "ques": "Search for guidelines on using indirect speech in English, with examples of how to change direct speech to indirect speech, on the Cambridge Dictionary.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--37", "ques": "Use Cambridge Dictionary to understand the use of articles ('a', 'an', 'the') in English Grammar, including examples of usage with both countable and uncountable nouns.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--38", "ques": "Go to the Plus section of Cambridge Dictionary, finish a recommended Grammar quiz without login and tell me your final score.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--39", "ques": "Try the Word Scramble game in the Plus section, Can you beat the clock by unscrambling the letters to spell the word? (Just try the first example.)", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--40", "ques": "Look up the definition, pronunciation in UK English, and at least one example using the word 'mitigate'.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--41", "ques": "Find and browse Cambridge Dictionary Shop section, listing 3 items.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Cambridge Dictionary", "id": "Cambridge Dictionary--42", "ques": "Convert the Cambridge Dictionary homepage from English (UK) to Deutsch.", "web": "https://dictionary.cambridge.org/"}
+{"web_name": "Coursera", "id": "Coursera--0", "ques": "Find a beginner-level online course about '3d printing' which lasts 1-3 months, and is provided by a renowned university.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--1", "ques": "Search for a beginner-level online course about Python programming, suitable for someone who has no programming experience on Coursera.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--2", "ques": "Find a Beginner's Spanish Specialization on Coursera and show all the courses in this Specialization.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--3", "ques": "Identify a new course or Specialization on Coursera related to Python Data Science, sort the courses by newest, what the first course is and which institution offers it.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--4", "ques": "Identify a course or Specialization on Coursera that helps business process management with with a rating 4.7.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--5", "ques": "Identify a Specialization on Coursera that teaches C++ programming for beginners, provide the name and what the learning outcomes are.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--6", "ques": "Identify a course on Coursera related to 'Artificial Intelligence for Healthcare' and note the course duration along with the number of quizzes in Assessments.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--7", "ques": "Find a course on Coursera that teaches Reinforcement Learning for Intermediate with a rating of at least 4.5. Provide the name of the course, the institution offering it, and the number of reviews it has received.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--8", "ques": "Find a free course related to 'R for Data Science' available on Coursera. Scroll to find a course with the Free tag. What language the course is taught in?", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--9", "ques": "Identify a Coursera course on artificial intelligence ethics that has a duration of less than 20 hours to complete and has been rated 4+ stars by participants.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--10", "ques": "Locate an introductory course related to artificial intelligence on Coursera, ensuring it's suitable for beginners and contains at least one module discussing Ethical Considerations.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--11", "ques": "Search for a Specialization on Coursera about project management that is produced by a university, show a testimonial for this Specialization.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--12", "ques": "Look for a Coursera course (not Specialization) that teaches Java programming basics.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--13", "ques": "Look for a Specialization on Coursera that teaches Python programming, and identify the skills you will learn by taking this Specialization.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--14", "ques": "Find a course on Coursera related to Introductory Project Management that includes modules on Agile methodology.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--15", "ques": "Find a course on Coursera named 'Introduction to Mathematical Thinking' offered by Stanford, what is the percentage (rounded) of 5 star ratings in reviews and which level has the least percentage?.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--16", "ques": "Identify a course on Coursera named 'Introduction to Finance: The Basics', who is the course instructor and what other courses does he/she teach.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--17", "ques": "How many results are there for a search on Coursera for Machine Learning, then filtered by Credit Eligible and 1-4 Years duration?", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--18", "ques": "Identify a Coursera course that teaches JavaScript, which is beginner-friendly and includes a certificate upon completion.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--19", "ques": "Identify a course on Coursera that provides an introduction to Psychology, list the instructor's name, the institution offering it, and how many hours it will approximately take to complete.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--20", "ques": "Find an Intermediate-level online course on Coursera about 'Blockchain Technology' which lasts between 1 to 4 weeks, and is provided by a well-known institution. Also, note the course's main goals and the instructor's name.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--21", "ques": "Search for an online course on Coursera about 'Digital Marketing', suitable for beginner-level learners. Specify the course duration, the main learning outcomes, and the institution offering the course.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--22", "ques": "Identify a Specialization on Coursera that focuses on 'Human Resource', list the courses included in this Specialization, and the institution offering it.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--23", "ques": "Find a course on Coursera about 'Artificial Intelligence Ethics', which has a duration of less than 5 weeks and has been rated 4.5 stars or higher. Provide the course name and the instructor's name.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--24", "ques": "Locate an online course on Coursera related to 'Sustainability' that belongs to Physical Science and Engineering subject. The course should include a module on Measuring Sustainability. Note the course duration and the offering institution.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--25", "ques": "Find a course on Coursera about 'Relativity' for beginners. List the course's main topics and the estimated time (in hours) required to complete it.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--26", "ques": "Identify a Specialization on Coursera that offers an overview of 'Renewable Energy'. The Specialization should be beginner-level and include a course on Renewable Energy Futures. Note the instructor's name and the number of weeks required to complete the course if I spend 5 hours a week.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--27", "ques": "Search for a Specialization on Coursera about 'Data Visualization' that includes a project. Provide the name of the Specialization, the institution offering it, and the skills that will be developed by completing it.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--28", "ques": "Locate a Coursera Guided project related to 'Astrophysics' suitable for advanced learners. Mention the course duration, the institution offering it, and the main subjects covered in the course.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--29", "ques": "Browse the Coursera website and find the price required for one year of Coursera Plus. How much is the discount? Then list 3 companies that work with Coursera.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--30", "ques": "Locate the course 'Modern Art & Ideas' on Coursera offered by The Museum of Modern Art. Find out the percentage (rounded) of 3-star ratings in the reviews and note which star level has the lowest percentage.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--31", "ques": "Search for the course 'Exploring Quantum Physics' on Coursera, offered by the University of Maryland, College Park. Identify the percentage (rounded) of 5-star ratings in the reviews.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--32", "ques": "Search for 'Data Analysis' courses on Coursera. Apply filters to find courses that are 'Beginner Level' and have a duration ranging from 1 to 3 months. Determine the total count of courses that match these specifications.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--33", "ques": "Find a beginner level Coursera course related to \"Internet of Things (IoT)\" with a high rating. Provide the course name, instructor's name, and a brief summary of the skills that will be taught.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--34", "ques": "Find the course on Coursera named 'Essentials of Global Health'. Determine the instructor of this course and summarize his bio, note if there are any additional courses he offers on Coursera.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--35", "ques": "Find a Coursera course on Sustainable Agriculture practices, and detail the course's objectives and the background of the lead instructor.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--36", "ques": "Browse Coursera, which universities offer Master of Advanced Study in Engineering degrees? Tell me what is the latest application deadline for this degree?", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--37", "ques": "Browse the Coursera homepage and list at least three free courses.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--38", "ques": "Browse Coursera, which universities and companies from Australia are partners of Coursera? List all of them.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--39", "ques": "Find the Space Safety course offered by TUM on Coursera. How many videos are there in module 2? What is the name of each video?", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--40", "ques": "Browse Coursera for Business and Coursera for Teams and summarise some of their advantages.", "web": "https://www.coursera.org/"}
+{"web_name": "Coursera", "id": "Coursera--41", "ques": "Browse online degrees section on Coursera and list 3 Bachelor's degree programmes.", "web": "https://www.coursera.org/"}
+{"web_name": "ESPN", "id": "ESPN--0", "ques": "Look up the current standings for the NBA Eastern Conference on ESPN.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--1", "ques": "Check the latest articles on ESPN for updates on any trades that occurred in the NBA within the past 2 days.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--2", "ques": "Show the scores and main highlight of the Milwaukee Bucks game that took place within the last 2 days on ESPN.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--3", "ques": "Retrieve the final score from the most recent NBA game broadcast on ESPN, including the playing teams' names and the date of the match.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--4", "ques": "Check ESPN for the final scores of NBA games that were played yesterday.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--5", "ques": "Identify the top scorer in the NBA from the latest completed game and note down the points scored, the team they play for, and their position on the team.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--6", "ques": "Find the result of the latest basketball game between the Los Angeles Lakers and the Boston Celtics, including the final score and top scorer from the match.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--7", "ques": "Retrieve the final score and a brief summary of the latest NBA game played by the Los Angeles Lakers as reported on ESPN.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--8", "ques": "Find information on ESPN about the top three scoring leaders in the NBA as of the last day of the regular season, and note which teams they play for.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--9", "ques": "Search on ESPN for how many teams have Los Angeles in their name and how many of them are NBA.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--10", "ques": "Check ESPN for the score and a brief recap of the latest college football championship game.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--11", "ques": "How many NBA teams are there and list all the teams with 'New' in their name.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--12", "ques": "The first three Top Headlines in the current ESPN home page correspond to which sports leagues?", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--13", "ques": "Identify today's top headline in the Basketball section of ESPN, and summarize the main points of that article.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--14", "ques": "Find the latest news about NBA trades or player movements on ESPN and report the most recent trade deal OR player acquisition.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--15", "ques": "Check the scores of the NBA games played on December 25, 2023.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--16", "ques": "Check the schedule for the NBA game on December 25, 2023, and provide the teams that are playing and their current standings in their respective conferences.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--17", "ques": "Check out the NBA Basketball Power Index 2023-24 to see which teams are in first place and which are in last place.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--18", "ques": "How many sports leagues can you choose from on the ESPN home page?", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--19", "ques": "Who has the highest salary in Boston Celtics Roster 2023-24?", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--20", "ques": "Look up the current leaders in rebounds and assists in the NBA Western Conference on ESPN.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--21", "ques": "Show the scores and main highlight of the Denver Nuggets game that occurred within the last 3 days on ESPN.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--22", "ques": "Find the latest Team transactions in the NBA within the past week.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--23", "ques": "Find the result of the latest basketball game between the Miami Heat and the New York Knicks, including the final score and top rebounder from the match.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--24", "ques": "Find the final score from the most recent NFL game broadcast on ESPN, including the teams' names and the date of the match.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--25", "ques": "Identify the player with the most assists in the latest NBA game and show me the assists, the team they play for, and their position.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--26", "ques": "Find information on ESPN NBA schedule. Tell me yesterday's matchups in which the loser high was higher than the winner high.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--27", "ques": "Search on ESPN for how many teams have 'Golden' in their name and how many of them are in the NHL.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--28", "ques": "How many MLB teams are there and list all the teams with 'City' in their name.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--29", "ques": "Identify today's top headline in the Soccer section of ESPN, and summarize the main points of that article.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--30", "ques": "Check out the NHL Standings 2023-24 on ESPN to see which teams are at the top and which are at the bottom in Eastern and Western Conference. What about the situation in Division.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--31", "ques": "Who has the heaviest weight among infielders in the New York Yankees Roster 2023-24?", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--32", "ques": "Review yesterday's NHL game results on ESPN, focusing on teams' performance.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--33", "ques": "Locate the latest ESPN articles discussing potential MVP candidates in the NFL for 2023 season.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--34", "ques": "Visit ESPN to view the Philadelphia 76ers' latest injuries.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--35", "ques": "Browse ESPN to find out when the next game of the Los Angeles Lakers will start. Then navigate to the ticket purchasing website from ESPN, what is the cheapest ticket available.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--36", "ques": "Search for Lionel Messi's last 5 games, which teams has he played for, and what are the results?", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--37", "ques": "Check out LeBron James' Stats to see how many games he has played in his career so far.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--38", "ques": "Check Los Angeles Lakers Stats 2023-24, calculate Anthony Davis' games played (GP) percentage, tell me if there are other players with the same games played percentage as Anthony Davis.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--39", "ques": "Check the New York Jets Depth Chart in the NFL section of ESPN and identify the players listed as injured in the 2ND position.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--40", "ques": "Browse the ESPN+ page from ESPN for a brief summary of what ESPN+ Tools is used for.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--41", "ques": "Find out which four teams the NFC North contains in the NFL on ESPN.", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--42", "ques": "Check out NCAAM standings on ESPN, what are the teams with equal wins and losses in the America East Conference currently?", "web": "https://www.espn.com/"}
+{"web_name": "ESPN", "id": "ESPN--43", "ques": "Check out NCAAW recruiting on ESPN, what colleges are the top three players from?", "web": "https://www.espn.com/"}
+{"web_name": "GitHub", "id": "GitHub--0", "ques": "Search for an open-source project related to 'climate change data visualization' on GitHub and report the project with the most stars.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--1", "ques": "Search for an open-source repository for machine learning in Python, specifically focused on decision trees, updated within the last 2 days.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--2", "ques": "Look for the trending Python repositories on GitHub with most stars.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--3", "ques": "Find out how much more package storage the Enterprise version has over Team in GitHub Pricing.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--4", "ques": "Find a popular JavaScript repository created in the last 30 days on GitHub with a Readme file.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--5", "ques": "Find a Python repository on GitHub that has been updated in the past 2 days and has at least 500 stars.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--6", "ques": "Search for an open-source project related to 'cryptocurrency wallet' updated in the past 30 days and provide the top three contributors.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--7", "ques": "Find the official GitHub repository for ALBERT and show me what files the repo changed in the most recent commit.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--8", "ques": "Look up the latest stable release version of Vuex and find out when it was published.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--9", "ques": "Locate a repository on GitHub that was created in the last week and has 50 or more stars. Provide brief details about the project's purpose and its programming language.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--10", "ques": "If I start using Copilot Individual, how much US dollars will it cost per year and what features does it have?", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--11", "ques": "Find a newly created open-source project on GitHub related to 'climate change' that has been initiated in January 2023; check the main programming language used and the project's description.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--12", "ques": "Retrieve the latest release from the 'electron/electron' repository on GitHub and note down the release version number and date.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--13", "ques": "Identify the latest top-trending open-source project in the category of 'Machine Learning' on GitHub, and check the number of stars it has received.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--14", "ques": "Locate the repository for the open-source project \"vscode\" and identify the top three contributors.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--15", "ques": "Locate a repository on GitHub related to 'quantum computing' that has been updated within the last week and has at least 50 stars. Provide a brief description of the project.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--16", "ques": "Find the GitHub Skill section and how many courses are under the 'First day on GitHub' heading.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--17", "ques": "Locate a C++ project on GitHub that has been recently updated in the last week and has at least 500 stars, then describe its main purpose.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--18", "ques": "Identify and report the most popular (in terms of stars) open-source image processing tool on GitHub.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--19", "ques": "Look up the most recently updated Python repository on GitHub that is tagged with 'web scraping' and has over 100 stars.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--20", "ques": "Open GitHub Copilot's FAQs to find the official answer to when Copilot chat can be used on mobile.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--21", "ques": "Find the Security topic in GitHub Resources and answer the role of GitHub Advanced Security.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--22", "ques": "Find an open-source repository on GitHub focused on natural language processing in Ruby, updated within the last week.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--23", "ques": "Find the wiki page of ohmyzsh on GitHub and tell me how to change the theme of zsh to agnoster.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--24", "ques": "Locate the GitHub repository for the open-source project \"angular\" and identify the last three issues closed.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--25", "ques": "Search for a 'virtual reality' related repository on GitHub updated in the last 10 days with at least 200 stars and summarize its main objective.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--26", "ques": "Find the Resolve merge conflicts course in GitHub Skills and what actions learners will perform in this course.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--27", "ques": "Find a Ruby repository on GitHub that has been updated in the past 3 days and has at least 1000 stars.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--28", "ques": "Identify the most starred JavaScript repositories on GitHub that were created after 2023-12-29.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--29", "ques": "Compare the maximum number of private repositories allowed in the Free and Pro plans in GitHub Pricing.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--30", "ques": "Search for an open-source project related to 'blockchain technology' on GitHub updated in the past 15 days and list the top five contributors.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--31", "ques": "Find the official GitHub repository for TensorFlow and list the files changed in the last commit. Tell me the name of changed files, total additions and total deletion.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--32", "ques": "Discover the latest C# repository on GitHub related to 'game development' and having over 150 stars, and describe its main features.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--33", "ques": "Find Customer Stories on the GitHub page and list the 2 stories that appear on the web page.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--34", "ques": "Search for an open-source project on GitHub related to 'Protein prediction' and identify the project with the highest number of forks.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--35", "ques": "Check the latest release version of React and the date it was published on GitHub.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--36", "ques": "Identify a new open-source project on GitHub related to 'AI agriculture' that created in 2022, and note its main programming language and description.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--37", "ques": "List the 3 features mentioned in GitHub's Copilot product page.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--38", "ques": "Identify and report the most popular (by stars) open-source repo related to cybersecurity on GitHub.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--39", "ques": "Browse the GitHub Trending and find out which developer is currently ranked first this month and the corresponding repository.", "web": "https://github.com/"}
+{"web_name": "GitHub", "id": "GitHub--40", "ques": "Select Sign up on the GitHub homepage to see if email 'test123@gmail.com' already exists.", "web": "https://github.com/"}
+{"web_name": "Google Flights", "id": "Google Flights--0", "ques": "Book a journey with return option on same day from Edinburg to Manchester on December 28th and show me the lowest price option available.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--1", "ques": "Show me the list of one-way flights today (February 17, 2024) from Chicago to Paris.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--2", "ques": "Find the lowest fare from all eligible one-way flights for 1 adult from JFK to Heathrow on Jan. 22.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--3", "ques": "Search for the one-way flight available from Calgary to New York on Jan. 1st with the lowest carbon dioxide emissions.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--4", "ques": "Search for one-way flights from New York to London on Dec. 26th and filter the results to show only non-stop flights.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--5", "ques": "Find flights from Chicago to London on 20 December and return on 23 December.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--6", "ques": "Search for a flight on December 19 and return on December 26 from Tel Aviv to Venice and Select First Class.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--7", "ques": "Find a round trip from Phoenix to Miami (Dec. 25th - Dec. 28th), show the First Class plane tickets for me that do not exceed $1320..", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--8", "ques": "Search a one-way filght from Dublin To Athens Greece for 1 Adult that leaves on December 30 and analyse the price graph for the next 2 months.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--9", "ques": "Find a one way economy flight from Pune to New York in Jan. 15th and show me how long it will take for flight transfer.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--10", "ques": "Locate the cheapest round-trip flights from New York to Tokyo leaving on January 25, 2024, and returning on February 15, 2024.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--11", "ques": "Compare the prices for round-trip flights from New York to Tokyo for a departure on February 10, 2024, and a return on February 24, 2024, and select the option with the least number of stops.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--12", "ques": "Find the best-priced round-trip flight from New York to London leaving on December 25, 2023, and returning on January 5, 2024, with one stop or fewer.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--13", "ques": "Find the cheapest round-trip flight option from New York City to Tokyo for a departure on January 10, 2024, and a return on January 24, 2024.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--14", "ques": "Compare flight options and find the lowest round trip fare from New York to London departing on January 10, 2024, and returning on January 17, 2024.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--15", "ques": "Compare the prices and total duration of non-stop flights from New York to Tokyo Narita Airport departing on February 12th, 2024, and returning on February 26th, 2024.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--16", "ques": "Find the cheapest one-way flight from New York to Tokyo departing on January 15, 2024, and provide the airline and total flight duration.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--17", "ques": "Find the cheapest round-trip flight from New York to Paris leaving on December 27, 2023, and returning on January 10, 2024.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--18", "ques": "Compare flight options from New York to Tokyo for a round trip leaving on January 25, 2024, and returning on February 15, 2024, for one adult. Prioritize the comparisons by the shortest travel time.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--19", "ques": "Find the cheapest one-way flight from London to Paris, departing on January 25, 2024. Include the airline, total travel time, and layovers for the chosen flight.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--20", "ques": "Book a round-trip flight from San Francisco to Berlin, departing on March 5, 2024, and returning on March 12, 2024, and find the option with the shortest total travel time.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--21", "ques": "Locate the lowest-priced one-way flight from Tokyo to Sydney for an adult, departing on February 25, 2024, and include the flight duration and number of layovers.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--22", "ques": "Find a round-trip flight from Rio de Janeiro to Los Angeles, leaving on March 15, 2024, and returning on March 22, 2024, and select the option with the least carbon dioxide emissions.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--23", "ques": "Search for a one-way flight from Mumbai to Vancouver on February 28, 2024, filtering the results to show only 1-stop flights.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--24", "ques": "Compare prices for economy class round-trip flights from Dubai to Rome, departing on March 1, 2024, and returning on March 8, 2024, and select the option with the fewest stops.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--25", "ques": "Find a one-way business class flight from Buenos Aires to Amsterdam on March 10, 2024, and provide the details of the flight with the shortest duration.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--26", "ques": "Search for the cheapest round-trip flights from Bangkok to Madrid, leaving on February 26, 2024, and returning on February 28, 2024, and provide options under $1000.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--27", "ques": "Locate a one-way flight from Johannesburg to Toronto on March 30, 2024, for one adult, and analyze the price trends for the following month.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--28", "ques": "Find the best-priced round-trip flight from Seattle to Paris, departing on February 27, 2024, and returning on March 1, 2024, with a maximum of one stop.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--29", "ques": "Compare the prices and total travel time of non-stop flights from Mexico City to Frankfurt, departing on March 5, 2024, and returning on March 15, 2024.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--30", "ques": "Find the most affordable one-way flight from Cape Town to Singapore, departing on March 20, 2024, and include the airline and total number of layovers.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--31", "ques": "Find a one-way economy flight from Auckland to Honolulu on March 25, 2024, browse the full page and display a flight option with the most stops.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--32", "ques": "Search for round-trip flights from Stockholm to Toronto, departing on March 3, 2024, and returning on March 10, 2024, and sort the results to find the shortest total travel time.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--33", "ques": "Find a one-way flight from Shanghai to Vancouver on February 27, 2024, and compare the options based on carbon dioxide emissions.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--34", "ques": "Compare business class flight options from Lisbon to Singapore for a one-way trip on March 15, 2024, select one of the flights and see which websites offer its booking options. Which one is the cheapest.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--35", "ques": "Find the lowest-priced one-way flight from Cairo to Montreal on February 21, 2024, including the total travel time and number of stops.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--36", "ques": "Search for round-trip flights from Helsinki to New Delhi, departing on March 28, 2024, and returning on April 4, 2024, and filter the results to show only flights under $1000.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--37", "ques": "Locate a round-trip flight from Buenos Aires to Beijing, leaving on February 28, 2024, and returning on March 3, 2024, check out one of the options and tell me if the airline for my return flight is the same as my departure flight.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--38", "ques": "Compare the prices and flight durations for economy class flights from Oslo to Dubai, departing on March 8, 2024, and show the options with no more than two layovers.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--39", "ques": "Find a one-way flight from Prague to a city in Japan on March 20, 2024, which city in Japan is cheaper to go to, Tokyo or a certain city in Hokkaido?", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--40", "ques": "Browse destinations on the Google Flights homepage from Seattle, look at destinations on a map, and recommend some famous places to travel that are within a reasonable distance and price.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Flights", "id": "Google Flights--41", "ques": "Choose one way business class ticket from Hong Kong to Glacier National Park on 8 March 2024, offering a 1 stop ticket.", "web": "https://www.google.com/travel/flights/"}
+{"web_name": "Google Map", "id": "Google Map--0", "ques": "Find 5 beauty salons with ratings greater than 4.8 in Seattle, WA.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--1", "ques": "Tell me one bus stop that is nearest to the intersection of main street and Amherst street in Altavista.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--2", "ques": "Find Apple Stores close to zip code 90028", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--3", "ques": "The least amount of walking from Central Park Zoo to the Broadway Theater in New York.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--4", "ques": "Plan a trip from Boston Logan Airport to North Station.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--5", "ques": "Search for a parking garage near Thalia Hall in Chicago that isn't open 24 hours.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--6", "ques": "Find all Uniqlo locations in Chicago, IL.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--7", "ques": "Find bus stops in Alanson, MI", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--8", "ques": "Find a place to climb within 2 miles of zip code 90028.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--9", "ques": "Find the art gallery that is nearest to Los Angeles Hindu Temple.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--10", "ques": "Search for a park in the state of California called Castle Mountains National Monument and find out it's Basic Information.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--11", "ques": "Locate a large store in Washington that has kids' and maternity products, also check if it has a parking lot.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--12", "ques": "Find 5 places that serve burgers near 44012 zip code and sort these 5 places by highest rating.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--13", "ques": "Find a parking lot in Gloucester and book a ride from there to North Plymouth, view the map to understand the route better.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--14", "ques": "Find motorcycle parking near Radio City Music Hall.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--15", "ques": "Find daytime only parking nearest to Madison Square Garden. Summarize what people are saying about it. ", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--16", "ques": "Find EV charging supported parking closest to Smithsonian museum.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--17", "ques": "Search for locksmiths open now but not open 24 hours in Texas City.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--18", "ques": "Find a route between Chicago to Los Angeles, then print the route details.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--19", "ques": "I will arrive Pittsburgh Airport soon. Provide the name of the Hilton hotel closest to the airport. Then, tell me the the walking time to the nearest supermarket from the hotel.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--20", "ques": "Find Tesla Destination Charger closest to the National Air and Space Museum.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--21", "ques": "Identify the nearest bus stop to the corner of Elm Street and Oak Street in Massachusetts.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--22", "ques": "Find a Best Buy store near zip code 33139.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--23", "ques": "Determine the shortest walking route from The Metropolitan Museum of Art to Times Square in New York.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--24", "ques": "Plan a journey from San Francisco International Airport to Union Square via driving.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--25", "ques": "Search for a parking facility near the Fox Theater in Detroit that closes at night.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--26", "ques": "Search for Los Angeles on Google Map, try to print the map as PDF and summarize the information on the map.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--27", "ques": "Locate the Target stores in Atlanta, GA. How many results are shown on the map.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--28", "ques": "Find the search settings for Google Map, what options are shown on that page?", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--29", "ques": "Identify bus stops in Ypsilanti, MI, list three of them.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--30", "ques": "Locate a parking lot near the Brooklyn Bridge that open 24 hours. Review the user comments about it.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--31", "ques": "First search New York's Central Park Zoo on Google Map, and then find the way to share the map. What is the generated sharing link?", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--32", "ques": "Search for plumbers available now but not open 24 hours in Orlando, FL.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--33", "ques": "Check out Denver International Airport's information and tell me: 1) which level has the least proportion in reviews; 2) what are its Accessibility and Amenities.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--34", "ques": "Find a hiking trail within 2 miles of zip code 80202.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--35", "ques": "Search for a natural reserve in Texas called Big Bend National Park and gather its Basic Information.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--36", "ques": "Identify 5 restaurants serving pizza near the 30309 zip code and rank them by their ratings.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--37", "ques": "Locate a parking area in Salem and find a route from there to Marblehead, including map directions for better understanding.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--38", "ques": "Search for bicycle parking near the Empire State Building.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--39", "ques": "Find a route from Miami to New Orleans, and provide the detailed route information.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Map", "id": "Google Map--40", "ques": "Find a restaurant in Boston that eats Boston lobster and asks for a rating of 4.6 or higher, and check out what a one-star review says.", "web": "https://www.google.com/maps/"}
+{"web_name": "Google Search", "id": "Google Search--0", "ques": "Find the initial release date for Guardians of the Galaxy Vol. 3 the movie.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--1", "ques": "Find Kevin Durant's bio", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--2", "ques": "Search for the latest news title about the NBA team the Los Angeles Lakers.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--3", "ques": "Show me a list of comedy movies, sorted by user ratings. Show me the Top 5 movies.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--4", "ques": "Show most played games in Steam. And tell me the number of players in In game at this time", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--5", "ques": "find the score of the latest nba game played by the phoenix suns.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--6", "ques": "Browse the monthly trending searches in Columbus.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--7", "ques": "Find the software requirements for iPhones that support AirDrop's ability to continue transmitting over the web when out of range.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--8", "ques": "Find the video on YouTube: 'Oscars 2023: Must-See Moments!'. Tell me who the first comment displayed under that video belongs to, and how many thumbs up and replies it has.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--9", "ques": "Show the rating of Prometheus movie on IMDb and Rotten Tomatoes.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--10", "ques": "Find the no. 1 weekly charts ranked artist based on Billboard and tell me 10 most played song by this artist until now.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--11", "ques": "According to FlightAware, tell me the busiest airport last week and its total arrivals and departures last week.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--12", "ques": "Find the year that Tom Brady had the most touchdowns in a single seasson.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--13", "ques": "What are Jerry Trainor's upcoming projects?", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--14", "ques": "Find the retired players the year before last named James Smith and tell me which club he has been a member of from 2020\u20132021.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--15", "ques": "Please try to log in to twitter with email: webagenttest@testmail.com and password: test123456. Let me know if the login was successful.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--16", "ques": "How many members are there in the OpenAI community on Reddit, and what is the hottest news right now?", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--17", "ques": "Tell me the names of Trump's kids", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--18", "ques": "When and where the most recent World Cup was held, and which team was the winner?", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--19", "ques": "What are the first 7 bits of the SHA of the Bert's latest commit on GitHub, and what exactly was changed in that commit.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--20", "ques": "Find the release date for the latest \"Fast & Furious\" movie.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--21", "ques": "Show a list of the top 5 highest-grossing animated movies, sorted by box office earnings.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--22", "ques": "Browse and list the top three trending topics this month in New York City.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--23", "ques": "Retrieve a short biography of LeBron James.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--24", "ques": "What is the name of the star system closest to the Solar System, and what are the discovered planets in it?", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--25", "ques": "Get the latest news headline about the English Premier League football club Manchester United.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--26", "ques": "Identify the hardware requirements for using the latest version of Adobe Photoshop on a Mac.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--27", "ques": "Check the current air quality index in Paris.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--28", "ques": "Check the IMDb and Metacritic scores of the movie \"Inception.\"", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--29", "ques": "Find out the current world record for the men's 100m sprint.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--30", "ques": "Find the current number one artist on the Spotify Global Top 50 chart and list his/her top 10 songs as of now.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--31", "ques": "Discover which year Cristiano Ronaldo scored the most goals in a single season.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--32", "ques": "Find out where and when the most recent UEFA Champions League final was held, and which team won.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--33", "ques": "Find and copy the SHA of the latest commit in the TensorFlow repository on GitHub, then find a textbox to paste and tell me what the SHA is.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--34", "ques": "Determine the distance from Earth to Mars as of today's date.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--35", "ques": "Look up the latest research paper related to black holes published in the journal \"Nature Astronomy\".", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--36", "ques": "Search for the most recent Nobel Prize winner in Physics and their contribution to the field.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--37", "ques": "Find the current top 3 super-earth planets and give a brief introduction to them.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--38", "ques": "Search for the next visible solar eclipse in North America and its expected date, and what about the one after that.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--39", "ques": "Identify the top-10 trending travel destination for 2024 through a blog, how many of them are in Asian.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--40", "ques": "Look up the elevation of Mount Kilimanjaro on Google Search.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--41", "ques": "Look up the current statistics of air pollution level in Los Angeles using Google Search.", "web": "https://www.google.com/"}
+{"web_name": "Google Search", "id": "Google Search--42", "ques": " Use Google Search to find an article that explains the major differences between American English and British English.", "web": "https://www.google.com/"}
+{"web_name": "Huggingface", "id": "Huggingface--0", "ques": "Find a pre-trained natural language processing model on Hugging Face that can perform sentiment analysis, and make sure the model's last update is within March 2023.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--1", "ques": "Use the Huggingface Inference API to generate a short story about a dragon and a wizard.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--2", "ques": "Discover three new and popular open-source NLP models for language translation released in the past month on Huggingface.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--3", "ques": "Look up a model with a license of cc-by-sa-4.0 with the most likes on Hugging face.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--4", "ques": "Locate an open-source conversational AI model on Hugging Face, trained in English and list its main features and applications.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--5", "ques": "Find a model released on Hugging Face for recipe generation. Retrieve the information of the model, including its name, model size and tensor type.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--6", "ques": "Find the model sentence-transformers/all-MiniLM-L6-v2 and use the Inference API on the webpage to get the similarity of the following two sentences: 'Tomorrow is Sunday', 'Eat a burger on Sunday'.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--7", "ques": "Which is the most downloaded audio related dataset on Hugging face currently.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--8", "ques": "Retrieve an example of a pre-trained language model in natural language processing and identify the tasks it is specifically designed for, like translation or text summarization.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--9", "ques": "Find the most download machine translation model on Huggingface which focuses on English and Japanese (en-ja) and report the evaluation metrics stated for it.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--10", "ques": "Open space: argilla/notux-chat-ui and interact with it by asking it 'which team trained you'. What is its answer.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--11", "ques": "Identify the latest updated image to video model available on Huggingface and summarize its main features.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--12", "ques": "Find the most recently updated machine learning model on Huggingface which focuses on Error Correction.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--13", "ques": "Search for LLaMA in the huggingface doc, what type is the spaces_between_special_tokens parameter in LlamaTokenizer and what is its default value.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--14", "ques": "How much is the Pro account of Hugging face for a month and what are the features?", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--15", "ques": "Identify the most downloaded models on Hugging face that use the PaddlePaddle library.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--16", "ques": "Find information on the latest (as of today's date) pre-trained language model on Huggingface suitable for text classification and briefly describe its intended use case and architecture.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--17", "ques": "Find the most recently updated open-source project related to natural language processing on the Huggingface platform. Provide the project's name, creator, and a brief description of its functionality.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--18", "ques": "Look up TRL's forward modelling in the hugging face documentation on how to add a margin to a loss.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--19", "ques": "Explore and summarize the features of the most recent open-source NLP model released by Hugging Face for English text summarization.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--20", "ques": "Locate a pre-trained natural language processing model on Hugging Face that specializes in named entity recognition (NER), confirm that the model was last updated in 2022 and has 1M+ downloads.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--21", "ques": "Look up the tour about how to use the 'pipeline' feature in the Hugging Face Transformers library for sentiment analysis, and identify the default model it uses.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--22", "ques": "Identify the steps to convert a PyTorch model to TensorFlow using the Hugging Face Transformers library as described in their documentation.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--23", "ques": "Identify three innovative and widely recognized open-source NLP models for automatic speech recognition released in the past month on Huggingface.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--24", "ques": "Search for a model on Hugging Face with an Apache-2.0 license that has received the highest number of likes.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--25", "ques": "In the Hugging Face documentation, find the tutorial on loading adapters with PEFT, tell me how to load in 8bit or 4bit.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--26", "ques": "Identify a model on Hugging Face designed for generating travel chats. Obtain information about the model, including its name, size and training framwork.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--27", "ques": "Determine the most downloaded dataset related to Text Retrieval in NLP on Hugging Face.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--28", "ques": "Retrieve an example of a pre-trained model on Hugging Face that is optimized for question answering tasks and detail the languages it supports.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--29", "ques": "Summarize the description of the recent open-source NLP model released on Hugging Face for medical summarization.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--30", "ques": "Identify the most downloaded English-Chinese (en-zh) machine translation model on Huggingface and report its latest performance metrics and usage guidelines.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--31", "ques": "Identify the latest machine learning model on Huggingface that specializes in detecting fake news, including the date of its last update.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--32", "ques": "On the Hugging Face website, search for the model 'GPT-J-6B' and find the 'temperature' parameter in its settings. What is the default value of this parameter?", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--33", "ques": "List three hugging face docs. How many GitHub stars have they earned so far?", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--34", "ques": "List the benefits of hugging face classroom mentioned on Hugging face website.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--35", "ques": "Find the latest Diffusion-related blog on Hugging Face, and read its intro or overview section to roughly summarize the content of the blog.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--36", "ques": "Summarize all the payment plans and their advantages in huggingface pricing.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--37", "ques": "Browse the daily paper on Hugging Face. What is the title of the first article, how many upvotes has it received, and is there any related model or data release?", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--38", "ques": "Investigate the 'transformers' library in the Hugging Face documentation, focusing on how to add new tokens to a tokenizer.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--39", "ques": "Investigate in the Hugging Face documentation how to utilize the 'Trainer' API for training a model on a custom dataset, and note the configurable parameters of the Trainer class.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--40", "ques": "Check out Text Embeddings Inference in Hugging face's Doc to summarise the strengths of the toolkit.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--41", "ques": "What is the current Text-to-3D model with the highest number of downloads and tell me are there Spaces that use the model.", "web": "https://huggingface.co/"}
+{"web_name": "Huggingface", "id": "Huggingface--42", "ques": "Check the Dataset Viewer for ai2lumos/lumos_complex_qa_plan_onetime on Hugging face. what is the content corresponding to user in the first message?", "web": "https://huggingface.co/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--0", "ques": "derivative of x^2 when x=5.6", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--1", "ques": "Give a constraint on the set of inequalities for the inner region of the pentagram.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--2", "ques": "Calculate 3^71 and retain 5 significant figures in scientific notation.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--3", "ques": "Let g(x) be the integral of x^2 cos(2x). Write the expression of g(x).", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--4", "ques": "Pack 24 circles in a circle radius r. Compare Densest known packing and Square packing. Then tell me the radius of the inner circles.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--5", "ques": "Show the solution of y\"(z) + sin(y(z)) = 0 from wolframalpha.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--6", "ques": "Simplify x^5-20x^4+163x^3-676x^2+1424x-1209 so that it has fewer items.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--7", "ques": "Give the final angle and final length after 6s of a Spring pendulum with spring equilibrium length=0.12m, initial length=0.24m, initial angle=80deg, mass=1kg, spring constant=120 N/m .", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--8", "ques": "Give 12 lbs of 4-cyanoindole, converted to molar and indicate the percentage of C, H, N.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--9", "ques": "Annual energy production of Diablo Canyon 2 in 2010.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--10", "ques": "Give the geomagnetic field on June 20, 2023 in Oslo.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--11", "ques": "Show the electrical resistivity of UNS A92024 and UNS G10800 at 20 degrees Celsius.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--12", "ques": "Which character in unicode 8900 to 8920 looks like a snowflake", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--13", "ques": "What is 10,000 US dollars worth now in 1980 and in 1970?", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--14", "ques": "Compare the total Calories: whopper vs baconator vs big mac. Assume that each serving of food is 300g.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--15", "ques": "Show the blood relationship fraction between you and your father's mother's sister's son.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--16", "ques": "Weight lose for a male with current weight 90 kg, 40 year old, 175 cm. If he intakes 1500 calories every day, how long will it take to lose 17 kg.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--17", "ques": "Show the average price of movie ticket in Providence, Nashville, Boise in 2023.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--18", "ques": "Plot Albert Einstein curve with Parametric equations.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--19", "ques": "Standing in the sun from 11:00 am with SPF 5 in Australia. Approximate time to sunburn for each skin type.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--20", "ques": "Compute the integral of 3e^(2x) from x=0 to x=5.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--21", "ques": "Calculate (1+0.1*i)^8 + (1\u22120.2*i)^8  where i is a complex number.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--22", "ques": "Determine the area of a regular hexagon with a side length of 7 cm.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--23", "ques": "Calculate the population growth rate of Canada from 2020 to 2023 using Wolfram Alpha.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--24", "ques": "Solve the differential equation y''(t) - 2y'(t) + 10y(t) = 0 and display its general solution.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--25", "ques": "Calculate the final position and velocity of a projectile launched at 45 degrees with an initial speed of 30 m/s after 3 seconds.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--26", "ques": "Convert 15 kilograms of sulfuric acid to moles and display the percentage composition of H, S, and O by weight.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--27", "ques": "Display the thermal conductivity of Copper (Cu) and Aluminum (Al) at 25 degrees Celsius.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--28", "ques": "Identify the character in Unicode range 9632 to 9650 that represents a hollow parallelogram.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--29", "ques": "Create a plot of cat curve using wolfram alpha.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--30", "ques": "Calculate the estimated time to sunburn for different skin types when exposed to the sun at 1:00 pm with SPF 1 in Brazil.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--31", "ques": "Using Wolfram Alpha, determine the current temperature and wind speed in Chicago, IL.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--32", "ques": "Print all prime numbers between 1000 and 1200 using Wolfram alpha.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--33", "ques": "Identify the electrical energy output of a hydroelectric power plant named Itaipu Dam in 2023 using Wolfram Alpha.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--34", "ques": "Calculate the mass of Jupiter compared to Earth using Wolfram Alpha. Also, find the length of one day on Jupiter.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--35", "ques": "Calculate the determinant of a 6x6 Hilbert matrix.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--36", "ques": "Determine the convergence or divergence of the series \u03a3 (n=1 to \u221e) of 1/(n^3 + 1).", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--37", "ques": "How many days are there between February 12, 2024 and August 9, 2050?", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--38", "ques": "Compute the length of a curve defined by y = 2x^3 - 3x^2 + 4x - 5 from x = 0 to x = 3.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--39", "ques": "Use Wolfram alpha to write the expression of the ellipse x^2 + 3 y^2 = 4 rotated 33 degrees counterclockwise.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--40", "ques": "Approximate amount of fat burned by a 28yo, 172cm tall, 70kg woman running for 30min at a pace of 6min/mile.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--41", "ques": "What is the approximate Heart Rate Reserve of a 50 year old man who has a heart rate of 60bpm at rest.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--42", "ques": "What is the raw memory of a 100.2\" * 123.5\" true colour picture at 72 ppi?", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--43", "ques": "A polyominoes of order 6 means you have 6 identical squares to combine different shapes (2-sided). How many combinations are there? Looking at all the shapes in the result, how many of them have only 2 rows in total?", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--44", "ques": "Solve the ODE, g' + cos(g) = 0, if there is a constant in the result, determine the value of the constant by the condition that g(0) = 1.", "web": "https://www.wolframalpha.com/"}
+{"web_name": "Wolfram Alpha", "id": "Wolfram Alpha--45", "ques": "A 175cm tall, 85kg, 40yo man climbs 2500 steps at about 18cm per step and 40 steps per minute. summarise the Metabolic properties.", "web": "https://www.wolframalpha.com/"}
\ No newline at end of file
diff --git a/packages/evals/env.ts b/packages/evals/env.ts
new file mode 100644
index 000000000..cf7e57e7e
--- /dev/null
+++ b/packages/evals/env.ts
@@ -0,0 +1,10 @@
+/**
+ * Determine the current environment in which the evaluations are running:
+ * - BROWSERBASE or LOCAL
+ *
+ * The environment is read from the EVAL_ENV environment variable.
+ */
+export const env: "BROWSERBASE" | "LOCAL" =
+  process.env.EVAL_ENV?.toLowerCase() === "browserbase"
+    ? "BROWSERBASE"
+    : "LOCAL";
diff --git a/packages/evals/evals.config.json b/packages/evals/evals.config.json
new file mode 100644
index 000000000..1db725021
--- /dev/null
+++ b/packages/evals/evals.config.json
@@ -0,0 +1,632 @@
+{
+  "defaults": {
+    "env": "local",
+    "trials": 3,
+    "concurrency": 10,
+    "provider": null,
+    "model": null,
+    "api": false
+  },
+  "benchmarks": {
+    "webbench": {
+      "limit": 25,
+      "filters": ["difficulty", "category", "use_hitl"]
+    },
+    "gaia": {
+      "limit": 25,
+      "filters": ["level"]
+    },
+    "webvoyager": {
+      "limit": 25
+    },
+    "osworld": {
+      "limit": 25,
+      "filters": ["source", "evaluation_type"],
+      "timeout": 60000
+    },
+    "onlineMind2Web": {
+      "limit": 25
+    },
+    "webtailbench": {
+      "limit": 25
+    }
+  },
+  "tasks": [
+    {
+      "name": "history",
+      "categories": ["combination"]
+    },
+    {
+      "name": "extract_repo_name",
+      "categories": ["extract"]
+    },
+    {
+      "name": "amazon_add_to_cart",
+      "categories": ["act"]
+    },
+    {
+      "name": "instructions",
+      "categories": ["regression", "combination"]
+    },
+    {
+      "name": "bidnet",
+      "categories": ["act"]
+    },
+    {
+      "name": "ionwave",
+      "categories": ["act", "regression"]
+    },
+    {
+      "name": "nonsense_action",
+      "categories": ["act"]
+    },
+    {
+      "name": "peeler_simple",
+      "categories": ["act"]
+    },
+    {
+      "name": "simple_google_search",
+      "categories": ["act"]
+    },
+    {
+      "name": "vantechjournal",
+      "categories": ["act"]
+    },
+    {
+      "name": "wikipedia",
+      "categories": ["act"]
+    },
+    {
+      "name": "allrecipes",
+      "categories": ["combination"]
+    },
+    {
+      "name": "arxiv",
+      "categories": ["combination"]
+    },
+    {
+      "name": "extract_collaborators",
+      "categories": ["combination"]
+    },
+    {
+      "name": "extract_github_commits",
+      "categories": ["combination"]
+    },
+    {
+      "name": "imdb_movie_details",
+      "categories": ["combination"]
+    },
+    {
+      "name": "peeler_complex",
+      "categories": ["combination"]
+    },
+    {
+      "name": "sciquest",
+      "categories": ["combination"]
+    },
+    {
+      "name": "wichita",
+      "categories": ["combination", "regression"]
+    },
+    {
+      "name": "hn_aisdk",
+      "categories": ["llm_clients"]
+    },
+    {
+      "name": "hn_langchain",
+      "categories": ["llm_clients"]
+    },
+    {
+      "name": "hn_customOpenAI",
+      "categories": ["llm_clients"]
+    },
+    {
+      "name": "apple",
+      "categories": ["experimental"]
+    },
+    {
+      "name": "combination_sauce",
+      "categories": ["experimental"]
+    },
+    {
+      "name": "costar",
+      "categories": ["experimental"]
+    },
+    {
+      "name": "extract_aigrant_companies",
+      "categories": ["regression"]
+    },
+    {
+      "name": "extract_capacitor_info",
+      "categories": ["experimental"]
+    },
+    {
+      "name": "extract_partners",
+      "categories": ["experimental"]
+    },
+    {
+      "name": "extract_press_releases",
+      "categories": ["experimental"]
+    },
+    {
+      "name": "extract_snowshoeing_destinations",
+      "categories": ["experimental"]
+    },
+    {
+      "name": "homedepot",
+      "categories": ["experimental"]
+    },
+    {
+      "name": "rakuten_jp",
+      "categories": ["experimental"]
+    },
+    {
+      "name": "stock_x",
+      "categories": ["experimental"]
+    },
+    {
+      "name": "ted_talk",
+      "categories": ["experimental"]
+    },
+    {
+      "name": "extract_baptist_health",
+      "categories": ["extract"]
+    },
+    {
+      "name": "extract_github_stars",
+      "categories": ["extract"]
+    },
+    {
+      "name": "extract_memorial_healthcare",
+      "categories": ["extract", "regression"]
+    },
+    {
+      "name": "extract_nhl_stats",
+      "categories": ["extract"]
+    },
+    {
+      "name": "extract_professional_info",
+      "categories": ["extract"]
+    },
+    {
+      "name": "extract_csa",
+      "categories": ["extract"]
+    },
+    {
+      "name": "extract_resistor_info",
+      "categories": ["extract"]
+    },
+    {
+      "name": "extract_rockauto",
+      "categories": ["extract"]
+    },
+    {
+      "name": "extract_staff_members",
+      "categories": ["extract"]
+    },
+    {
+      "name": "ionwave_observe",
+      "categories": ["observe"]
+    },
+    {
+      "name": "panamcs",
+      "categories": ["observe"]
+    },
+    {
+      "name": "vanta_h",
+      "categories": ["experimental"]
+    },
+    {
+      "name": "extract_area_codes",
+      "categories": ["extract"]
+    },
+    {
+      "name": "extract_public_notices",
+      "categories": ["extract"]
+    },
+    {
+      "name": "extract_jstor_news",
+      "categories": ["extract"]
+    },
+    {
+      "name": "extract_apartments",
+      "categories": ["extract"]
+    },
+    {
+      "name": "extract_zillow",
+      "categories": ["extract"]
+    },
+    {
+      "name": "observe_github",
+      "categories": ["observe", "regression"]
+    },
+    {
+      "name": "observe_vantechjournal",
+      "categories": ["observe", "regression"]
+    },
+    {
+      "name": "observe_amazon_add_to_cart",
+      "categories": ["observe"]
+    },
+    {
+      "name": "observe_simple_google_search",
+      "categories": ["observe"]
+    },
+    {
+      "name": "observe_yc_startup",
+      "categories": ["observe"]
+    },
+    {
+      "name": "observe_taxes",
+      "categories": ["observe"]
+    },
+    {
+      "name": "observe_iframes1",
+      "categories": ["regression", "observe"]
+    },
+    {
+      "name": "observe_iframes2",
+      "categories": ["regression", "observe"]
+    },
+    {
+      "name": "extract_hamilton_weather",
+      "categories": ["targeted_extract", "regression"]
+    },
+    {
+      "name": "extract_regulations_table",
+      "categories": ["targeted_extract"]
+    },
+    {
+      "name": "extract_recipe",
+      "categories": ["targeted_extract"]
+    },
+    {
+      "name": "extract_aigrant_targeted",
+      "categories": ["targeted_extract"]
+    },
+    {
+      "name": "extract_aigrant_targeted_2",
+      "categories": ["targeted_extract"]
+    },
+    {
+      "name": "extract_geniusee",
+      "categories": ["targeted_extract"]
+    },
+    {
+      "name": "extract_geniusee_2",
+      "categories": ["targeted_extract"]
+    },
+    {
+      "name": "scroll_50",
+      "categories": ["regression", "act"]
+    },
+    {
+      "name": "scroll_75",
+      "categories": ["regression", "act"]
+    },
+    {
+      "name": "next_chunk",
+      "categories": ["regression", "act"]
+    },
+    {
+      "name": "prev_chunk",
+      "categories": ["regression", "act"]
+    },
+    {
+      "name": "google_flights",
+      "categories": ["act"]
+    },
+    {
+      "name": "extract_jfk_links",
+      "categories": ["extract"]
+    },
+    {
+      "name": "extract_single_link",
+      "categories": ["extract"]
+    },
+    {
+      "name": "dropdown",
+      "categories": ["act"]
+    },
+    {
+      "name": "radio_btn",
+      "categories": ["act"]
+    },
+    {
+      "name": "checkboxes",
+      "categories": ["act"]
+    },
+    {
+      "name": "agent/iframe_form",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/iframe_form_multiple",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/google_flights",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/github_react_version",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/steam_games",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/ubereats",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/kith",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/apple_tv",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/apple_trade_in",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/arxiv_gpt_report",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/sf_library_card",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/sf_library_card_multiple",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/hugging_face",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/google_maps_3",
+      "categories": ["agent"]
+    },
+    {
+      "name": "login",
+      "categories": ["act", "regression"]
+    },
+    {
+      "name": "iframe_hn",
+      "categories": ["extract"]
+    },
+    {
+      "name": "iframe_same_proc",
+      "categories": ["act"]
+    },
+    {
+      "name": "iframe_form_filling",
+      "categories": ["act"]
+    },
+    {
+      "name": "iframes_nested",
+      "categories": ["act"]
+    },
+    {
+      "name": "no_js_click",
+      "categories": ["act", "regression"]
+    },
+    {
+      "name": "tab_handling",
+      "categories": ["act"]
+    },
+    {
+      "name": "agent/kayak",
+      "categories": ["agent"]
+    },
+    {
+      "name": "multi_tab",
+      "categories": ["act"]
+    },
+    {
+      "name": "shadow_dom",
+      "categories": ["act"]
+    },
+    {
+      "name": "os_dropdown",
+      "categories": ["act"]
+    },
+    {
+      "name": "custom_dropdown",
+      "categories": ["act"]
+    },
+    {
+      "name": "hidden_input_dropdown",
+      "categories": ["act"]
+    },
+    {
+      "name": "nested_iframes_2",
+      "categories": ["act"]
+    },
+    {
+      "name": "heal_scroll_50",
+      "categories": ["act"]
+    },
+    {
+      "name": "heal_simple_google_search",
+      "categories": ["regression", "act"]
+    },
+    {
+      "name": "heal_custom_dropdown",
+      "categories": ["act"]
+    },
+    {
+      "name": "agent/trivago",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/google_maps",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/google_maps_2",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/sign_in",
+      "categories": ["agent"]
+    },
+    {
+      "name": "osr_in_oopif",
+      "categories": ["act"]
+    },
+    {
+      "name": "csr_in_oopif",
+      "categories": ["act"]
+    },
+    {
+      "name": "csr_in_spif",
+      "categories": ["act"]
+    },
+    {
+      "name": "csr_in_spif",
+      "categories": ["act"]
+    },
+    {
+      "name": "spif_in_osr",
+      "categories": ["act"]
+    },
+    {
+      "name": "oopif_in_osr",
+      "categories": ["act"]
+    },
+    {
+      "name": "spif_in_csr",
+      "categories": ["act"]
+    },
+    {
+      "name": "oopif_in_csr",
+      "categories": ["act"]
+    },
+    {
+      "name": "osr_in_spif",
+      "categories": ["act"]
+    },
+    {
+      "name": "namespace_xpath",
+      "categories": ["act"]
+    },
+    {
+      "name": "iframe_scroll",
+      "categories": ["act"]
+    },
+    {
+      "name": "agent/gaia",
+      "categories": ["external_agent_benchmarks"]
+    },
+    {
+      "name": "agent/webvoyager",
+      "categories": ["external_agent_benchmarks"]
+    },
+    {
+      "name": "agent/nba_trades",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/hotel_booking",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/github",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/all_recipes",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/onlineMind2Web",
+      "categories": ["external_agent_benchmarks"]
+    },
+    {
+      "name": "agent/webtailbench",
+      "categories": ["external_agent_benchmarks"]
+    },
+    {
+      "name": "agent/alibaba_supplier_search",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/amazon_shoes_cart",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/columbia_tuition",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/flipkart_laptops",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/google_shopping",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/hotels_paris_amenities",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/instacart_organic_bananas",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/kfc_tenders_combo",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/made_in_china_supplier",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/nvidia_hgx_driver",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/oed_word_search",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/radiotimes_tv_schedule",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/redfin_apartment_rental",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/thegamer_opinion_article",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/trailhead_superbadge",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/trustpilot_hr_companies",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/uniqlo_mens_blazers",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/webmd_audiologist_search",
+      "categories": ["agent"]
+    },
+    {
+      "name": "agent/webmd_ovulation_calculator",
+      "categories": ["agent"]
+    }
+  ]
+}
diff --git a/packages/evals/index.eval.ts b/packages/evals/index.eval.ts
new file mode 100644
index 000000000..54b230db6
--- /dev/null
+++ b/packages/evals/index.eval.ts
@@ -0,0 +1,474 @@
+/**
+ * This script orchestrates the running of evaluations against a set of tasks.
+ * It uses Braintrust to run multiple testcases (each testcase representing a
+ * given task-model combination) and then aggregates the results, producing
+ * a summary of passes, failures, and categorized success rates.
+ *
+ * Overview:
+ * - Reads a configuration file `evals.config.json` to determine what tasks (evaluations)
+ *   are available and which categories they belong to.
+ * - Supports filtering which tasks to run either by evaluation category or by specific task name.
+ * - Supports multiple models, defaulting to certain sets of models depending on the category.
+ * - Runs each selected task against each selected model in parallel, collecting results.
+ * - Saves a summary of the evaluation results to `../../eval-summary.json`.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import {
+  DEFAULT_EVAL_CATEGORIES,
+  filterByCategory,
+  filterByEvalName,
+} from "./args.js";
+import { generateExperimentName } from "./utils.js";
+import { exactMatch, errorMatch } from "./scoring.js";
+import {
+  tasksByName,
+  tasksConfig,
+  getModelList,
+  getAgentModelEntries,
+} from "./taskConfig.js";
+import { Eval } from "braintrust";
+import { SummaryResult, Testcase, EvalInput } from "./types/evals.js";
+import { EvalLogger } from "./logger.js";
+import {
+  AvailableModel,
+  LLMClient,
+  StagehandEvalError,
+  AgentProvider,
+  loadApiKeyFromEnv,
+  LogLine,
+  getAISDKLanguageModel,
+} from "@browserbasehq/stagehand";
+import { AISdkClientWrapped } from "./lib/AISdkClientWrapped.js";
+import { env } from "./env.js";
+import { initV3 } from "./initV3.js";
+import { generateSummary } from "./summary.js";
+import { buildGAIATestcases } from "./suites/gaia.js";
+import { buildWebVoyagerTestcases } from "./suites/webvoyager.js";
+import { buildOnlineMind2WebTestcases } from "./suites/onlineMind2Web.js";
+import { endBrowserbaseSession } from "./browserbaseCleanup.js";
+import { buildWebTailBenchTestcases } from "./suites/webtailbench.js";
+import { getCurrentDirPath } from "./runtimePaths.js";
+
+import dotenv from "dotenv";
+dotenv.config();
+
+const moduleDir = getCurrentDirPath();
+
+/**
+ * Read max concurrency and trial count from environment variables set in args.ts.
+ * Fallback to defaults (20 and 5) if they're not provided.
+ */
+const MAX_CONCURRENCY = process.env.EVAL_MAX_CONCURRENCY
+  ? parseInt(process.env.EVAL_MAX_CONCURRENCY, 10)
+  : 3;
+
+const TRIAL_COUNT = process.env.EVAL_TRIAL_COUNT
+  ? parseInt(process.env.EVAL_TRIAL_COUNT, 10)
+  : 3;
+
+const USE_API: boolean = (process.env.USE_API ?? "").toLowerCase() === "true";
+console.log(`[EVALS] USE_API: ${USE_API}`);
+
+/**
+ * generateFilteredTestcases:
+ * Based on the chosen filters (category or specific eval name) and environment,
+ * this function generates the set of testcases to run. Each testcase is a combination
+ * of a task and a model.
+ *
+ * Steps:
+ * - Dynamically determine the list of models based on filters.
+ * - Start with all combinations of tasks (from `tasksByName`) and the determined models.
+ * - Filter by category if a category filter was specified.
+ * - Filter by evaluation name if specified.
+ * - In the BROWSERBASE environment, exclude certain tasks that are not suitable.
+ */
+const generateFilteredTestcases = (): Testcase[] => {
+  let taskNamesToRun: string[];
+  let effectiveCategory: string | null = filterByCategory; // Start with the command-line filter
+
+  if (filterByEvalName) {
+    // If a specific task name is given, that's the only one we run
+    taskNamesToRun = [filterByEvalName];
+    // Check if this single task belongs to agent-related categories to override models
+    const taskCategories = tasksByName[filterByEvalName]?.categories || [];
+    if (
+      taskCategories.length === 1 &&
+      (taskCategories[0] === "agent" ||
+        taskCategories[0] === "external_agent_benchmarks")
+    ) {
+      // Treat this run as an agent category run for model selection
+      effectiveCategory = taskCategories[0];
+      console.log(
+        `Task ${filterByEvalName} is in ${taskCategories[0]} category, using agent models.`,
+      );
+    }
+  } else if (filterByCategory) {
+    // If filtering by category, get all tasks in that category
+    taskNamesToRun = Object.keys(tasksByName).filter((name) =>
+      tasksByName[name].categories.includes(filterByCategory!),
+    );
+  } else {
+    // If no specific task or category filter, run tasks from default categories
+    taskNamesToRun = Object.keys(tasksByName).filter((name) =>
+      DEFAULT_EVAL_CATEGORIES.some((category) =>
+        tasksByName[name].categories.includes(category),
+      ),
+    );
+  }
+
+  // Dynamically determine the MODELS based on the effective category
+  const currentModels = getModelList(effectiveCategory);
+
+  console.log(
+    `Using models for this run (${effectiveCategory || "default"}):`,
+    currentModels,
+  );
+
+  // Check for dataset filter from environment
+  const datasetFilter = process.env.EVAL_DATASET;
+
+  // Special handling: fan out GAIA dataset for agent/gaia
+  const isGAIATaskIncluded = taskNamesToRun.includes("agent/gaia");
+  // Special handling: fan out WebVoyager dataset for agent/webvoyager
+  const isWebVoyagerTaskIncluded = taskNamesToRun.includes("agent/webvoyager");
+  // Special handling: fan out Mind2Web dataset for agent/onlineMind2Web
+  const isMind2WebTaskIncluded = taskNamesToRun.includes(
+    "agent/onlineMind2Web",
+  );
+
+  let allTestcases: Testcase[] = [];
+
+  // Only include GAIA if no dataset filter or if gaia is selected
+  if (isGAIATaskIncluded && (!datasetFilter || datasetFilter === "gaia")) {
+    taskNamesToRun = taskNamesToRun.filter((t) => t !== "agent/gaia");
+    allTestcases.push(...buildGAIATestcases(currentModels));
+  } else if (isGAIATaskIncluded && datasetFilter && datasetFilter !== "gaia") {
+    // Remove GAIA from tasks to run if dataset filter excludes it
+    taskNamesToRun = taskNamesToRun.filter((t) => t !== "agent/gaia");
+  }
+
+  // Only include WebVoyager if no dataset filter or if webvoyager is selected
+  if (
+    isWebVoyagerTaskIncluded &&
+    (!datasetFilter || datasetFilter === "webvoyager")
+  ) {
+    taskNamesToRun = taskNamesToRun.filter((t) => t !== "agent/webvoyager");
+    allTestcases.push(...buildWebVoyagerTestcases(currentModels));
+  } else if (
+    isWebVoyagerTaskIncluded &&
+    datasetFilter &&
+    datasetFilter !== "webvoyager"
+  ) {
+    // Remove WebVoyager from tasks to run if dataset filter excludes it
+    taskNamesToRun = taskNamesToRun.filter((t) => t !== "agent/webvoyager");
+  }
+
+  // Only include Mind2Web if no dataset filter or if onlineMind2Web is selected
+  if (
+    isMind2WebTaskIncluded &&
+    (!datasetFilter || datasetFilter === "onlineMind2Web")
+  ) {
+    taskNamesToRun = taskNamesToRun.filter((t) => t !== "agent/onlineMind2Web");
+    allTestcases.push(...buildOnlineMind2WebTestcases(currentModels));
+  } else if (
+    isMind2WebTaskIncluded &&
+    datasetFilter &&
+    datasetFilter !== "onlineMind2Web"
+  ) {
+    // Remove Mind2Web from tasks to run if dataset filter excludes it
+    taskNamesToRun = taskNamesToRun.filter((t) => t !== "agent/onlineMind2Web");
+  }
+
+  // Special handling: fan out WebTailBench dataset for agent/webtailbench
+  const isWebTailBenchTaskIncluded =
+    taskNamesToRun.includes("agent/webtailbench");
+
+  if (
+    isWebTailBenchTaskIncluded &&
+    (!datasetFilter || datasetFilter === "webtailbench")
+  ) {
+    taskNamesToRun = taskNamesToRun.filter((t) => t !== "agent/webtailbench");
+    allTestcases.push(...buildWebTailBenchTestcases(currentModels));
+  } else if (
+    isWebTailBenchTaskIncluded &&
+    datasetFilter &&
+    datasetFilter !== "webtailbench"
+  ) {
+    taskNamesToRun = taskNamesToRun.filter((t) => t !== "agent/webtailbench");
+  }
+
+  // Create a list of all remaining testcases using the determined task names and models
+  const isAgentCategory =
+    effectiveCategory === "agent" ||
+    effectiveCategory === "external_agent_benchmarks";
+
+  // Use agent model entries (with cua flag) for agent categories, otherwise map currentModels
+  const modelEntries = isAgentCategory
+    ? getAgentModelEntries()
+    : currentModels.map((m) => ({ modelName: m, cua: false }));
+
+  const regularTestcases = modelEntries.flatMap((entry) =>
+    taskNamesToRun.map((testName) => ({
+      input: {
+        name: testName,
+        modelName: entry.modelName as AvailableModel,
+        ...(isAgentCategory && { isCUA: entry.cua }),
+      },
+      name: testName,
+      tags: [
+        entry.modelName,
+        ...(isAgentCategory ? [entry.cua ? "cua" : "agent"] : []),
+        testName,
+        ...(tasksConfig.find((t) => t.name === testName)?.categories || []).map(
+          (x) => `category/${x}`,
+        ),
+      ],
+      metadata: {
+        model: entry.modelName as AvailableModel,
+        test: testName,
+      },
+      expected: true,
+    })),
+  );
+
+  allTestcases = [...allTestcases, ...regularTestcases];
+
+  // This filtering step might now be redundant if taskNamesToRun is already filtered
+  if (filterByCategory) {
+    allTestcases = allTestcases.filter((testcase) =>
+      tasksByName[testcase.name].categories.includes(filterByCategory!),
+    );
+  }
+
+  // If running in BROWSERBASE environment, exclude tasks that are not applicable.
+  if (env === "BROWSERBASE") {
+    allTestcases = allTestcases.filter(
+      (testcase) => !["peeler_simple", "stock_x"].includes(testcase.name),
+    );
+  }
+
+  console.log(
+    "Final test cases to run:",
+    allTestcases
+      .map(
+        (t, i) =>
+          `${i}: ${t.name} (${t.input.modelName}): ${tasksByName[t.name].categories}`,
+      )
+      .join("\n"),
+  );
+
+  return allTestcases;
+};
+
+/**
+ * Main execution block:
+ * - Determine experiment name
+ * - Determine the project name (braintrustProjectName) based on CI or dev environment
+ * - Run the Eval function with the given configuration:
+ *    * experimentName: A label for this run
+ *    * data: A function that returns the testcases to run
+ *    * task: A function that executes each task, given input specifying model and task name
+ *    * scores: An array of scoring functions
+ *    * maxConcurrency: Limit on parallel tasks
+ *    * trialCount: Number of trials (retries) per task
+ * - Collect and summarize results using `generateSummary`.
+ */
+(async () => {
+  // Generate a unique name for the experiment
+  const experimentName: string = generateExperimentName({
+    evalName: filterByEvalName || undefined,
+    category: filterByCategory || undefined,
+    environment: env,
+  });
+
+  // Determine braintrust project name to use (stagehand in CI, stagehand-dev otherwise)
+  const braintrustProjectName =
+    process.env.CI === "true" ? "stagehand" : "stagehand-dev";
+
+  try {
+    // Run the evaluations with the braintrust Eval function
+    const evalResult = await Eval(braintrustProjectName, {
+      experimentName,
+      data: generateFilteredTestcases,
+      // Each test is a function that runs the corresponding task module
+      task: async (input: EvalInput) => {
+        const logger = new EvalLogger();
+        // Track V3 instance at outer scope to ensure cleanup in all cases
+        let v3Input: Awaited<ReturnType<typeof initV3>> | undefined;
+        let v3ToClose: Awaited<ReturnType<typeof initV3>>["v3"] | null = null;
+
+        try {
+          const taskBasePath = path.join(moduleDir, "tasks", input.name);
+          const taskCandidates = [`${taskBasePath}.js`, `${taskBasePath}.ts`];
+          const taskModulePath = taskCandidates.find((candidate) =>
+            fs.existsSync(candidate),
+          );
+
+          if (!taskModulePath) {
+            throw new StagehandEvalError(
+              `Failed to find task module for ${input.name}. Tried paths:\n` +
+                taskCandidates.map((candidate) => `- ${candidate}`).join("\n"),
+            );
+          }
+
+          const taskModule = await import(pathToFileURL(taskModulePath).href);
+
+          // Extract the task function
+          const taskName = input.name.includes("/")
+            ? input.name.split("/").pop() // Get the last part of the path for nested tasks
+            : input.name;
+
+          const taskFunction = taskModule[taskName];
+
+          if (typeof taskFunction !== "function") {
+            throw new StagehandEvalError(
+              `No Eval function found for task name: ${taskName} in module ${input.name}`,
+            );
+          }
+
+          // Execute the task
+          const isAgentTask =
+            input.name.startsWith("agent/") || input.name.includes("/agent/");
+          if (USE_API) {
+            // Derive provider from model. Prefer explicit "provider/model"; otherwise infer for agent models
+            let provider: string;
+            if (input.modelName.includes("/")) {
+              provider = input.modelName.split("/")[0];
+            } else {
+              // Fall back to agent provider inference for bare agent model names (e.g., "computer-use-preview")
+              try {
+                provider = AgentProvider.getAgentProvider(input.modelName);
+              } catch {
+                // If not an agent model, leave provider undefined to trigger helpful error below
+                provider = undefined as unknown as string;
+              }
+            }
+
+            const logFn = (line: LogLine): void => logger.log(line);
+            const apiKey = loadApiKeyFromEnv(provider, logFn);
+
+            if (!apiKey) {
+              throw new StagehandEvalError(
+                `USE_API=true but no API key found for provider “${provider}”.`,
+              );
+            }
+
+            // taskInput = await initStagehand({
+            //   logger,
+            //   modelName: input.modelName,
+            //   modelClientOptions: { apiKey: apiKey },
+            // });
+            // Also initialize V3 so tasks can migrate to it progressively
+            v3Input = await initV3({
+              logger,
+              modelName: input.modelName,
+              modelClientOptions: { apiKey: apiKey },
+              createAgent: isAgentTask,
+              isCUA: input.isCUA,
+            });
+            v3ToClose = v3Input.v3;
+          } else {
+            let llmClient: LLMClient;
+            if (input.modelName.includes("/")) {
+              const firstSlashIndex = input.modelName.indexOf("/");
+              llmClient = new AISdkClientWrapped({
+                model: getAISDKLanguageModel(
+                  input.modelName.substring(0, firstSlashIndex),
+                  input.modelName.substring(firstSlashIndex + 1),
+                ),
+              });
+            }
+            v3Input = await initV3({
+              logger,
+              llmClient,
+              modelName: input.modelName,
+              createAgent: isAgentTask,
+              isCUA: input.isCUA,
+            });
+            v3ToClose = v3Input.v3;
+          }
+          // Pass full EvalInput to the task (data-driven params available via input.params)
+          const result = await taskFunction({ ...v3Input, input });
+
+          // Log result to console
+          if (result && result._success) {
+            console.log(`✅ ${input.name}: Passed`);
+          } else {
+            console.log(`❌ ${input.name}: Failed`);
+          }
+
+          return result;
+        } catch (error) {
+          // Log any errors that occur during task execution
+          console.error(`❌ ${input.name}: Error - ${error}`);
+          logger.error({
+            message: `Error in task ${input.name}`,
+            level: 0,
+            auxiliary: {
+              error: {
+                value: error.message,
+                type: "string",
+              },
+              trace: {
+                value: error.stack,
+                type: "string",
+              },
+            },
+          });
+          return {
+            _success: false,
+            error: JSON.parse(JSON.stringify(error, null, 2)),
+            logs: logger.getLogs(),
+          };
+        } finally {
+          // Always close V3 instance, regardless of success or failure.
+          // This ensures proper cleanup even if the task threw an error or
+          // the Browserbase session disconnected mid-execution.
+          if (v3Input?.v3) {
+            try {
+              await v3Input.v3.close();
+            } catch (closeError) {
+              // Log but don't throw - we don't want close errors to mask
+              // the original task result or prevent subsequent evals
+              console.error(
+                `Warning: Error closing V3 instance for ${input.name}:`,
+                closeError,
+              );
+            }
+          }
+          await endBrowserbaseSession(v3ToClose);
+          // Clear logger to free memory (logs already captured in result)
+          logger.clear();
+        }
+      },
+      // Use the scoring functions defined above
+      scores: [exactMatch, errorMatch],
+      maxConcurrency: MAX_CONCURRENCY,
+      trialCount: TRIAL_COUNT,
+    });
+
+    // Map results to the SummaryResult format
+    const summaryResults: SummaryResult[] = evalResult.results.map((result) => {
+      const output =
+        typeof result.output === "boolean"
+          ? { _success: result.output }
+          : result.output;
+
+      return {
+        input: result.input,
+        output,
+        name: result.input.name,
+        score: output._success ? 1 : 0,
+      };
+    });
+
+    // Generate and write the summary
+    await generateSummary(summaryResults, experimentName);
+  } catch (error) {
+    console.error("Error during evaluation run:", error);
+    process.exit(1);
+  }
+})();
diff --git a/packages/evals/initV3.ts b/packages/evals/initV3.ts
new file mode 100644
index 000000000..075252471
--- /dev/null
+++ b/packages/evals/initV3.ts
@@ -0,0 +1,173 @@
+/**
+ * Initializes a V3 instance for use in evaluations without modifying
+ * the existing Stagehand-based init flow. Tasks can gradually migrate
+ * to consume `v3` directly.
+ */
+
+import type {
+  AvailableCuaModel,
+  AvailableModel,
+  AgentInstance,
+  ClientOptions,
+  LLMClient,
+  LocalBrowserLaunchOptions,
+  ModelConfiguration,
+  V3Options,
+  AgentModelConfig,
+} from "@browserbasehq/stagehand";
+import {
+  loadApiKeyFromEnv,
+  modelToAgentProviderMap,
+  V3,
+} from "@browserbasehq/stagehand";
+import { env } from "./env.js";
+import { EvalLogger } from "./logger.js";
+
+type InitV3Args = {
+  llmClient?: LLMClient;
+  modelClientOptions?: ClientOptions;
+  domSettleTimeoutMs?: number; // retained for parity; v3 handlers accept timeouts per-call
+  logger: EvalLogger;
+  createAgent?: boolean; // only create an agent for agent tasks
+  isCUA?: boolean;
+  configOverrides?: {
+    localBrowserLaunchOptions?: Partial<
+      Pick<LocalBrowserLaunchOptions, "headless" | "args">
+    >;
+    // Back-compat alias for args
+    chromeFlags?: string[];
+    browserbaseSessionCreateParams?: V3Options["browserbaseSessionCreateParams"];
+    browserbaseSessionID?: V3Options["browserbaseSessionID"];
+    experimental?: boolean;
+  };
+  actTimeoutMs?: number; // retained for parity (v3 agent tools don't use this globally)
+  modelName: AvailableModel;
+};
+
+export type V3InitResult = {
+  v3: V3;
+  logger: EvalLogger;
+  debugUrl?: string; // not exposed by v3; placeholder for parity
+  sessionUrl?: string; // not exposed by v3; placeholder for parity
+  modelName: AvailableModel;
+  agent?: AgentInstance;
+};
+
+export async function initV3({
+  llmClient,
+  modelClientOptions,
+  logger,
+  configOverrides,
+  modelName,
+  createAgent,
+  isCUA,
+}: InitV3Args): Promise<V3InitResult> {
+  // If CUA, choose a safe internal AISDK model for V3 handlers based on available API keys
+  let internalModel: AvailableModel = modelName;
+  if (isCUA) {
+    if (process.env.OPENAI_API_KEY)
+      internalModel = "openai/gpt-4.1-mini" as AvailableModel;
+    else if (
+      process.env.GEMINI_API_KEY ||
+      process.env.GOOGLE_GENERATIVE_AI_API_KEY
+    )
+      internalModel = "google/gemini-2.0-flash" as AvailableModel;
+    else if (process.env.ANTHROPIC_API_KEY)
+      internalModel = "anthropic/claude-sonnet-4-6" as AvailableModel;
+    else
+      throw new Error(
+        "V3 init: No AISDK API key found. Set one of OPENAI_API_KEY, GEMINI_API_KEY/GOOGLE_GENERATIVE_AI_API_KEY, or ANTHROPIC_API_KEY to run CUA evals.",
+      );
+  }
+
+  const resolvedModelConfig: ModelConfiguration =
+    !isCUA && modelClientOptions
+      ? ({
+          ...modelClientOptions,
+          modelName: internalModel,
+        } as ModelConfiguration)
+      : internalModel;
+
+  const v3Options: V3Options = {
+    env,
+    apiKey: process.env.BROWSERBASE_API_KEY,
+    projectId: process.env.BROWSERBASE_PROJECT_ID,
+    localBrowserLaunchOptions: {
+      headless: configOverrides?.localBrowserLaunchOptions?.headless ?? false,
+      args:
+        configOverrides?.localBrowserLaunchOptions?.args ??
+        configOverrides?.chromeFlags,
+    },
+    model: resolvedModelConfig,
+    experimental:
+      typeof configOverrides?.experimental === "boolean"
+        ? configOverrides.experimental && process.env.USE_API !== "true" // experimental only when not using API
+        : false,
+    verbose: 2,
+    browserbaseSessionCreateParams:
+      configOverrides?.browserbaseSessionCreateParams,
+    browserbaseSessionID: configOverrides?.browserbaseSessionID,
+    selfHeal: true,
+    disablePino: true,
+    disableAPI: process.env.USE_API !== "true", // Negate: USE_API=true → disableAPI=false
+    serverCache: false,
+    logger: logger.log.bind(logger),
+  };
+
+  if (!isCUA && llmClient) {
+    v3Options.llmClient = llmClient;
+  }
+
+  const v3 = new V3(v3Options);
+
+  // Associate the logger with the V3 instance
+  logger.init(v3);
+  await v3.init();
+
+  let agent: AgentInstance | undefined;
+  if (createAgent) {
+    if (isCUA) {
+      const shortModelName = modelName.includes("/")
+        ? modelName.split("/")[1]
+        : modelName;
+
+      const providerType = modelToAgentProviderMap[shortModelName];
+      if (!providerType) {
+        throw new Error(
+          `CUA model "${shortModelName}" not found in modelToAgentProviderMap. ` +
+            `Available: ${Object.keys(modelToAgentProviderMap).join(", ")}`,
+        );
+      }
+
+      const apiKey = loadApiKeyFromEnv(providerType, logger.log.bind(logger));
+
+      const cuaModel: AvailableCuaModel | AgentModelConfig<AvailableCuaModel> =
+        apiKey && apiKey.length > 0
+          ? {
+              modelName: modelName as AvailableCuaModel,
+              apiKey,
+            }
+          : (modelName as AvailableCuaModel);
+
+      agent = v3.agent({
+        cua: true,
+        model: cuaModel,
+        systemPrompt: `You are a helpful assistant that must solve the task by browsing. At the end, produce a single line: "Final Answer: <answer>" summarizing the requested result (e.g., score, list, or text). ALWAYS OPERATE WITHIN THE PAGE OPENED BY THE USER, YOU WILL ALWAYS BE PROVIDED WITH AN OPENED PAGE, WHICHEVER TASK YOU ARE ATTEMPTING TO COMPLETE CAN BE ACCOMPLISHED WITHIN THE PAGE. Simple perform the task provided, do not overthink or overdo it. The user trusts you to complete the task without any additional instructions, or answering any questions.`,
+      });
+    } else {
+      agent = v3.agent({
+        model: modelName,
+        executionModel: "google/gemini-2.5-flash",
+      });
+    }
+  }
+
+  return {
+    v3,
+    logger,
+    debugUrl: "",
+    sessionUrl: "",
+    modelName,
+    agent,
+  };
+}
diff --git a/packages/evals/lib/AISdkClientWrapped.ts b/packages/evals/lib/AISdkClientWrapped.ts
new file mode 100644
index 000000000..4a231a431
--- /dev/null
+++ b/packages/evals/lib/AISdkClientWrapped.ts
@@ -0,0 +1,339 @@
+import {
+  CoreAssistantMessage,
+  ModelMessage,
+  CoreSystemMessage,
+  CoreUserMessage,
+  ImagePart,
+  NoObjectGeneratedError,
+  TextPart,
+  ToolSet,
+  Tool,
+} from "ai";
+import * as ai from "ai";
+import { wrapAISDK } from "braintrust";
+import type { LanguageModelV2 } from "@ai-sdk/provider";
+import { ChatCompletion } from "openai/resources";
+import {
+  AvailableModel,
+  CreateChatCompletionOptions,
+  LLMClient,
+  LogLine,
+  toJsonSchema,
+} from "@browserbasehq/stagehand";
+
+// Wrap AI SDK functions with Braintrust for tracing
+const { generateObject, generateText } = wrapAISDK(ai);
+
+export class AISdkClientWrapped extends LLMClient {
+  public type = "aisdk" as const;
+  private model: LanguageModelV2;
+  private logger?: (message: LogLine) => void;
+
+  constructor({
+    model,
+    logger,
+  }: {
+    model: LanguageModelV2;
+    logger?: (message: LogLine) => void;
+  }) {
+    super(model.modelId as AvailableModel);
+    this.model = model;
+    this.logger = logger;
+  }
+
+  public getLanguageModel(): LanguageModelV2 {
+    return this.model;
+  }
+
+  async createChatCompletion<T = ChatCompletion>({
+    options,
+  }: CreateChatCompletionOptions): Promise<T> {
+    this.logger?.({
+      category: "aisdk",
+      message: "creating chat completion",
+      level: 2,
+      auxiliary: {
+        options: {
+          value: JSON.stringify({
+            ...options,
+            image: undefined,
+            messages: options.messages.map((msg) => ({
+              ...msg,
+              content: Array.isArray(msg.content)
+                ? msg.content.map((c) =>
+                    "image_url" in c
+                      ? { ...c, image_url: { url: "[IMAGE_REDACTED]" } }
+                      : c,
+                  )
+                : msg.content,
+            })),
+          }),
+          type: "object",
+        },
+        modelName: {
+          value: this.model.modelId,
+          type: "string",
+        },
+      },
+    });
+
+    const formattedMessages: ModelMessage[] = options.messages.map(
+      (message) => {
+        if (Array.isArray(message.content)) {
+          if (message.role === "system") {
+            const systemMessage: CoreSystemMessage = {
+              role: "system",
+              content: message.content
+                .map((c) => ("text" in c ? c.text : ""))
+                .join("\n"),
+            };
+            return systemMessage;
+          }
+
+          const contentParts = message.content.map((content) => {
+            if ("image_url" in content) {
+              const imageContent: ImagePart = {
+                type: "image",
+                image: content.image_url.url,
+              };
+              return imageContent;
+            } else {
+              const textContent: TextPart = {
+                type: "text",
+                text: content.text,
+              };
+              return textContent;
+            }
+          });
+
+          if (message.role === "user") {
+            const userMessage: CoreUserMessage = {
+              role: "user",
+              content: contentParts,
+            };
+            return userMessage;
+          } else {
+            const textOnlyParts = contentParts.map((part) => ({
+              type: "text" as const,
+              text: part.type === "image" ? "[Image]" : part.text,
+            }));
+            const assistantMessage: CoreAssistantMessage = {
+              role: "assistant",
+              content: textOnlyParts,
+            };
+            return assistantMessage;
+          }
+        }
+
+        return {
+          role: message.role,
+          content: message.content,
+        };
+      },
+    );
+
+    let objectResponse: Awaited<ReturnType<typeof generateObject>>;
+    const isGPT5 = this.model.modelId.includes("gpt-5");
+    const isCodex = this.model.modelId.includes("codex");
+    const usesLowReasoningEffort =
+      (this.model.modelId.includes("gpt-5.1") ||
+        this.model.modelId.includes("gpt-5.2")) &&
+      !isCodex;
+    const isDeepSeek = this.model.modelId.includes("deepseek");
+    // Kimi models only support temperature=1
+    const isKimi = this.model.modelId.includes("kimi");
+    const temperature = isKimi ? 1 : options.temperature;
+    if (options.response_model) {
+      if (isDeepSeek || isKimi) {
+        const parsedSchema = JSON.stringify(
+          toJsonSchema(options.response_model.schema),
+        );
+
+        formattedMessages.push({
+          role: "user",
+          content: `Respond in this zod schema format:\n${parsedSchema}\n
+You must respond in JSON format. respond WITH JSON. Do not include any other text, formatting or markdown in your output. Do not include \`\`\` or \`\`\`json in your response. Only the JSON object itself.`,
+        });
+      }
+
+      try {
+        objectResponse = await generateObject({
+          model: this.model,
+          messages: formattedMessages,
+          schema: options.response_model.schema,
+          temperature,
+          providerOptions: isGPT5
+            ? {
+                openai: {
+                  textVerbosity: isCodex ? "medium" : "low", // codex models only support 'medium'
+                  reasoningEffort: isCodex
+                    ? "medium"
+                    : usesLowReasoningEffort
+                      ? "low"
+                      : "minimal",
+                },
+              }
+            : undefined,
+        });
+      } catch (err) {
+        if (NoObjectGeneratedError.isInstance(err)) {
+          this.logger?.({
+            category: "AISDK error",
+            message: err.message,
+            level: 0,
+            auxiliary: {
+              cause: {
+                value: JSON.stringify(err.cause ?? {}),
+                type: "object",
+              },
+              text: {
+                value: err.text ?? "",
+                type: "string",
+              },
+              response: {
+                value: JSON.stringify(err.response ?? {}),
+                type: "object",
+              },
+              usage: {
+                value: JSON.stringify(err.usage ?? {}),
+                type: "object",
+              },
+              finishReason: {
+                value: err.finishReason ?? "unknown",
+                type: "string",
+              },
+              requestId: {
+                value: options.requestId,
+                type: "string",
+              },
+            },
+          });
+
+          throw err;
+        }
+        throw err;
+      }
+
+      const result = {
+        data: objectResponse.object,
+        usage: {
+          prompt_tokens: objectResponse.usage.inputTokens ?? 0,
+          completion_tokens: objectResponse.usage.outputTokens ?? 0,
+          reasoning_tokens: objectResponse.usage.reasoningTokens ?? 0,
+          cached_input_tokens: objectResponse.usage.cachedInputTokens ?? 0,
+          total_tokens: objectResponse.usage.totalTokens ?? 0,
+        },
+      } as T;
+
+      this.logger?.({
+        category: "aisdk",
+        message: "response",
+        level: 1,
+        auxiliary: {
+          response: {
+            value: JSON.stringify({
+              object: objectResponse.object,
+              usage: objectResponse.usage,
+              finishReason: objectResponse.finishReason,
+              // Omit request and response properties that might contain images
+            }),
+            type: "object",
+          },
+          requestId: {
+            value: options.requestId,
+            type: "string",
+          },
+        },
+      });
+
+      return result;
+    }
+
+    const tools: ToolSet = {};
+    if (options.tools && options.tools.length > 0) {
+      for (const tool of options.tools) {
+        tools[tool.name] = {
+          description: tool.description,
+          inputSchema: tool.parameters,
+        } as Tool;
+      }
+    }
+
+    const textResponse = await generateText({
+      model: this.model,
+      messages: formattedMessages,
+      tools: Object.keys(tools).length > 0 ? tools : undefined,
+      toolChoice:
+        Object.keys(tools).length > 0
+          ? options.tool_choice === "required"
+            ? "required"
+            : options.tool_choice === "none"
+              ? "none"
+              : "auto"
+          : undefined,
+      temperature,
+    });
+
+    // Transform AI SDK response to match LLMResponse format expected by operator handler
+    const transformedToolCalls = (textResponse.toolCalls || []).map(
+      (toolCall) => ({
+        id:
+          toolCall.toolCallId ||
+          `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+        type: "function",
+        function: {
+          name: toolCall.toolName,
+          arguments: JSON.stringify(toolCall.input),
+        },
+      }),
+    );
+
+    const result = {
+      id: `chatcmpl_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      object: "chat.completion",
+      created: Math.floor(Date.now() / 1000),
+      model: this.model.modelId,
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: "assistant",
+            content: textResponse.text || null,
+            tool_calls: transformedToolCalls,
+          },
+          finish_reason: textResponse.finishReason || "stop",
+        },
+      ],
+      usage: {
+        prompt_tokens: textResponse.usage.inputTokens ?? 0,
+        completion_tokens: textResponse.usage.outputTokens ?? 0,
+        reasoning_tokens: textResponse.usage.reasoningTokens ?? 0,
+        cached_input_tokens: textResponse.usage.cachedInputTokens ?? 0,
+        total_tokens: textResponse.usage.totalTokens ?? 0,
+      },
+    } as T;
+
+    this.logger?.({
+      category: "aisdk",
+      message: "response",
+      level: 2,
+      auxiliary: {
+        response: {
+          value: JSON.stringify({
+            text: textResponse.text,
+            usage: textResponse.usage,
+            finishReason: textResponse.finishReason,
+            // Omit request and response properties that might contain images
+          }),
+          type: "object",
+        },
+        requestId: {
+          value: options.requestId,
+          type: "string",
+        },
+      },
+    });
+
+    return result;
+  }
+}
diff --git a/packages/evals/llm_clients/hn_aisdk.ts b/packages/evals/llm_clients/hn_aisdk.ts
new file mode 100644
index 000000000..f69211e85
--- /dev/null
+++ b/packages/evals/llm_clients/hn_aisdk.ts
@@ -0,0 +1,115 @@
+// import { Stagehand } from "@browserbasehq/stagehand";
+// import { EvalFunction } from "@/types/evals";
+// import { z } from "zod";
+//
+// export const hn_aisdk: EvalFunction = async ({
+//   debugUrl,
+//   sessionUrl,
+//   stagehandConfig,
+//   logger,
+// }) => {
+//   const stagehand = new Stagehand({
+//     ...stagehandConfig,
+//     modelName: "openai/gpt-4o-mini",
+//   });
+//   await stagehand.init();
+//   await stagehand.page.goto(
+//     "https://browserbase.github.io/stagehand-eval-sites/sites/hackernews/",
+//   );
+//
+//   let { story } = await stagehand.page.extract({
+//     instruction: "extract the title of the top story on the page",
+//     schema: z.object({
+//       story: z.string().describe("the title of the top story on the page"),
+//     }),
+//   });
+//   // remove the (url) part of the story title
+//   story = story.split(" (")[0];
+//
+//   const expectedStoryElement = await stagehand.page.$(
+//     "xpath=/html/body/center/table/tbody/tr[3]/td/table/tbody/tr[1]/td[3]/span/a",
+//   );
+//   // remove the (url) part of the story title
+//   const expectedStory = (await expectedStoryElement?.textContent())?.split(
+//     " (",
+//   )?.[0];
+//
+//   if (!expectedStory) {
+//     logger.error({
+//       message: "Could not find expected story element",
+//       level: 0,
+//     });
+//     return {
+//       _success: false,
+//       error: "Could not find expected story element",
+//       debugUrl,
+//       sessionUrl,
+//       logs: logger.getLogs(),
+//     };
+//   }
+//
+//   if (story !== expectedStory) {
+//     logger.error({
+//       message: "Extracted story does not match expected story",
+//       level: 0,
+//       auxiliary: {
+//         expected: {
+//           value: expectedStory,
+//           type: "string",
+//         },
+//         actual: {
+//           value: story,
+//           type: "string",
+//         },
+//       },
+//     });
+//     return {
+//       _success: false,
+//       error: "Extracted story does not match expected story",
+//       expectedStory,
+//       actualStory: story,
+//       debugUrl,
+//       sessionUrl,
+//       logs: logger.getLogs(),
+//     };
+//   }
+//
+//   await stagehand.page.act("Click on the 'new' tab");
+//
+//   if (stagehand.page.url() !== "https://news.ycombinator.com/newest") {
+//     logger.error({
+//       message: "Page did not navigate to the 'new' tab",
+//       level: 0,
+//       auxiliary: {
+//         expected: {
+//           value: "https://news.ycombinator.com/newest",
+//           type: "string",
+//         },
+//         actual: {
+//           value: stagehand.page.url(),
+//           type: "string",
+//         },
+//       },
+//     });
+//     return {
+//       _success: false,
+//       error: "Page did not navigate to the 'new' tab",
+//       expectedUrl: "https://news.ycombinator.com/newest",
+//       actualUrl: stagehand.page.url(),
+//       debugUrl,
+//       sessionUrl,
+//       logs: logger.getLogs(),
+//     };
+//   }
+//
+//   await stagehand.close();
+//
+//   return {
+//     _success: true,
+//     expectedStory,
+//     actualStory: story,
+//     debugUrl,
+//     sessionUrl,
+//     logs: logger.getLogs(),
+//   };
+// };
diff --git a/packages/evals/llm_clients/hn_customOpenAI.ts b/packages/evals/llm_clients/hn_customOpenAI.ts
new file mode 100644
index 000000000..8dd35f31b
--- /dev/null
+++ b/packages/evals/llm_clients/hn_customOpenAI.ts
@@ -0,0 +1,124 @@
+// import { EvalFunction } from "@/types/evals";
+// import { z } from "zod";
+// import { CustomOpenAIClient } from "@/examples/external_clients/customOpenAI";
+// import OpenAI from "openai";
+// import { Stagehand } from "@browserbasehq/stagehand";
+//
+// export const hn_customOpenAI: EvalFunction = async ({
+//   logger,
+//   stagehandConfig,
+//   debugUrl,
+//   sessionUrl,
+// }) => {
+//   const stagehand = new Stagehand({
+//     ...stagehandConfig,
+//     llmClient: new CustomOpenAIClient({
+//       modelName: "gpt-4o-mini",
+//       client: new OpenAI({
+//         apiKey: process.env.OPENAI_API_KEY,
+//       }),
+//     }),
+//   });
+//
+//   await stagehand.init();
+//
+//   await stagehand.page.goto(
+//     "https://browserbase.github.io/stagehand-eval-sites/sites/hackernews/",
+//   );
+//
+//   let { story } = await stagehand.page.extract({
+//     instruction: "extract the title of the top story on the page",
+//     schema: z.object({
+//       story: z.string().describe("the title of the top story on the page"),
+//     }),
+//   });
+//   // remove the (url) part of the story title
+//   story = story.split(" (")[0];
+//
+//   const expectedStoryElement = await stagehand.page.$(
+//     "xpath=/html/body/center/table/tbody/tr[3]/td/table/tbody/tr[1]/td[3]/span/a",
+//   );
+//   // remove the (url) part of the story title
+//   const expectedStory = (await expectedStoryElement?.textContent())?.split(
+//     " (",
+//   )?.[0];
+//
+//   if (!expectedStory) {
+//     logger.error({
+//       message: "Could not find expected story element",
+//       level: 0,
+//     });
+//     return {
+//       _success: false,
+//       error: "Could not find expected story element",
+//       debugUrl,
+//       sessionUrl,
+//       logs: logger.getLogs(),
+//     };
+//   }
+//
+//   if (story !== expectedStory) {
+//     logger.error({
+//       message: "Extracted story does not match expected story",
+//       level: 0,
+//       auxiliary: {
+//         expected: {
+//           value: expectedStory,
+//           type: "string",
+//         },
+//         actual: {
+//           value: story,
+//           type: "string",
+//         },
+//       },
+//     });
+//     return {
+//       _success: false,
+//       error: "Extracted story does not match expected story",
+//       expectedStory,
+//       actualStory: story,
+//       debugUrl,
+//       sessionUrl,
+//       logs: logger.getLogs(),
+//     };
+//   }
+//
+//   await stagehand.page.act("Click on the 'new' tab");
+//
+//   if (stagehand.page.url() !== "https://news.ycombinator.com/newest") {
+//     logger.error({
+//       message: "Page did not navigate to the 'new' tab",
+//       level: 0,
+//       auxiliary: {
+//         expected: {
+//           value: "https://news.ycombinator.com/newest",
+//           type: "string",
+//         },
+//         actual: {
+//           value: stagehand.page.url(),
+//           type: "string",
+//         },
+//       },
+//     });
+//     return {
+//       _success: false,
+//       error: "Page did not navigate to the 'new' tab",
+//       expectedUrl: "https://news.ycombinator.com/newest",
+//       actualUrl: stagehand.page.url(),
+//       debugUrl,
+//       sessionUrl,
+//       logs: logger.getLogs(),
+//     };
+//   }
+//
+//   await stagehand.close();
+//
+//   return {
+//     _success: true,
+//     expectedStory,
+//     actualStory: story,
+//     debugUrl,
+//     sessionUrl,
+//     logs: logger.getLogs(),
+//   };
+// };
diff --git a/packages/evals/llm_clients/hn_langchain.ts b/packages/evals/llm_clients/hn_langchain.ts
new file mode 100644
index 000000000..a86fecb87
--- /dev/null
+++ b/packages/evals/llm_clients/hn_langchain.ts
@@ -0,0 +1,122 @@
+// import { EvalFunction } from "@/types/evals";
+// import { z } from "zod";
+// import { LangchainClient } from "@/examples/external_clients/langchain";
+// import { ChatOpenAI } from "@langchain/openai";
+// import { Stagehand } from "@browserbasehq/stagehand";
+//
+// export const hn_langchain: EvalFunction = async ({
+//   logger,
+//   stagehandConfig,
+//   debugUrl,
+//   sessionUrl,
+// }) => {
+//   const stagehand = new Stagehand({
+//     ...stagehandConfig,
+//     llmClient: new LangchainClient(
+//       new ChatOpenAI({
+//         model: "gpt-4o-mini",
+//       }),
+//     ),
+//   });
+//   await stagehand.init();
+//
+//   await stagehand.page.goto(
+//     "https://browserbase.github.io/stagehand-eval-sites/sites/hackernews/",
+//   );
+//
+//   let { story } = await stagehand.page.extract({
+//     instruction: "extract the title of the top story on the page",
+//     schema: z.object({
+//       story: z.string().describe("the title of the top story on the page"),
+//     }),
+//   });
+//   // remove the (url) part of the story title
+//   story = story.split(" (")[0];
+//
+//   const expectedStoryElement = await stagehand.page.$(
+//     "xpath=/html/body/center/table/tbody/tr[3]/td/table/tbody/tr[1]/td[3]/span/a",
+//   );
+//   // remove the (url) part of the story title
+//   const expectedStory = (await expectedStoryElement?.textContent())?.split(
+//     " (",
+//   )?.[0];
+//
+//   if (!expectedStory) {
+//     logger.error({
+//       message: "Could not find expected story element",
+//       level: 0,
+//     });
+//     return {
+//       _success: false,
+//       error: "Could not find expected story element",
+//       debugUrl,
+//       sessionUrl,
+//       logs: logger.getLogs(),
+//     };
+//   }
+//
+//   if (story !== expectedStory) {
+//     logger.error({
+//       message: "Extracted story does not match expected story",
+//       level: 0,
+//       auxiliary: {
+//         expected: {
+//           value: expectedStory,
+//           type: "string",
+//         },
+//         actual: {
+//           value: story,
+//           type: "string",
+//         },
+//       },
+//     });
+//     return {
+//       _success: false,
+//       error: "Extracted story does not match expected story",
+//       expectedStory,
+//       actualStory: story,
+//       debugUrl,
+//       sessionUrl,
+//       logs: logger.getLogs(),
+//     };
+//   }
+//
+//   await stagehand.page.act("Click on the 'new' tab");
+//
+//   if (stagehand.page.url() !== "https://news.ycombinator.com/newest") {
+//     logger.error({
+//       message: "Page did not navigate to the 'new' tab",
+//       level: 0,
+//       auxiliary: {
+//         expected: {
+//           value: "https://news.ycombinator.com/newest",
+//           type: "string",
+//         },
+//         actual: {
+//           value: stagehand.page.url(),
+//           type: "string",
+//         },
+//       },
+//     });
+//     return {
+//       _success: false,
+//       error: "Page did not navigate to the 'new' tab",
+//       expectedUrl: "https://news.ycombinator.com/newest",
+//       actualUrl: stagehand.page.url(),
+//       debugUrl,
+//       sessionUrl,
+//       logs: logger.getLogs(),
+//     };
+//   }
+//
+//   await stagehand.close();
+//
+//   return {
+//     _success: true,
+//     expectedStory,
+//     actualStory: story,
+//     debugUrl,
+//     sessionUrl,
+//     logs: logger.getLogs(),
+//   };
+// };
diff --git a/evals/logger.ts b/packages/evals/logger.ts
similarity index 89%
rename from evals/logger.ts
rename to packages/evals/logger.ts
index c234ada44..981a8e5b4 100644
--- a/evals/logger.ts
+++ b/packages/evals/logger.ts
@@ -10,9 +10,10 @@
  * all logs emitted during the evaluation process can be captured, persisted, and
  * reviewed after the tasks complete.
  */
-import { logLineToString } from "./utils";
-import { LogLineEval } from "@/types/evals";
-import { Stagehand, LogLine } from "@/dist";
+import { logLineToString } from "./utils.js";
+import { LogLineEval } from "./types/evals.js";
+import { LogLine } from "@browserbasehq/stagehand";
+import type { V3 } from "@browserbasehq/stagehand";
 
 /**
  * parseLogLine:
@@ -66,7 +67,7 @@ function parseLogLine(logLine: LogLine): LogLineEval {
  */
 export class EvalLogger {
   private logs: LogLineEval[] = [];
-  stagehand?: Stagehand;
+  stagehand?: V3;
 
   constructor() {
     this.logs = [];
@@ -77,7 +78,7 @@ export class EvalLogger {
    * Associates this logger with a given Stagehand instance.
    * This allows the logger to provide additional context if needed.
    */
-  init(stagehand: Stagehand) {
+  init(stagehand?: V3) {
     this.stagehand = stagehand;
   }
 
@@ -120,4 +121,14 @@ export class EvalLogger {
   getLogs(): LogLineEval[] {
     return this.logs || [];
   }
+
+  /**
+   * clear:
+   * Clears all stored logs to free memory.
+   * Should be called after logs have been retrieved and processed.
+   */
+  clear(): void {
+    this.logs = [];
+    this.stagehand = undefined;
+  }
 }
diff --git a/packages/evals/package.json b/packages/evals/package.json
new file mode 100644
index 000000000..0b90f922b
--- /dev/null
+++ b/packages/evals/package.json
@@ -0,0 +1,36 @@
+{
+  "name": "@browserbasehq/stagehand-evals",
+  "version": "1.1.8",
+  "private": true,
+  "description": "Evaluation suite for Stagehand",
+  "type": "module",
+  "main": "./",
+  "bin": {
+    "evals": "./dist/cli/cli.js"
+  },
+  "scripts": {
+    "typecheck": "pnpm -w --dir ../.. exec tsc -p packages/evals/tsconfig.json --noEmit",
+    "build": "pnpm --filter @browserbasehq/stagehand-evals run --parallel \"/^build:(esm|cli)$/\"",
+    "build:esm": "tsx scripts/build-esm.ts",
+    "build:cli": "tsx scripts/build-cli.ts",
+    "test": "pnpm -w --dir ../.. exec turbo run test:evals --filter=@browserbasehq/stagehand-evals --",
+    "test:evals": "tsx scripts/test-evals.ts --cli packages/evals/dist/cli/cli.js",
+    "lint": "pnpm -w --dir ../.. exec prettier --check packages/evals && pnpm -w --dir ../.. exec eslint packages/evals && pnpm run typecheck",
+    "format": "prettier --write ."
+  },
+  "dependencies": {
+    "@ai-sdk/provider": "^2.0.0",
+    "@browserbasehq/stagehand": "workspace:*",
+    "ai": "^5.0.133",
+    "dotenv": "^17.3.1",
+    "openai": "^4.87.1",
+    "sharp": "^0.34.5",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "braintrust": "^0.4.7",
+    "chalk": "^5.4.1",
+    "string-comparison": "^1.3.0",
+    "tsx": "*"
+  }
+}
diff --git a/packages/evals/run.ts b/packages/evals/run.ts
new file mode 100644
index 000000000..a524ee4b9
--- /dev/null
+++ b/packages/evals/run.ts
@@ -0,0 +1,24 @@
+import { spawnSync } from "node:child_process";
+import process from "node:process";
+import { getCurrentDirPath } from "./runtimePaths.js";
+
+const args: readonly string[] = process.argv.slice(2);
+const moduleDir = getCurrentDirPath();
+
+const wantsHelp: boolean = args.some((a) => /^(?:--?)?(?:h|help)$/i.test(a));
+const wantsMan: boolean = args.some((a) => /^(?:--?)?man$/i.test(a));
+
+// Skip build if just showing help
+if (!wantsHelp && !wantsMan) {
+  const build = spawnSync("pnpm", ["run", "build"], {
+    stdio: "inherit",
+    cwd: "../..",
+  });
+  if (build.status !== 0) process.exit(build.status ?? 1);
+}
+
+const run = spawnSync("tsx", ["index.eval.ts", ...args], {
+  stdio: "inherit",
+  cwd: moduleDir,
+});
+process.exit(run.status ?? 0);
diff --git a/packages/evals/runtimePaths.ts b/packages/evals/runtimePaths.ts
new file mode 100644
index 000000000..d624a815d
--- /dev/null
+++ b/packages/evals/runtimePaths.ts
@@ -0,0 +1,123 @@
+/**
+ * Keep this file in sync with:
+ * - /packages/core/lib/v3/runtimePaths.ts
+ * - /packages/server-v3/scripts/runtimePaths.ts
+ * - /packages/server-v4/scripts/runtimePaths.ts
+ * - /packages/evals/runtimePaths.ts
+ * - /packages/docs/scripts/runtimePaths.js
+ */
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+
+const PACKAGE_SEGMENT = "/packages/evals/";
+const EVAL_FRAMES = new Set(["[eval]", "[eval]-wrapper"]);
+const INTERNAL_FRAME_NAMES = new Set([
+  "readCallsites",
+  "readCallsitePath",
+  "resolveCallerFilePath",
+  "getCurrentFilePath",
+  "getCurrentDirPath",
+  "getRepoRootDir",
+  "getPackageRootDir",
+  "createRequireFromCaller",
+  "isMainModule",
+]);
+
+const normalizePath = (value: string): string => {
+  const input = value.startsWith("file://") ? fileURLToPath(value) : value;
+  return path.resolve(input).replaceAll("\\", "/");
+};
+
+const readCallsites = (): NodeJS.CallSite[] => {
+  const previousPrepare = Error.prepareStackTrace;
+  try {
+    Error.prepareStackTrace = (_, stack) => stack;
+    return (
+      (new Error().stack as unknown as NodeJS.CallSite[] | undefined) ?? []
+    );
+  } finally {
+    Error.prepareStackTrace = previousPrepare;
+  }
+};
+
+type CallSiteWithScriptName = NodeJS.CallSite & {
+  getScriptNameOrSourceURL?: () => string | null;
+};
+
+const readCallsitePath = (callsite: NodeJS.CallSite): string | null => {
+  const callsiteWithScript = callsite as CallSiteWithScriptName;
+  const rawPath =
+    callsite.getFileName() ?? callsiteWithScript.getScriptNameOrSourceURL?.();
+  if (!rawPath) return null;
+  if (rawPath.startsWith("node:")) return null;
+  if (EVAL_FRAMES.has(rawPath)) return null;
+  return normalizePath(rawPath);
+};
+
+const isInternalCallsite = (callsite: NodeJS.CallSite): boolean => {
+  const functionName = callsite.getFunctionName();
+  if (functionName && INTERNAL_FRAME_NAMES.has(functionName)) return true;
+
+  const methodName = callsite.getMethodName();
+  if (methodName && INTERNAL_FRAME_NAMES.has(methodName)) return true;
+
+  const callsiteString = callsite.toString();
+  for (const frameName of INTERNAL_FRAME_NAMES) {
+    if (callsiteString.includes(`${frameName} (`)) return true;
+    if (callsiteString.includes(`.${frameName} (`)) return true;
+  }
+  return false;
+};
+
+const resolveCallerFilePath = (): string => {
+  const packageCandidates: string[] = [];
+  const fallbackCandidates: string[] = [];
+
+  for (const callsite of readCallsites()) {
+    const filePath = readCallsitePath(callsite);
+    if (!filePath) continue;
+    if (isInternalCallsite(callsite)) continue;
+    if (filePath.includes(PACKAGE_SEGMENT)) {
+      packageCandidates.push(filePath);
+      continue;
+    }
+    fallbackCandidates.push(filePath);
+  }
+
+  const packageCandidate = packageCandidates[0];
+  if (packageCandidate) return packageCandidate;
+
+  const fallbackCandidate = fallbackCandidates[0];
+  if (fallbackCandidate) return fallbackCandidate;
+
+  throw new Error("Unable to resolve caller file path.");
+};
+
+export const getCurrentFilePath = (): string => resolveCallerFilePath();
+
+export const getCurrentDirPath = (): string =>
+  path.dirname(getCurrentFilePath());
+
+export const getRepoRootDir = (): string => {
+  const currentFilePath = getCurrentFilePath();
+  const index = currentFilePath.lastIndexOf(PACKAGE_SEGMENT);
+  if (index === -1) {
+    throw new Error(
+      `Unable to determine repo root from ${currentFilePath} (missing ${PACKAGE_SEGMENT}).`,
+    );
+  }
+  return currentFilePath.slice(0, index);
+};
+
+export const getPackageRootDir = (): string =>
+  `${getRepoRootDir()}${PACKAGE_SEGMENT.slice(0, -1)}`;
+
+export const createRequireFromCaller = () =>
+  createRequire(getCurrentFilePath());
+
+export const isMainModule = (): boolean => {
+  const entryScript = process.argv.at(1);
+  if (!entryScript) return false;
+  return normalizePath(entryScript) === getCurrentFilePath();
+};
diff --git a/evals/scoring.ts b/packages/evals/scoring.ts
similarity index 60%
rename from evals/scoring.ts
rename to packages/evals/scoring.ts
index 42552e5e1..b17ae4c64 100644
--- a/evals/scoring.ts
+++ b/packages/evals/scoring.ts
@@ -2,7 +2,39 @@
  * This file implements scoring functions needed by braintrust.
  */
 
-import { EvalArgs, EvalInput, EvalResult } from "@/types/evals";
+import { EvalArgs, EvalInput, EvalResult } from "./types/evals.js";
+
+function formatTaskOutput(output: unknown): string {
+  let value: string | undefined;
+  if (typeof output === "string") {
+    value = output;
+  } else if (output instanceof Error) {
+    value = output.stack ?? `${output.name}: ${output.message}`;
+  } else {
+    try {
+      value = JSON.stringify(output, (_key, current) => {
+        if (current instanceof Error) {
+          return {
+            name: current.name,
+            message: current.message,
+            stack: current.stack,
+          };
+        }
+        return current;
+      });
+    } catch {
+      value = undefined;
+    }
+    if (value === undefined) {
+      value = String(output);
+    }
+  }
+
+  if (value.length > 160) {
+    return `${value.slice(0, 157)}...`;
+  }
+  return value;
+}
 
 /**
  * Scoring function: exactMatch
@@ -16,7 +48,9 @@ import { EvalArgs, EvalInput, EvalResult } from "@/types/evals";
 export function exactMatch(
   args: EvalArgs<EvalInput, boolean | { _success: boolean }, unknown>,
 ): EvalResult {
-  console.log(`Task "${args.input.name}" returned: ${args.output}`);
+  console.log(
+    `Task "${args.input.name}" returned: ${formatTaskOutput(args.output)}`,
+  );
 
   const expected = args.expected ?? true;
   if (expected === true) {
@@ -53,7 +87,9 @@ export function errorMatch(
     unknown
   >,
 ): EvalResult {
-  console.log(`Task "${args.input.name}" returned: ${args.output}`);
+  console.log(
+    `Task "${args.input.name}" returned: ${formatTaskOutput(args.output)}`,
+  );
 
   return {
     name: "Error rate",
diff --git a/packages/evals/scripts/build-cli.ts b/packages/evals/scripts/build-cli.ts
new file mode 100644
index 000000000..1650fd43e
--- /dev/null
+++ b/packages/evals/scripts/build-cli.ts
@@ -0,0 +1,74 @@
+/**
+ * Build the evals CLI (packages/evals/dist/cli/cli.js + config), including a node shebang.
+ *
+ * Prereqs: pnpm install.
+ * Args: none.
+ * Env: none.
+ * Example: pnpm run build:cli
+ */
+import fs from "node:fs";
+import { spawnSync } from "node:child_process";
+import { getRepoRootDir } from "../runtimePaths.js";
+
+const repoRoot = getRepoRootDir();
+
+const run = (args: string[]) => {
+  const result = spawnSync("pnpm", args, { stdio: "inherit", cwd: repoRoot });
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
+  }
+};
+
+fs.mkdirSync(`${repoRoot}/packages/evals/dist/cli`, { recursive: true });
+
+run([
+  "exec",
+  "esbuild",
+  "packages/evals/cli.ts",
+  "--bundle",
+  "--platform=node",
+  "--format=esm",
+  `--outfile=${repoRoot}/packages/evals/dist/cli/cli.js`,
+  "--sourcemap",
+  "--packages=external",
+  "--banner:js=#!/usr/bin/env node",
+  "--log-level=warning",
+]);
+
+/* ── merge config: always update tasks/benchmarks from source, but preserve user defaults ── */
+const sourceConfig = JSON.parse(
+  fs.readFileSync(`${repoRoot}/packages/evals/evals.config.json`, "utf-8"),
+);
+const distConfigPath = `${repoRoot}/packages/evals/dist/cli/evals.config.json`;
+
+if (fs.existsSync(distConfigPath)) {
+  try {
+    const existing = JSON.parse(fs.readFileSync(distConfigPath, "utf-8"));
+    if (existing.defaults) {
+      sourceConfig.defaults = {
+        ...sourceConfig.defaults,
+        ...existing.defaults,
+      };
+    }
+  } catch {
+    // invalid existing config – overwrite entirely
+  }
+}
+
+fs.writeFileSync(distConfigPath, JSON.stringify(sourceConfig, null, 2) + "\n");
+fs.writeFileSync(
+  `${repoRoot}/packages/evals/dist/cli/package.json`,
+  '{\n  "type": "module"\n}\n',
+);
+fs.chmodSync(`${repoRoot}/packages/evals/dist/cli/cli.js`, 0o755);
+
+/* ── auto-link the `evals` binary globally ── */
+const link = spawnSync("npm", ["link", "--force"], {
+  stdio: "inherit",
+  cwd: `${repoRoot}/packages/evals`,
+});
+if (link.status !== 0) {
+  console.warn(
+    "⚠  npm link failed (non-fatal) – you can run `npm link` manually from packages/evals",
+  );
+}
diff --git a/packages/evals/scripts/build-esm.ts b/packages/evals/scripts/build-esm.ts
new file mode 100644
index 000000000..4100f6b34
--- /dev/null
+++ b/packages/evals/scripts/build-esm.ts
@@ -0,0 +1,53 @@
+/**
+ * Build canonical dist/esm output for evals (plus assets/config).
+ *
+ * Prereqs: pnpm install.
+ * Args: none.
+ * Env: none.
+ * Example: pnpm run build:esm
+ */
+import fs from "node:fs";
+import { spawnSync } from "node:child_process";
+import { getRepoRootDir } from "../runtimePaths.js";
+
+const repoRoot = getRepoRootDir();
+
+const run = (args: string[]) => {
+  const result = spawnSync("pnpm", args, { stdio: "inherit", cwd: repoRoot });
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
+  }
+};
+
+fs.rmSync(`${repoRoot}/packages/evals/dist/esm`, {
+  recursive: true,
+  force: true,
+});
+// Evals run from dist/esm JS, but still need config/assets/datasets on disk.
+run(["exec", "tsc", "-p", "packages/evals/tsconfig.json"]);
+
+fs.mkdirSync(`${repoRoot}/packages/evals/dist/esm`, { recursive: true });
+fs.writeFileSync(
+  `${repoRoot}/packages/evals/dist/esm/package.json`,
+  '{\n  "type": "module"\n}\n',
+);
+
+const copyFile = (filename: string) => {
+  const src = `${repoRoot}/packages/evals/${filename}`;
+  if (fs.existsSync(src)) {
+    fs.copyFileSync(src, `${repoRoot}/packages/evals/dist/esm/${filename}`);
+  }
+};
+
+const copyDir = (dirname: string) => {
+  const srcDir = `${repoRoot}/packages/evals/${dirname}`;
+  if (fs.existsSync(srcDir)) {
+    fs.cpSync(srcDir, `${repoRoot}/packages/evals/dist/esm/${dirname}`, {
+      recursive: true,
+    });
+  }
+};
+
+copyFile("evals.config.json");
+copyDir("datasets");
+copyDir("assets");
diff --git a/packages/evals/scripts/test-evals.ts b/packages/evals/scripts/test-evals.ts
new file mode 100644
index 000000000..f20ec86d0
--- /dev/null
+++ b/packages/evals/scripts/test-evals.ts
@@ -0,0 +1,305 @@
+/**
+ * Eval runs via the evals CLI from source or dist/esm.
+ *
+ * Prereqs: source mode uses tsx loader; dist mode requires compiled CLI output.
+ * Args: [target] [options...] (passed to evals run) | --cli <path> [target] [options...] | --list (prints JSON matrix).
+ * Env: STAGEHAND_BROWSER_TARGET=local|browserbase, NODE_V8_COVERAGE, NODE_OPTIONS;
+ *      writes JUnit to ctrf/evals/<target>.xml and CTRF to ctrf/evals/<target>.json.
+ * Example: STAGEHAND_BROWSER_TARGET=browserbase pnpm run test:evals -- act -t 3 -c 10
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { getCurrentFilePath, getRepoRootDir } from "../runtimePaths.js";
+
+type Runtime = "source" | "dist-esm";
+
+type EvalSummaryEntry = {
+  eval: string;
+  model: string;
+  categories?: string[];
+};
+
+type EvalSummary = {
+  passed?: EvalSummaryEntry[];
+  failed?: EvalSummaryEntry[];
+};
+
+const toSafeName = (name: string) => name.replace(/[\\/]/g, "-");
+
+const readEvalSummary = (summaryPath: string): EvalSummary | null => {
+  if (!fs.existsSync(summaryPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(summaryPath, "utf8")) as EvalSummary;
+  } catch (error) {
+    console.warn(
+      `Failed to parse eval summary at ${summaryPath}: ${String(error)}`,
+    );
+    return null;
+  }
+};
+
+const escapeXml = (value: string) =>
+  value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;");
+
+const writeEvalJunit = (
+  summaryPath: string,
+  outputPath: string,
+  category: string,
+) => {
+  const summary = readEvalSummary(summaryPath);
+  const passed = summary?.passed ?? [];
+  const failed = summary?.failed ?? [];
+  const missingSummary = summary === null;
+  const tests = missingSummary ? 1 : passed.length + failed.length;
+  const failures = missingSummary ? 1 : failed.length;
+  const suiteName = `evals-${category}`;
+  const cases: string[] = [];
+
+  if (missingSummary) {
+    cases.push(
+      `    <testcase name="${escapeXml(`evals/${category} summary missing`)}" classname="${escapeXml(suiteName)}" time="0">`,
+      `      <failure message="eval summary missing">Missing eval summary at ${escapeXml(summaryPath)}</failure>`,
+      "    </testcase>",
+    );
+  } else {
+    for (const item of passed) {
+      cases.push(
+        `    <testcase name="${escapeXml(`evals/${item.eval} [${item.model}]`)}" classname="${escapeXml(suiteName)}" time="0" />`,
+      );
+    }
+    for (const item of failed) {
+      cases.push(
+        `    <testcase name="${escapeXml(`evals/${item.eval} [${item.model}]`)}" classname="${escapeXml(suiteName)}" time="0">`,
+        `      <failure message="eval failed">${escapeXml(`categories=${(item.categories ?? []).join(",")}`)}</failure>`,
+        "    </testcase>",
+      );
+    }
+  }
+
+  const xml = [
+    '<?xml version="1.0" encoding="utf-8"?>',
+    "<testsuites>",
+    `  <testsuite name="${escapeXml(suiteName)}" tests="${tests}" failures="${failures}" errors="0" skipped="0" time="0">`,
+    ...cases,
+    "  </testsuite>",
+    "</testsuites>",
+    "",
+  ].join("\n");
+
+  fs.writeFileSync(outputPath, xml);
+};
+
+const writeEvalCtrf = (
+  summaryPath: string,
+  outputPath: string,
+  category: string,
+) => {
+  const timestamp = new Date().toISOString();
+  const summary = readEvalSummary(summaryPath);
+  if (summary) {
+    const passed = summary.passed ?? [];
+    const failed = summary.failed ?? [];
+    const toTests = (arr: typeof passed, status: "passed" | "failed") =>
+      arr.map((item) => ({
+        name: `evals/${item.eval} [${item.model}]`,
+        status,
+        duration: 0,
+        suite: ["evals", category, ...(item.categories ?? [])],
+      }));
+    const report = {
+      reportFormat: "CTRF",
+      specVersion: "0.0.0",
+      generatedBy: "stagehand-evals",
+      timestamp,
+      results: {
+        tool: { name: "evals" },
+        summary: {
+          tests: passed.length + failed.length,
+          passed: passed.length,
+          failed: failed.length,
+          skipped: 0,
+          pending: 0,
+          other: 0,
+          start: 0,
+          stop: 0,
+        },
+        tests: [...toTests(passed, "passed"), ...toTests(failed, "failed")],
+      },
+    };
+    fs.writeFileSync(outputPath, JSON.stringify(report, null, 2));
+    return;
+  }
+
+  const missingReport = {
+    reportFormat: "CTRF",
+    specVersion: "0.0.0",
+    generatedBy: "stagehand-evals",
+    timestamp,
+    results: {
+      tool: { name: "evals" },
+      summary: {
+        tests: 1,
+        passed: 0,
+        failed: 1,
+        skipped: 0,
+        pending: 0,
+        other: 0,
+        start: 0,
+        stop: 0,
+      },
+      tests: [
+        {
+          name: `evals/${category} summary missing`,
+          status: "failed",
+          duration: 0,
+          suite: ["evals", category],
+        },
+      ],
+    },
+  };
+  fs.writeFileSync(outputPath, JSON.stringify(missingReport, null, 2));
+};
+
+const repoRoot = getRepoRootDir();
+const toPosix = (value: string) => value.replaceAll("\\", "/");
+const resolveRepoRelative = (value: string) =>
+  path.isAbsolute(value) ? value : path.resolve(repoRoot, value);
+const inferRuntimeFromPath = (value: string) => {
+  const normalized = toPosix(value);
+  if (normalized.includes("/dist/cli/") || normalized.includes("/dist/esm/")) {
+    return "dist-esm" as const;
+  }
+  return null;
+};
+const inferRuntimeFromExecution = () =>
+  inferRuntimeFromPath(getCurrentFilePath()) ??
+  inferRuntimeFromPath(process.cwd());
+const rawArgs = process.argv.slice(2).filter((arg) => arg !== "--");
+const listRequested = rawArgs.includes("--list");
+const stripCliArg = (values: string[]) => {
+  const filtered: string[] = [];
+  let cliPath: string | null = null;
+  for (let i = 0; i < values.length; i++) {
+    const arg = values[i];
+    if (arg === "--cli") {
+      if (values[i + 1] && !values[i + 1].startsWith("--")) {
+        cliPath = values[i + 1];
+        i += 1;
+      } else {
+        cliPath = "";
+      }
+      continue;
+    }
+    if (arg.startsWith("--cli=")) {
+      cliPath = arg.slice("--cli=".length);
+      continue;
+    }
+    filtered.push(arg);
+  }
+  return { filtered, cliPath };
+};
+const strippedCli = stripCliArg(rawArgs.filter((arg) => arg !== "--list"));
+if (strippedCli.cliPath === "") {
+  console.error("Missing value for --cli.");
+  process.exit(1);
+}
+const args = strippedCli.filtered;
+
+if (listRequested) {
+  const categories = (
+    process.env.EVAL_CATEGORIES ??
+    "observe,act,combination,extract,targeted_extract,regression,agent"
+  ).split(",");
+  const entries = categories.map((category) => ({
+    category,
+    name: category,
+    safe_name: toSafeName(category),
+  }));
+  console.log(JSON.stringify(entries));
+  process.exit(0);
+}
+
+if (
+  strippedCli.cliPath &&
+  toPosix(resolveRepoRelative(strippedCli.cliPath)).includes("/dist/cjs/")
+) {
+  console.error("CJS eval runtime is not supported. Use source or dist/cli.");
+  process.exit(1);
+}
+
+const runtime: Runtime =
+  (strippedCli.cliPath
+    ? inferRuntimeFromPath(resolveRepoRelative(strippedCli.cliPath))
+    : null) ??
+  inferRuntimeFromExecution() ??
+  "source";
+
+const cliPath = strippedCli.cliPath
+  ? resolveRepoRelative(strippedCli.cliPath)
+  : runtime === "source"
+    ? `${repoRoot}/packages/evals/cli.ts`
+    : `${repoRoot}/packages/evals/dist/cli/cli.js`;
+if (!fs.existsSync(cliPath)) {
+  console.error(`Missing ${cliPath}.`);
+  process.exit(1);
+}
+
+if (args.includes("--help") || args.includes("-h") || args[0] === "help") {
+  const result = spawnSync(
+    process.execPath,
+    [...(runtime === "source" ? ["--import", "tsx"] : []), cliPath, "--help"],
+    {
+      stdio: "inherit",
+      cwd: repoRoot,
+    },
+  );
+  process.exit(result.status ?? 0);
+}
+
+const hasRun = args[0] === "run";
+const argsAfterRun = hasRun ? args.slice(1) : args;
+const target =
+  argsAfterRun.find((arg) => !arg.startsWith("-"))?.trim() || "all";
+const safeTarget = toSafeName(target);
+const cliArgs = hasRun ? args : ["run", ...args];
+
+const baseNodeOptions = "--enable-source-maps";
+const nodeOptions = [process.env.NODE_OPTIONS, baseNodeOptions]
+  .filter(Boolean)
+  .join(" ");
+
+const coverageDir = resolveRepoRelative(
+  process.env.NODE_V8_COVERAGE ?? `${repoRoot}/coverage/evals/${safeTarget}`,
+);
+fs.mkdirSync(coverageDir, { recursive: true });
+const summaryPath = `${repoRoot}/eval-summary.json`;
+fs.mkdirSync(`${repoRoot}/ctrf/evals`, { recursive: true });
+const junitPath = `${repoRoot}/ctrf/evals/${safeTarget}.xml`;
+const ctrfPath = `${repoRoot}/ctrf/evals/${safeTarget}.json`;
+
+const env = {
+  ...process.env,
+  NODE_OPTIONS: nodeOptions,
+  NODE_V8_COVERAGE: coverageDir,
+};
+
+const result = spawnSync(
+  process.execPath,
+  [...(runtime === "source" ? ["--import", "tsx"] : []), cliPath, ...cliArgs],
+  {
+    stdio: "inherit",
+    env,
+    cwd: repoRoot,
+  },
+);
+
+writeEvalJunit(summaryPath, junitPath, safeTarget);
+writeEvalCtrf(summaryPath, ctrfPath, safeTarget);
+
+process.exit(result.status ?? 1);
diff --git a/packages/evals/suites/gaia.ts b/packages/evals/suites/gaia.ts
new file mode 100644
index 000000000..28d48e15a
--- /dev/null
+++ b/packages/evals/suites/gaia.ts
@@ -0,0 +1,95 @@
+import path from "path";
+import type { Testcase, EvalInput } from "../types/evals.js";
+import type { AvailableModel } from "@browserbasehq/stagehand";
+import { tasksConfig } from "../taskConfig.js";
+import { getCurrentDirPath } from "../runtimePaths.js";
+import { readJsonlFile, parseJsonlRows, applySampling } from "../utils.js";
+
+export const buildGAIATestcases = (models: string[]): Testcase[] => {
+  const moduleDir = getCurrentDirPath();
+  const gaiaFilePath =
+    process.env.EVAL_GAIA_FILE ||
+    path.join(moduleDir, "..", "datasets", "gaia", "GAIA_web.jsonl");
+
+  const gaiaLines = readJsonlFile(gaiaFilePath);
+
+  const levelFilter = process.env.EVAL_GAIA_LEVEL
+    ? Number(process.env.EVAL_GAIA_LEVEL)
+    : undefined;
+  // Use EVAL_MAX_K if set, otherwise fall back to EVAL_GAIA_LIMIT or default to 25
+  const maxCases = process.env.EVAL_MAX_K
+    ? Number(process.env.EVAL_MAX_K)
+    : process.env.EVAL_GAIA_LIMIT
+      ? Number(process.env.EVAL_GAIA_LIMIT)
+      : 25;
+  const sampleCount = process.env.EVAL_GAIA_SAMPLE
+    ? Number(process.env.EVAL_GAIA_SAMPLE)
+    : undefined;
+
+  type GaiaRow = {
+    id: string;
+    Level?: number;
+    web: string;
+    ques: string;
+    [key: string]: unknown;
+  };
+
+  function isGaiaRow(parsed: unknown): parsed is GaiaRow {
+    if (parsed === null || typeof parsed !== "object") return false;
+    const obj = parsed as Record<string, unknown>;
+    return (
+      typeof obj.id === "string" &&
+      typeof obj.web === "string" &&
+      typeof obj.ques === "string"
+    );
+  }
+
+  const candidates = parseJsonlRows(gaiaLines, isGaiaRow);
+
+  // Filter by level if specified
+  const filteredCandidates = levelFilter
+    ? candidates.filter((row) => row.Level === levelFilter)
+    : candidates;
+
+  const gaiaRows = applySampling(filteredCandidates, sampleCount, maxCases);
+
+  const allTestcases: Testcase[] = [];
+  for (const model of models) {
+    for (const row of gaiaRows) {
+      const finalAnswer = (row as Record<string, unknown>)[
+        "Final answer"
+      ] as unknown;
+      const input: EvalInput = {
+        name: "agent/gaia",
+        modelName: model as AvailableModel,
+        params: {
+          id: row.id,
+          level: row.Level,
+          web: row.web,
+          ques: row.ques,
+          expected: typeof finalAnswer === "string" ? finalAnswer : undefined,
+        },
+      };
+      allTestcases.push({
+        input,
+        name: input.name,
+        tags: [
+          model,
+          input.name,
+          ...(
+            tasksConfig.find((t) => t.name === input.name)?.categories || []
+          ).map((x) => `category/${x}`),
+          `gaia/id/${row.id}`,
+          row.Level ? `gaia/level/${row.Level}` : "gaia/level/unknown",
+        ],
+        metadata: {
+          model: model as AvailableModel,
+          test: `${input.name}:${row.id}`,
+        },
+        expected: true,
+      });
+    }
+  }
+
+  return allTestcases;
+};
diff --git a/packages/evals/suites/onlineMind2Web.ts b/packages/evals/suites/onlineMind2Web.ts
new file mode 100644
index 000000000..64075eee5
--- /dev/null
+++ b/packages/evals/suites/onlineMind2Web.ts
@@ -0,0 +1,91 @@
+import path from "path";
+import type { Testcase, EvalInput } from "../types/evals.js";
+import type { AvailableModel } from "@browserbasehq/stagehand";
+import { tasksConfig } from "../taskConfig.js";
+import { getCurrentDirPath } from "../runtimePaths.js";
+import { readJsonlFile, parseJsonlRows, applySampling } from "../utils.js";
+
+export const buildOnlineMind2WebTestcases = (models: string[]): Testcase[] => {
+  const moduleDir = getCurrentDirPath();
+  const mind2webFilePath = path.join(
+    moduleDir,
+    "..",
+    "datasets",
+    "onlineMind2Web",
+    "onlineMind2Web.jsonl",
+  );
+
+  const lines = readJsonlFile(mind2webFilePath);
+
+  // Use EVAL_MAX_K if set, otherwise fall back to EVAL_ONLINEMIND2WEB_LIMIT or default to 25
+  const maxCases = process.env.EVAL_MAX_K
+    ? Number(process.env.EVAL_MAX_K)
+    : process.env.EVAL_ONLINEMIND2WEB_LIMIT
+      ? Number(process.env.EVAL_ONLINEMIND2WEB_LIMIT)
+      : 25;
+  const sampleCount = process.env.EVAL_ONLINEMIND2WEB_SAMPLE
+    ? Number(process.env.EVAL_ONLINEMIND2WEB_SAMPLE)
+    : undefined;
+
+  type Mind2WebRow = {
+    task_id: string;
+    confirmed_task: string;
+    website: string;
+    reference_length?: number;
+    level?: string;
+    [key: string]: unknown;
+  };
+
+  function isMind2WebRow(parsed: unknown): parsed is Mind2WebRow {
+    if (parsed === null || typeof parsed !== "object") return false;
+    const obj = parsed as Record<string, unknown>;
+    return (
+      typeof obj.task_id === "string" &&
+      typeof obj.confirmed_task === "string" &&
+      typeof obj.website === "string"
+    );
+  }
+
+  const candidates = parseJsonlRows(lines, isMind2WebRow);
+  const rows = applySampling(candidates, sampleCount, maxCases);
+
+  const allTestcases: Testcase[] = [];
+  for (const model of models) {
+    for (const row of rows) {
+      const input: EvalInput = {
+        name: "agent/onlineMind2Web",
+        modelName: model as AvailableModel,
+        params: {
+          task_id: row.task_id,
+          confirmed_task: row.confirmed_task,
+          website: row.website,
+          reference_length: row.reference_length,
+          level: row.level,
+        },
+      };
+      const taskCategories =
+        tasksConfig.find((t) => t.name === input.name)?.categories || [];
+      allTestcases.push({
+        input,
+        name: input.name,
+        tags: [
+          model,
+          "mind2web", // Simple dataset tag
+        ],
+        metadata: {
+          model: model as AvailableModel,
+          test: `${input.name}:${row.task_id}`,
+          category: taskCategories[0] || "agent",
+          categories: taskCategories,
+          dataset: "onlineMind2Web",
+          task_id: row.task_id,
+          difficulty: row.level,
+          website: row.website,
+        },
+        expected: true,
+      });
+    }
+  }
+
+  return allTestcases;
+};
diff --git a/packages/evals/suites/webtailbench.ts b/packages/evals/suites/webtailbench.ts
new file mode 100644
index 000000000..069bd637b
--- /dev/null
+++ b/packages/evals/suites/webtailbench.ts
@@ -0,0 +1,75 @@
+import type { Testcase, EvalInput } from "../types/evals.js";
+import type { AvailableModel } from "@browserbasehq/stagehand";
+import { tasksConfig } from "../taskConfig.js";
+import { getCurrentDirPath } from "../runtimePaths.js";
+import { readJsonlFile, parseJsonlRows, applySampling } from "../utils.js";
+
+export const buildWebTailBenchTestcases = (models: string[]): Testcase[] => {
+  const moduleDir = getCurrentDirPath();
+  const webtailbenchFilePath =
+    moduleDir + "/../datasets/webtailbench/WebTailBench_data.jsonl";
+
+  const lines = readJsonlFile(webtailbenchFilePath);
+
+  // Use EVAL_MAX_K if set, otherwise fall back to EVAL_WEBTAILBENCH_LIMIT or default to 25
+  const maxCases = process.env.EVAL_MAX_K
+    ? Number(process.env.EVAL_MAX_K)
+    : process.env.EVAL_WEBTAILBENCH_LIMIT
+      ? Number(process.env.EVAL_WEBTAILBENCH_LIMIT)
+      : 25;
+  const sampleCount = process.env.EVAL_WEBTAILBENCH_SAMPLE
+    ? Number(process.env.EVAL_WEBTAILBENCH_SAMPLE)
+    : undefined;
+
+  type WebTailBenchRow = {
+    id: string;
+    ques: string;
+    category?: string;
+    web?: string;
+    [key: string]: unknown;
+  };
+
+  function isWebTailBenchRow(parsed: unknown): parsed is WebTailBenchRow {
+    if (parsed === null || typeof parsed !== "object") return false;
+    const obj = parsed as Record<string, unknown>;
+    return typeof obj.id === "string" && typeof obj.ques === "string";
+  }
+
+  const candidates = parseJsonlRows(lines, isWebTailBenchRow);
+  const rows = applySampling(candidates, sampleCount, maxCases);
+
+  const allTestcases: Testcase[] = [];
+  for (const model of models) {
+    for (const row of rows) {
+      const input: EvalInput = {
+        name: "agent/webtailbench",
+        modelName: model as AvailableModel,
+        params: {
+          id: row.id,
+          category: row.category,
+          ques: row.ques,
+          web: row.web,
+        },
+      };
+      const taskCategories =
+        tasksConfig.find((t) => t.name === input.name)?.categories || [];
+      allTestcases.push({
+        input,
+        name: input.name,
+        tags: [model, "webtailbench"],
+        metadata: {
+          model: model as AvailableModel,
+          test: `${input.name}:${row.id}`,
+          category: taskCategories[0] || "agent",
+          categories: taskCategories,
+          dataset: "webtailbench",
+          task_id: row.id,
+          task_category: row.category,
+        },
+        expected: true,
+      });
+    }
+  }
+
+  return allTestcases;
+};
diff --git a/packages/evals/suites/webvoyager.ts b/packages/evals/suites/webvoyager.ts
new file mode 100644
index 000000000..630b7035e
--- /dev/null
+++ b/packages/evals/suites/webvoyager.ts
@@ -0,0 +1,88 @@
+import path from "path";
+import type { Testcase, EvalInput } from "../types/evals.js";
+import type { AvailableModel } from "@browserbasehq/stagehand";
+import { tasksConfig } from "../taskConfig.js";
+import { getCurrentDirPath } from "../runtimePaths.js";
+import { readJsonlFile, parseJsonlRows, applySampling } from "../utils.js";
+
+export const buildWebVoyagerTestcases = (models: string[]): Testcase[] => {
+  const moduleDir = getCurrentDirPath();
+  const voyagerFilePath = path.join(
+    moduleDir,
+    "..",
+    "datasets",
+    "webvoyager",
+    "WebVoyager_data.jsonl",
+  );
+
+  const lines = readJsonlFile(voyagerFilePath);
+
+  // Use EVAL_MAX_K if set, otherwise fall back to EVAL_WEBVOYAGER_LIMIT or default to 25
+  const maxCases = process.env.EVAL_MAX_K
+    ? Number(process.env.EVAL_MAX_K)
+    : process.env.EVAL_WEBVOYAGER_LIMIT
+      ? Number(process.env.EVAL_WEBVOYAGER_LIMIT)
+      : 25;
+  const sampleCount = process.env.EVAL_WEBVOYAGER_SAMPLE
+    ? Number(process.env.EVAL_WEBVOYAGER_SAMPLE)
+    : undefined;
+
+  type VoyagerRow = {
+    id: string;
+    web: string;
+    ques: string;
+    web_name?: string;
+    [key: string]: unknown;
+  };
+
+  function isVoyagerRow(parsed: unknown): parsed is VoyagerRow {
+    if (parsed === null || typeof parsed !== "object") return false;
+    const obj = parsed as Record<string, unknown>;
+    return (
+      typeof obj.id === "string" &&
+      typeof obj.web === "string" &&
+      typeof obj.ques === "string"
+    );
+  }
+
+  const candidates = parseJsonlRows(lines, isVoyagerRow);
+  const rows = applySampling(candidates, sampleCount, maxCases);
+
+  const allTestcases: Testcase[] = [];
+  for (const model of models) {
+    for (const row of rows) {
+      const input: EvalInput = {
+        name: "agent/webvoyager",
+        modelName: model as AvailableModel,
+        params: {
+          id: row.id,
+          web: row.web,
+          ques: row.ques,
+          web_name: row.web_name,
+        },
+      };
+      const taskCategories =
+        tasksConfig.find((t) => t.name === input.name)?.categories || [];
+      allTestcases.push({
+        input,
+        name: input.name,
+        tags: [
+          model,
+          "webvoyager", // Simple dataset tag
+        ],
+        metadata: {
+          model: model as AvailableModel,
+          test: `${input.name}:${row.id}`,
+          category: taskCategories[0] || "agent",
+          categories: taskCategories,
+          dataset: "webvoyager",
+          task_id: row.id,
+          website: row.web_name || row.web,
+        },
+        expected: true,
+      });
+    }
+  }
+
+  return allTestcases;
+};
diff --git a/packages/evals/summary.ts b/packages/evals/summary.ts
new file mode 100644
index 000000000..9538a0860
--- /dev/null
+++ b/packages/evals/summary.ts
@@ -0,0 +1,70 @@
+import fs from "fs";
+import { tasksByName } from "./taskConfig.js";
+import type { SummaryResult } from "./types/evals.js";
+import { getRepoRootDir } from "./runtimePaths.js";
+
+const repoRoot = getRepoRootDir();
+
+export const generateSummary = async (
+  results: SummaryResult[],
+  experimentName: string,
+) => {
+  const passed = results
+    .filter((r) => r.output._success)
+    .map((r) => ({
+      eval: r.input.name,
+      model: r.input.modelName,
+      categories: tasksByName[r.input.name].categories,
+    }));
+
+  const failed = results
+    .filter((r) => !r.output._success)
+    .map((r) => ({
+      eval: r.input.name,
+      model: r.input.modelName,
+      categories: tasksByName[r.input.name].categories,
+    }));
+
+  const categorySuccessCounts: Record<
+    string,
+    { total: number; success: number }
+  > = {};
+  for (const taskName of Object.keys(tasksByName)) {
+    const taskCategories = tasksByName[taskName].categories;
+    const taskResults = results.filter((r) => r.input.name === taskName);
+    const successCount = taskResults.filter((r) => r.output._success).length;
+
+    for (const cat of taskCategories) {
+      if (!categorySuccessCounts[cat]) {
+        categorySuccessCounts[cat] = { total: 0, success: 0 };
+      }
+      categorySuccessCounts[cat].total += taskResults.length;
+      categorySuccessCounts[cat].success += successCount;
+    }
+  }
+
+  const categories: Record<string, number> = {};
+  for (const [cat, counts] of Object.entries(categorySuccessCounts)) {
+    categories[cat] = Math.round((counts.success / counts.total) * 100);
+  }
+
+  const models: Record<string, number> = {};
+  const allModels = [...new Set(results.map((r) => r.input.modelName))];
+  for (const model of allModels) {
+    const modelResults = results.filter((r) => r.input.modelName === model);
+    const successCount = modelResults.filter((r) => r.output._success).length;
+    models[model] = Math.round((successCount / modelResults.length) * 100);
+  }
+
+  const formattedSummary = {
+    experimentName,
+    passed,
+    failed,
+    categories,
+    models,
+  };
+
+  const summaryPath = `${repoRoot}/eval-summary.json`;
+  fs.writeFileSync(summaryPath, JSON.stringify(formattedSummary, null, 2));
+  console.log(`Evaluation summary written to ${summaryPath}`);
+};
diff --git a/evals/taskConfig.ts b/packages/evals/taskConfig.ts
similarity index 52%
rename from evals/taskConfig.ts
rename to packages/evals/taskConfig.ts
index e5ea48b02..193f7ae6b 100644
--- a/evals/taskConfig.ts
+++ b/packages/evals/taskConfig.ts
@@ -12,8 +12,10 @@
 
 import fs from "fs";
 import path from "path";
-import { AvailableModel } from "@/dist";
-import { filterByEvalName } from "./args";
+import { AvailableModel } from "@browserbasehq/stagehand";
+import { filterByEvalName } from "./args.js";
+import { AgentModelEntry } from "./types/evals.js";
+import { getCurrentDirPath } from "./runtimePaths.js";
 
 const ALL_EVAL_MODELS = [
   // GOOGLE
@@ -23,13 +25,17 @@ const ALL_EVAL_MODELS = [
   "gemini-2.5-pro-exp-03-25",
   "gemini-1.5-pro",
   "gemini-1.5-flash-8b",
+  "gemini-2.5-flash-preview-04-17",
+  "gemini-2.5-pro-preview-03-25",
   // ANTHROPIC
-  "claude-3-5-sonnet-latest",
-  "claude-3-7-sonnet-latest",
+  "claude-sonnet-4-6",
   // OPENAI
   "gpt-4o-mini",
   "gpt-4o",
   "gpt-4.5-preview",
+  "o3",
+  "o3-mini",
+  "o4-mini",
   // TOGETHER - META
   "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
   "meta-llama/Llama-3.3-70B-Instruct-Turbo",
@@ -51,7 +57,8 @@ const ALL_EVAL_MODELS = [
 ];
 
 // The configuration file `evals.config.json` contains a list of tasks and their associated categories.
-const configPath = path.join(__dirname, "evals.config.json");
+const moduleDir = getCurrentDirPath();
+const configPath = path.join(moduleDir, "evals.config.json");
 const config = JSON.parse(fs.readFileSync(configPath, "utf-8")) satisfies {
   tasks: {
     name: string;
@@ -66,16 +73,14 @@ const config = JSON.parse(fs.readFileSync(configPath, "utf-8")) satisfies {
 type TaskConfig = {
   name: string;
   categories: string[];
-  extract_method?: string;
 };
 const tasksConfig = config.tasks as TaskConfig[];
 
 const tasksByName = tasksConfig.reduce<
-  Record<string, { categories: string[]; extractMethod?: string }>
+  Record<string, { categories: string[] }>
 >((acc, task) => {
   acc[task.name] = {
     categories: task.categories,
-    extractMethod: task.extract_method,
   };
   return acc;
 }, {});
@@ -95,7 +100,32 @@ if (filterByEvalName && !tasksByName[filterByEvalName]) {
  */
 const DEFAULT_EVAL_MODELS = process.env.EVAL_MODELS
   ? process.env.EVAL_MODELS.split(",")
-  : ["claude-3-5-sonnet-latest", "gpt-4o-mini", "gpt-4o"];
+  : [
+      "google/gemini-2.0-flash",
+      "openai/gpt-4.1-mini",
+      "anthropic/claude-haiku-4-5",
+    ];
+
+// Standard agent models - these run with stagehand.agent()
+const AGENT_MODELS = process.env.EVAL_AGENT_MODELS
+  ? process.env.EVAL_AGENT_MODELS.split(",")
+  : ["anthropic/claude-sonnet-4-20250514"];
+
+// CUA agent models - these run with stagehand.agent({ cua: true })
+const AGENT_MODELS_CUA = process.env.EVAL_AGENT_MODELS_CUA
+  ? process.env.EVAL_AGENT_MODELS_CUA.split(",")
+  : [
+      "openai/computer-use-preview-2025-03-11",
+      "anthropic/claude-sonnet-4-20250514",
+      "google/gemini-2.5-computer-use-preview-10-2025",
+    ];
+
+const AGENT_MODEL_ENTRIES: AgentModelEntry[] = [
+  ...AGENT_MODELS.map((m) => ({ modelName: m, cua: false })),
+  ...AGENT_MODELS_CUA.map((m) => ({ modelName: m, cua: true })),
+];
+
+const DEFAULT_AGENT_MODELS = AGENT_MODEL_ENTRIES.map((e) => e.modelName);
 
 /**
  * getModelList:
@@ -103,38 +133,58 @@ const DEFAULT_EVAL_MODELS = process.env.EVAL_MODELS
  * If category is "experimental", it merges DEFAULT_EVAL_MODELS and EXPERIMENTAL_EVAL_MODELS.
  * Otherwise, returns DEFAULT_EVAL_MODELS filtered by provider if specified.
  */
-const getModelList = (): string[] => {
+const getModelList = (category?: string): string[] => {
   const provider = process.env.EVAL_PROVIDER?.toLowerCase();
 
-  if (!provider) {
-    return DEFAULT_EVAL_MODELS;
+  if (category === "agent" || category === "external_agent_benchmarks") {
+    return DEFAULT_AGENT_MODELS;
+  }
+
+  if (provider) {
+    return ALL_EVAL_MODELS.filter((model) =>
+      filterModelByProvider(model, provider),
+    );
   }
 
-  return ALL_EVAL_MODELS.filter((model) => {
-    const modelLower = model.toLowerCase();
-    if (provider === "openai") {
-      return modelLower.startsWith("gpt");
-    } else if (provider === "anthropic") {
-      return modelLower.startsWith("claude");
-    } else if (provider === "google") {
-      return modelLower.startsWith("gemini");
-    } else if (provider === "together") {
-      return (
-        modelLower.startsWith("meta-llama") ||
-        modelLower.startsWith("llama") ||
-        modelLower.startsWith("deepseek") ||
-        modelLower.startsWith("qwen")
-      );
-    } else if (provider === "groq") {
-      return modelLower.startsWith("groq");
-    } else if (provider === "cerebras") {
-      return modelLower.startsWith("cerebras");
-    }
-    return true;
-  });
+  // If no agent category and no provider, return default eval models
+  return DEFAULT_EVAL_MODELS;
 };
+
+// Helper function to contain the provider filtering logic
+const filterModelByProvider = (model: string, provider: string): boolean => {
+  const modelLower = model.toLowerCase();
+  if (provider === "openai") {
+    return modelLower.startsWith("gpt");
+  } else if (provider === "anthropic") {
+    return modelLower.startsWith("claude");
+  } else if (provider === "google") {
+    return modelLower.startsWith("gemini");
+  } else if (provider === "together") {
+    return (
+      modelLower.startsWith("meta-llama") ||
+      modelLower.startsWith("llama") ||
+      modelLower.startsWith("deepseek") ||
+      modelLower.startsWith("qwen")
+    );
+  } else if (provider === "groq") {
+    return modelLower.startsWith("groq");
+  } else if (provider === "cerebras") {
+    return modelLower.startsWith("cerebras");
+  }
+  console.warn(
+    `Unknown provider specified or model doesn't match: ${provider}`,
+  );
+  return false;
+};
+
 const MODELS: AvailableModel[] = getModelList().map((model) => {
   return model as AvailableModel;
 });
 
-export { tasksByName, MODELS, tasksConfig };
+/**
+ * Get agent model entries with CUA flag for test case generation.
+ */
+const getAgentModelEntries = (): AgentModelEntry[] => AGENT_MODEL_ENTRIES;
+
+export { tasksByName, MODELS, tasksConfig, getModelList, getAgentModelEntries };
+export type { AgentModelEntry };
diff --git a/packages/evals/tasks/agent/alibaba_supplier_search.ts b/packages/evals/tasks/agent/alibaba_supplier_search.ts
new file mode 100644
index 000000000..a999860c0
--- /dev/null
+++ b/packages/evals/tasks/agent/alibaba_supplier_search.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const alibaba_supplier_search: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.alibaba.com/");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Search for 'solar panels' on Alibaba and find 3 suppliers. For each supplier, tell me their company name, minimum order quantity, and price range if available.";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 30,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/all_recipes.ts b/packages/evals/tasks/agent/all_recipes.ts
new file mode 100644
index 000000000..2bb6ec060
--- /dev/null
+++ b/packages/evals/tasks/agent/all_recipes.ts
@@ -0,0 +1,56 @@
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { EvalFunction } from "../../types/evals.js";
+
+export const all_recipes: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.allrecipes.com/");
+    const evaluator = new V3Evaluator(v3);
+    const agentResult = await agent.execute({
+      instruction:
+        "Search for a recipe for Beef Wellington on Allrecipes that has at least 200 reviews and an average rating of 4.5 stars or higher. List the main ingredients required for the dish.",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 30,
+    });
+
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: "Did the agent find a recipe for Beef Wellington",
+    });
+
+    logger.log(agentResult);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/amazon_shoes_cart.ts b/packages/evals/tasks/agent/amazon_shoes_cart.ts
new file mode 100644
index 000000000..ba707e270
--- /dev/null
+++ b/packages/evals/tasks/agent/amazon_shoes_cart.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const amazon_shoes_cart: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.amazon.com");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "go to amazon, and add a pair of black running shoes to cart in size 14. stop after you add the item to cart, and reach the login page";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 40,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/apple_trade_in.ts b/packages/evals/tasks/agent/apple_trade_in.ts
new file mode 100644
index 000000000..dcfbb56ce
--- /dev/null
+++ b/packages/evals/tasks/agent/apple_trade_in.ts
@@ -0,0 +1,57 @@
+//this eval is expected to fail due to issues scrolling within the trade in dialog
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+
+export const apple_trade_in: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.apple.com/shop/trade-in");
+    const evaluator = new V3Evaluator(v3);
+    await agent.execute({
+      instruction:
+        "Find out the trade-in value for an iPhone 13 Pro Max in good condition on the Apple website.",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 30,
+    });
+
+    const { evaluation, reasoning } = await evaluator.ask({
+      question:
+        "Did the agent find the trade-in value for an iPhone 13 Pro Max in good condition on the Apple website?",
+      screenshot: false,
+      answer: "360",
+    });
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: error.message,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/apple_tv.ts b/packages/evals/tasks/agent/apple_tv.ts
new file mode 100644
index 000000000..71cfe2c49
--- /dev/null
+++ b/packages/evals/tasks/agent/apple_tv.ts
@@ -0,0 +1,55 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+
+export const apple_tv: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.apple.com/");
+
+    const agentResult = await agent.execute({
+      instruction:
+        "Identify the size and weight for the Apple TV 4K and list the Siri Remote features introduced.",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 50,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const result = await evaluator.ask({
+      question:
+        "did the agent find the height and width of the Apple TV 4K in its reasoning which is 1.2 and 3.66?",
+      answer: agentResult.message,
+    });
+
+    const success = result.evaluation === "YES";
+    if (!success) {
+      return {
+        _success: false,
+        message: agentResult.message,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: error.message,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/arxiv_gpt_report.ts b/packages/evals/tasks/agent/arxiv_gpt_report.ts
new file mode 100644
index 000000000..52e0d1126
--- /dev/null
+++ b/packages/evals/tasks/agent/arxiv_gpt_report.ts
@@ -0,0 +1,77 @@
+//agent often fails on this one,
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const arxiv_gpt_report: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://arxiv.org/");
+
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Find the paper 'GPT-4 Technical Report', when was v3 submitted?";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 25,
+    });
+
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    // Mon, 27 Mar 2023 17:46:54 UTC
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `Did the agent complete this task successfully? ${instruction}, the correct answer the agent should have provided is '03-27-2023'`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/columbia_tuition.ts b/packages/evals/tasks/agent/columbia_tuition.ts
new file mode 100644
index 000000000..cdcbe4890
--- /dev/null
+++ b/packages/evals/tasks/agent/columbia_tuition.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const columbia_tuition: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://columbia.edu/");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Use the search functionality to locate pages detailing tuition and fees, then extract the published tuition fee information for undergraduate programs. Only use http://columbia.edu to achieve the task. Don't go to any other site. The task is achievable with just navigation from this site.";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 50,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/flipkart_laptops.ts b/packages/evals/tasks/agent/flipkart_laptops.ts
new file mode 100644
index 000000000..81e7c6f01
--- /dev/null
+++ b/packages/evals/tasks/agent/flipkart_laptops.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const flipkart_laptops: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.flipkart.com/");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "In the 'Laptops' section, apply the filter for 'Dell' and extract the average discount percentage on the first 3 Dell laptops displayed. Only use http://flipkart.com to achieve the task. Don't go to any other site. The task is achievable with just navigation from this site.";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 50,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/gaia.ts b/packages/evals/tasks/agent/gaia.ts
new file mode 100644
index 000000000..403811616
--- /dev/null
+++ b/packages/evals/tasks/agent/gaia.ts
@@ -0,0 +1,99 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+
+/**
+ * Data-driven GAIA agent eval
+ * - Expects per-test params injected via eval runner: { id, level, web, ques }
+ * - Starts at `web`, runs the agent with `ques` as instruction
+ * - Requires the agent to output a final answer in the form: "Final Answer: <value>"
+ * - Marks success if such an answer string is present (exact matching against dataset can be layered later)
+ */
+export const gaia: EvalFunction = async ({
+  v3,
+  logger,
+  debugUrl,
+  sessionUrl,
+  modelName,
+  input,
+}) => {
+  try {
+    const params = ((input && input.params) || {}) as {
+      id?: string;
+      level?: number;
+      web?: string;
+      ques?: string;
+    };
+
+    if (!params.web || !params.ques) {
+      logger.error({
+        category: "gaia",
+        level: 0,
+        message: `Missing GAIA params (web, ques).`,
+        auxiliary: {
+          params: { value: JSON.stringify(params), type: "object" },
+        },
+      });
+      return {
+        _success: false,
+        error: `Missing GAIA params (web, ques). Got: ${JSON.stringify(params)}`,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    const page = v3.context.pages()[0];
+    await page.goto(params.web);
+
+    const agent = v3.agent({
+      model: modelName,
+      systemPrompt: `You are a helpful assistant that must solve the task by browsing. You must produce a single line at the end like: "Final Answer: <answer>". Do not ask follow up questions. Current page: ${await page.title()}`,
+    });
+
+    const result = await agent.execute({
+      instruction: params.ques,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 50,
+    });
+
+    const expected = (params as Record<string, unknown>).expected as
+      | string
+      | undefined;
+    const evaluator = new V3Evaluator(v3);
+    const evalResult = await evaluator.ask({
+      question: `Did the agent provide the expected answer: "${expected}"?`,
+      answer: result?.message || "",
+      screenshot: false,
+    });
+
+    return {
+      _success: evalResult.evaluation === "YES",
+      reasoning: evalResult.reasoning,
+      expectedAnswer: expected,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    logger.error({
+      category: "gaia",
+      level: 0,
+      message: `Unhandled error in GAIA task`,
+      auxiliary: {
+        error: {
+          value: error instanceof Error ? error.message : String(error),
+          type: "string",
+        },
+        trace: {
+          value: error instanceof Error && error.stack ? error.stack : "",
+          type: "string",
+        },
+      },
+    });
+    return {
+      _success: false,
+      error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  }
+};
diff --git a/packages/evals/tasks/agent/github.ts b/packages/evals/tasks/agent/github.ts
new file mode 100644
index 000000000..8b7e76f0a
--- /dev/null
+++ b/packages/evals/tasks/agent/github.ts
@@ -0,0 +1,56 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+
+export const github: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://github.com/");
+    const evaluator = new V3Evaluator(v3);
+    const agentResult = await agent.execute({
+      instruction:
+        "Find a Ruby repository on GitHub that has been updated in the past 3 days and has at least 1000 stars.",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 20,
+    });
+    logger.log(agentResult);
+
+    const { evaluation, reasoning } = await evaluator.ask({
+      question:
+        "Ruby repository on GitHub that has been updated in the past 3 days and has at least 1000 stars.",
+    });
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/github_react_version.ts b/packages/evals/tasks/agent/github_react_version.ts
new file mode 100644
index 000000000..fb653ae9b
--- /dev/null
+++ b/packages/evals/tasks/agent/github_react_version.ts
@@ -0,0 +1,76 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const github_react_version: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  v3,
+  agent,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://github.com/");
+
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Check the latest release version of React and the date it was published.";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 20,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `Did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/google_flights.ts b/packages/evals/tasks/agent/google_flights.ts
new file mode 100644
index 000000000..900c8aa19
--- /dev/null
+++ b/packages/evals/tasks/agent/google_flights.ts
@@ -0,0 +1,66 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+
+export const google_flights: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://google.com/travel/flights");
+
+    const agentResult = await agent.execute({
+      instruction:
+        "Search for flights from San Francisco to New York for next weekend",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 30,
+    });
+    logger.log(agentResult);
+
+    const evaluator = new V3Evaluator(v3);
+    const result = await evaluator.ask({
+      question:
+        "Does the page show flights (options, available flights, not a search form) from San Francisco to New York?",
+    });
+
+    if (result.evaluation !== "YES" && result.evaluation !== "NO") {
+      return {
+        _success: false,
+        observations: "Evaluator provided an invalid response",
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    if (result.evaluation === "YES") {
+      return {
+        _success: true,
+        observations: result.reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    } else {
+      return {
+        _success: false,
+        observations: result.reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/google_maps.ts b/packages/evals/tasks/agent/google_maps.ts
new file mode 100644
index 000000000..ef6e6a869
--- /dev/null
+++ b/packages/evals/tasks/agent/google_maps.ts
@@ -0,0 +1,75 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const google_maps: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://maps.google.com");
+
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "How long does it take to get from San Francisco to New York driving?";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 15,
+    });
+
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `Did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/google_maps_2.ts b/packages/evals/tasks/agent/google_maps_2.ts
new file mode 100644
index 000000000..48902415e
--- /dev/null
+++ b/packages/evals/tasks/agent/google_maps_2.ts
@@ -0,0 +1,74 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const google_maps_2: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://maps.google.com");
+
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Search for the fastest walking route from La Puerta de Alcalá to La Puerta del Sol";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 20,
+    });
+
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `Did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    if (evaluation !== "YES") {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/google_maps_3.ts b/packages/evals/tasks/agent/google_maps_3.ts
new file mode 100644
index 000000000..44ddff3fe
--- /dev/null
+++ b/packages/evals/tasks/agent/google_maps_3.ts
@@ -0,0 +1,54 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+
+export const google_maps_3: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://maps.google.com/");
+    const evaluator = new V3Evaluator(v3);
+    await agent.execute({
+      instruction:
+        "Search for locksmiths open now but not open 24 hours in Texas City.",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 35,
+    });
+
+    const { evaluation, reasoning } = await evaluator.ask({
+      question:
+        "Does the page show a locksmiths open now but not open 24 hours in Texas City?",
+    });
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: error.message,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/google_shopping.ts b/packages/evals/tasks/agent/google_shopping.ts
new file mode 100644
index 000000000..4ee8c43d9
--- /dev/null
+++ b/packages/evals/tasks/agent/google_shopping.ts
@@ -0,0 +1,57 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+
+export const google_shopping: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.google.com/shopping");
+
+    const agentResult = await agent.execute({
+      instruction:
+        "Find a drip coffee maker that is on sale and within $25-60 and has a black finish",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 20,
+    });
+    logger.log(agentResult);
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question:
+        "Does the page show a drip coffee maker that is on sale and within $25-60 and has a black finish?",
+    });
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/hotel_booking.ts b/packages/evals/tasks/agent/hotel_booking.ts
new file mode 100644
index 000000000..001ae75a4
--- /dev/null
+++ b/packages/evals/tasks/agent/hotel_booking.ts
@@ -0,0 +1,58 @@
+//this eval is expected to fail.
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+
+export const hotel_booking: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.booking.com/");
+
+    const agentResult = await agent.execute({
+      instruction:
+        "Find a hotel in Sydney with a rating of 8 or higher, providing free Wi-Fi and parking, available for a four-night stay starting on December 10, 2025.",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 20,
+    });
+    logger.log(agentResult);
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question:
+        "Does the page show a hotel in Sydney with a rating of 8 or higher, providing free Wi-Fi and parking, available for a four-night stay starting on December 10, 2025?",
+    });
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/hotels_paris_amenities.ts b/packages/evals/tasks/agent/hotels_paris_amenities.ts
new file mode 100644
index 000000000..a2949495d
--- /dev/null
+++ b/packages/evals/tasks/agent/hotels_paris_amenities.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const hotels_paris_amenities: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.hotels.com/");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Filter search results for properties in Paris available next month that offer spa amenities and bars, and list the amenities of the first three hotels. Only use http://hotels.com to achieve the task. Don't go to any other site. The task is achievable with just navigation from this site.";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 40,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/hugging_face.ts b/packages/evals/tasks/agent/hugging_face.ts
new file mode 100644
index 000000000..50c22d3ad
--- /dev/null
+++ b/packages/evals/tasks/agent/hugging_face.ts
@@ -0,0 +1,57 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+
+export const hugging_face: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const evaluator = new V3Evaluator(v3);
+    const page = v3.context.pages()[0];
+    await page.goto("https://huggingface.co/");
+    const agentResult = await agent.execute({
+      instruction:
+        "Search for a model on Hugging Face with an Apache-2.0 license that has received the highest number of likes.",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 20,
+    });
+    console.log(`agentResult: ${agentResult.message}`);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question:
+        "Does the message mention 'kokoro-82m' or 'hexgrad/Kokoro-82M'?",
+      answer: agentResult.message || "",
+      screenshot: false,
+    });
+
+    const success = evaluation === "YES";
+
+    console.log(`reasoning: ${reasoning}`);
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: error.message,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/iframe_form.ts b/packages/evals/tasks/agent/iframe_form.ts
new file mode 100644
index 000000000..e5a675ff5
--- /dev/null
+++ b/packages/evals/tasks/agent/iframe_form.ts
@@ -0,0 +1,88 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+
+export const iframe_form: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/iframe-form-filling/",
+    );
+
+    const agentResult = await agent.execute({
+      instruction: "Fill in the form name with 'John Smith'",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 5,
+    });
+    logger.log(agentResult);
+
+    const evaluator = new V3Evaluator(v3);
+    const result = await evaluator.ask({
+      question: "Is the form name input filled with 'John Smith'?",
+    });
+
+    if (result.evaluation !== "YES" && result.evaluation !== "NO") {
+      return {
+        _success: false,
+        observations: "Evaluator provided an invalid response",
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    const agentResult2 = await agent.execute({
+      instruction: "Fill in the form email with 'john.smith@example.com'",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 3,
+    });
+    logger.log(agentResult2);
+
+    await page.scroll(0, 0, 0, -1000);
+    const result2 = await evaluator.ask({
+      question: "Is the form email input filled with 'john.smith@example.com'?",
+      screenshot: true,
+    });
+
+    if (result2.evaluation !== "YES" && result2.evaluation !== "NO") {
+      return {
+        _success: false,
+        observations: "Evaluator provided an invalid response",
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    if (result.evaluation === "YES" && result2.evaluation === "YES") {
+      return {
+        _success: true,
+        observations: "All fields were filled correctly",
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    } else {
+      return {
+        _success: false,
+        observations: "One or more fields were not filled correctly",
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/iframe_form_multiple.ts b/packages/evals/tasks/agent/iframe_form_multiple.ts
new file mode 100644
index 000000000..d8a8addbb
--- /dev/null
+++ b/packages/evals/tasks/agent/iframe_form_multiple.ts
@@ -0,0 +1,79 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const iframe_form_multiple: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/iframe-form-filling/",
+    );
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Fill in the first name with 'John', the last name with 'Smith', the email with 'john.smith@example.com', and select the email radio button as preferred contact method";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 10,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `Did the agent complete this task successfully? ${instruction}. The form should have: first name = 'John', last name = 'Smith', email = 'john.smith@example.com', and the email radio button selected as preferred contact method.`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/instacart_organic_bananas.ts b/packages/evals/tasks/agent/instacart_organic_bananas.ts
new file mode 100644
index 000000000..0cb94bb9a
--- /dev/null
+++ b/packages/evals/tasks/agent/instacart_organic_bananas.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const instacart_organic_bananas: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.instacart.com");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Search for organic bananas on Instacart and list the top 3 prices along with their retailer names. Only use http://instacart.com to achieve the task. Don't go to any other site. The task is achievable with just navigation from this site.";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 30,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/kayak.ts b/packages/evals/tasks/agent/kayak.ts
new file mode 100644
index 000000000..bdd19fc31
--- /dev/null
+++ b/packages/evals/tasks/agent/kayak.ts
@@ -0,0 +1,66 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+
+export const kayak: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const evaluator = new V3Evaluator(v3);
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.kayak.com");
+
+    await agent.execute({
+      instruction: "Find flights from San Francisco to Tokyo next week",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 25,
+    });
+    await agent.execute({
+      instruction: "Sort the flights by price",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 8,
+    });
+
+    if (v3.context.pages().length !== 2) {
+      return {
+        _success: false,
+        message: "No new pages were opened",
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    const { evaluation, reasoning } = await evaluator.ask({
+      question:
+        "Are the flights shown sorted by price? Check the sort button in the top left corner of the page. It should show cheapest first; use this as the success criteria since the page might promote other flights and not show the list in order.",
+    });
+
+    const success = evaluation === "YES";
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: error.message,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/kfc_tenders_combo.ts b/packages/evals/tasks/agent/kfc_tenders_combo.ts
new file mode 100644
index 000000000..393080fe5
--- /dev/null
+++ b/packages/evals/tasks/agent/kfc_tenders_combo.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const kfc_tenders_combo: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.kfc.com/");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Add a 5-piece Tenders Combo to my bag with Sweet Corn as the side, Sweet Tea as the drink, and both Honey BBQ and Honey Mustard sauces. Select the store closest to Zip code 10001 for pick-up tomorrow at 12:00 PM.";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 40,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/kith.ts b/packages/evals/tasks/agent/kith.ts
new file mode 100644
index 000000000..d74b2d1c6
--- /dev/null
+++ b/packages/evals/tasks/agent/kith.ts
@@ -0,0 +1,80 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+
+export const kith: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const evaluator = new V3Evaluator(v3);
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://kith.com/collections/nike-air-force-1/products/nkcw2288-111?variant=19439468707968",
+    );
+
+    await agent.execute({
+      instruction:
+        "add the shoes to cart, go to checkout, and fill the delivery information. Don't fill the payment information",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 25,
+    });
+
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: "Did the agent fill the delivery information",
+    });
+
+    const success = evaluation === "YES";
+
+    if (success) {
+      await agent.execute({
+        instruction:
+          "fill the credit card information, do not submit the order just add placeholders",
+        maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 10,
+      });
+
+      const { evaluation: evaluation2, reasoning: reasoning2 } =
+        await evaluator.ask({
+          question: "Did the agent fill the payment information",
+        });
+
+      const success2 = evaluation2 === "YES";
+
+      if (success2) {
+        return {
+          _success: true,
+          debugUrl,
+          sessionUrl,
+          logs: logger.getLogs(),
+        };
+      } else {
+        return {
+          _success: false,
+          message: reasoning2,
+          debugUrl,
+          sessionUrl,
+          logs: logger.getLogs(),
+        };
+      }
+    } else {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+  } catch (error) {
+    return {
+      _success: false,
+      message: error.message,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/made_in_china_supplier.ts b/packages/evals/tasks/agent/made_in_china_supplier.ts
new file mode 100644
index 000000000..3bd3670e3
--- /dev/null
+++ b/packages/evals/tasks/agent/made_in_china_supplier.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const made_in_china_supplier: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.made-in-china.com");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Navigate to the suppliers profiles section, select a verified supplier offering 'electronic components', and extract the certification details provided on their profile. Only use http://made-in-china.com to achieve the task. Don't go to any other site. The task is achievable with just navigation from this site.";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 30,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/nba_trades.ts b/packages/evals/tasks/agent/nba_trades.ts
new file mode 100644
index 000000000..285db9c26
--- /dev/null
+++ b/packages/evals/tasks/agent/nba_trades.ts
@@ -0,0 +1,56 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+
+export const nba_trades: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    const evaluator = new V3Evaluator(v3);
+    await page.goto("https://www.espn.com/");
+
+    const agentResult = await agent.execute({
+      instruction:
+        "Find the latest Team transaction in the NBA within the past week.",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 25,
+    });
+    logger.log(agentResult);
+
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: "Did the agent make it to the nba transactions page?",
+    });
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/nvidia_hgx_driver.ts b/packages/evals/tasks/agent/nvidia_hgx_driver.ts
new file mode 100644
index 000000000..4443c64fc
--- /dev/null
+++ b/packages/evals/tasks/agent/nvidia_hgx_driver.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const nvidia_hgx_driver: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://nvidia.com/");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Find the HGX H100 driver for Ubuntu 22.04 on AMD64 CPU. use https://nvidia.com/ to achieve the task. Don't go to any other site. The task is achievable with just navigation from this site.";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 40,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/oed_word_search.ts b/packages/evals/tasks/agent/oed_word_search.ts
new file mode 100644
index 000000000..5becb4acc
--- /dev/null
+++ b/packages/evals/tasks/agent/oed_word_search.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const oed_word_search: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.oed.com");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Filter search results to show only entries for words first used from 1500 to 1600 and list the headwords of the first 10 results. Only use http://oed.com/ to achieve the task. Don't go to any other site. The task is achievable with just navigation from this site.";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 30,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/onlineMind2Web.ts b/packages/evals/tasks/agent/onlineMind2Web.ts
new file mode 100644
index 000000000..79a6466cb
--- /dev/null
+++ b/packages/evals/tasks/agent/onlineMind2Web.ts
@@ -0,0 +1,127 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+import { imageResize } from "../../utils/imageResize.js";
+
+export const onlineMind2Web: EvalFunction = async ({
+  v3,
+  logger,
+  debugUrl,
+  sessionUrl,
+  modelName,
+  input,
+}) => {
+  // Track resources that need cleanup
+  let screenshotCollector: ScreenshotCollector | null = null;
+  let screenshotHandler: ((buffer: Buffer) => void) | null = null;
+
+  try {
+    const params = ((input && input.params) || {}) as {
+      task_id?: string;
+      confirmed_task?: string;
+      website?: string;
+      reference_length?: number;
+      level?: string;
+    };
+
+    if (!params.website || !params.confirmed_task) {
+      return {
+        _success: false,
+        error: `Missing onlineMind2Web params (website, confirmed_task). Got: ${JSON.stringify(params)}`,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    const page = v3.context.pages()[0];
+    await page.goto(params.website, {
+      timeoutMs: 120_000,
+    });
+
+    const agent = v3.agent({
+      cua: true,
+      model: modelName,
+      systemPrompt: `You are a helpful assistant that must solve the task by browsing. At the end, produce a single line: "Final Answer: <answer>" summarizing the requested result (e.g., score, list, or text). Current page: ${await page.title()}. ALWAYS OPERATE WITHIN THE PAGE OPENED BY THE USER, WHICHEVER TASK YOU ARE ATTEMPTING TO COMPLETE CAN BE ACCOMPLISHED WITHIN THE PAGE.`,
+    });
+
+    // Set up event-driven screenshot collection via the V3 event bus
+    screenshotCollector = new ScreenshotCollector(v3, {
+      maxScreenshots: 7,
+    });
+
+    // Subscribe to screenshot events from the agent
+    screenshotHandler = (buffer: Buffer) => {
+      screenshotCollector?.addScreenshot(buffer);
+    };
+    v3.bus.on("agent_screenshot_taken_event", screenshotHandler);
+
+    const agentResult = await agent.execute({
+      instruction: params.confirmed_task,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 50,
+    });
+
+    // Stop collecting, clean up event listener, and get all screenshots
+    v3.bus.off("agent_screenshot_taken_event", screenshotHandler);
+    let screenshots = await screenshotCollector.stop();
+
+    // Resize screenshots if we have any
+    if (screenshots.length > 0) {
+      screenshots = await Promise.all(
+        screenshots.map(async (screenshot) => {
+          return await imageResize(screenshot, 0.7);
+        }),
+      );
+    }
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const evalResult = await evaluator.ask({
+      question: `Did the agent successfully complete this task: "${params.confirmed_task}"?`,
+      screenshot: screenshots,
+      agentReasoning:
+        agentResult.message ||
+        "no reasoning available, agent potentially hit step limit",
+    });
+
+    // Clear screenshot buffers to free memory
+    screenshots.length = 0;
+
+    return {
+      _success: evalResult.evaluation === "YES",
+      reasoning: evalResult.reasoning,
+      task_level: params.level,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    // Always clean up event listener and stop collector to prevent hanging
+    if (screenshotHandler) {
+      try {
+        v3.bus.off("agent_screenshot_taken_event", screenshotHandler);
+      } catch {
+        // Ignore errors during cleanup
+      }
+    }
+    if (screenshotCollector) {
+      try {
+        await screenshotCollector.stop();
+      } catch {
+        // Ignore errors during cleanup
+      }
+    }
+  }
+};
diff --git a/packages/evals/tasks/agent/radiotimes_tv_schedule.ts b/packages/evals/tasks/agent/radiotimes_tv_schedule.ts
new file mode 100644
index 000000000..ff92ab431
--- /dev/null
+++ b/packages/evals/tasks/agent/radiotimes_tv_schedule.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const radiotimes_tv_schedule: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://radiotimes.com");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Locate tonight's featured TV schedule on Radiotimes, and list the titles of shows airing on both BBC and ITV. Only use http://radiotimes.com to achieve the task. Don't go to any other site. The task is achievable with just navigation from this site.";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 40,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/redfin_apartment_rental.ts b/packages/evals/tasks/agent/redfin_apartment_rental.ts
new file mode 100644
index 000000000..c061a2d93
--- /dev/null
+++ b/packages/evals/tasks/agent/redfin_apartment_rental.ts
@@ -0,0 +1,85 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const redfin_apartment_rental: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://redfin.com/");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    // Calculate move-in date as 30 days from now
+    const moveInDate = new Date();
+    moveInDate.setDate(moveInDate.getDate() + 30);
+    const moveInDateFormatted = moveInDate.toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "long",
+      day: "numeric",
+    });
+
+    const instruction = `Find a 2 bed and 1.5+ bath apartment listing for rent in New York, with a move in date of ${moveInDateFormatted}. use https://redfin.com/ to achieve the task. Don't go to any other site. The task is achievable with just navigation from this site.`;
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 40,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/sf_library_card.ts b/packages/evals/tasks/agent/sf_library_card.ts
new file mode 100644
index 000000000..4c22f5636
--- /dev/null
+++ b/packages/evals/tasks/agent/sf_library_card.ts
@@ -0,0 +1,63 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+
+export const sf_library_card: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://sflib1.sfpl.org/selfreg");
+    const agentResult = await agent.execute({
+      instruction: "Fill in the 'street Address' field with '166 Geary St'",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 1,
+    });
+    logger.log(agentResult);
+    const evaluator = new V3Evaluator(v3);
+    const result = await evaluator.ask({
+      question:
+        "Does the page show the 'street Address' field filled with '166 Geary St'?",
+    });
+
+    if (result.evaluation !== "YES" && result.evaluation !== "NO") {
+      return {
+        _success: false,
+        observations: "Evaluator provided an invalid response",
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    if (result.evaluation === "YES") {
+      return {
+        _success: true,
+        observations: result.reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    } else {
+      return {
+        _success: false,
+        observations: result.reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/sf_library_card_multiple.ts b/packages/evals/tasks/agent/sf_library_card_multiple.ts
new file mode 100644
index 000000000..5026c04c3
--- /dev/null
+++ b/packages/evals/tasks/agent/sf_library_card_multiple.ts
@@ -0,0 +1,65 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+
+export const sf_library_card_multiple: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://sflib1.sfpl.org/selfreg");
+
+    const agentResult = await agent.execute({
+      instruction:
+        "Fill in ALL the required fields with mock data. DO NOT submit the form",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 20,
+    });
+    logger.log(agentResult);
+
+    const evaluator = new V3Evaluator(v3);
+    const result = await evaluator.ask({
+      question: "Does the page show all the required fields filled?",
+    });
+
+    if (result.evaluation !== "YES" && result.evaluation !== "NO") {
+      return {
+        _success: false,
+        observations: "Evaluator provided an invalid response",
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    if (result.evaluation === "YES") {
+      return {
+        _success: true,
+        observations: result.reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    } else {
+      return {
+        _success: false,
+        observations: result.reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/sign_in.ts b/packages/evals/tasks/agent/sign_in.ts
new file mode 100644
index 000000000..a5db8938a
--- /dev/null
+++ b/packages/evals/tasks/agent/sign_in.ts
@@ -0,0 +1,50 @@
+import { EvalFunction } from "../../types/evals.js";
+
+export const sign_in: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://v0-modern-login-flow.vercel.app/");
+
+    const agentResult = await agent.execute({
+      instruction:
+        "Sign in with the email address 'test@browserbaser.com' and the password 'stagehand=goated' ",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 15,
+    });
+    logger.log(agentResult);
+    const url = page.url();
+
+    if (url === "https://v0-modern-login-flow.vercel.app/authorized") {
+      return {
+        _success: true,
+        observations: url,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    return {
+      _success: false,
+      observations: url,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/steam_games.ts b/packages/evals/tasks/agent/steam_games.ts
new file mode 100644
index 000000000..2671bc2ee
--- /dev/null
+++ b/packages/evals/tasks/agent/steam_games.ts
@@ -0,0 +1,49 @@
+import { EvalFunction } from "../../types/evals.js";
+
+export const steam_games: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://store.steampowered.com/");
+
+    const agentResult = await agent.execute({
+      instruction:
+        "Show most played games in Steam. And tell me the number of players in game at this time",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 30,
+    });
+
+    //strictly used url check and no extract as the top games / players can vary
+    const success = page.url().includes("https://store.steampowered.com/");
+
+    if (!success) {
+      return {
+        _success: false,
+        message: agentResult.message,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: error.message,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/thegamer_opinion_article.ts b/packages/evals/tasks/agent/thegamer_opinion_article.ts
new file mode 100644
index 000000000..9efd6a994
--- /dev/null
+++ b/packages/evals/tasks/agent/thegamer_opinion_article.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const thegamer_opinion_article: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.thegamer.com");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Locate an Opinion or Cultural Commentary article discussing modern gaming culture and summarize its central argument in one or two sentences. Only use http://thegamer.com to achieve the task. Don't go to any other site. The task is achievable with just navigation from this site.";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 30,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/trailhead_superbadge.ts b/packages/evals/tasks/agent/trailhead_superbadge.ts
new file mode 100644
index 000000000..c862ebd07
--- /dev/null
+++ b/packages/evals/tasks/agent/trailhead_superbadge.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const trailhead_superbadge: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://trailhead.salesforce.com/");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Find the tasks needed to complete the Assess Your Access & Security Skills category in the secure your app trailhead";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 40,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/trivago.ts b/packages/evals/tasks/agent/trivago.ts
new file mode 100644
index 000000000..3a0b0fa9f
--- /dev/null
+++ b/packages/evals/tasks/agent/trivago.ts
@@ -0,0 +1,54 @@
+import { EvalFunction } from "../../types/evals.js";
+
+export const trivago: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.trivago.com/");
+
+    const agentResult = await agent.execute({
+      instruction:
+        "Find the cheapest room in the hotel H10 Tribeca in Madrid next weekend. Stop at the trivago page showing the results",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 13,
+    });
+    logger.log(agentResult);
+
+    const url = page.url();
+
+    if (
+      url.includes("hotel-h10-tribeca-madrid") &&
+      url.includes("trivago.com")
+    ) {
+      return {
+        _success: true,
+        observations: url,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    } else {
+      return {
+        _success: false,
+        observations: url,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/trustpilot_hr_companies.ts b/packages/evals/tasks/agent/trustpilot_hr_companies.ts
new file mode 100644
index 000000000..8d9d38578
--- /dev/null
+++ b/packages/evals/tasks/agent/trustpilot_hr_companies.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const trustpilot_hr_companies: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://trustpilot.com");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Use Trustpilot's search function to filter HR & Recruiting located in 'London', then list the review summaries for the first three companies listed above 4.5 stars. Only use http://trustpilot.com to achieve the task. Don't go to any other site. The task is achievable with just navigation from this site.";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 40,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/ubereats.ts b/packages/evals/tasks/agent/ubereats.ts
new file mode 100644
index 000000000..9f300ff3a
--- /dev/null
+++ b/packages/evals/tasks/agent/ubereats.ts
@@ -0,0 +1,54 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+
+export const ubereats: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const evaluator = new V3Evaluator(v3);
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.ubereats.com/");
+
+    await agent.execute({
+      instruction:
+        "Order a pizza from ubereats to 639 geary st in sf, call the task complete once the login page is shown after adding pizza and viewing the cart",
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 35,
+    });
+
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: "Did the agent make it to the login page?",
+    });
+
+    const success =
+      evaluation === "YES" && page.url().includes("https://auth.uber.com/");
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: error.message,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/uniqlo_mens_blazers.ts b/packages/evals/tasks/agent/uniqlo_mens_blazers.ts
new file mode 100644
index 000000000..233bfcdc9
--- /dev/null
+++ b/packages/evals/tasks/agent/uniqlo_mens_blazers.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const uniqlo_mens_blazers: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.uniqlo.com");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Show me the list of Men's Blazers, Black, Size M on Uniqlo.";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 40,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/webmd_audiologist_search.ts b/packages/evals/tasks/agent/webmd_audiologist_search.ts
new file mode 100644
index 000000000..4c5da4f27
--- /dev/null
+++ b/packages/evals/tasks/agent/webmd_audiologist_search.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const webmd_audiologist_search: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://doctor.webmd.com/");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Find the best Audiologist within 50 miles of New York, NY, with a rating of 4 and above. use https://doctor.webmd.com/ to achieve the task. Don't go to any other site. The task is achievable with just navigation from this site.";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 40,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/webmd_ovulation_calculator.ts b/packages/evals/tasks/agent/webmd_ovulation_calculator.ts
new file mode 100644
index 000000000..2fcc7107c
--- /dev/null
+++ b/packages/evals/tasks/agent/webmd_ovulation_calculator.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+
+export const webmd_ovulation_calculator: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  logger,
+  agent,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.webmd.com/");
+
+    // Start collecting screenshots throughout the agent's journey
+    const screenshotCollector = new ScreenshotCollector(v3, {
+      interval: 3000,
+      maxScreenshots: 15,
+    });
+    screenshotCollector.start();
+
+    const instruction =
+      "Search for the ovulation calculator and enter Mar 1 as the first date of the period and calculate the date of ovulation and pregnancy test day. use https://www.webmd.com/ to achieve the task. Don't go to any other site. The task is achievable with just navigation from this site.";
+    const agentResult = await agent.execute({
+      instruction,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 40,
+    });
+
+    // Stop and collect all screenshots from the journey
+    const screenshots = await screenshotCollector.stop();
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const { evaluation, reasoning } = await evaluator.ask({
+      question: `did the agent complete this task successfully? ${instruction}`,
+      screenshot: screenshots,
+      agentReasoning: agentResult.message,
+    });
+
+    console.log(`reasoning: ${reasoning}`);
+
+    const success = evaluation === "YES";
+
+    if (!success) {
+      return {
+        _success: false,
+        message: reasoning,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: true,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      _success: false,
+      message: errorMessage,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/agent/webtailbench.ts b/packages/evals/tasks/agent/webtailbench.ts
new file mode 100644
index 000000000..11c45d368
--- /dev/null
+++ b/packages/evals/tasks/agent/webtailbench.ts
@@ -0,0 +1,129 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+import { imageResize } from "../../utils/imageResize.js";
+
+export const webtailbench: EvalFunction = async ({
+  v3,
+  logger,
+  debugUrl,
+  sessionUrl,
+  modelName,
+  input,
+}) => {
+  // Track resources that need cleanup
+  let screenshotCollector: ScreenshotCollector | null = null;
+  let screenshotHandler: ((buffer: Buffer) => void) | null = null;
+
+  try {
+    const params = ((input && input.params) || {}) as {
+      id?: string;
+      category?: string;
+      ques?: string;
+      web?: string;
+    };
+
+    if (!params.ques) {
+      return {
+        _success: false,
+        error: `Missing webtailbench params (ques). Got: ${JSON.stringify(params)}`,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    const page = v3.context.pages()[0];
+    // web field is always empty in WebTailBench; start from Google
+    const startUrl = params.web || "https://www.google.com";
+    await page.goto(startUrl, {
+      timeoutMs: 120_000,
+    });
+
+    const agent = v3.agent({
+      cua: true,
+      model: modelName,
+      systemPrompt: `You are a helpful assistant that must solve the task by browsing. At the end, produce a single line: "Final Answer: <answer>" summarizing the requested result (e.g., score, list, or text). Current page: ${await page.title()}. You will need to navigate to the appropriate website to complete the task.`,
+    });
+
+    // Set up event-driven screenshot collection via the V3 event bus
+    screenshotCollector = new ScreenshotCollector(v3, {
+      maxScreenshots: 8,
+    });
+
+    // Subscribe to screenshot events from the agent
+    screenshotHandler = (buffer: Buffer) => {
+      screenshotCollector?.addScreenshot(buffer);
+    };
+    v3.bus.on("agent_screenshot_taken_event", screenshotHandler);
+
+    const agentResult = await agent.execute({
+      instruction: params.ques,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 50,
+    });
+
+    // Clean up event listener and stop collecting
+    v3.bus.off("agent_screenshot_taken_event", screenshotHandler);
+    // Stop collecting and get all screenshots
+    let screenshots = await screenshotCollector.stop();
+
+    // Resize screenshots if we have any
+    if (screenshots.length > 0) {
+      screenshots = await Promise.all(
+        screenshots.map(async (screenshot) => {
+          return await imageResize(screenshot, 0.7);
+        }),
+      );
+    }
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const evalResult = await evaluator.ask({
+      question: `Did the agent successfully complete this task: "${params.ques}"? Note that the agent does not have purchasing/booking capabilities; mark as pass if the agent has successfully performed all necessary steps for the task up to the point of purchasing/booking/entering payment/user information`,
+      screenshot: screenshots,
+      agentReasoning:
+        agentResult.message ||
+        "no reasoning available, agent potentially hit step limit",
+    });
+
+    // Clear screenshot buffers to free memory
+    screenshots.length = 0;
+
+    return {
+      _success: evalResult.evaluation === "YES",
+      reasoning: evalResult.reasoning,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    // Always clean up event listener and stop collector to prevent hanging
+    if (screenshotHandler) {
+      try {
+        v3.bus.off("agent_screenshot_taken_event", screenshotHandler);
+      } catch {
+        // Ignore errors during cleanup
+      }
+    }
+    if (screenshotCollector) {
+      try {
+        await screenshotCollector.stop();
+      } catch {
+        // Ignore errors during cleanup
+      }
+    }
+  }
+};
diff --git a/packages/evals/tasks/agent/webvoyager.ts b/packages/evals/tasks/agent/webvoyager.ts
new file mode 100644
index 000000000..3b14d1c11
--- /dev/null
+++ b/packages/evals/tasks/agent/webvoyager.ts
@@ -0,0 +1,126 @@
+import { EvalFunction } from "../../types/evals.js";
+import { V3Evaluator } from "@browserbasehq/stagehand";
+import { ScreenshotCollector } from "../../utils/ScreenshotCollector.js";
+import { imageResize } from "../../utils/imageResize.js";
+
+export const webvoyager: EvalFunction = async ({
+  v3,
+  logger,
+  debugUrl,
+  sessionUrl,
+  modelName,
+  input,
+}) => {
+  // Track resources that need cleanup
+  let screenshotCollector: ScreenshotCollector | null = null;
+  let screenshotHandler: ((buffer: Buffer) => void) | null = null;
+
+  try {
+    const params = ((input && input.params) || {}) as {
+      id?: string;
+      web?: string;
+      ques?: string;
+      web_name?: string;
+    };
+
+    if (!params.web || !params.ques) {
+      return {
+        _success: false,
+        error: `Missing WebVoyager params (web, ques). Got: ${JSON.stringify(params)}`,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    const page = v3.context.pages()[0];
+    await page.goto(params.web, {
+      timeoutMs: 120_000,
+    });
+
+    const agent = v3.agent({
+      model: modelName,
+      systemPrompt: `You are a helpful assistant that must solve the task by browsing. At the end, produce a single line: "Final Answer: <answer>" summarizing the requested result (e.g., score, list, or text). Current page: ${await page.title()}`,
+    });
+
+    // Set up event-driven screenshot collection via the V3 event bus
+    screenshotCollector = new ScreenshotCollector(v3, {
+      maxScreenshots: 7,
+    });
+
+    // Subscribe to screenshot events from the agent
+    screenshotHandler = (buffer: Buffer) => {
+      screenshotCollector?.addScreenshot(buffer);
+    };
+    v3.bus.on("agent_screenshot_taken_event", screenshotHandler);
+
+    const agentResult = await agent.execute({
+      instruction: params.ques,
+      maxSteps: Number(process.env.AGENT_EVAL_MAX_STEPS) || 50,
+    });
+
+    // Clean up event listener and stop collecting
+    v3.bus.off("agent_screenshot_taken_event", screenshotHandler);
+    // Stop collecting and get all screenshots
+    let screenshots = await screenshotCollector.stop();
+
+    // Resize screenshots if we have any
+    if (screenshots.length > 0) {
+      screenshots = await Promise.all(
+        screenshots.map(async (screenshot) => {
+          return await imageResize(screenshot, 0.7);
+        }),
+      );
+    }
+
+    logger.log({
+      category: "evaluation",
+      message: `Collected ${screenshots.length} screenshots for evaluation`,
+      level: 1,
+    });
+
+    const evaluator = new V3Evaluator(v3);
+    const evalResult = await evaluator.ask({
+      question: `Did the agent successfully complete this task: "${params.ques}"?`,
+      screenshot: screenshots,
+      agentReasoning:
+        agentResult.message ||
+        "no reasoning available, agent potentially hit step limit",
+    });
+
+    // Clear screenshot buffers to free memory
+    screenshots.length = 0;
+
+    return {
+      _success: evalResult.evaluation === "YES",
+      reasoning: evalResult.reasoning,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    // Always clean up event listener and stop collector to prevent hanging
+    if (screenshotHandler) {
+      try {
+        v3.bus.off("agent_screenshot_taken_event", screenshotHandler);
+      } catch {
+        // Ignore errors during cleanup
+      }
+    }
+    if (screenshotCollector) {
+      try {
+        screenshotCollector.stop();
+      } catch {
+        // Ignore errors during cleanup
+      }
+    }
+  }
+};
diff --git a/packages/evals/tasks/allrecipes.ts b/packages/evals/tasks/allrecipes.ts
new file mode 100644
index 000000000..9fdd46929
--- /dev/null
+++ b/packages/evals/tasks/allrecipes.ts
@@ -0,0 +1,97 @@
+import { EvalFunction } from "../types/evals.js";
+import { z } from "zod";
+
+export const allrecipes: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.allrecipes.com/", {
+      waitUntil: "domcontentloaded",
+    });
+
+    await v3.act('Type "chocolate chip cookies" in the search bar');
+    await v3.act("press enter");
+
+    const recipeDetails = await v3.extract(
+      "Extract the title of the first recipe and the total number of ratings it has received.",
+      z.object({
+        title: z.string().describe("Title of the recipe"),
+        total_ratings: z
+          .string()
+          .describe("Total number of ratings for the recipe"),
+      }),
+    );
+
+    const { title, total_ratings } = recipeDetails;
+    const expectedTitle = "Best Chocolate Chip Cookies";
+    const expectedRatings = 19164;
+
+    const extractedRatings = parseInt(total_ratings.replace(/[^\d]/g, ""), 10);
+    const isRatingsWithinRange =
+      extractedRatings >= expectedRatings - 1000 &&
+      extractedRatings <= expectedRatings + 1000;
+
+    if (title !== expectedTitle || !isRatingsWithinRange) {
+      const errors = [];
+      if (title !== expectedTitle) {
+        errors.push({
+          message: "Extracted title does not match the expected title",
+          expected: expectedTitle,
+          actual: title,
+        });
+      }
+      if (!isRatingsWithinRange) {
+        errors.push({
+          message: "Extracted ratings are not within the expected range",
+          expected: `${expectedRatings} ± 1000`,
+          actual: extractedRatings.toString(),
+        });
+      }
+
+      logger.error({
+        message: "Failed to extract correct recipe details",
+        level: 0,
+        auxiliary: {
+          errors: {
+            value: JSON.stringify(errors),
+            type: "object",
+          },
+        },
+      });
+
+      return {
+        _success: false,
+        error: "Recipe details extraction validation failed",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      recipeDetails: {
+        title,
+        total_ratings: extractedRatings,
+      },
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: "Recipe details extraction validation failed",
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/amazon_add_to_cart.ts b/packages/evals/tasks/amazon_add_to_cart.ts
new file mode 100644
index 000000000..27e8cfac0
--- /dev/null
+++ b/packages/evals/tasks/amazon_add_to_cart.ts
@@ -0,0 +1,43 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const amazon_add_to_cart: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/amazon/",
+    );
+
+    await v3.act("click the 'Add to Cart' button");
+
+    await v3.act("click the 'Proceed to checkout' button");
+
+    const currentUrl = page.url();
+    const expectedUrl =
+      "https://browserbase.github.io/stagehand-eval-sites/sites/amazon/sign-in.html";
+
+    console.log("currentUrl", currentUrl);
+    console.log("expectedUrl", expectedUrl);
+    return {
+      _success: currentUrl === expectedUrl,
+      currentUrl,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/apple.ts b/packages/evals/tasks/apple.ts
new file mode 100644
index 000000000..36eae4f25
--- /dev/null
+++ b/packages/evals/tasks/apple.ts
@@ -0,0 +1,44 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const apple: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.apple.com/iphone-16-pro/");
+
+    await v3.act("click on the buy button");
+    await v3.act("select the Pro Max model");
+    await v3.act("select the natural titanium color");
+    await v3.act("select the 256GB storage option");
+    await v3.act("click on the 'select a smartphone' trade-in option");
+
+    await v3.act("select the iPhone 13 mini model from the dropdown");
+    await v3.act("select the iPhone 13 mini is in good condition");
+
+    const successMessageLocator = page.locator(
+      'text="Good News. Your iPhone 13 mini qualifies for credit."',
+    );
+    const isVisible = await successMessageLocator.isVisible();
+
+    return {
+      _success: isVisible,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/evals/tasks/arxiv.ts b/packages/evals/tasks/arxiv.ts
similarity index 79%
rename from evals/tasks/arxiv.ts
rename to packages/evals/tasks/arxiv.ts
index 919d28c7f..8a2cf2656 100644
--- a/evals/tasks/arxiv.ts
+++ b/packages/evals/tasks/arxiv.ts
@@ -1,44 +1,39 @@
-import { EvalFunction } from "@/types/evals";
+import { EvalFunction } from "../types/evals.js";
 import { z } from "zod";
 
 export const arxiv: EvalFunction = async ({
   logger,
   debugUrl,
   sessionUrl,
-  stagehand,
-  useTextExtract,
+  v3,
 }) => {
   try {
-    await stagehand.page.goto("https://arxiv.org/search/");
+    const page = v3.context.pages()[0];
+    await page.goto("https://arxiv.org/search/");
 
-    await stagehand.page.act(
-      "type web agents with multimodal models in the search bar",
-    );
+    await v3.act("type web agents with multimodal models in the search bar");
 
-    await stagehand.page.act("hit enter");
+    await v3.act("hit enter");
 
-    const paper_links = await stagehand.page.extract({
-      instruction: "extract the titles and links for two papers",
-      schema: z.object({
+    const paper_links = await v3.extract(
+      "extract the titles and links for two papers",
+      z.object({
         papers: z
           .array(
             z.object({
               title: z.string().describe("the title of the paper"),
-              link: z.string().describe("the link to the paper").nullable(),
+              link: z.string().url().describe("the link to the paper"),
             }),
           )
           .describe("list of papers"),
       }),
-      useTextExtract,
-    });
+    );
 
     if (
       !paper_links ||
       !paper_links.papers ||
       paper_links.papers.length === 0
     ) {
-      await stagehand.close();
-
       return {
         _success: false,
         logs: logger.getLogs(),
@@ -50,10 +45,10 @@ export const arxiv: EvalFunction = async ({
     const papers = [];
     for (const paper of paper_links.papers) {
       if (paper.link) {
-        await stagehand.page.goto(paper.link);
-        const abstract = await stagehand.page.extract({
-          instruction: "extract details of the paper from the abstract",
-          schema: z.object({
+        await page.goto(paper.link);
+        const abstract = await v3.extract(
+          "extract details of the paper from the abstract",
+          z.object({
             category: z
               .string()
               .describe(
@@ -86,8 +81,7 @@ export const arxiv: EvalFunction = async ({
               )
               .nullable(),
           }),
-          useTextExtract,
-        });
+        );
 
         papers.push({
           title: paper.title,
@@ -98,8 +92,6 @@ export const arxiv: EvalFunction = async ({
     }
 
     if (!papers || papers.length === 0) {
-      await stagehand.close();
-
       return {
         _success: false,
         logs: logger.getLogs(),
@@ -124,8 +116,6 @@ export const arxiv: EvalFunction = async ({
         },
       });
 
-      await stagehand.close();
-
       return {
         _success: false,
         error: "Incorrect number of papers extracted",
@@ -149,8 +139,6 @@ export const arxiv: EvalFunction = async ({
           },
         });
 
-        await stagehand.close();
-
         return {
           _success: false,
           error: "Incomplete paper information",
@@ -161,8 +149,6 @@ export const arxiv: EvalFunction = async ({
       }
     }
 
-    await stagehand.close();
-
     return {
       _success: true,
       papers,
@@ -186,13 +172,14 @@ export const arxiv: EvalFunction = async ({
       },
     });
 
-    await stagehand.close();
-
     return {
       _success: false,
+      error: error,
       logs: logger.getLogs(),
       debugUrl,
       sessionUrl,
     };
+  } finally {
+    await v3.close();
   }
 };
diff --git a/packages/evals/tasks/bidnet.ts b/packages/evals/tasks/bidnet.ts
new file mode 100644
index 000000000..a88c1a83b
--- /dev/null
+++ b/packages/evals/tasks/bidnet.ts
@@ -0,0 +1,37 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const bidnet: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.bidnetdirect.com/");
+
+    await v3.act('Click on the "Construction" keyword');
+
+    const expectedUrl =
+      "https://www.bidnetdirect.com/public/solicitations/open?keywords=Construction";
+    const currentUrl = page.url();
+
+    return {
+      _success: currentUrl.startsWith(expectedUrl),
+      currentUrl,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/checkboxes.ts b/packages/evals/tasks/checkboxes.ts
new file mode 100644
index 000000000..09c6cd5c6
--- /dev/null
+++ b/packages/evals/tasks/checkboxes.ts
@@ -0,0 +1,44 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const checkboxes: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/checkboxes/",
+    );
+
+    await v3.act("click the 'baseball' option");
+
+    await v3.act("click the 'netball' option");
+
+    const baseballChecked = await page
+      .locator('input[type="checkbox"][name="sports"][value="baseball"]')
+      .isChecked();
+
+    const netballChecked = await page
+      .locator('input[type="checkbox"][name="sports"][value="netball"]')
+      .isChecked();
+
+    return {
+      _success: baseballChecked && netballChecked,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (e) {
+    return {
+      _success: false,
+      error: e,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/combination_sauce.ts b/packages/evals/tasks/combination_sauce.ts
new file mode 100644
index 000000000..8685a7c0e
--- /dev/null
+++ b/packages/evals/tasks/combination_sauce.ts
@@ -0,0 +1,53 @@
+import { EvalFunction } from "../types/evals.js";
+import { z } from "zod";
+
+export const combination_sauce: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.saucedemo.com/");
+
+    const { usernames, password } = await v3.extract(
+      "extract the accepted usernames and the password for login",
+      z.object({
+        usernames: z.array(z.string()).describe("the accepted usernames"),
+        password: z.string().describe("the password for login"),
+      }),
+    );
+
+    await v3.act(`enter username 'standard_user'`);
+
+    await v3.act(`enter password '${password}'`);
+
+    await v3.act("click on 'login'");
+
+    const observations = await v3.observe("find all the 'add to cart' buttons");
+
+    const url = page.url();
+
+    const usernamesCheck = usernames.length === 6;
+    const urlCheck = url === "https://www.saucedemo.com/inventory.html";
+    const observationsCheck = observations.length === 6;
+
+    return {
+      _success: usernamesCheck && urlCheck && observationsCheck,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: JSON.parse(JSON.stringify(error, null, 2)),
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/evals/tasks/costar.ts b/packages/evals/tasks/costar.ts
similarity index 61%
rename from evals/tasks/costar.ts
rename to packages/evals/tasks/costar.ts
index 221919e4e..71ccf5a31 100644
--- a/evals/tasks/costar.ts
+++ b/packages/evals/tasks/costar.ts
@@ -1,35 +1,26 @@
-import { EvalFunction } from "@/types/evals";
+import { EvalFunction } from "../types/evals.js";
 import { z } from "zod";
 
 export const costar: EvalFunction = async ({
   logger,
   debugUrl,
   sessionUrl,
-  stagehand,
-  useTextExtract,
+  v3,
 }) => {
-  // TODO: fix this eval - does not work in headless mode
   try {
-    await Promise.race([
-      stagehand.page.goto("https://www.costar.com/"),
-      new Promise((_, reject) =>
-        setTimeout(() => reject(new Error("Navigation timeout")), 30000),
-      ),
-    ]);
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.costar.com/");
 
-    await stagehand.page.act({ action: "click on the first article" });
+    await v3.act("click on the first article");
 
-    await stagehand.page.act({
-      action: "click on the learn more button for the first job",
-    });
+    await v3.act("click on the learn more button for the first job");
 
-    const articleTitle = await stagehand.page.extract({
-      instruction: "extract the title of the article",
-      schema: z.object({
+    const articleTitle = await v3.extract(
+      "extract the title of the article",
+      z.object({
         title: z.string().describe("the title of the article").nullable(),
       }),
-      useTextExtract,
-    });
+    );
 
     logger.log({
       message: "got article title",
@@ -46,7 +37,7 @@ export const costar: EvalFunction = async ({
     const isTitleValid =
       articleTitle.title !== null && articleTitle.title.length > 5;
 
-    await stagehand.close();
+    await v3.close();
 
     return {
       title: articleTitle.title,
@@ -71,14 +62,15 @@ export const costar: EvalFunction = async ({
       },
     });
 
-    await stagehand.close();
-
     return {
       title: null,
       _success: false,
+      error: error,
       debugUrl,
       sessionUrl,
       logs: logger.getLogs(),
     };
+  } finally {
+    await v3.close();
   }
 };
diff --git a/packages/evals/tasks/csr_in_oopif.ts b/packages/evals/tasks/csr_in_oopif.ts
new file mode 100644
index 000000000..1a8b606b0
--- /dev/null
+++ b/packages/evals/tasks/csr_in_oopif.ts
@@ -0,0 +1,52 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const csr_in_oopif: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  // this eval is designed to test whether stagehand can successfully
+  // click inside an CSR (closed mode shadow) root that is inside an
+  // OOPIF (out of process iframe)
+
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/closed-shadow-root-in-oopif/",
+    );
+    await v3.act("click the button");
+
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    const extraction = await v3.extract("extract the entire page text");
+
+    const pageText = extraction.extraction;
+
+    if (pageText.includes("button successfully clicked")) {
+      return {
+        _success: true,
+        message: `successfully clicked the button`,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: false,
+      message: `unable to click on the button`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: `error: ${error.message}`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/csr_in_spif.ts b/packages/evals/tasks/csr_in_spif.ts
new file mode 100644
index 000000000..0845c7f2d
--- /dev/null
+++ b/packages/evals/tasks/csr_in_spif.ts
@@ -0,0 +1,51 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const csr_in_spif: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  // this eval is designed to test whether stagehand can successfully
+  // click inside an CSR (closed mode shadow) root that is inside an
+  // SPIF (same process iframe)
+
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/closed-shadow-dom-in-spif/",
+    );
+    await v3.act("click the button");
+
+    const extraction = await v3.extract("extract the entire page text");
+
+    const pageText = extraction.extraction;
+
+    if (pageText.includes("button successfully clicked")) {
+      return {
+        _success: true,
+        message: `successfully clicked the button`,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: false,
+      message: `unable to click on the button`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: `error: ${error.message}`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/custom_dropdown.ts b/packages/evals/tasks/custom_dropdown.ts
new file mode 100644
index 000000000..7225bb14a
--- /dev/null
+++ b/packages/evals/tasks/custom_dropdown.ts
@@ -0,0 +1,56 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const custom_dropdown: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  /**
+   * This eval is meant to test whether we do not incorrectly attempt
+   * the selectOptionFromDropdown method (defined in actHandlerUtils.ts) on a
+   * 'dropdown' that is not a <select> element.
+   *
+   * This kind of dropdown must be clicked to be expanded before being interacted
+   * with.
+   */
+
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/expand-dropdown/",
+    );
+
+    await v3.act("choose Canada from the 'Select a Country' dropdown");
+
+    // to test, we'll grab the full a11y tree, and make sure it contains 'Canada'
+    const extraction = await v3.extract();
+    const fullTree = extraction.pageText;
+
+    if (fullTree.includes("Canada")) {
+      return {
+        _success: true,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: false,
+      message: "unable to expand the dropdown",
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: `error attempting to select an option from the dropdown: ${error.message}`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/dropdown.ts b/packages/evals/tasks/dropdown.ts
new file mode 100644
index 000000000..b2ff3d98d
--- /dev/null
+++ b/packages/evals/tasks/dropdown.ts
@@ -0,0 +1,49 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const dropdown: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/dropdown/",
+    );
+
+    // click the dropdown element to expand it
+    const xpath = "xpath=/html/body/div/div/button";
+    await page.locator(xpath).click();
+
+    // type into the input box (which should be hidden behind the
+    // expanded dropdown)
+    await v3.act("type 'test fill' into the input field");
+
+    const input = page.locator(`xpath=/html/body/div/input`);
+    const expectedValue = "test fill";
+
+    // get the value of the input box
+    const actualValue = await input.inputValue();
+
+    // pass if the value matches expected
+    return {
+      _success: actualValue === expectedValue,
+      expectedValue,
+      actualValue,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/extract_aigrant_companies.ts b/packages/evals/tasks/extract_aigrant_companies.ts
new file mode 100644
index 000000000..b558ff431
--- /dev/null
+++ b/packages/evals/tasks/extract_aigrant_companies.ts
@@ -0,0 +1,135 @@
+import { z } from "zod";
+import { EvalFunction } from "../types/evals.js";
+
+export const extract_aigrant_companies: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/aigrant/",
+    );
+    const companyList = await v3.extract(
+      "Extract all companies that received the AI grant and group them with their batch numbers as an array of objects. Each object should contain the company name and its corresponding batch number.",
+      z.object({
+        companies: z.array(
+          z.object({
+            company: z.string(),
+            batch: z.string(),
+          }),
+        ),
+      }),
+    );
+    const companies = companyList.companies;
+    const expectedLength = 91;
+
+    const expectedFirstItem = {
+      company: "Goodfire",
+      batch: "4",
+    };
+
+    const expectedLastItem = {
+      company: "Forefront",
+      batch: "1",
+    };
+
+    if (companies.length !== expectedLength) {
+      logger.error({
+        message: "Incorrect number of companies extracted",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: expectedLength.toString(),
+            type: "integer",
+          },
+          actual: {
+            value: companies.length.toString(),
+            type: "integer",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Incorrect number of companies extracted",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+    const firstItemMatches =
+      companies[0].company === expectedFirstItem.company &&
+      companies[0].batch === expectedFirstItem.batch;
+
+    if (!firstItemMatches) {
+      logger.error({
+        message: "First company extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: JSON.stringify(expectedFirstItem),
+            type: "object",
+          },
+          actual: {
+            value: JSON.stringify(companies[0]),
+            type: "object",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "First company extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    const lastItemMatches =
+      companies[companies.length - 1].company === expectedLastItem.company &&
+      companies[companies.length - 1].batch === expectedLastItem.batch;
+
+    if (!lastItemMatches) {
+      logger.error({
+        message: "Last company extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: JSON.stringify(expectedLastItem),
+            type: "object",
+          },
+          actual: {
+            value: JSON.stringify(companies[companies.length - 1]),
+            type: "object",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Last company extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/extract_aigrant_targeted.ts b/packages/evals/tasks/extract_aigrant_targeted.ts
new file mode 100644
index 000000000..94e80f056
--- /dev/null
+++ b/packages/evals/tasks/extract_aigrant_targeted.ts
@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { EvalFunction } from "../types/evals.js";
+
+export const extract_aigrant_targeted: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/aigrant/",
+    );
+    const selector = "/html/body/div/ul[5]/li[28]";
+    const company = await v3.extract(
+      "Extract the company name.",
+      z.object({
+        company_name: z.string(),
+      }),
+      { selector: selector },
+    );
+
+    const companyName = company.company_name;
+
+    const expectedName = {
+      company_name: "Coframe",
+    };
+
+    const nameMatches = companyName == expectedName.company_name;
+
+    if (!nameMatches) {
+      logger.error({
+        message: "extracted company name does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: expectedName.company_name,
+            type: "string",
+          },
+          actual: {
+            value: companyName,
+            type: "string",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Company name does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/extract_aigrant_targeted_2.ts b/packages/evals/tasks/extract_aigrant_targeted_2.ts
new file mode 100644
index 000000000..29f31a212
--- /dev/null
+++ b/packages/evals/tasks/extract_aigrant_targeted_2.ts
@@ -0,0 +1,79 @@
+import { z } from "zod";
+import { EvalFunction } from "../types/evals.js";
+
+export const extract_aigrant_targeted_2: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/aigrant/",
+    );
+    const selector = "/html/body/div/ul[5]/li[28]";
+    const company = await v3.extract(
+      "Extract the name of the company that comes after 'Coframe'.",
+      z.object({
+        company_name: z.string(),
+      }),
+      { selector: selector },
+    );
+    const companyName = company.company_name;
+
+    // nameWeShouldNotGet matches the name of the company that comes after
+    // CoFrame on the website. Since we are using targeted_extract here,
+    // and passing in a selector that does NOT contain the nameWeShouldNotGet,
+    // the LLM should have no visibility into what comes after 'CoFrame' if
+    // targeted_extract is performing correctly
+    const nameWeShouldNotGet = {
+      company_name: "OpusClip",
+    };
+
+    const nameMatches = companyName == nameWeShouldNotGet.company_name;
+
+    if (nameMatches) {
+      logger.error({
+        message:
+          "extracted company name matches the company name that we SHOULD NOT get",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: nameWeShouldNotGet.company_name,
+            type: "string",
+          },
+          actual: {
+            value: companyName,
+            type: "string",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error:
+          "extracted company name matches the company name that we SHOULD NOT get",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/extract_apartments.ts b/packages/evals/tasks/extract_apartments.ts
new file mode 100644
index 000000000..6c68b97b3
--- /dev/null
+++ b/packages/evals/tasks/extract_apartments.ts
@@ -0,0 +1,71 @@
+import { z } from "zod";
+import { EvalFunction } from "../types/evals.js";
+
+export const extract_apartments: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.apartments.com/san-francisco-ca/2-bedrooms/", {
+      waitUntil: "load",
+    });
+    const apartment_listings = await v3.extract(
+      "Extract all the apartment listings with their prices and their addresses.",
+      z.object({
+        listings: z.array(
+          z.object({
+            price: z.string().describe("The price of the listing"),
+            address: z.string().describe("The address of the listing"),
+          }),
+        ),
+      }),
+    );
+
+    const listings = apartment_listings.listings;
+    const expectedLength = 40;
+
+    if (listings.length < expectedLength) {
+      logger.error({
+        message: "Incorrect number of listings extracted",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: expectedLength.toString(),
+            type: "integer",
+          },
+          actual: {
+            value: listings.length.toString(),
+            type: "integer",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Incorrect number of listings extracted",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/extract_area_codes.ts b/packages/evals/tasks/extract_area_codes.ts
new file mode 100644
index 000000000..78b97b671
--- /dev/null
+++ b/packages/evals/tasks/extract_area_codes.ts
@@ -0,0 +1,161 @@
+import { EvalFunction } from "../types/evals.js";
+import { z } from "zod";
+
+export const extract_area_codes: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/ncc-area-codes/",
+      { waitUntil: "domcontentloaded" },
+    );
+
+    const result = await v3.extract(
+      "Extract ALL the Primary Center names and their corresponding Area Code, and the name of their corresponding Zone.",
+      z.object({
+        primary_center_list: z.array(
+          z.object({
+            zone_name: z
+              .string()
+              .describe(
+                "The name of the Zone that the Primary Center is in. For example, 'North Central Zone'.",
+              ),
+            primary_center_name: z
+              .string()
+              .describe(
+                "The name of the Primary Center. I.e., this is the name of the city or town.",
+              ),
+            area_code: z
+              .string()
+              .describe(
+                "The area code for the Primary Center. This will either be 2 or 3 digits.",
+              ),
+          }),
+        ),
+      }),
+    );
+
+    const primaryCenterList = result.primary_center_list;
+    const expectedLength = 56;
+
+    const expectedFirstItem = {
+      zone_name: "Lagos Zone",
+      primary_center_name: "Lagos",
+      area_code: "01",
+    };
+
+    const expectedLastItem = {
+      zone_name: "South-East",
+      primary_center_name: "Yenagoa",
+      area_code: "089",
+    };
+
+    if (primaryCenterList.length !== expectedLength) {
+      logger.error({
+        message: "Incorrect number of primary centers extracted",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: expectedLength.toString(),
+            type: "integer",
+          },
+          actual: {
+            value: primaryCenterList.length.toString(),
+            type: "integer",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Incorrect number of primary centers extracted",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+    const firstItemMatches =
+      primaryCenterList[0].zone_name === expectedFirstItem.zone_name &&
+      primaryCenterList[0].primary_center_name ===
+        expectedFirstItem.primary_center_name &&
+      primaryCenterList[0].area_code === expectedFirstItem.area_code;
+
+    if (!firstItemMatches) {
+      logger.error({
+        message: "First primary center extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: JSON.stringify(expectedFirstItem),
+            type: "object",
+          },
+          actual: {
+            value: JSON.stringify(primaryCenterList[0]),
+            type: "object",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "First primary center extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    const lastItemMatches =
+      primaryCenterList[primaryCenterList.length - 1].zone_name ===
+        expectedLastItem.zone_name &&
+      primaryCenterList[primaryCenterList.length - 1].primary_center_name ===
+        expectedLastItem.primary_center_name &&
+      primaryCenterList[primaryCenterList.length - 1].area_code ===
+        expectedLastItem.area_code;
+
+    if (!lastItemMatches) {
+      logger.error({
+        message: "Last primary center extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: JSON.stringify(expectedLastItem),
+            type: "object",
+          },
+          actual: {
+            value: JSON.stringify(
+              primaryCenterList[primaryCenterList.length - 1],
+            ),
+            type: "object",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Last primary center extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/extract_baptist_health.ts b/packages/evals/tasks/extract_baptist_health.ts
new file mode 100644
index 000000000..4d5fc63a0
--- /dev/null
+++ b/packages/evals/tasks/extract_baptist_health.ts
@@ -0,0 +1,106 @@
+import { EvalFunction } from "../types/evals.js";
+import { compareStrings } from "../utils.js";
+import { z } from "zod";
+
+export const extract_baptist_health: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/baptist-health/",
+    );
+
+    const result = await v3.extract(
+      "Extract the address, phone number, and fax number of the healthcare location.",
+      z.object({
+        address: z.string(),
+        phone: z.string(),
+        fax: z.string(),
+      }),
+    );
+
+    const { address, phone, fax } = result;
+    const expected = {
+      address: "2055 East South Blvd; Suite 908 Montgomery, AL 36116",
+      phone: "334-747-2273",
+      fax: "334-747-7501",
+    };
+
+    const similarityThreshold = 0.85;
+    const failedFields: Array<{
+      field: string;
+      similarity: number;
+      expected: string;
+      actual: string;
+    }> = [];
+
+    const compareField = (
+      actualVal: string,
+      expectedVal: string,
+      fieldName: string,
+    ) => {
+      const { similarity, meetsThreshold } = compareStrings(
+        actualVal,
+        expectedVal,
+        similarityThreshold,
+      );
+
+      if (!meetsThreshold) {
+        failedFields.push({
+          field: fieldName,
+          similarity,
+          expected: expectedVal,
+          actual: actualVal,
+        });
+        logger.error({
+          message: `${fieldName} extracted does not meet similarity threshold`,
+          level: 0,
+          auxiliary: {
+            field: { value: fieldName, type: "string" },
+            similarity: { value: similarity.toFixed(2), type: "string" },
+            expected: { value: expectedVal, type: "string" },
+            actual: { value: actualVal, type: "string" },
+          },
+        });
+      }
+
+      return meetsThreshold;
+    };
+
+    const addressOk = compareField(address, expected.address, "Address");
+    const phoneOk = compareField(phone, expected.phone, "Phone number");
+    const faxOk = compareField(fax, expected.fax, "Fax number");
+
+    if (!addressOk || !phoneOk || !faxOk) {
+      return {
+        _success: false,
+        error: "Some fields did not meet similarity threshold",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+        failedFields,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/extract_capacitor_info.ts b/packages/evals/tasks/extract_capacitor_info.ts
new file mode 100644
index 000000000..433e4420b
--- /dev/null
+++ b/packages/evals/tasks/extract_capacitor_info.ts
@@ -0,0 +1,125 @@
+import { EvalFunction } from "../types/evals.js";
+import { normalizeString } from "../utils.js";
+import { z } from "zod";
+
+export const extract_capacitor_info: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/capacitor/",
+    );
+
+    const result = await v3.extract(
+      "Extract the ECCN Code, RoHS Status, and Impedance.",
+      z.object({
+        ECCN_code: z.string(),
+        RoHS_Status: z.string(),
+        Impedance: z.string(),
+      }),
+    );
+
+    const { ECCN_code, RoHS_Status, Impedance } = result;
+
+    const expected = {
+      ECCN_code: "EAR99",
+      RoHS_Status: "RoHS Compliant",
+      Impedance: "12mOhm",
+    };
+
+    if (normalizeString(ECCN_code) !== normalizeString(expected.ECCN_code)) {
+      logger.error({
+        message: "ECCN code extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: normalizeString(expected.ECCN_code),
+            type: "string",
+          },
+          actual: {
+            value: normalizeString(ECCN_code),
+            type: "string",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "ECCN code extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    if (
+      normalizeString(RoHS_Status) !== normalizeString(expected.RoHS_Status)
+    ) {
+      logger.error({
+        message: "RoHS Status extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: normalizeString(expected.RoHS_Status),
+            type: "string",
+          },
+          actual: {
+            value: normalizeString(RoHS_Status),
+            type: "string",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "RoHS Status extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    if (normalizeString(Impedance) !== normalizeString(expected.Impedance)) {
+      logger.error({
+        message: "Impedance extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: normalizeString(expected.Impedance),
+            type: "string",
+          },
+          actual: {
+            value: normalizeString(Impedance),
+            type: "string",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Impedance extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/evals/tasks/extract_collaborators.ts b/packages/evals/tasks/extract_collaborators.ts
similarity index 60%
rename from evals/tasks/extract_collaborators.ts
rename to packages/evals/tasks/extract_collaborators.ts
index 8e10ee020..cc6bea2f7 100644
--- a/evals/tasks/extract_collaborators.ts
+++ b/packages/evals/tasks/extract_collaborators.ts
@@ -1,26 +1,22 @@
-import { EvalFunction } from "@/types/evals";
+import { EvalFunction } from "../types/evals.js";
 import { z } from "zod";
 
 export const extract_collaborators: EvalFunction = async ({
   logger,
-  useTextExtract,
   debugUrl,
   sessionUrl,
-  stagehand,
+  v3,
 }) => {
   try {
-    await stagehand.page.goto("https://github.com/facebook/react");
-    await stagehand.page.act({
-      action: "find and click the contributors section",
-    });
+    const page = v3.context.pages()[0];
+    await page.goto("https://github.com/facebook/react");
+    await v3.act("find and click the contributors section");
 
-    await stagehand.page.waitForLoadState("domcontentloaded");
-    await stagehand.page.waitForLoadState("networkidle");
-    await stagehand.page.waitForTimeout(5000);
+    await v3.act("scroll halfway down the page");
 
-    const { contributors } = await stagehand.page.extract({
-      instruction: "Extract top 5 contributors of this repository",
-      schema: z.object({
+    const { contributors } = await v3.extract(
+      "Extract top 5 contributors of this repository",
+      z.object({
         contributors: z.array(
           z.object({
             github_username: z
@@ -30,10 +26,7 @@ export const extract_collaborators: EvalFunction = async ({
           }),
         ),
       }),
-      useTextExtract,
-    });
-
-    await stagehand.close();
+    );
 
     const EXPECTED_CONTRIBUTORS = [
       "zpao",
@@ -55,10 +48,6 @@ export const extract_collaborators: EvalFunction = async ({
       logs: logger.getLogs(),
     };
   } catch (error) {
-    console.error("Error or timeout occurred:", error);
-
-    await stagehand.close();
-
     return {
       _success: false,
       error: JSON.parse(JSON.stringify(error, null, 2)),
@@ -66,5 +55,7 @@ export const extract_collaborators: EvalFunction = async ({
       sessionUrl,
       logs: logger.getLogs(),
     };
+  } finally {
+    await v3.close();
   }
 };
diff --git a/packages/evals/tasks/extract_csa.ts b/packages/evals/tasks/extract_csa.ts
new file mode 100644
index 000000000..1c69aa085
--- /dev/null
+++ b/packages/evals/tasks/extract_csa.ts
@@ -0,0 +1,155 @@
+import { EvalFunction } from "../types/evals.js";
+import { z } from "zod";
+
+export const extract_csa: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/csa/",
+    );
+
+    const result = await v3.extract(
+      "Extract all the publications on the page including the publication date, session type, publication type, and annotation",
+      z.object({
+        publications: z.array(
+          z.object({
+            publication_date: z.string(),
+            session_type: z.string(),
+            publication_type: z.string(),
+            annotation: z.string(),
+          }),
+        ),
+      }),
+    );
+
+    const publications = result.publications;
+    const expectedLength = 14;
+
+    const expectedFirstItem = {
+      publication_date: "11-30-2024",
+      session_type: "Regular Session",
+      publication_type: "Assembly Weekly History",
+      annotation:
+        "2024 -- This publication includes the complete histories of second-year bills. The complete electronic history of all bills is always available at leginfo.legislature.ca.gov",
+    };
+
+    const expectedLastItem = {
+      publication_date: "11-30-2016",
+      session_type: "1st Extraordinary Session",
+      publication_type: "Assembly Weekly History",
+      annotation: "",
+    };
+
+    if (publications.length < expectedLength) {
+      logger.error({
+        message: "Incorrect number of publications extracted",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: `>= ${expectedLength}`,
+            type: "integer",
+          },
+          actual: {
+            value: publications.length.toString(),
+            type: "integer",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Incorrect number of publications extracted",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    const hasExpectedFirstItem = publications.some((publication) => {
+      return (
+        publication.publication_date === expectedFirstItem.publication_date &&
+        publication.session_type === expectedFirstItem.session_type &&
+        publication.publication_type === expectedFirstItem.publication_type &&
+        publication.annotation === expectedFirstItem.annotation
+      );
+    });
+
+    if (!hasExpectedFirstItem) {
+      logger.error({
+        message: "Expected 'first' item not found in publications",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: JSON.stringify(expectedFirstItem),
+            type: "object",
+          },
+          actual: {
+            value: JSON.stringify(publications),
+            type: "object",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Expected 'first' item not found in publications",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    const hasExpectedLastItem = publications.some((publication) => {
+      return (
+        publication.publication_date === expectedLastItem.publication_date &&
+        publication.session_type === expectedLastItem.session_type &&
+        publication.publication_type === expectedLastItem.publication_type &&
+        publication.annotation === expectedLastItem.annotation
+      );
+    });
+
+    if (!hasExpectedLastItem) {
+      logger.error({
+        message: "Expected 'last' item not found in publications",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: JSON.stringify(expectedLastItem),
+            type: "object",
+          },
+          actual: {
+            value: JSON.stringify(publications),
+            type: "object",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Expected 'last' item not found in publications",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/extract_geniusee.ts b/packages/evals/tasks/extract_geniusee.ts
new file mode 100644
index 000000000..ca6839d33
--- /dev/null
+++ b/packages/evals/tasks/extract_geniusee.ts
@@ -0,0 +1,74 @@
+import { z } from "zod";
+import { EvalFunction } from "../types/evals.js";
+
+export const extract_geniusee: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/geniusee/",
+    );
+    const selector = "/html/body/main/div[2]/div[2]/div[2]/table";
+    const scalability = await v3.extract(
+      "Extract the scalability comment in the table for Gemini (Google)",
+      z.object({
+        scalability: z.string(),
+      }),
+      { selector: selector },
+    );
+
+    const scalabilityComment = scalability.scalability;
+
+    const expectedScalabilityComment = {
+      scalability: "Scalable architecture with API access",
+    };
+
+    const commentMatches =
+      scalabilityComment == expectedScalabilityComment.scalability;
+
+    if (!commentMatches) {
+      logger.error({
+        message: "extracted scalability comment does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: expectedScalabilityComment.scalability,
+            type: "string",
+          },
+          actual: {
+            value: scalabilityComment,
+            type: "string",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "extracted scalability comment does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/extract_geniusee_2.ts b/packages/evals/tasks/extract_geniusee_2.ts
new file mode 100644
index 000000000..a4c563223
--- /dev/null
+++ b/packages/evals/tasks/extract_geniusee_2.ts
@@ -0,0 +1,81 @@
+import { z } from "zod";
+import { EvalFunction } from "../types/evals.js";
+
+export const extract_geniusee_2: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/geniusee/",
+    );
+    const selector = "/html/body/main/div[2]/div[2]/div[2]/table/tbody/tr[9]";
+    const scalability = await v3.extract(
+      "Extract the scalability comment in the table for Gemini (Google)",
+      z.object({
+        scalability: z.string(),
+      }),
+      { selector: selector },
+    );
+
+    const scalabilityComment = scalability.scalability;
+
+    // scalabilityCommentWeShouldNotGet matches a scalability comment in the table,
+    // but since we are using targeted_extract here,
+    // and passing in a selector that does NOT contain the scalabilityCommentWeShouldNotGet,
+    // the LLM should have no visibility into scalabilityCommentWeShouldNotGet if
+    // targeted_extract is performing correctly
+    const scalabilityCommentWeShouldNotGet = {
+      scalability: "Scalable architecture with API access",
+    };
+
+    const commentMatches =
+      scalabilityComment == scalabilityCommentWeShouldNotGet.scalability;
+
+    if (commentMatches) {
+      logger.error({
+        message:
+          "extracted scalability comment matches the scalability comment that we SHOULD NOT get",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: scalabilityCommentWeShouldNotGet.scalability,
+            type: "string",
+          },
+          actual: {
+            value: scalabilityComment,
+            type: "string",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error:
+          "scalability comment matches the scalability comment that we SHOULD NOT get",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/evals/tasks/extract_github_commits.ts b/packages/evals/tasks/extract_github_commits.ts
similarity index 61%
rename from evals/tasks/extract_github_commits.ts
rename to packages/evals/tasks/extract_github_commits.ts
index 4d8256345..4a132c2b1 100644
--- a/evals/tasks/extract_github_commits.ts
+++ b/packages/evals/tasks/extract_github_commits.ts
@@ -1,23 +1,22 @@
-import { EvalFunction } from "@/types/evals";
+import { EvalFunction } from "../types/evals.js";
 import { z } from "zod";
 
 export const extract_github_commits: EvalFunction = async ({
   logger,
-  useTextExtract,
   debugUrl,
   sessionUrl,
-  stagehand,
+  v3,
 }) => {
   try {
-    await stagehand.page.goto("https://github.com/facebook/react");
+    const page = v3.context.pages()[0];
+    await page.goto("https://github.com/facebook/react");
 
-    await stagehand.page.act({
-      action:
-        "find commit history, generally described by the number of commits",
-    });
-    const { commits } = await stagehand.page.extract({
-      instruction: "Extract last 20 commits",
-      schema: z.object({
+    await v3.act(
+      "find commit history, generally described by the number of commits",
+    );
+    const { commits } = await v3.extract(
+      "Extract last 20 commits",
+      z.object({
         commits: z.array(
           z.object({
             commit_message: z.string(),
@@ -26,8 +25,7 @@ export const extract_github_commits: EvalFunction = async ({
           }),
         ),
       }),
-      useTextExtract,
-    });
+    );
 
     logger.log({
       message: "Extracted commits",
@@ -40,8 +38,6 @@ export const extract_github_commits: EvalFunction = async ({
       },
     });
 
-    await stagehand.close();
-
     return {
       _success: commits.length === 20,
       commits,
@@ -50,10 +46,6 @@ export const extract_github_commits: EvalFunction = async ({
       logs: logger.getLogs(),
     };
   } catch (error) {
-    console.error("Error or timeout occurred:", error);
-
-    await stagehand.close();
-
     return {
       _success: false,
       error: JSON.parse(JSON.stringify(error, null, 2)),
@@ -61,5 +53,7 @@ export const extract_github_commits: EvalFunction = async ({
       sessionUrl,
       logs: logger.getLogs(),
     };
+  } finally {
+    await v3.close();
   }
 };
diff --git a/evals/tasks/extract_github_stars.ts b/packages/evals/tasks/extract_github_stars.ts
similarity index 63%
rename from evals/tasks/extract_github_stars.ts
rename to packages/evals/tasks/extract_github_stars.ts
index 7ab994076..d509e1cc9 100644
--- a/evals/tasks/extract_github_stars.ts
+++ b/packages/evals/tasks/extract_github_stars.ts
@@ -1,28 +1,27 @@
-import { EvalFunction } from "@/types/evals";
+import { EvalFunction } from "../types/evals.js";
 import { z } from "zod";
 
 export const extract_github_stars: EvalFunction = async ({
   logger,
-  useTextExtract,
   debugUrl,
   sessionUrl,
-  stagehand,
+  v3,
 }) => {
   try {
-    await stagehand.page.goto("https://github.com/facebook/react");
+    const page = v3.context.pages()[0];
+    await page.goto("https://github.com/facebook/react");
 
-    const { stars } = await stagehand.page.extract({
-      instruction: "Extract the number of stars for the project",
-      schema: z.object({
+    const { stars } = await v3.extract(
+      "Extract the number of stars for the project",
+      z.object({
         stars: z.number().describe("the number of stars for the project"),
       }),
-      useTextExtract,
-    });
+    );
 
-    const expectedStarsString = await stagehand.page
+    const expectedStarsString = await page
       .locator("#repo-stars-counter-star")
       .first()
-      .innerHTML();
+      .innerHtml();
 
     const expectedStars = expectedStarsString.toLowerCase().endsWith("k")
       ? parseFloat(expectedStarsString.slice(0, -1)) * 1000
@@ -31,8 +30,6 @@ export const extract_github_stars: EvalFunction = async ({
     const tolerance = 1000;
     const isWithinTolerance = Math.abs(stars - expectedStars) <= tolerance;
 
-    await stagehand.close();
-
     return {
       _success: isWithinTolerance,
       stars,
@@ -41,10 +38,6 @@ export const extract_github_stars: EvalFunction = async ({
       logs: logger.getLogs(),
     };
   } catch (error) {
-    console.error("Error or timeout occurred:", error);
-
-    await stagehand.close();
-
     return {
       _success: false,
       error: JSON.parse(JSON.stringify(error, null, 2)),
@@ -52,5 +45,7 @@ export const extract_github_stars: EvalFunction = async ({
       sessionUrl,
       logs: logger.getLogs(),
     };
+  } finally {
+    await v3.close();
   }
 };
diff --git a/evals/tasks/extract_hamilton_weather.ts b/packages/evals/tasks/extract_hamilton_weather.ts
similarity index 52%
rename from evals/tasks/extract_hamilton_weather.ts
rename to packages/evals/tasks/extract_hamilton_weather.ts
index 683c14c65..9af31210c 100644
--- a/evals/tasks/extract_hamilton_weather.ts
+++ b/packages/evals/tasks/extract_hamilton_weather.ts
@@ -1,23 +1,24 @@
-import { EvalFunction } from "@/types/evals";
+import { EvalFunction } from "../types/evals.js";
 import { z } from "zod";
+import { compareStrings } from "../utils.js";
 
 export const extract_hamilton_weather: EvalFunction = async ({
   logger,
-  useTextExtract,
   debugUrl,
   sessionUrl,
-  stagehand,
+  v3,
 }) => {
   try {
-    await stagehand.page.goto(
+    const page = v3.context.pages()[0];
+    await page.goto(
       "https://browserbase.github.io/stagehand-eval-sites/sites/hamilton-weather/",
     );
     const xpath =
       "/html/body[1]/div[5]/main[1]/article[1]/div[6]/div[2]/div[1]/table[1]";
 
-    const weatherData = await stagehand.page.extract({
-      instruction: "extract the weather data for Sun, Feb 23 at 11PM",
-      schema: z.object({
+    const weatherData = await v3.extract(
+      "extract the weather data for Sun, Feb 23 at 11PM",
+      z.object({
         temperature: z.string(),
         weather_description: z.string(),
         wind: z.string(),
@@ -25,9 +26,8 @@ export const extract_hamilton_weather: EvalFunction = async ({
         barometer: z.string(),
         visibility: z.string(),
       }),
-      useTextExtract,
-      selector: xpath,
-    });
+      { selector: xpath },
+    );
 
     // Define the expected weather data
     const expectedWeatherData = {
@@ -41,15 +41,27 @@ export const extract_hamilton_weather: EvalFunction = async ({
 
     // Check that every field matches the expected value
     const isWeatherCorrect =
-      weatherData.temperature === expectedWeatherData.temperature &&
-      weatherData.weather_description ===
-        expectedWeatherData.weather_description &&
-      weatherData.wind === expectedWeatherData.wind &&
-      weatherData.humidity === expectedWeatherData.humidity &&
-      weatherData.barometer === expectedWeatherData.barometer &&
-      weatherData.visibility === expectedWeatherData.visibility;
-
-    await stagehand.close();
+      compareStrings(
+        weatherData.temperature,
+        expectedWeatherData.temperature,
+        0.9,
+      ).meetsThreshold &&
+      compareStrings(
+        weatherData.weather_description,
+        expectedWeatherData.weather_description,
+        0.9,
+      ).meetsThreshold &&
+      compareStrings(weatherData.wind, expectedWeatherData.wind, 0.9)
+        .meetsThreshold &&
+      compareStrings(weatherData.humidity, expectedWeatherData.humidity, 0.9)
+        .meetsThreshold &&
+      compareStrings(weatherData.barometer, expectedWeatherData.barometer, 0.9)
+        .meetsThreshold &&
+      compareStrings(
+        weatherData.visibility,
+        expectedWeatherData.visibility,
+        0.9,
+      ).meetsThreshold;
 
     return {
       _success: isWeatherCorrect,
@@ -59,10 +71,6 @@ export const extract_hamilton_weather: EvalFunction = async ({
       logs: logger.getLogs(),
     };
   } catch (error) {
-    console.error("Error or timeout occurred:", error);
-
-    await stagehand.close();
-
     return {
       _success: false,
       error: JSON.parse(JSON.stringify(error, null, 2)),
@@ -70,5 +78,7 @@ export const extract_hamilton_weather: EvalFunction = async ({
       sessionUrl,
       logs: logger.getLogs(),
     };
+  } finally {
+    await v3.close();
   }
 };
diff --git a/evals/tasks/extract_jfk_links.ts b/packages/evals/tasks/extract_jfk_links.ts
similarity index 89%
rename from evals/tasks/extract_jfk_links.ts
rename to packages/evals/tasks/extract_jfk_links.ts
index dc735c49b..b8908d836 100644
--- a/evals/tasks/extract_jfk_links.ts
+++ b/packages/evals/tasks/extract_jfk_links.ts
@@ -1,21 +1,21 @@
-import { EvalFunction } from "@/types/evals";
+import { EvalFunction } from "../types/evals.js";
 import { z } from "zod";
 
 export const extract_jfk_links: EvalFunction = async ({
   logger,
   debugUrl,
   sessionUrl,
-  stagehand,
+  v3,
 }) => {
   try {
-    await stagehand.page.goto(
+    const page = v3.context.pages()[0];
+    await page.goto(
       "https://browserbase.github.io/stagehand-eval-sites/sites/jfk/",
     );
 
-    const extraction = await stagehand.page.extract({
-      instruction:
-        "extract all the record file name and their corresponding links",
-      schema: z.object({
+    const extraction = await v3.extract(
+      "extract all the record file name and their corresponding links",
+      z.object({
         records: z.array(
           z.object({
             file_name: z.string().describe("the file name of the record"),
@@ -23,7 +23,7 @@ export const extract_jfk_links: EvalFunction = async ({
           }),
         ),
       }),
-    });
+    );
 
     // The list of records we expect to see
     const expectedRecords = [
@@ -80,7 +80,6 @@ export const extract_jfk_links: EvalFunction = async ({
 
     // Check that the extraction array is exactly length 10
     if (extractedRecords.length !== 10) {
-      await stagehand.close();
       return {
         _success: false,
         reason: `Extraction has ${extractedRecords.length} records (expected 10).`,
@@ -91,7 +90,6 @@ export const extract_jfk_links: EvalFunction = async ({
     }
 
     if (missingRecords.length > 0) {
-      await stagehand.close();
       return {
         _success: false,
         reason: "Missing one or more expected records.",
@@ -104,7 +102,6 @@ export const extract_jfk_links: EvalFunction = async ({
     }
 
     // If we reach here, the number of records is correct, and all are present
-    await stagehand.close();
     return {
       _success: true,
       debugUrl,
@@ -112,8 +109,6 @@ export const extract_jfk_links: EvalFunction = async ({
       logs: logger.getLogs(),
     };
   } catch (error) {
-    await stagehand.close();
-
     return {
       _success: false,
       error: JSON.parse(JSON.stringify(error, null, 2)),
@@ -121,5 +116,7 @@ export const extract_jfk_links: EvalFunction = async ({
       sessionUrl,
       logs: logger.getLogs(),
     };
+  } finally {
+    await v3.close();
   }
 };
diff --git a/packages/evals/tasks/extract_jstor_news.ts b/packages/evals/tasks/extract_jstor_news.ts
new file mode 100644
index 000000000..c882a9736
--- /dev/null
+++ b/packages/evals/tasks/extract_jstor_news.ts
@@ -0,0 +1,148 @@
+import { EvalFunction } from "../types/evals.js";
+import { z } from "zod";
+
+export const extract_jstor_news: EvalFunction = async ({
+  logger,
+
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/jstor/",
+      {
+        waitUntil: "load",
+      },
+    );
+    await v3.act("close the cookie");
+
+    const result = await v3.extract(
+      "Extract ALL the news report titles and their dates.",
+      z.object({
+        reports: z.array(
+          z.object({
+            report_name: z
+              .string()
+              .describe("The name or title of the news report."),
+            publish_date: z
+              .string()
+              .describe("The date the news report was published."),
+          }),
+        ),
+      }),
+    );
+
+    const reports = result.reports;
+    const expectedLength = 10;
+
+    const expectedFirstItem = {
+      report_name: "JSTOR retires Publisher Sales Service",
+      publish_date: "December 9, 2024",
+    };
+
+    const expectedLastItem = {
+      report_name: "Path to Open announces 2024 titles",
+      publish_date: "May 10, 2024",
+    };
+
+    if (reports.length !== expectedLength) {
+      logger.error({
+        message: "Incorrect number of reports extracted",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: expectedLength.toString(),
+            type: "integer",
+          },
+          actual: {
+            value: reports.length.toString(),
+            type: "integer",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Incorrect number of reports extracted",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+    const firstItemMatches =
+      reports[0].report_name === expectedFirstItem.report_name &&
+      reports[0].publish_date === expectedFirstItem.publish_date;
+
+    if (!firstItemMatches) {
+      logger.error({
+        message: "First report extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: JSON.stringify(expectedFirstItem),
+            type: "object",
+          },
+          actual: {
+            value: JSON.stringify(reports[0]),
+            type: "object",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "First report extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    const lastItemMatches =
+      reports[reports.length - 1].report_name ===
+        expectedLastItem.report_name &&
+      reports[reports.length - 1].publish_date ===
+        expectedLastItem.publish_date;
+
+    if (!lastItemMatches) {
+      logger.error({
+        message: "Last report extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: JSON.stringify(expectedLastItem),
+            type: "object",
+          },
+          actual: {
+            value: JSON.stringify(reports[reports.length - 1]),
+            type: "object",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Last report extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/extract_memorial_healthcare.ts b/packages/evals/tasks/extract_memorial_healthcare.ts
new file mode 100644
index 000000000..58247ecbb
--- /dev/null
+++ b/packages/evals/tasks/extract_memorial_healthcare.ts
@@ -0,0 +1,202 @@
+import { EvalFunction } from "../types/evals.js";
+import { z } from "zod";
+import { compareStrings } from "../utils.js";
+
+export const extract_memorial_healthcare: EvalFunction = async ({
+  logger,
+
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/mycmh/",
+    );
+
+    const result = await v3.extract(
+      "extract a list of the first three healthcare centers on this page, with their name, full address, and phone number",
+      z.object({
+        health_centers: z.array(
+          z.object({
+            name: z.string(),
+            phone_number: z.string(),
+            address: z.string(),
+          }),
+        ),
+      }),
+    );
+
+    const health_centers: Array<
+      Partial<{ name: string; phone_number: string; address: string }>
+    > = result.health_centers;
+
+    const expectedLength = 3;
+    const similarityThreshold = 0.85;
+
+    const expectedFirstItem = {
+      name: "Community Memorial Breast Center",
+      phone_number: "805-948-5093",
+      address: "168 North Brent Street, Suite 401, Ventura, CA 93003",
+    };
+
+    const expectedLastItem = {
+      name: "Community Memorial Dermatology and Mohs Surgery",
+      phone_number: "805-948-6920",
+      address: "168 North Brent Street, Suite 403, Ventura, CA 93003",
+    };
+
+    if (health_centers.length !== expectedLength) {
+      logger.error({
+        message: "Incorrect number of health centers extracted",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: expectedLength.toString(),
+            type: "integer",
+          },
+          actual: {
+            value: health_centers.length.toString(),
+            type: "integer",
+          },
+        },
+      });
+
+      return {
+        _success: false,
+        error: "Incorrect number of health centers extracted",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    const validateHealthCenter = (
+      center: Partial<{ name: string; phone_number: string; address: string }>,
+    ): { name: string; phone_number: string; address: string } | null => {
+      if (center.name && center.phone_number && center.address) {
+        return center as {
+          name: string;
+          phone_number: string;
+          address: string;
+        };
+      }
+      logger.error({
+        message: "Invalid health center data",
+        level: 0,
+        auxiliary: {
+          center: { value: JSON.stringify(center), type: "object" },
+        },
+      });
+      return null;
+    };
+
+    const validHealthCenters = health_centers
+      .map(validateHealthCenter)
+      .filter(Boolean) as Array<{
+      name: string;
+      phone_number: string;
+      address: string;
+    }>;
+
+    if (validHealthCenters.length < expectedLength) {
+      return {
+        _success: false,
+        error: "One or more health centers have missing fields",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    const compareField = (
+      actual: string,
+      expected: string,
+      fieldName: string,
+    ): boolean => {
+      const { similarity, meetsThreshold } = compareStrings(
+        actual,
+        expected,
+        similarityThreshold,
+      );
+
+      if (!meetsThreshold) {
+        logger.error({
+          message: `Field "${fieldName}" does not meet similarity threshold`,
+          level: 0,
+          auxiliary: {
+            field: { value: fieldName, type: "string" },
+            similarity: { value: similarity.toFixed(2), type: "float" },
+            expected: { value: expected, type: "string" },
+            actual: { value: actual, type: "string" },
+          },
+        });
+      }
+
+      return meetsThreshold;
+    };
+
+    const compareItem = (
+      actual: { name: string; phone_number: string; address: string },
+      expected: { name: string; phone_number: string; address: string },
+      position: string,
+    ): boolean => {
+      const fields = [
+        { field: "name", actual: actual.name, expected: expected.name },
+        {
+          field: "phone_number",
+          actual: actual.phone_number,
+          expected: expected.phone_number,
+        },
+        {
+          field: "address",
+          actual: actual.address,
+          expected: expected.address,
+        },
+      ];
+
+      return fields.every(({ field, actual, expected }) =>
+        compareField(actual, expected, `${position} ${field}`),
+      );
+    };
+
+    const firstItemMatches = compareItem(
+      validHealthCenters[0],
+      expectedFirstItem,
+      "First",
+    );
+    const lastItemMatches = compareItem(
+      validHealthCenters[validHealthCenters.length - 1],
+      expectedLastItem,
+      "Last",
+    );
+
+    if (!firstItemMatches || !lastItemMatches) {
+      return {
+        _success: false,
+        error: "One or more fields do not match expected values",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/extract_nhl_stats.ts b/packages/evals/tasks/extract_nhl_stats.ts
new file mode 100644
index 000000000..060f41249
--- /dev/null
+++ b/packages/evals/tasks/extract_nhl_stats.ts
@@ -0,0 +1,126 @@
+import { EvalFunction } from "../types/evals.js";
+import { normalizeString } from "../utils.js";
+import { z } from "zod";
+
+export const extract_nhl_stats: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://www.hockeydb.com/ihdb/stats/top_league.php?lid=nhl1927&sid=1990",
+      {
+        waitUntil: "domcontentloaded",
+      },
+    );
+
+    const result = await v3.extract(
+      "Extract the name of the goal scoring leader, their number of goals they scored, and the team they played for.",
+      z.object({
+        name: z.string(),
+        num_goals: z.string(),
+        team: z.string(),
+      }),
+    );
+
+    const { name, num_goals, team } = result;
+
+    const expected = {
+      name: "Brett Hull",
+      num_goals: "72",
+      team: "St. Louis",
+    };
+
+    if (normalizeString(name) !== normalizeString(expected.name)) {
+      logger.error({
+        message: "Player name extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: normalizeString(expected.name),
+            type: "string",
+          },
+          actual: {
+            value: normalizeString(name),
+            type: "string",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Player name extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    if (normalizeString(num_goals) !== normalizeString(expected.num_goals)) {
+      logger.error({
+        message: "Number of goals extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: normalizeString(expected.num_goals),
+            type: "string",
+          },
+          actual: {
+            value: normalizeString(num_goals),
+            type: "string",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Number of goals extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    if (normalizeString(team) !== normalizeString(expected.team)) {
+      logger.error({
+        message: "Player team extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: normalizeString(expected.team),
+            type: "string",
+          },
+          actual: {
+            value: normalizeString(team),
+            type: "string",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Player team extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/evals/tasks/extract_partners.ts b/packages/evals/tasks/extract_partners.ts
similarity index 69%
rename from evals/tasks/extract_partners.ts
rename to packages/evals/tasks/extract_partners.ts
index e1851802f..a241d9a42 100644
--- a/evals/tasks/extract_partners.ts
+++ b/packages/evals/tasks/extract_partners.ts
@@ -1,33 +1,25 @@
-import { EvalFunction } from "@/types/evals";
+import { EvalFunction } from "../types/evals.js";
 import { z } from "zod";
 
 export const extract_partners: EvalFunction = async ({
   debugUrl,
   sessionUrl,
-  stagehand,
+  v3,
   logger,
-  useTextExtract,
 }) => {
   try {
-    await stagehand.page.goto("https://ramp.com");
+    const page = v3.context.pages()[0];
+    await page.goto("https://ramp.com");
 
-    await stagehand.page.act({
-      action: "move down to the bottom of the page.",
-    });
+    await v3.act("scroll to the bottom of the page");
 
-    await stagehand.page.act({
-      action: "Close the popup.",
-    });
+    await v3.act("Close the popup.");
 
-    await stagehand.page.act({
-      action: "Find and click on the link that leads to the partners page.",
-    });
+    await v3.act("click on the link that leads to the partners page.");
 
-    const partners = await stagehand.page.extract({
-      instruction: `
-      Extract all of the partner categories on the page.
-    `,
-      schema: z.object({
+    const partners = await v3.extract(
+      `Extract all of the partner categories on the page.`,
+      z.object({
         partners: z.array(
           z.object({
             partner_category: z.string().describe("The partner category"),
@@ -38,8 +30,7 @@ export const extract_partners: EvalFunction = async ({
           .optional()
           .describe("Any explanation about partner listing or absence thereof"),
       }),
-      useTextExtract,
-    });
+    );
 
     const expectedPartners = [
       "Accounting Partners",
@@ -56,8 +47,6 @@ export const extract_partners: EvalFunction = async ({
       foundPartners.includes(partner.toLowerCase()),
     );
 
-    await stagehand.close();
-
     return {
       _success: allExpectedPartnersFound,
       partners,
@@ -81,8 +70,6 @@ export const extract_partners: EvalFunction = async ({
       },
     });
 
-    await stagehand.close();
-
     return {
       _success: false,
       debugUrl,
@@ -90,5 +77,7 @@ export const extract_partners: EvalFunction = async ({
       error: JSON.parse(JSON.stringify(error, null, 2)),
       logs: logger.getLogs(),
     };
+  } finally {
+    await v3.close();
   }
 };
diff --git a/evals/tasks/extract_press_releases.ts b/packages/evals/tasks/extract_press_releases.ts
similarity index 84%
rename from evals/tasks/extract_press_releases.ts
rename to packages/evals/tasks/extract_press_releases.ts
index b2fe815e3..55c79a275 100644
--- a/evals/tasks/extract_press_releases.ts
+++ b/packages/evals/tasks/extract_press_releases.ts
@@ -1,13 +1,12 @@
-import { EvalFunction } from "@/types/evals";
+import { EvalFunction } from "../types/evals.js";
 import { z } from "zod";
-import { compareStrings } from "@/evals/utils";
+import { compareStrings } from "../utils.js";
 
 export const extract_press_releases: EvalFunction = async ({
   debugUrl,
   sessionUrl,
-  stagehand,
+  v3,
   logger,
-  useTextExtract,
 }) => {
   const schema = z.object({
     items: z.array(
@@ -23,26 +22,20 @@ export const extract_press_releases: EvalFunction = async ({
   type PressRelease = z.infer<typeof schema>["items"][number];
 
   try {
-    await stagehand.page.goto(
+    const page = v3.context.pages()[0];
+    await page.goto(
       "https://browserbase.github.io/stagehand-eval-sites/sites/press-releases/",
-      {
-        waitUntil: "networkidle",
-      },
     );
     await new Promise((resolve) => setTimeout(resolve, 5000));
 
-    const rawResult = await stagehand.page.extract({
-      instruction:
-        "extract the title and corresponding publish date of EACH AND EVERY press releases on this page. DO NOT MISS ANY PRESS RELEASES.",
+    const rawResult = await v3.extract(
+      "extract the title and corresponding publish date of EACH AND EVERY press releases on this page. DO NOT MISS ANY PRESS RELEASES.",
       schema,
-      useTextExtract,
-    });
+    );
 
     const parsed = schema.parse(rawResult);
     const { items } = parsed;
 
-    await stagehand.close();
-
     const expectedLength = 28;
     const expectedFirstItem: PressRelease = {
       title: "UAW Region 9A Endorses Brad Lander for Mayor",
@@ -123,6 +116,6 @@ export const extract_press_releases: EvalFunction = async ({
       sessionUrl,
     };
   } finally {
-    await stagehand.context.close();
+    await v3.close();
   }
 };
diff --git a/packages/evals/tasks/extract_professional_info.ts b/packages/evals/tasks/extract_professional_info.ts
new file mode 100644
index 000000000..c8fb6cca3
--- /dev/null
+++ b/packages/evals/tasks/extract_professional_info.ts
@@ -0,0 +1,133 @@
+import { EvalFunction } from "../types/evals.js";
+import { normalizeString } from "../utils.js";
+import { z } from "zod";
+
+export const extract_professional_info: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/professional-info/",
+    );
+
+    const result = await v3.extract(
+      "Extract the list of Practices, phone number, and fax number of the professional.",
+      z.object({
+        practices: z.array(z.string()),
+        phone: z.string(),
+        fax: z.string(),
+      }),
+    );
+
+    await v3.close();
+
+    const { practices, phone, fax } = result;
+
+    const expected = {
+      practices: [
+        "Restructuring",
+        "Finance",
+        "Hybrid Capital & Special Situations",
+        "Private Credit",
+      ],
+      phone: "+1-212-373-3262",
+      fax: "+1-212-492-0262",
+    };
+
+    if (
+      JSON.stringify(practices.map(normalizeString)) !==
+      JSON.stringify(expected.practices.map(normalizeString))
+    ) {
+      logger.error({
+        message: "Practices extracted do not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: JSON.stringify(expected.practices),
+            type: "object",
+          },
+          actual: {
+            value: JSON.stringify(practices),
+            type: "object",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Practices extracted do not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    if (normalizeString(phone) !== normalizeString(expected.phone)) {
+      logger.error({
+        message: "Phone number extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: normalizeString(expected.phone),
+            type: "string",
+          },
+          actual: {
+            value: normalizeString(phone),
+            type: "string",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Phone number extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    if (normalizeString(fax) !== normalizeString(expected.fax)) {
+      logger.error({
+        message: "Fax number extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: normalizeString(expected.fax),
+            type: "string",
+          },
+          actual: {
+            value: normalizeString(fax),
+            type: "string",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Fax number extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/extract_public_notices.ts b/packages/evals/tasks/extract_public_notices.ts
new file mode 100644
index 000000000..6628c4a5f
--- /dev/null
+++ b/packages/evals/tasks/extract_public_notices.ts
@@ -0,0 +1,180 @@
+import { EvalFunction } from "../types/evals.js";
+import { z } from "zod";
+import { compareStrings } from "../utils.js";
+
+export const extract_public_notices: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/sars/",
+      { waitUntil: "load" },
+    );
+
+    const result = await v3.extract(
+      "Extract ALL the public notice descriptions with their corresponding, GG number and publication date. Extract ALL notices from 2024 through 2020. Do not include the Notice number.",
+      z.object({
+        public_notices: z.array(
+          z.object({
+            notice_description: z
+              .string()
+              .describe(
+                "the description of the notice. Do not include the Notice number",
+              ),
+            gg_number: z
+              .string()
+              .describe("the GG number of the notice. For example, GG 12345"),
+            publication_date: z
+              .string()
+              .describe(
+                "the publication date of the notice. For example, 8 December 2021",
+              ),
+          }),
+        ),
+      }),
+    );
+
+    const publicNotices = result.public_notices;
+    const expectedLength = 24;
+
+    const expectedFirstItem = {
+      notice_description:
+        "Additional considerations in terms of section 80(2) in respect of which an application for a binding private ruling or a binding class ruling may be rejected",
+      gg_number: "GG 51526",
+      publication_date: "8 November 2024",
+    };
+
+    const expectedLastItem = {
+      notice_description:
+        "Notice in terms of section 25, read with section 66(1) of the Income Tax Act, 1962, for submission of 2020 income tax returns",
+      gg_number: "GG 43495",
+      publication_date: "3 July 2020",
+    };
+
+    if (publicNotices.length !== expectedLength) {
+      logger.error({
+        message: "Incorrect number of public notices extracted",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: expectedLength.toString(),
+            type: "integer",
+          },
+          actual: {
+            value: publicNotices.length.toString(),
+            type: "integer",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Incorrect number of public notices extracted",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+    const firstItemMatches =
+      compareStrings(
+        publicNotices[0].notice_description,
+        expectedFirstItem.notice_description,
+        0.9,
+      ) &&
+      compareStrings(
+        publicNotices[0].gg_number,
+        expectedFirstItem.gg_number,
+        0.9,
+      ) &&
+      compareStrings(
+        publicNotices[0].publication_date,
+        expectedFirstItem.publication_date,
+        0.9,
+      );
+
+    if (!firstItemMatches) {
+      logger.error({
+        message: "First public notice extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: JSON.stringify(expectedFirstItem),
+            type: "object",
+          },
+          actual: {
+            value: JSON.stringify(publicNotices[0]),
+            type: "object",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "First public notice extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    const lastItemMatches =
+      compareStrings(
+        publicNotices[publicNotices.length - 1].notice_description,
+        expectedLastItem.notice_description,
+        0.9,
+      ) &&
+      compareStrings(
+        publicNotices[publicNotices.length - 1].gg_number,
+        expectedLastItem.gg_number,
+        0.9,
+      ) &&
+      compareStrings(
+        publicNotices[publicNotices.length - 1].publication_date,
+        expectedLastItem.publication_date,
+        0.9,
+      );
+
+    if (!lastItemMatches) {
+      logger.error({
+        message: "Last public notice extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: JSON.stringify(expectedLastItem),
+            type: "object",
+          },
+          actual: {
+            value: JSON.stringify(publicNotices[publicNotices.length - 1]),
+            type: "object",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Last public notice extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/extract_recipe.ts b/packages/evals/tasks/extract_recipe.ts
new file mode 100644
index 000000000..0483e24dc
--- /dev/null
+++ b/packages/evals/tasks/extract_recipe.ts
@@ -0,0 +1,104 @@
+import { EvalFunction } from "../types/evals.js";
+import { z } from "zod";
+
+export const extract_recipe: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/allrecipes-extract/",
+      {
+        waitUntil: "domcontentloaded",
+      },
+    );
+
+    const selector = "/html/body/main/article/div[3]/div[3]/div[4]";
+    const recipeDetails = await v3.extract(
+      "Extract the title of the number of tablespoons of olive oil needed for the steak, and the number of teaspoons of lemon juice needed for the mushroom pan sauce.",
+      z.object({
+        tablespoons_olive_oil: z
+          .number()
+          .describe(
+            "the number of tablespoons of olive oil needed for the steak",
+          ),
+        teaspoons_lemon_juice: z
+          .number()
+          .describe(
+            "the number of teaspoons of lemon juice needed for the mushroom pan sauce",
+          ),
+      }),
+      { selector: selector },
+    );
+
+    const { tablespoons_olive_oil, teaspoons_lemon_juice } = recipeDetails;
+    const expectedTablespoons = 2;
+    const expectedTeaspoons = 2;
+
+    if (
+      tablespoons_olive_oil !== expectedTablespoons ||
+      teaspoons_lemon_juice !== expectedTeaspoons
+    ) {
+      const errors = [];
+      if (tablespoons_olive_oil !== expectedTablespoons) {
+        errors.push({
+          message:
+            "Extracted tablespoons of olive oil do not match the extracted tablespoons of olive oil",
+          expected: expectedTablespoons.toString(),
+          actual: tablespoons_olive_oil.toString(),
+        });
+      }
+      if (teaspoons_lemon_juice !== expectedTeaspoons) {
+        errors.push({
+          message:
+            "Extracted teaspoons of lemon juice do not match the extracted teaspoons of lemon juice",
+          expected: expectedTeaspoons.toString(),
+          actual: teaspoons_lemon_juice.toString(),
+        });
+      }
+
+      logger.error({
+        message: "Failed to extract correct recipe details",
+        level: 0,
+        auxiliary: {
+          errors: {
+            value: JSON.stringify(errors),
+            type: "object",
+          },
+        },
+      });
+
+      return {
+        _success: false,
+        error: "Recipe details extraction validation failed",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      recipeDetails: {
+        tablespoons_olive_oil: expectedTablespoons,
+        teaspoons_lemon_juice: expectedTeaspoons,
+      },
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/evals/tasks/extract_regulations_table.ts b/packages/evals/tasks/extract_regulations_table.ts
similarity index 80%
rename from evals/tasks/extract_regulations_table.ts
rename to packages/evals/tasks/extract_regulations_table.ts
index 5bd75abe3..3798759bf 100644
--- a/evals/tasks/extract_regulations_table.ts
+++ b/packages/evals/tasks/extract_regulations_table.ts
@@ -1,25 +1,24 @@
-import { EvalFunction } from "@/types/evals";
+import { EvalFunction } from "../types/evals.js";
 import { z } from "zod";
 
 export const extract_regulations_table: EvalFunction = async ({
   debugUrl,
   sessionUrl,
-  stagehand,
+  v3,
   logger,
-  useTextExtract,
 }) => {
   try {
-    await stagehand.page.goto(
+    const page = v3.context.pages()[0];
+    await page.goto(
       "https://browserbase.github.io/stagehand-eval-sites/sites/ncc-numbering-plan/",
     );
 
     const xpath =
       "/html/body/div[3]/main/div[2]/div[2]/div/div/div[2]/article/div[2]/div[1]/div/table";
 
-    const allottees = await stagehand.page.extract({
-      instruction:
-        "Extract ALL of the Allottees and their corresponding name, area, and area code.",
-      schema: z.object({
+    const allottees = await v3.extract(
+      "Extract ALL of the Allottees and their corresponding name, area, and area code.",
+      z.object({
         allottee_list: z.array(
           z.object({
             allottee_name: z.string(),
@@ -29,9 +28,8 @@ export const extract_regulations_table: EvalFunction = async ({
           }),
         ),
       }),
-      useTextExtract,
-      selector: xpath,
-    });
+      { selector: xpath },
+    );
 
     // Define the expected weather data
     const allottees_expected_first = {
@@ -64,8 +62,6 @@ export const extract_regulations_table: EvalFunction = async ({
     const isRegulationsCorrect =
       isFirstCorrect && isLastCorrect && isLengthCorrect;
 
-    await stagehand.close();
-
     return {
       _success: isRegulationsCorrect,
       regulationsData: allottees,
@@ -74,10 +70,6 @@ export const extract_regulations_table: EvalFunction = async ({
       logs: logger.getLogs(),
     };
   } catch (error) {
-    console.error("Error or timeout occurred:", error);
-
-    await stagehand.close();
-
     return {
       _success: false,
       error: JSON.parse(JSON.stringify(error, null, 2)),
@@ -85,5 +77,7 @@ export const extract_regulations_table: EvalFunction = async ({
       sessionUrl,
       logs: logger.getLogs(),
     };
+  } finally {
+    await v3.close();
   }
 };
diff --git a/evals/tasks/extract_repo_name.ts b/packages/evals/tasks/extract_repo_name.ts
similarity index 71%
rename from evals/tasks/extract_repo_name.ts
rename to packages/evals/tasks/extract_repo_name.ts
index ff4f48238..9ef4dd2bd 100644
--- a/evals/tasks/extract_repo_name.ts
+++ b/packages/evals/tasks/extract_repo_name.ts
@@ -1,15 +1,16 @@
-import { EvalFunction } from "@/types/evals";
+import { EvalFunction } from "../types/evals.js";
 
 export const extract_repo_name: EvalFunction = async ({
   debugUrl,
   sessionUrl,
-  stagehand,
+  v3,
   logger,
 }) => {
   try {
-    await stagehand.page.goto("https://github.com/facebook/react");
+    const page = v3.context.pages()[0];
+    await page.goto("https://github.com/facebook/react");
 
-    const { extraction } = await stagehand.page.extract(
+    const { extraction } = await v3.extract(
       "extract the title of the Github repository. Do not include the owner of the repository.",
     );
 
@@ -24,8 +25,6 @@ export const extract_repo_name: EvalFunction = async ({
       },
     });
 
-    await stagehand.close();
-
     return {
       _success: extraction === "react",
       extraction,
@@ -34,10 +33,6 @@ export const extract_repo_name: EvalFunction = async ({
       logs: logger.getLogs(),
     };
   } catch (error) {
-    console.error("Error or timeout occurred:", error);
-
-    await stagehand.close();
-
     return {
       _success: false,
       error: JSON.parse(JSON.stringify(error, null, 2)),
@@ -45,5 +40,7 @@ export const extract_repo_name: EvalFunction = async ({
       sessionUrl,
       logs: logger.getLogs(),
     };
+  } finally {
+    await v3.close();
   }
 };
diff --git a/packages/evals/tasks/extract_resistor_info.ts b/packages/evals/tasks/extract_resistor_info.ts
new file mode 100644
index 000000000..05075b61b
--- /dev/null
+++ b/packages/evals/tasks/extract_resistor_info.ts
@@ -0,0 +1,166 @@
+import { EvalFunction } from "../types/evals.js";
+import { normalizeString } from "../utils.js";
+import { z } from "zod";
+
+export const extract_resistor_info: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/resistor/",
+    );
+
+    const result = await v3.extract(
+      "Extract the manufacturer standard lead time, tolerance percentage, resistance, and operating temperature range of the resistor.",
+      z.object({
+        manufacturer_standard_lead_time: z.string(),
+        tolerance_percentage: z.string(),
+        resistance: z.string(),
+        operating_temperature_range: z.string(),
+      }),
+    );
+
+    const {
+      manufacturer_standard_lead_time,
+      tolerance_percentage,
+      resistance,
+      operating_temperature_range,
+    } = result;
+
+    const expected = {
+      manufacturer_standard_lead_time: "11 Weeks",
+      tolerance_percentage: "±5",
+      resistance: "330 ohms",
+      operating_temperature_range: "-55°C ~ 155°C",
+    };
+
+    if (
+      normalizeString(manufacturer_standard_lead_time) !==
+      normalizeString(expected.manufacturer_standard_lead_time)
+    ) {
+      logger.error({
+        message:
+          "manufacturer standard lead time extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: normalizeString(expected.manufacturer_standard_lead_time),
+            type: "string",
+          },
+          actual: {
+            value: normalizeString(manufacturer_standard_lead_time),
+            type: "string",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error:
+          "manufacturer standard lead time extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    if (
+      normalizeString(tolerance_percentage) !==
+      normalizeString(expected.tolerance_percentage)
+    ) {
+      logger.error({
+        message: "Tolerance percentage extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: normalizeString(expected.tolerance_percentage),
+            type: "string",
+          },
+          actual: {
+            value: normalizeString(tolerance_percentage),
+            type: "string",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Tolerance percentage extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    if (normalizeString(resistance) !== normalizeString(expected.resistance)) {
+      logger.error({
+        message: "resistance extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: normalizeString(expected.resistance),
+            type: "string",
+          },
+          actual: {
+            value: normalizeString(resistance),
+            type: "string",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "resistance extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    if (
+      normalizeString(operating_temperature_range) !==
+      normalizeString(expected.operating_temperature_range)
+    ) {
+      logger.error({
+        message:
+          "Operating temperature range extracted does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: normalizeString(expected.operating_temperature_range),
+            type: "string",
+          },
+          actual: {
+            value: normalizeString(operating_temperature_range),
+            type: "string",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Operating temperature range extracted does not match expected",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/extract_rockauto.ts b/packages/evals/tasks/extract_rockauto.ts
new file mode 100644
index 000000000..6c184aa45
--- /dev/null
+++ b/packages/evals/tasks/extract_rockauto.ts
@@ -0,0 +1,108 @@
+import { EvalFunction } from "../types/evals.js";
+import { z } from "zod";
+
+export const extract_rockauto: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/rockauto/",
+    );
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+    const result = await v3.extract(
+      "Extract the part number of all the coolant and antifreeze products in the 'economy' category. " +
+        "Do not include the manufacturer name. Do not include products from the premium category.",
+      z.object({
+        coolant_products: z.array(
+          z.object({
+            part_number: z.string(),
+          }),
+        ),
+      }),
+    );
+
+    const coolantProducts = result.coolant_products;
+    const expectedPartNumbers = [
+      "GREEN5050GAL",
+      "719009",
+      "AF3300",
+      "AF3100",
+      "MV5050GAL",
+    ];
+    const expectedLength = expectedPartNumbers.length;
+
+    if (coolantProducts.length !== expectedLength) {
+      logger.error({
+        message: "Incorrect number of coolant products extracted",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: expectedLength.toString(),
+            type: "integer",
+          },
+          actual: {
+            value: coolantProducts.length.toString(),
+            type: "integer",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Incorrect number of coolant products extracted",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    const missingParts = expectedPartNumbers.filter(
+      (expectedPart) =>
+        !coolantProducts.some((p) => p.part_number === expectedPart),
+    );
+
+    if (missingParts.length > 0) {
+      logger.error({
+        message: "Missing expected part number(s)",
+        level: 0,
+        auxiliary: {
+          missingParts: {
+            value: JSON.stringify(missingParts),
+            type: "object",
+          },
+          actualExtracted: {
+            value: JSON.stringify(coolantProducts),
+            type: "object",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: `One or more expected part numbers were not found: ${missingParts.join(", ")}`,
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/evals/tasks/extract_single_link.ts b/packages/evals/tasks/extract_single_link.ts
similarity index 76%
rename from evals/tasks/extract_single_link.ts
rename to packages/evals/tasks/extract_single_link.ts
index d2e19957f..4ed0f70ab 100644
--- a/evals/tasks/extract_single_link.ts
+++ b/packages/evals/tasks/extract_single_link.ts
@@ -1,25 +1,24 @@
-import { EvalFunction } from "@/types/evals";
+import { EvalFunction } from "../types/evals.js";
 import { z } from "zod";
 
 export const extract_single_link: EvalFunction = async ({
   logger,
   debugUrl,
   sessionUrl,
-  stagehand,
+  v3,
 }) => {
   try {
-    await stagehand.page.goto(
+    const page = v3.context.pages()[0];
+    await page.goto(
       "https://browserbase.github.io/stagehand-eval-sites/sites/geniusee/",
     );
 
-    const extraction = await stagehand.page.extract({
-      instruction: "extract the link to the 'contact us' page",
-      schema: z.object({
+    const extraction = await v3.extract(
+      "extract the link to the 'contact us' page",
+      z.object({
         link: z.string().url(),
       }),
-    });
-
-    await stagehand.close();
+    );
     const extractedLink = extraction.link;
     const expectedLink =
       "https://browserbase.github.io/stagehand-eval-sites/sites/geniusee/#contact";
@@ -40,7 +39,6 @@ export const extract_single_link: EvalFunction = async ({
       logs: logger.getLogs(),
     };
   } catch (error) {
-    await stagehand.close();
     return {
       _success: false,
       error: JSON.parse(JSON.stringify(error, null, 2)),
@@ -48,5 +46,7 @@ export const extract_single_link: EvalFunction = async ({
       sessionUrl,
       logs: logger.getLogs(),
     };
+  } finally {
+    await v3.close();
   }
 };
diff --git a/evals/tasks/extract_snowshoeing_destinations.ts b/packages/evals/tasks/extract_snowshoeing_destinations.ts
similarity index 77%
rename from evals/tasks/extract_snowshoeing_destinations.ts
rename to packages/evals/tasks/extract_snowshoeing_destinations.ts
index b35e7be64..d56045c9f 100644
--- a/evals/tasks/extract_snowshoeing_destinations.ts
+++ b/packages/evals/tasks/extract_snowshoeing_destinations.ts
@@ -1,24 +1,23 @@
 import { z } from "zod";
-import { EvalFunction } from "@/types/evals";
+import { EvalFunction } from "../types/evals.js";
 
 export const extract_snowshoeing_destinations: EvalFunction = async ({
   debugUrl,
   sessionUrl,
-  stagehand,
+  v3,
   logger,
-  useTextExtract,
 }) => {
   try {
-    await stagehand.page.goto(
+    const page = v3.context.pages()[0];
+    await page.goto(
       "https://www.cbisland.com/blog/10-snowshoeing-adventures-on-cape-breton-island/",
     );
 
-    await stagehand.page.act({ action: "accept the cookies" });
+    await v3.act("accept the cookies");
 
-    const snowshoeing_regions = await stagehand.page.extract({
-      instruction:
-        "Extract all the snowshoeing regions and the names of the trails within each region.",
-      schema: z.object({
+    const snowshoeing_regions = await v3.extract(
+      "Extract all the snowshoeing regions and the names of the trails within each region.",
+      z.object({
         snowshoeing_regions: z.array(
           z.object({
             region_name: z
@@ -34,8 +33,7 @@ export const extract_snowshoeing_destinations: EvalFunction = async ({
           }),
         ),
       }),
-      useTextExtract,
-    });
+    );
 
     logger.log({
       message: "Extracted destinations and trails",
@@ -48,8 +46,6 @@ export const extract_snowshoeing_destinations: EvalFunction = async ({
       },
     });
 
-    await stagehand.close();
-
     const _success = snowshoeing_regions.snowshoeing_regions.length === 10;
 
     return {
@@ -82,6 +78,6 @@ export const extract_snowshoeing_destinations: EvalFunction = async ({
       logs: logger.getLogs(),
     };
   } finally {
-    await stagehand.context.close().catch(() => {});
+    await v3.close();
   }
 };
diff --git a/packages/evals/tasks/extract_staff_members.ts b/packages/evals/tasks/extract_staff_members.ts
new file mode 100644
index 000000000..621059858
--- /dev/null
+++ b/packages/evals/tasks/extract_staff_members.ts
@@ -0,0 +1,147 @@
+import { z } from "zod";
+import { EvalFunction } from "../types/evals.js";
+
+export const extract_staff_members: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/panamcs/",
+    );
+
+    const result = await v3.extract(
+      "extract a list of ALL the staff members on this page, with their name and their job title",
+      z.object({
+        staff_members: z.array(
+          z.object({
+            name: z.string(),
+            job_title: z.string(),
+          }),
+        ),
+      }),
+    );
+
+    const staff_members = result.staff_members;
+
+    const expectedLength = 50;
+
+    const expectedFirstItem = {
+      name: "Louis Alvarez",
+      job_title: "School Resource Officer",
+    };
+
+    const expectedLastItem = {
+      name: "Jessica Zipin",
+      job_title: "School Based Therapist",
+    };
+
+    if (staff_members.length !== expectedLength) {
+      logger.error({
+        message: "Incorrect number of items extracted",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: expectedLength.toString(),
+            type: "integer",
+          },
+          actual: {
+            value: staff_members.length.toString(),
+            type: "integer",
+          },
+        },
+      });
+
+      return {
+        _success: false,
+        error: "Incorrect number of staff members extracted",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    // Check for the presence of the expected items
+    const firstItemExists = staff_members.some(
+      (member) =>
+        member.name === expectedFirstItem.name &&
+        member.job_title === expectedFirstItem.job_title,
+    );
+
+    if (!firstItemExists) {
+      logger.error({
+        message: "Expected first staff member not found in extracted data",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: JSON.stringify(expectedFirstItem),
+            type: "object",
+          },
+          actual: {
+            value: JSON.stringify(staff_members),
+            type: "object",
+          },
+        },
+      });
+
+      return {
+        _success: false,
+        error: "Expected first staff member not found in extracted data",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    const lastItemExists = staff_members.some(
+      (member) =>
+        member.name === expectedLastItem.name &&
+        member.job_title === expectedLastItem.job_title,
+    );
+
+    if (!lastItemExists) {
+      logger.error({
+        message: "Expected last staff member not found in extracted data",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: JSON.stringify(expectedLastItem),
+            type: "object",
+          },
+          actual: {
+            value: JSON.stringify(staff_members),
+            type: "object",
+          },
+        },
+      });
+
+      return {
+        _success: false,
+        error: "Expected last staff member not found in extracted data",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/extract_zillow.ts b/packages/evals/tasks/extract_zillow.ts
new file mode 100644
index 000000000..c306b0d35
--- /dev/null
+++ b/packages/evals/tasks/extract_zillow.ts
@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { EvalFunction } from "../types/evals.js";
+
+export const extract_zillow: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/zillow/",
+    );
+
+    const real_estate_listings = await v3.extract(
+      "Extract EACH AND EVERY HOME PRICE AND ADDRESS ON THE PAGE. DO NOT MISS ANY OF THEM.",
+      z.object({
+        listings: z.array(
+          z.object({
+            price: z.string().describe("The price of the home"),
+            trails: z.string().describe("The address of the home"),
+          }),
+        ),
+      }),
+    );
+
+    await v3.close();
+    const listings = real_estate_listings.listings;
+    const expectedLength = 38;
+
+    if (listings.length < expectedLength) {
+      logger.error({
+        message: "Incorrect number of listings extracted",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: expectedLength.toString(),
+            type: "integer",
+          },
+          actual: {
+            value: listings.length.toString(),
+            type: "integer",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Incorrect number of listings extracted",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/google_flights.ts b/packages/evals/tasks/google_flights.ts
new file mode 100644
index 000000000..249b59f4d
--- /dev/null
+++ b/packages/evals/tasks/google_flights.ts
@@ -0,0 +1,68 @@
+import { EvalFunction } from "../types/evals.js";
+import { Action } from "@browserbasehq/stagehand";
+
+/**
+ * This eval attempts to click on an element that should not pass the playwright actionability check
+ * which happens by default if you call locator.click (more information here:
+ * https://playwright.dev/docs/actionability)
+ *
+ * If this eval passes, it means that we have correctly set {force: true} in performPlaywrightMethod,
+ * and the click was successful even though the target element (found by the xpath) did not
+ * pass the actionability check.
+ */
+
+export const google_flights: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/google-flights/",
+    );
+
+    const observeResult: Action = {
+      selector:
+        "xpath=/html/body/c-wiz[2]/div/div[2]/c-wiz/div[1]/c-wiz/div[2]/div[2]/div[2]/div/div[2]/div[1]/ul/li[1]/div/div[1]",
+      description: "the first departing flight",
+      method: "click",
+      arguments: [],
+    };
+    await v3.act(observeResult);
+
+    const expectedUrl =
+      "https://browserbase.github.io/stagehand-eval-sites/sites/google-flights/return-flight.html";
+    const currentUrl = page.url();
+
+    await v3.close();
+
+    if (currentUrl === expectedUrl) {
+      return {
+        _success: true,
+        currentUrl,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: false,
+      error: "The current URL does not match expected.",
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/heal_custom_dropdown.ts b/packages/evals/tasks/heal_custom_dropdown.ts
new file mode 100644
index 000000000..163295261
--- /dev/null
+++ b/packages/evals/tasks/heal_custom_dropdown.ts
@@ -0,0 +1,65 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const heal_custom_dropdown: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  /**
+   * This eval is meant to test whether we do not incorrectly attempt
+   * the selectOptionFromDropdown method (defined in actHandlerUtils.ts) on a
+   * 'dropdown' that is not a <select> element.
+   *
+   * This kind of dropdown must be clicked to be expanded before being interacted
+   * with.
+   */
+
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/expand-dropdown/",
+    );
+
+    await v3.act({
+      description: "The 'Select a country' dropdown",
+      selector: "/html/not-a-dropdown",
+      arguments: [],
+      method: "click",
+    });
+
+    // we are expecting stagehand to click the dropdown to expand it,
+    // and therefore the available options should now be contained in the full
+    // a11y tree.
+
+    // to test, we'll grab the full a11y tree, and make sure it contains 'Canada'
+    const extraction = await v3.extract();
+    const fullTree = extraction.pageText;
+
+    if (fullTree.includes("Canada")) {
+      return {
+        _success: true,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: false,
+      message: "unable to expand the dropdown",
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: `error attempting to select an option from the dropdown: ${error.message}`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/heal_scroll_50.ts b/packages/evals/tasks/heal_scroll_50.ts
new file mode 100644
index 000000000..bd143d84b
--- /dev/null
+++ b/packages/evals/tasks/heal_scroll_50.ts
@@ -0,0 +1,61 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const heal_scroll_50: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/aigrant/",
+    );
+    await v3.act({
+      description: "the element to scroll on",
+      selector: "/html/body/div/div/button",
+      arguments: ["50%"],
+      method: "scrollTo",
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+
+    // Get the current scroll position and total scroll height
+    const scrollInfo = await page.evaluate(() => {
+      return {
+        scrollTop: window.scrollY + window.innerHeight / 2,
+        scrollHeight: document.documentElement.scrollHeight,
+      };
+    });
+
+    const halfwayScroll = scrollInfo.scrollHeight / 2;
+    const halfwayReached =
+      Math.abs(scrollInfo.scrollTop - halfwayScroll) <= 200;
+    const evaluationResult = halfwayReached
+      ? {
+          _success: true,
+          logs: logger.getLogs(),
+          debugUrl,
+          sessionUrl,
+        }
+      : {
+          _success: false,
+          logs: logger.getLogs(),
+          debugUrl,
+          sessionUrl,
+          message: `Scroll position (${scrollInfo.scrollTop}px) is not halfway down the page (${halfwayScroll}px).`,
+        };
+
+    return evaluationResult;
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/heal_simple_google_search.ts b/packages/evals/tasks/heal_simple_google_search.ts
new file mode 100644
index 000000000..c60dc11bc
--- /dev/null
+++ b/packages/evals/tasks/heal_simple_google_search.ts
@@ -0,0 +1,46 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const heal_simple_google_search: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/google/",
+    );
+
+    await v3.act({
+      description: "The search bar",
+      selector: "/html/not-the-search-bar",
+      arguments: ["OpenAI"],
+      method: "fill",
+    });
+
+    await v3.act("press enter");
+
+    const expectedUrl =
+      "https://browserbase.github.io/stagehand-eval-sites/sites/google/openai.html";
+    const currentUrl = page.url();
+
+    return {
+      _success: currentUrl.startsWith(expectedUrl),
+      currentUrl,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/hidden_input_dropdown.ts b/packages/evals/tasks/hidden_input_dropdown.ts
new file mode 100644
index 000000000..55483afb6
--- /dev/null
+++ b/packages/evals/tasks/hidden_input_dropdown.ts
@@ -0,0 +1,60 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const hidden_input_dropdown: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  /**
+   * This eval is meant to test whether we do not incorrectly attempt
+   * the selectOptionFromDropdown method (defined in actHandlerUtils.ts) on a
+   * hidden input 'dropdown'.
+   *
+   * This kind of dropdown must be clicked to be expanded before being interacted
+   * with.
+   */
+
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/hidden-input-dropdown/",
+    );
+
+    await v3.act("click to expand the 'Favourite Colour' dropdown");
+
+    // we are expecting stagehand to click the dropdown to expand it,
+    // and therefore the available options should now be contained in the full
+    // a11y tree.
+
+    // to test, we'll grab the full a11y tree, and make sure it contains 'Green'
+    const extraction = await v3.extract();
+    const fullTree = extraction.pageText;
+
+    if (fullTree.includes("Green")) {
+      return {
+        _success: true,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: false,
+      message: "unable to expand the dropdown",
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: `error attempting click to expand the dropdown: ${error.message}`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/history.ts b/packages/evals/tasks/history.ts
new file mode 100644
index 000000000..b15d270ed
--- /dev/null
+++ b/packages/evals/tasks/history.ts
@@ -0,0 +1,59 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const history: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://docs.stagehand.dev");
+    await v3.act("click on the 'Quickstart' tab");
+    await v3.extract("Extract the title of the page");
+    await v3.observe("Find all links on the page");
+
+    const history = await v3.history;
+
+    const hasCorrectNumberOfEntries = history.length === 4;
+
+    const hasNavigateEntry = history[0].method === "navigate";
+    const hasActEntry = history[1].method === "act";
+    const hasExtractEntry = history[2].method === "extract";
+    const hasObserveEntry = history[3].method === "observe";
+
+    const allEntriesHaveTimestamps = history.every(
+      (entry) =>
+        typeof entry.timestamp === "string" && entry.timestamp.length > 0,
+    );
+    const allEntriesHaveResults = history.every(
+      (entry) => entry.result !== undefined,
+    );
+
+    const success =
+      hasCorrectNumberOfEntries &&
+      hasNavigateEntry &&
+      hasActEntry &&
+      hasExtractEntry &&
+      hasObserveEntry &&
+      allEntriesHaveTimestamps &&
+      allEntriesHaveResults;
+
+    return {
+      _success: success,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/homedepot.ts b/packages/evals/tasks/homedepot.ts
new file mode 100644
index 000000000..0b80afcfa
--- /dev/null
+++ b/packages/evals/tasks/homedepot.ts
@@ -0,0 +1,83 @@
+import { EvalFunction } from "../types/evals.js";
+import { z } from "zod";
+
+export const homedepot: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.homedepot.com/");
+    await v3.act("enter 'gas grills' in the search bar");
+    await v3.act("press enter");
+    await v3.act("click on the best selling gas grill");
+    await v3.act("click on the Product Details");
+
+    const productSpecs = await v3.extract(
+      "Extract the Primary exact Burner BTU of the product",
+      z.object({
+        productSpecs: z.object({
+          burnerBTU: z.number().describe("Primary Burner BTU exact value"),
+        }),
+      }),
+    );
+
+    logger.log({
+      message: `gas grill primary burner BTU`,
+      level: 1,
+      auxiliary: {
+        productSpecs: {
+          value: JSON.stringify(productSpecs),
+          type: "object",
+        },
+      },
+    });
+
+    if (!productSpecs || !productSpecs.productSpecs) {
+      return {
+        _success: false,
+        productSpecs,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    const isLargerThan1000 = productSpecs.productSpecs.burnerBTU >= 10000;
+
+    return {
+      _success: isLargerThan1000,
+      productSpecs,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    logger.error({
+      message: "error in homedepot function",
+      level: 0,
+      auxiliary: {
+        error: {
+          value: error.message,
+          type: "string",
+        },
+        trace: {
+          value: error.stack,
+          type: "string",
+        },
+      },
+    });
+
+    return {
+      _success: false,
+      error: JSON.parse(JSON.stringify(error, null, 2)),
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/iframe_form_filling.ts b/packages/evals/tasks/iframe_form_filling.ts
new file mode 100644
index 000000000..f2feafa67
--- /dev/null
+++ b/packages/evals/tasks/iframe_form_filling.ts
@@ -0,0 +1,67 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const iframe_form_filling: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/iframe-form-filling/",
+    );
+
+    await v3.act("type 'nunya' into the 'first name' field");
+    await v3.act("type 'business' into the 'last name' field");
+    await v3.act("type 'test@email.com' into the 'email' field");
+    await v3.act("click 'phone' as the preferred contact method");
+    await v3.act("type 'yooooooooooooooo' into the message box");
+
+    const iframe = page.frameLocator("iframe");
+
+    const firstNameValue: string = await iframe
+      .locator('input[placeholder="Jane"]')
+      .inputValue();
+
+    const lastNameValue: string = await iframe
+      .locator('input[placeholder="Doe"]')
+      .inputValue();
+
+    const emailValue: string = await iframe
+      .locator('input[placeholder="jane@example.com"]')
+      .inputValue();
+
+    const contactValue: boolean = await iframe
+      .locator("xpath=/html/body/main/section[1]/form/fieldset/label[2]/input")
+      .isChecked();
+
+    const messageValue: string = await iframe
+      .locator('textarea[placeholder="Say hello…"]')
+      .inputValue();
+
+    const passed: boolean =
+      firstNameValue.toLowerCase().trim() === "nunya" &&
+      lastNameValue.toLowerCase().trim() === "business" &&
+      emailValue.toLowerCase() === "test@email.com" &&
+      messageValue.toLowerCase() === "yooooooooooooooo" &&
+      contactValue;
+
+    return {
+      _success: passed,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/iframe_hn.ts b/packages/evals/tasks/iframe_hn.ts
new file mode 100644
index 000000000..eb4c76344
--- /dev/null
+++ b/packages/evals/tasks/iframe_hn.ts
@@ -0,0 +1,57 @@
+import { EvalFunction } from "../types/evals.js";
+import { z } from "zod";
+
+export const iframe_hn: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/iframe-hn/",
+    );
+
+    const result = await v3.extract(
+      "extract the title of the first hackernews story",
+      z.object({
+        story_title: z.string(),
+      }),
+    );
+
+    const title = result.story_title.toLowerCase();
+    const expectedTitleSubstring = "overengineered anchor links";
+
+    if (!title.includes(expectedTitleSubstring)) {
+      logger.error({
+        message: `Extracted title: ${title} does not contain expected substring: ${expectedTitleSubstring}`,
+        level: 0,
+      });
+      return {
+        _success: false,
+        error: `Extracted title: ${title} does not contain expected substring: ${expectedTitleSubstring}`,
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/iframe_same_proc.ts b/packages/evals/tasks/iframe_same_proc.ts
new file mode 100644
index 000000000..e8bf1a6b2
--- /dev/null
+++ b/packages/evals/tasks/iframe_same_proc.ts
@@ -0,0 +1,52 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const iframe_same_proc: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/iframe-same-proc/",
+    );
+
+    await v3.act("type 'stagehand' into the 'your name' field");
+
+    // overly specific prompting is okay here. we are just trying to evaluate whether
+    // we are properly traversing iframes
+    await v3.act(
+      "select 'Green' from the favorite colour dropdown. Ensure the word 'Green' is capitalized. Choose the selectOption method.",
+    );
+
+    const iframe = page.frameLocator("iframe");
+
+    const nameValue: string = await iframe
+      .locator('input[placeholder="Alice"]')
+      .inputValue();
+
+    const colorValue: string = await iframe.locator("select").inputValue();
+
+    const passed: boolean =
+      nameValue.toLowerCase().trim() === "stagehand" &&
+      colorValue.toLowerCase().trim() === "green";
+
+    return {
+      _success: passed,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/iframe_scroll.ts b/packages/evals/tasks/iframe_scroll.ts
new file mode 100644
index 000000000..d4c453974
--- /dev/null
+++ b/packages/evals/tasks/iframe_scroll.ts
@@ -0,0 +1,58 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const iframe_scroll: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/iframe-same-proc-scroll/",
+    );
+    await v3.act("scroll down 50% inside the iframe");
+
+    const frames = page.frames();
+    const frame = frames[1];
+
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+
+    // Get the current scroll position and total scroll height
+    const scrollInfo = await frame.evaluate(() => {
+      return {
+        scrollTop: window.scrollY + window.innerHeight / 2,
+        scrollHeight: document.documentElement.scrollHeight,
+      };
+    });
+
+    const halfwayScroll = scrollInfo.scrollHeight / 2;
+    const halfwayReached = Math.abs(scrollInfo.scrollTop - halfwayScroll) <= 1;
+    const evaluationResult = halfwayReached
+      ? {
+          _success: true,
+          logs: logger.getLogs(),
+          debugUrl,
+          sessionUrl,
+        }
+      : {
+          _success: false,
+          logs: logger.getLogs(),
+          debugUrl,
+          sessionUrl,
+          message: `Scroll position (${scrollInfo.scrollTop}px) is not halfway down the page (${halfwayScroll}px).`,
+        };
+
+    return evaluationResult;
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/iframes_nested.ts b/packages/evals/tasks/iframes_nested.ts
new file mode 100644
index 000000000..253e3abfc
--- /dev/null
+++ b/packages/evals/tasks/iframes_nested.ts
@@ -0,0 +1,45 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const iframes_nested: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/nested-iframes/",
+    );
+
+    await v3.act("type 'stagehand' into the 'username' field");
+
+    const inner = page
+      .frameLocator("iframe.lvl1") // level 1
+      .frameLocator("iframe.lvl2") // level 2
+      .frameLocator("iframe.lvl3"); // level 3 – form lives here
+
+    const usernameText = await inner
+      .locator('input[name="username"]')
+      .inputValue();
+
+    const passed: boolean = usernameText.toLowerCase().trim() === "stagehand";
+
+    return {
+      _success: passed,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/imdb_movie_details.ts b/packages/evals/tasks/imdb_movie_details.ts
new file mode 100644
index 000000000..b48bf323b
--- /dev/null
+++ b/packages/evals/tasks/imdb_movie_details.ts
@@ -0,0 +1,106 @@
+import { EvalFunction } from "../types/evals.js";
+import { z } from "zod";
+
+export const imdb_movie_details: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.imdb.com/title/tt0111161/", {
+      waitUntil: "domcontentloaded",
+    });
+    await v3.act("click on the movie ratings");
+
+    const movieDetails = await v3.extract(
+      "Extract the list of countries with the most ratings.",
+      z.object({
+        countries: z
+          .array(z.string())
+          .describe("List of countries with the most ratings"),
+      }),
+    );
+
+    const expectedCountries = [
+      "United States",
+      "United Kingdom",
+      "Turkey",
+      "India",
+      "Germany",
+    ];
+
+    if (!movieDetails.countries || movieDetails.countries.length !== 5) {
+      logger.error({
+        message: "Failed to extract exactly five countries",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: JSON.stringify(expectedCountries),
+            type: "object",
+          },
+          actual: {
+            value: JSON.stringify(movieDetails.countries || []),
+            type: "object",
+          },
+        },
+      });
+
+      return {
+        _success: false,
+        error: "Incorrect number of countries extracted",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    const missingCountries = expectedCountries.filter(
+      (country) => !movieDetails.countries.includes(country),
+    );
+
+    if (missingCountries.length > 0) {
+      logger.error({
+        message: "Extracted countries do not match expected countries",
+        level: 0,
+        auxiliary: {
+          missing: {
+            value: JSON.stringify(missingCountries),
+            type: "object",
+          },
+          extracted: {
+            value: JSON.stringify(movieDetails.countries),
+            type: "object",
+          },
+        },
+      });
+
+      return {
+        _success: false,
+        error: "Extracted countries do not match expected countries",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      countries: movieDetails.countries,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/evals/tasks/instructions.ts b/packages/evals/tasks/instructions.ts
similarity index 65%
rename from evals/tasks/instructions.ts
rename to packages/evals/tasks/instructions.ts
index 75e4955b7..8377151f9 100644
--- a/evals/tasks/instructions.ts
+++ b/packages/evals/tasks/instructions.ts
@@ -1,26 +1,25 @@
-import { EvalFunction } from "@/types/evals";
+import { EvalFunction } from "../types/evals.js";
 
 export const instructions: EvalFunction = async ({
   debugUrl,
   sessionUrl,
-  stagehand,
+  v3,
   logger,
 }) => {
   try {
-    const page = stagehand.page;
+    const page = v3.context.pages()[0];
 
     await page.goto("https://docs.browserbase.com/");
 
-    await page.act({
-      action: "secret12345",
-    });
+    await v3.act("secret12345");
 
     await page.waitForLoadState("domcontentloaded");
 
     const url = page.url();
 
     const isCorrectUrl =
-      url === "https://docs.browserbase.com/introduction/what-is-browserbase";
+      (await url) ===
+      "https://docs.browserbase.com/introduction/what-is-browserbase";
 
     return {
       _success: isCorrectUrl,
@@ -29,8 +28,6 @@ export const instructions: EvalFunction = async ({
       logs: logger.getLogs(),
     };
   } catch (error) {
-    console.error("Error or timeout occurred:", error);
-
     return {
       _success: false,
       error: JSON.parse(JSON.stringify(error, null, 2)),
@@ -39,6 +36,6 @@ export const instructions: EvalFunction = async ({
       logs: logger.getLogs(),
     };
   } finally {
-    await stagehand.close();
+    await v3.close();
   }
 };
diff --git a/packages/evals/tasks/ionwave.ts b/packages/evals/tasks/ionwave.ts
new file mode 100644
index 000000000..cb78edfbf
--- /dev/null
+++ b/packages/evals/tasks/ionwave.ts
@@ -0,0 +1,39 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const ionwave: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/ionwave/",
+    );
+
+    await v3.act('Click on "Closed Bids"');
+
+    const expectedUrl =
+      "https://browserbase.github.io/stagehand-eval-sites/sites/ionwave/closed-bids.html";
+    const currentUrl = page.url();
+
+    return {
+      _success: currentUrl.startsWith(expectedUrl),
+      currentUrl,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/ionwave_observe.ts b/packages/evals/tasks/ionwave_observe.ts
new file mode 100644
index 000000000..9ea15ad46
--- /dev/null
+++ b/packages/evals/tasks/ionwave_observe.ts
@@ -0,0 +1,74 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const ionwave_observe: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/ionwave/",
+    );
+
+    const observations = await v3.observe();
+
+    if (observations.length === 0) {
+      return {
+        _success: false,
+        observations,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    const expectedLocator = `#Form1 > div:nth-child(5) > div:nth-child(1) > a`;
+
+    const expectedResult = await page
+      .locator(expectedLocator)
+      .first()
+      .innerText();
+
+    let foundMatch = false;
+    for (const observation of observations) {
+      try {
+        const observationResult = await page
+          .locator(observation.selector)
+          .first()
+          .innerText();
+
+        if (observationResult === expectedResult) {
+          foundMatch = true;
+          break;
+        }
+      } catch (error) {
+        console.warn(
+          `Failed to check observation with selector ${observation.selector}:`,
+          error.message,
+        );
+        continue;
+      }
+    }
+
+    return {
+      _success: foundMatch,
+      expected: expectedResult,
+      observations,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/login.ts b/packages/evals/tasks/login.ts
new file mode 100644
index 000000000..39b604c43
--- /dev/null
+++ b/packages/evals/tasks/login.ts
@@ -0,0 +1,43 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const login: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/login/",
+    );
+
+    await v3.act("type %nunya% into the username field", {
+      variables: { nunya: "business" },
+    });
+
+    const xpath = "xpath=/html/body/main/form/div[1]/input";
+    const actualValue = await page.locator(xpath).inputValue();
+
+    const expectedValue = "business";
+
+    return {
+      _success: actualValue === expectedValue,
+      expectedValue,
+      actualValue,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/multi_tab.ts b/packages/evals/tasks/multi_tab.ts
new file mode 100644
index 000000000..4bb7a1018
--- /dev/null
+++ b/packages/evals/tasks/multi_tab.ts
@@ -0,0 +1,83 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const multi_tab: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/five-tab/",
+    );
+
+    await v3.act("click the button to open the other page");
+    await v3.act("click the button to open the other page");
+    await v3.act("click the button to open the other page");
+    await v3.act("click the button to open the other page");
+    let activePage = await v3.context.awaitActivePage();
+
+    let currentPageUrl = await activePage.url();
+    let expectedUrl =
+      "https://browserbase.github.io/stagehand-eval-sites/sites/five-tab/page5.html";
+
+    if (currentPageUrl !== expectedUrl) {
+      return {
+        _success: false,
+        message: "expected URL does not match current URL",
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    // try acting on the first page again
+    const pages = v3.context.pages();
+    const page1 = pages[0];
+    await v3.act("click the button to open the other page", { page: page1 });
+
+    activePage = await v3.context.awaitActivePage();
+    currentPageUrl = await activePage.url();
+    expectedUrl =
+      "https://browserbase.github.io/stagehand-eval-sites/sites/five-tab/page2.html";
+    if (currentPageUrl !== expectedUrl) {
+      return {
+        _success: false,
+        message: "expected URL does not match current URL",
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    const page2text = await v3.extract({ page: activePage });
+    const expectedPage2text = "You've made it to page 2";
+
+    if (page2text.pageText.includes(expectedPage2text)) {
+      return {
+        _success: true,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: false,
+      message: `extracted page text: ${page2text.pageText} does not match expected page text: ${expectedPage2text}`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: error.message,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/namespace_xpath.ts b/packages/evals/tasks/namespace_xpath.ts
new file mode 100644
index 000000000..a0d8b1b55
--- /dev/null
+++ b/packages/evals/tasks/namespace_xpath.ts
@@ -0,0 +1,38 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const namespace_xpath: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/namespaced-xpath/",
+    );
+
+    await v3.act("fill 'nunya' into the 'type here' form");
+
+    const inputValue = await page.locator("#ns-text").inputValue();
+    // confirm that the form was filled
+    const formHasBeenFilled = inputValue === "nunya";
+
+    return {
+      _success: formHasBeenFilled,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/nested_iframes_2.ts b/packages/evals/tasks/nested_iframes_2.ts
new file mode 100644
index 000000000..de07e50a0
--- /dev/null
+++ b/packages/evals/tasks/nested_iframes_2.ts
@@ -0,0 +1,44 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const nested_iframes_2: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/nested-iframes-2/",
+    );
+
+    await v3.act("click the button called 'click me (inner 2)'");
+
+    const inner = page
+      .frameLocator('iframe[src="iframe2.html"]')
+      .frameLocator('iframe[src="inner2.html"]');
+
+    const messageText = await inner.locator("#msg").textContent();
+
+    const passed: boolean =
+      messageText.toLowerCase().trim() ===
+      "clicked the button in the second inner iframe";
+
+    return {
+      _success: passed,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+      error,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/next_chunk.ts b/packages/evals/tasks/next_chunk.ts
new file mode 100644
index 000000000..f14c95ebc
--- /dev/null
+++ b/packages/evals/tasks/next_chunk.ts
@@ -0,0 +1,75 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const next_chunk: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.apartments.com/san-francisco-ca/", {
+      waitUntil: "domcontentloaded",
+    });
+    await v3.act("click on the all filters button");
+
+    const { initialScrollTop, chunkHeight } = await page.evaluate(() => {
+      const container = document.querySelector(
+        "#advancedFilters > div",
+      ) as HTMLElement;
+      if (!container) {
+        console.warn(
+          "Could not find #advancedFilters > div. Returning 0 for measurements.",
+        );
+        return { initialScrollTop: 0, chunkHeight: 0 };
+      }
+      return {
+        initialScrollTop: container.scrollTop,
+        chunkHeight: container.getBoundingClientRect().height,
+      };
+    });
+
+    await v3.act("scroll down one chunk on the filters modal");
+
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+
+    const newScrollTop = await page.evaluate(() => {
+      const container = document.querySelector(
+        "#advancedFilters > div",
+      ) as HTMLElement;
+      return container?.scrollTop ?? 0;
+    });
+
+    const actualDiff = newScrollTop - initialScrollTop;
+    const threshold = 20; // allowable difference in px
+    const scrolledOneChunk = Math.abs(actualDiff - chunkHeight) <= threshold;
+
+    const evaluationResult = scrolledOneChunk
+      ? {
+          _success: true,
+          logs: logger.getLogs(),
+          debugUrl,
+          sessionUrl,
+          message: `Successfully scrolled ~one chunk: expected ~${chunkHeight}, got ${actualDiff}`,
+        }
+      : {
+          _success: false,
+          logs: logger.getLogs(),
+          debugUrl,
+          sessionUrl,
+          message: `Scroll difference expected ~${chunkHeight} but only scrolled ${actualDiff}.`,
+        };
+
+    return evaluationResult;
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/no_js_click.ts b/packages/evals/tasks/no_js_click.ts
new file mode 100644
index 000000000..cfec32093
--- /dev/null
+++ b/packages/evals/tasks/no_js_click.ts
@@ -0,0 +1,57 @@
+import { EvalFunction } from "../types/evals.js";
+import { Action } from "@browserbasehq/stagehand";
+
+export const no_js_click: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  /**
+   * This eval is meant to test whether our `clickElement` function
+   * (inside actHandlerUtils.ts) is able to click elements even if
+   * the site blocks programmatic JS click events.
+   */
+
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/no-js-click/",
+    );
+
+    const observeResult: Action = {
+      method: "click",
+      selector: "xpath=/html/body/button",
+      description: "the button to click",
+      arguments: [],
+    };
+    await v3.act(observeResult);
+
+    const text = await page.locator("#success-msg").textContent();
+    if (text?.trim() === "click succeeded") {
+      return {
+        _success: true,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: false,
+      message: "unable to click element on website that blocks JS click events",
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: `error attempting to click the button: ${error.message}`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/evals/tasks/nonsense_action.ts b/packages/evals/tasks/nonsense_action.ts
similarity index 58%
rename from evals/tasks/nonsense_action.ts
rename to packages/evals/tasks/nonsense_action.ts
index be6f90dbd..01c022105 100644
--- a/evals/tasks/nonsense_action.ts
+++ b/packages/evals/tasks/nonsense_action.ts
@@ -1,17 +1,16 @@
-import { EvalFunction } from "@/types/evals";
+import { EvalFunction } from "../types/evals.js";
 
 export const nonsense_action: EvalFunction = async ({
   debugUrl,
   sessionUrl,
-  stagehand,
+  v3,
   logger,
 }) => {
   try {
-    await stagehand.page.goto("https://www.homedepot.com/");
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.homedepot.com/");
 
-    const result = await stagehand.page.act({
-      action: "what is the capital of the moon?",
-    });
+    const result = await v3.act("what is the capital of the moon?");
 
     return {
       _success: !result.success, // We expect this to fail
@@ -20,7 +19,6 @@ export const nonsense_action: EvalFunction = async ({
       logs: logger.getLogs(),
     };
   } catch (error) {
-    console.error(`Error in nonsense_action function: ${error.message}`);
     return {
       _success: false,
       error: JSON.parse(JSON.stringify(error, null, 2)),
@@ -29,6 +27,6 @@ export const nonsense_action: EvalFunction = async ({
       logs: logger.getLogs(),
     };
   } finally {
-    await stagehand.close();
+    await v3.close();
   }
 };
diff --git a/packages/evals/tasks/observe_amazon_add_to_cart.ts b/packages/evals/tasks/observe_amazon_add_to_cart.ts
new file mode 100644
index 000000000..658f83e04
--- /dev/null
+++ b/packages/evals/tasks/observe_amazon_add_to_cart.ts
@@ -0,0 +1,57 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const observe_amazon_add_to_cart: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/amazon/",
+    );
+
+    const observations1 = await v3.observe(
+      "Find and click the 'Add to Cart' button",
+    );
+
+    // Example of using performPlaywrightMethod if you have the xpath
+    if (observations1.length > 0) {
+      const action1 = observations1[0];
+      await v3.act(action1);
+    }
+
+    const observations2 = await v3.observe(
+      "Find and click the 'Proceed to checkout' button",
+    );
+
+    // Example of using performPlaywrightMethod if you have the xpath
+    if (observations2.length > 0) {
+      const action2 = observations2[0];
+      await v3.act(action2);
+    }
+
+    const currentUrl = page.url();
+    const expectedUrlPrefix =
+      "https://browserbase.github.io/stagehand-eval-sites/sites/amazon/sign-in.html";
+
+    return {
+      _success: currentUrl.startsWith(expectedUrlPrefix),
+      currentUrl,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/observe_github.ts b/packages/evals/tasks/observe_github.ts
new file mode 100644
index 000000000..40c411810
--- /dev/null
+++ b/packages/evals/tasks/observe_github.ts
@@ -0,0 +1,94 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const observe_github: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/github/",
+    );
+
+    const observations = await v3.observe(
+      "find the scrollable element that holds the repos file tree.",
+    );
+
+    if (observations.length === 0) {
+      return {
+        _success: false,
+        observations,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    const possibleLocators = [
+      `#repo-content-pjax-container > react-app > div > div > div.prc-PageLayout-PageLayoutRoot-1zlEO > div > div > div.Box-sc-g0xbh4-0.gISSDQ`,
+      `#repo-content-pjax-container > react-app > div > div > div.prc-PageLayout-PageLayoutRoot-1zlEO > div > div > div.Box-sc-g0xbh4-0.gISSDQ > div`,
+      `#repo-content-pjax-container > react-app > div > div > div.prc-PageLayout-PageLayoutRoot-1zlEO > div > div > div.Box-sc-g0xbh4-0.gISSDQ > div > div.prc-PageLayout-Pane-Vl5LI`,
+      `#repo-content-pjax-container > react-app > div > div > div.prc-PageLayout-PageLayoutRoot-1zlEO > div > div > div.Box-sc-g0xbh4-0.gISSDQ > div > div.prc-PageLayout-Pane-Vl5LI > div`,
+      `#repos-file-tree > div.Box-sc-g0xbh4-0.ReposFileTreePane-module__Box_5--tQNH_`,
+      `#repos-file-tree > div.Box-sc-g0xbh4-0.ReposFileTreePane-module__Box_5--tQNH_ > div`,
+      `#repos-file-tree > div.Box-sc-g0xbh4-0.ReposFileTreePane-module__Box_5--tQNH_ > div > div`,
+      `#repos-file-tree > div.Box-sc-g0xbh4-0.ReposFileTreePane-module__Box_5--tQNH_ > div > div > div > nav`,
+      `#repos-file-tree > div.Box-sc-g0xbh4-0.ReposFileTreePane-module__Box_5--tQNH_ > div > div > div > nav > ul`,
+    ];
+
+    // Precompute candidate backendNodeIds
+    const candidateIds = new Map<string, number>();
+    for (const sel of possibleLocators) {
+      try {
+        const id = await page.locator(sel).backendNodeId();
+        candidateIds.set(sel, id);
+      } catch {
+        // ignore candidates that fail to resolve
+      }
+    }
+
+    let foundMatch = false;
+    let matchedLocator: string | null = null;
+
+    for (const observation of observations) {
+      try {
+        const obsId = await page.locator(observation.selector).backendNodeId();
+        for (const [candSel, candId] of candidateIds) {
+          if (candId === obsId) {
+            foundMatch = true;
+            matchedLocator = candSel;
+            break;
+          }
+        }
+        if (foundMatch) break;
+      } catch (error) {
+        console.warn(
+          `Failed to check observation with selector ${observation.selector}:`,
+          error?.message ?? String(error),
+        );
+        continue;
+      }
+    }
+
+    return {
+      _success: foundMatch,
+      matchedLocator,
+      observations,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/observe_iframes1.ts b/packages/evals/tasks/observe_iframes1.ts
new file mode 100644
index 000000000..d50da9bee
--- /dev/null
+++ b/packages/evals/tasks/observe_iframes1.ts
@@ -0,0 +1,85 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const observe_iframes1: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/iframe-hn/",
+    );
+
+    const observations = await v3.observe("find the main header of the page");
+
+    if (observations.length === 0) {
+      return {
+        _success: false,
+        observations,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    const possibleLocators = [
+      `body > main > section.iframe-wrapper > iframe`,
+      `body > header > h1`,
+    ];
+
+    // Precompute candidate backendNodeIds
+    const candidateIds = new Map<string, number>();
+    for (const sel of possibleLocators) {
+      try {
+        const id = await page.locator(sel).backendNodeId();
+        candidateIds.set(sel, id);
+      } catch {
+        // ignore candidates that fail to resolve
+      }
+    }
+
+    let foundMatch = false;
+    let matchedLocator: string | null = null;
+
+    for (const observation of observations) {
+      try {
+        const obsId = await page.locator(observation.selector).backendNodeId();
+        for (const [candSel, candId] of candidateIds) {
+          if (candId === obsId) {
+            foundMatch = true;
+            matchedLocator = candSel;
+            break;
+          }
+        }
+        if (foundMatch) break;
+      } catch (error) {
+        console.warn(
+          `Failed to check observation with selector ${observation.selector}:`,
+          error?.message ?? String(error),
+        );
+        continue;
+      }
+    }
+
+    return {
+      _success: foundMatch,
+      matchedLocator,
+      observations,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/observe_iframes2.ts b/packages/evals/tasks/observe_iframes2.ts
new file mode 100644
index 000000000..a2d0fd54f
--- /dev/null
+++ b/packages/evals/tasks/observe_iframes2.ts
@@ -0,0 +1,93 @@
+import { EvalFunction } from "../types/evals.js";
+import { Action } from "@browserbasehq/stagehand";
+
+export const observe_iframes2: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://iframetester.com/?url=https://shopify.com");
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+
+    let observations: Action[];
+    try {
+      observations = await v3.observe("find the main header of the page");
+    } catch (err) {
+      return {
+        _success: false,
+        message: err.message,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    if (observations.length === 0) {
+      return {
+        _success: false,
+        observations,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    const possibleLocators = [`#iframe-window`, `body > header > h1`];
+
+    // Precompute candidate backendNodeIds
+    const candidateIds = new Map<string, number>();
+    for (const sel of possibleLocators) {
+      try {
+        const id = await page.locator(sel).backendNodeId();
+        candidateIds.set(sel, id);
+      } catch {
+        // ignore candidates that fail to resolve
+      }
+    }
+
+    let foundMatch = false;
+    let matchedLocator: string | null = null;
+
+    for (const observation of observations) {
+      try {
+        const obsId = await page.locator(observation.selector).backendNodeId();
+        for (const [candSel, candId] of candidateIds) {
+          if (candId === obsId) {
+            foundMatch = true;
+            matchedLocator = candSel;
+            break;
+          }
+        }
+        if (foundMatch) break;
+      } catch (error) {
+        console.warn(
+          `Failed to check observation with selector ${observation.selector}:`,
+          error?.message ?? String(error),
+        );
+        continue;
+      }
+    }
+
+    return {
+      _success: foundMatch,
+      matchedLocator,
+      observations,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/observe_simple_google_search.ts b/packages/evals/tasks/observe_simple_google_search.ts
new file mode 100644
index 000000000..63c4f3cae
--- /dev/null
+++ b/packages/evals/tasks/observe_simple_google_search.ts
@@ -0,0 +1,52 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const observe_simple_google_search: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/google/",
+    );
+    const observation1 = await v3.observe(
+      "Find the search bar and type 'OpenAI'",
+    );
+
+    if (observation1.length > 0) {
+      const action1 = observation1[0];
+      await v3.act(action1);
+    }
+    const observation2 = await v3.observe("Press enter");
+
+    if (observation2.length > 0) {
+      const action2 = observation2[0];
+      await v3.act(action2);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 3000));
+
+    const expectedUrl =
+      "https://browserbase.github.io/stagehand-eval-sites/sites/google/openai.html";
+    const currentUrl = page.url();
+
+    return {
+      _success: currentUrl.startsWith(expectedUrl),
+      currentUrl,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/observe_taxes.ts b/packages/evals/tasks/observe_taxes.ts
new file mode 100644
index 000000000..fcae024e8
--- /dev/null
+++ b/packages/evals/tasks/observe_taxes.ts
@@ -0,0 +1,82 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const observe_taxes: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://file.1040.com/estimate/");
+
+    const observations = await v3.observe(
+      "Find all the form input elements under the 'Income' section",
+    );
+
+    if (observations.length === 0) {
+      return {
+        _success: false,
+        observations,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    } else if (observations.length < 13) {
+      return {
+        _success: false,
+        observations,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    const expectedLocator = `#tpWages`;
+
+    const expectedResult = await page
+      .locator(expectedLocator)
+      .first()
+      .innerText();
+
+    let foundMatch = false;
+    for (const observation of observations) {
+      try {
+        const observationResult = await page
+          .locator(observation.selector)
+          .first()
+          .innerText();
+
+        if (observationResult === expectedResult) {
+          foundMatch = true;
+          break;
+        }
+      } catch (error) {
+        console.warn(
+          `Failed to check observation with selector ${observation.selector}:`,
+          error.message,
+        );
+        continue;
+      }
+    }
+
+    return {
+      _success: foundMatch,
+      expected: expectedResult,
+      observations,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/observe_vantechjournal.ts b/packages/evals/tasks/observe_vantechjournal.ts
new file mode 100644
index 000000000..f719e1610
--- /dev/null
+++ b/packages/evals/tasks/observe_vantechjournal.ts
@@ -0,0 +1,61 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const observe_vantechjournal: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://vantechjournal.com/archive");
+
+    const observations = await v3.observe("Find the 'load more' link");
+
+    if (observations.length === 0) {
+      return {
+        _success: false,
+        observations,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    const expectedLocators = [
+      "xpath=/html/body/div[2]/div/section/div/div/div[3]/a",
+      "xpath=/html/body/div[2]/div/section/div/div/div[3]/a/span",
+    ];
+
+    const expectedIds: number[] = [];
+    for (const locator of expectedLocators) {
+      const node = page.locator(locator);
+      const id = await node.backendNodeId();
+      if (id !== undefined && id !== null) expectedIds.push(id);
+    }
+
+    const observedNode = page.locator(observations[0].selector);
+    const observedId = await observedNode.backendNodeId();
+
+    const foundMatch = expectedIds.includes(observedId);
+
+    return {
+      _success: foundMatch,
+      expected: expectedLocators,
+      observations,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error: unknown) {
+    return {
+      _success: false,
+      error: error instanceof Error ? error.message : String(error),
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/observe_yc_startup.ts b/packages/evals/tasks/observe_yc_startup.ts
new file mode 100644
index 000000000..8240198ea
--- /dev/null
+++ b/packages/evals/tasks/observe_yc_startup.ts
@@ -0,0 +1,87 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const observe_yc_startup: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.ycombinator.com/companies", {
+      waitUntil: "networkidle",
+    });
+
+    const observations = await v3.observe(
+      "Click the container element that holds links to each of the startup companies. The companies each have a name, a description, and a link to their website.",
+    );
+
+    if (observations.length === 0) {
+      return {
+        _success: false,
+        observations,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    const possibleLocators = [
+      `div._rightCol_zhfs4_592`,
+      `div._section_zhfs4_163._results_zhfs4_343`,
+    ];
+
+    // Precompute candidate backendNodeIds
+    const candidateIds = new Map<string, number>();
+    for (const sel of possibleLocators) {
+      try {
+        const id = await page.locator(sel).backendNodeId();
+        candidateIds.set(sel, id);
+      } catch {
+        // ignore candidates that fail to resolve
+      }
+    }
+
+    let foundMatch = false;
+    let matchedLocator: string | null = null;
+
+    for (const observation of observations) {
+      try {
+        const obsId = await page.locator(observation.selector).backendNodeId();
+        for (const [candSel, candId] of candidateIds) {
+          if (candId === obsId) {
+            foundMatch = true;
+            matchedLocator = candSel;
+            break;
+          }
+        }
+        if (foundMatch) break;
+      } catch (error) {
+        console.warn(
+          `Failed to check observation with selector ${observation.selector}:`,
+          error?.message ?? String(error),
+        );
+        continue;
+      }
+    }
+
+    return {
+      _success: foundMatch,
+      matchedLocator,
+      observations,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/oopif_in_csr.ts b/packages/evals/tasks/oopif_in_csr.ts
new file mode 100644
index 000000000..96cf00acc
--- /dev/null
+++ b/packages/evals/tasks/oopif_in_csr.ts
@@ -0,0 +1,51 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const oopif_in_csr: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  // this eval is designed to test whether stagehand can successfully
+  // fill a form inside a OOPIF (out of process iframe) that is inside an
+  // CSR (closed mode shadow) root
+
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/oopif-in-open-shadow-dom/",
+    );
+    await v3.act("fill 'nunya' into the first name field");
+
+    const extraction = await v3.extract("extract the entire page text");
+
+    const pageText = extraction.extraction;
+
+    if (pageText.includes("nunya")) {
+      return {
+        _success: true,
+        message: `successfully filled the form`,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: false,
+      message: `unable to fill the form`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: `error: ${error.message}`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/oopif_in_osr.ts b/packages/evals/tasks/oopif_in_osr.ts
new file mode 100644
index 000000000..15e29baa6
--- /dev/null
+++ b/packages/evals/tasks/oopif_in_osr.ts
@@ -0,0 +1,51 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const oopif_in_osr: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  // this eval is designed to test whether stagehand can successfully
+  // fill a form inside a OOPIF (out of process iframe) that is inside an
+  // OSR (open mode shadow) root
+
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/oopif-in-open-shadow-dom/",
+    );
+    await v3.act("fill 'nunya' into the first name field");
+
+    const extraction = await v3.extract("extract the entire page text");
+
+    const pageText = extraction.extraction;
+
+    if (pageText.includes("nunya")) {
+      return {
+        _success: true,
+        message: `successfully filled the form`,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: false,
+      message: `unable to fill the form`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: `error: ${error.message}`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/os_dropdown.ts b/packages/evals/tasks/os_dropdown.ts
new file mode 100644
index 000000000..2e5fbe670
--- /dev/null
+++ b/packages/evals/tasks/os_dropdown.ts
@@ -0,0 +1,53 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const os_dropdown: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  /**
+   * This eval is meant to test whether we can correctly select an element
+   * from an OS level dropdown
+   */
+
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/nested-dropdown/",
+    );
+
+    await v3.act(
+      "choose 'Smog Check Technician' from the 'License Type' dropdown",
+    );
+    const selectedOption = await page
+      .locator("#licenseType >> option:checked")
+      .textContent();
+
+    if (selectedOption === "Smog Check Technician") {
+      return {
+        _success: true,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: false,
+      message: "incorrect option selected from the dropdown",
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: `error attempting to select an option from the dropdown: ${error.message}`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/osr_in_oopif.ts b/packages/evals/tasks/osr_in_oopif.ts
new file mode 100644
index 000000000..31f7630ab
--- /dev/null
+++ b/packages/evals/tasks/osr_in_oopif.ts
@@ -0,0 +1,51 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const osr_in_oopif: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  // this eval is designed to test whether stagehand can successfully
+  // click inside an OSR (open mode shadow) root that is inside an
+  // OOPIF (out of process iframe)
+
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/open-shadow-root-in-oopif/",
+    );
+    await v3.act("click the button");
+
+    const extraction = await v3.extract("extract the entire page text");
+
+    const pageText = extraction.extraction;
+
+    if (pageText.includes("button successfully clicked")) {
+      return {
+        _success: true,
+        message: `successfully clicked the button`,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: false,
+      message: `unable to click on the button`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: `error: ${error.message}`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/osr_in_spif.ts b/packages/evals/tasks/osr_in_spif.ts
new file mode 100644
index 000000000..1fdd8f3e6
--- /dev/null
+++ b/packages/evals/tasks/osr_in_spif.ts
@@ -0,0 +1,51 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const osr_in_spif: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  // this eval is designed to test whether stagehand can successfully
+  // click inside an OSR (open mode shadow) root that is inside an
+  // SPIF (same process iframe)
+
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/open-shadow-root-in-spif/",
+    );
+    await v3.act("click the button");
+
+    const extraction = await v3.extract("extract the entire page text");
+
+    const pageText = extraction.extraction;
+
+    if (pageText.includes("button successfully clicked")) {
+      return {
+        _success: true,
+        message: `successfully clicked the button`,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: false,
+      message: `unable to click on the button`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: `error: ${error.message}`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/panamcs.ts b/packages/evals/tasks/panamcs.ts
new file mode 100644
index 000000000..3bc81bacd
--- /dev/null
+++ b/packages/evals/tasks/panamcs.ts
@@ -0,0 +1,74 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const panamcs: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/panamcs/",
+    );
+
+    const observations = await v3.observe("click the 'about us' link");
+
+    if (observations.length === 0) {
+      return {
+        _success: false,
+        observations,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    const expectedLocator = `#menu > li:nth-child(1) > a`;
+
+    const expectedResult = await page
+      .locator(expectedLocator)
+      .first()
+      .innerText();
+
+    let foundMatch = false;
+    for (const observation of observations) {
+      try {
+        const observationResult = await page
+          .locator(observation.selector)
+          .first()
+          .innerText();
+
+        if (observationResult === expectedResult) {
+          foundMatch = true;
+          break;
+        }
+      } catch (error) {
+        console.warn(
+          `Failed to check observation with selector ${observation.selector}:`,
+          error.message,
+        );
+        continue;
+      }
+    }
+
+    return {
+      _success: foundMatch,
+      expected: expectedResult,
+      observations,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/evals/tasks/peeler_complex.ts b/packages/evals/tasks/peeler_complex.ts
similarity index 54%
rename from evals/tasks/peeler_complex.ts
rename to packages/evals/tasks/peeler_complex.ts
index 4b9ad170c..0df4e26ff 100644
--- a/evals/tasks/peeler_complex.ts
+++ b/packages/evals/tasks/peeler_complex.ts
@@ -1,36 +1,30 @@
-import { EvalFunction } from "@/types/evals";
+import { EvalFunction } from "../types/evals.js";
 import { z } from "zod";
 
 export const peeler_complex: EvalFunction = async ({
   debugUrl,
   sessionUrl,
-  stagehand,
+  v3,
   logger,
-  useTextExtract,
 }) => {
   try {
-    await stagehand.page.goto(`https://chefstoys.com/`, { timeout: 60000 });
-    await stagehand.page.waitForLoadState("networkidle");
+    const page = v3.context.pages()[0];
+    await page.goto(`https://chefstoys.com/`, { timeoutMs: 60000 });
+    await page.waitForLoadState("networkidle");
 
-    await stagehand.page.act("find the button to close the popup");
-    await stagehand.page.act({
-      action: "search for %search_query%",
+    await v3.act("find the button to close the popup");
+    await v3.act("search for %search_query%", {
       variables: {
         search_query: "peeler",
       },
     });
 
-    await stagehand.page.act({
-      action: 'click on the first "OXO" brand peeler',
-    });
-
-    const { price } = await stagehand.page.extract({
-      instruction: "get the price of the peeler",
-      schema: z.object({ price: z.number().nullable() }),
-      useTextExtract,
-    });
+    await v3.act('click on the first "OXO" brand peeler');
 
-    await stagehand.close();
+    const { price } = await v3.extract(
+      "get the price of the peeler",
+      z.object({ price: z.number().nullable() }),
+    );
 
     return {
       _success: price === 11.99,
@@ -55,8 +49,6 @@ export const peeler_complex: EvalFunction = async ({
       },
     });
 
-    await stagehand.close();
-
     return {
       _success: false,
       error: JSON.parse(JSON.stringify(error, null, 2)),
@@ -64,5 +56,7 @@ export const peeler_complex: EvalFunction = async ({
       sessionUrl,
       logs: logger.getLogs(),
     };
+  } finally {
+    await v3.close();
   }
 };
diff --git a/packages/evals/tasks/prev_chunk.ts b/packages/evals/tasks/prev_chunk.ts
new file mode 100644
index 000000000..7bb9047a5
--- /dev/null
+++ b/packages/evals/tasks/prev_chunk.ts
@@ -0,0 +1,70 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const prev_chunk: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/aigrant/",
+    );
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    const { initialScrollTop, chunkHeight } = await page.evaluate(() => {
+      const halfPage = document.body.scrollHeight / 2;
+
+      window.scrollTo({
+        top: halfPage,
+        left: 0,
+        behavior: "instant",
+      });
+
+      const chunk = window.innerHeight;
+
+      return {
+        initialScrollTop: window.scrollY,
+        chunkHeight: chunk,
+      };
+    });
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    await v3.act("scroll up one chunk");
+
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+
+    const finalScrollTop = await page.evaluate(() => window.scrollY);
+
+    const actualDiff = initialScrollTop - finalScrollTop;
+    const threshold = 20; // px tolerance
+    const scrolledOneChunk = Math.abs(actualDiff - chunkHeight) <= threshold;
+
+    const evaluationResult = scrolledOneChunk
+      ? {
+          _success: true,
+          logs: logger.getLogs(),
+          debugUrl,
+          sessionUrl,
+          message: `Successfully scrolled ~one chunk UP: expected ~${chunkHeight}, got ${actualDiff}.`,
+        }
+      : {
+          _success: false,
+          logs: logger.getLogs(),
+          debugUrl,
+          sessionUrl,
+          message: `Scroll difference expected ~${chunkHeight} but only scrolled ${actualDiff}.`,
+        };
+
+    return evaluationResult;
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/radio_btn.ts b/packages/evals/tasks/radio_btn.ts
new file mode 100644
index 000000000..27ca8db1c
--- /dev/null
+++ b/packages/evals/tasks/radio_btn.ts
@@ -0,0 +1,39 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const radio_btn: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/paneer-pizza/",
+    );
+
+    await v3.act("click the 'medium' option");
+
+    // confirm that the Medium radio is now checked
+    const radioBtnClicked = await page
+      .locator('input[type="radio"][name="Pizza"][value="Medium"]')
+      .isChecked();
+
+    return {
+      _success: radioBtnClicked,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/rakuten_jp.ts b/packages/evals/tasks/rakuten_jp.ts
new file mode 100644
index 000000000..8c2edc5ed
--- /dev/null
+++ b/packages/evals/tasks/rakuten_jp.ts
@@ -0,0 +1,36 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const rakuten_jp: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.rakuten.co.jp/");
+
+    await v3.act("type '香菜' into the search bar");
+    await v3.act("press enter");
+    const url = page.url();
+    const successUrl =
+      "https://search.rakuten.co.jp/search/mall/%E9%A6%99%E8%8F%9C/";
+
+    return {
+      _success: url === successUrl,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/sciquest.ts b/packages/evals/tasks/sciquest.ts
new file mode 100644
index 000000000..df6185f75
--- /dev/null
+++ b/packages/evals/tasks/sciquest.ts
@@ -0,0 +1,77 @@
+import { EvalFunction } from "../types/evals.js";
+import { z } from "zod";
+
+export const sciquest: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://bids.sciquest.com/apps/Router/PublicEvent?tab=PHX_NAV_SourcingAllOpps&CustomerOrg=StateOfUtah",
+    );
+
+    await v3.act('Click on the "Closed" tab');
+
+    const result = await v3.extract(
+      "Extract the total number of results that the search produced. Not the number of results displayed on the page.",
+      z.object({
+        total_results: z.string(),
+      }),
+    );
+
+    const { total_results } = result;
+
+    const expectedNumber = 12637;
+    const extractedNumber = parseInt(total_results.replace(/[^\d]/g, ""), 10);
+
+    const isWithinRange =
+      extractedNumber >= expectedNumber - 1000 &&
+      extractedNumber <= expectedNumber + 1000;
+
+    if (!isWithinRange) {
+      logger.error({
+        message: "Total number of results is not within the expected range",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: `${expectedNumber} ± 1000`,
+            type: "string",
+          },
+          actual: {
+            value: extractedNumber.toString(),
+            type: "integer",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Total number of results is not within the expected range",
+        extractedNumber,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    return {
+      _success: true,
+      extractedNumber,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/scroll_50.ts b/packages/evals/tasks/scroll_50.ts
new file mode 100644
index 000000000..7b2a02eca
--- /dev/null
+++ b/packages/evals/tasks/scroll_50.ts
@@ -0,0 +1,56 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const scroll_50: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/aigrant/",
+    );
+    await v3.act("Scroll 50% down the page");
+
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+
+    // Get the current scroll position and total scroll height
+    const scrollInfo = await page.evaluate(() => {
+      return {
+        scrollTop: window.scrollY + window.innerHeight / 2,
+        scrollHeight: document.documentElement.scrollHeight,
+      };
+    });
+
+    const halfwayScroll = scrollInfo.scrollHeight / 2;
+    const halfwayReached =
+      Math.abs(scrollInfo.scrollTop - halfwayScroll) <= 200;
+    const evaluationResult = halfwayReached
+      ? {
+          _success: true,
+          logs: logger.getLogs(),
+          debugUrl,
+          sessionUrl,
+        }
+      : {
+          _success: false,
+          logs: logger.getLogs(),
+          debugUrl,
+          sessionUrl,
+          message: `Scroll position (${scrollInfo.scrollTop}px) is not halfway down the page (${halfwayScroll}px).`,
+        };
+
+    return evaluationResult;
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/scroll_75.ts b/packages/evals/tasks/scroll_75.ts
new file mode 100644
index 000000000..a017e3a78
--- /dev/null
+++ b/packages/evals/tasks/scroll_75.ts
@@ -0,0 +1,56 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const scroll_75: EvalFunction = async ({
+  logger,
+  debugUrl,
+  sessionUrl,
+  v3,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/aigrant/",
+    );
+    await v3.act("Scroll 75% down the page");
+
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+
+    // Get the current scroll position and total scroll height
+    const scrollInfo = await page.evaluate(() => {
+      return {
+        scrollTop: window.scrollY + window.innerHeight * 0.75,
+        scrollHeight: document.documentElement.scrollHeight,
+      };
+    });
+
+    const threeQuartersScroll = scrollInfo.scrollHeight * 0.75;
+    const threeQuartersReached =
+      Math.abs(scrollInfo.scrollTop - threeQuartersScroll) <= 200;
+    const evaluationResult = threeQuartersReached
+      ? {
+          _success: true,
+          logs: logger.getLogs(),
+          debugUrl,
+          sessionUrl,
+        }
+      : {
+          _success: false,
+          logs: logger.getLogs(),
+          debugUrl,
+          sessionUrl,
+          message: `Scroll position (${scrollInfo.scrollTop}px) is not three quarters down the page (${threeQuartersScroll}px).`,
+        };
+
+    return evaluationResult;
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/shadow_dom.ts b/packages/evals/tasks/shadow_dom.ts
new file mode 100644
index 000000000..acd007100
--- /dev/null
+++ b/packages/evals/tasks/shadow_dom.ts
@@ -0,0 +1,44 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const shadow_dom: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/shadow-dom/",
+    );
+    await v3.act("click the button");
+    const extraction = await v3.extract("extract the page text");
+
+    const pageText = extraction.extraction;
+
+    if (pageText.includes("button successfully clicked")) {
+      return {
+        _success: true,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: false,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: `error: ${error.message}`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/simple_google_search.ts b/packages/evals/tasks/simple_google_search.ts
new file mode 100644
index 000000000..1163ddc58
--- /dev/null
+++ b/packages/evals/tasks/simple_google_search.ts
@@ -0,0 +1,41 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const simple_google_search: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/google/",
+    );
+
+    await v3.act('type "OpenAI" into the search bar');
+
+    await v3.act("press enter");
+
+    const expectedUrl =
+      "https://browserbase.github.io/stagehand-eval-sites/sites/google/openai.html";
+    const currentUrl = page.url();
+
+    return {
+      _success: currentUrl.startsWith(expectedUrl),
+      currentUrl,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/spif_in_csr.ts b/packages/evals/tasks/spif_in_csr.ts
new file mode 100644
index 000000000..6ab348ca4
--- /dev/null
+++ b/packages/evals/tasks/spif_in_csr.ts
@@ -0,0 +1,50 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const spif_in_csr: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  // this eval is designed to test whether stagehand can successfully
+  // click inside a SPIF (same process iframe) that is inside an
+  // CSR (closed mode shadow) root
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/spif-in-closed-shadow-dom/",
+    );
+    await v3.act("click the button");
+
+    const extraction = await v3.extract("extract the entire page text");
+
+    const pageText = extraction.extraction;
+
+    if (pageText.includes("button successfully clicked")) {
+      return {
+        _success: true,
+        message: `successfully clicked the button`,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: false,
+      message: `unable to click on the button`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: `error: ${error.message}`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/spif_in_osr.ts b/packages/evals/tasks/spif_in_osr.ts
new file mode 100644
index 000000000..4ae5012b3
--- /dev/null
+++ b/packages/evals/tasks/spif_in_osr.ts
@@ -0,0 +1,51 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const spif_in_osr: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  // this eval is designed to test whether stagehand can successfully
+  // click inside a SPIF (same process iframe) that is inside an
+  // OSR (open mode shadow) root
+
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/spif-in-open-shadow-dom/",
+    );
+    await v3.act("click the button");
+
+    const extraction = await v3.extract("extract the entire page text");
+
+    const pageText = extraction.extraction;
+
+    if (pageText.includes("button successfully clicked")) {
+      return {
+        _success: true,
+        message: `successfully clicked the button`,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+    return {
+      _success: false,
+      message: `unable to click on the button`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: `error: ${error.message}`,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/stock_x.ts b/packages/evals/tasks/stock_x.ts
new file mode 100644
index 000000000..c05fbfd71
--- /dev/null
+++ b/packages/evals/tasks/stock_x.ts
@@ -0,0 +1,38 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const stock_x: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://stockx.com/air-jordan-3-retro-black-cement-2024");
+
+    await v3.act("click on Jordan 3 Retro Crimson in the related products");
+
+    const currentUrl = page.url();
+    const expectedUrlPrefix = "https://stockx.com/jordan-3-retro-crimson";
+
+    await v3.close();
+
+    return {
+      _success: currentUrl.startsWith(expectedUrlPrefix),
+      currentUrl,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/tab_handling.ts b/packages/evals/tasks/tab_handling.ts
new file mode 100644
index 000000000..cc97e3671
--- /dev/null
+++ b/packages/evals/tasks/tab_handling.ts
@@ -0,0 +1,48 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const tab_handling: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/new-tab/",
+    );
+
+    await v3.act("click the button to open the other page");
+
+    const pages = v3.context.pages();
+    const page1 = pages[0];
+    const page2 = pages[1];
+
+    // extract all the text from the first page
+    const extraction1 = await v3.extract({ page: page1 });
+    // extract all the text from the second page
+    const extraction2 = await v3.extract({ page: page2 });
+
+    const extraction1Success = extraction1.pageText.includes("Welcome!");
+    const extraction2Success = extraction2.pageText.includes(
+      "You’re on the other page",
+    );
+
+    return {
+      _success: extraction1Success && extraction2Success,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      message: error.message,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/ted_talk.ts b/packages/evals/tasks/ted_talk.ts
new file mode 100644
index 000000000..17efa6b78
--- /dev/null
+++ b/packages/evals/tasks/ted_talk.ts
@@ -0,0 +1,127 @@
+import { EvalFunction } from "../types/evals.js";
+import { normalizeString } from "../utils.js";
+import { z } from "zod";
+
+export const ted_talk: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://www.ted.com/talks/sir_ken_robinson_do_schools_kill_creativity",
+      {
+        waitUntil: "domcontentloaded",
+      },
+    );
+
+    await v3.act("scroll 10% down the page");
+
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+
+    await v3.act(
+      "Click the link that takes you to the page about the 'Culture' topic",
+    );
+
+    const playlists = await v3.extract(
+      "Extract the video playlist titles and the number of talks in each playlist. This info is in the Video Playlists about Culture section of the webpage.",
+      z.object({
+        playlists: z
+          .array(
+            z.object({
+              title: z.string().describe("Title of the playlist"),
+              num_talks: z.number().describe("Number of talks in the playlist"),
+            }),
+          )
+          .describe("List of culture video playlists"),
+      }),
+    );
+
+    const expectedPlaylists = [
+      {
+        title: "Talks that celebrate the boundless creativity of an open mind",
+        num_talks: 6,
+      },
+      {
+        title: "Little-known big history",
+        num_talks: 15,
+      },
+      {
+        title: "Extraordinary, larger-than-life art",
+        num_talks: 10,
+      },
+      {
+        title: "How perfectionism fails us",
+        num_talks: 4,
+      },
+    ];
+
+    if (!playlists.playlists || playlists.playlists.length === 0) {
+      logger.error({
+        message: "Failed to extract playlists on culture",
+        level: 0,
+      });
+
+      return {
+        _success: false,
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    const missingPlaylists = expectedPlaylists.filter((expected) =>
+      playlists.playlists.every(
+        (extracted) =>
+          normalizeString(extracted.title) !==
+            normalizeString(expected.title) ||
+          extracted.num_talks !== expected.num_talks,
+      ),
+    );
+
+    if (missingPlaylists.length > 0) {
+      logger.error({
+        message: "Extracted playlists do not match expected playlists",
+        level: 0,
+        auxiliary: {
+          missing: {
+            value: JSON.stringify(missingPlaylists),
+            type: "object",
+          },
+          extracted: {
+            value: JSON.stringify(playlists.playlists),
+            type: "object",
+          },
+        },
+      });
+
+      return {
+        _success: false,
+        error: "Extracted playlists do not match expected playlists",
+        logs: logger.getLogs(),
+        debugUrl,
+        sessionUrl,
+      };
+    }
+
+    return {
+      _success: true,
+      playlists: playlists.playlists,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      logs: logger.getLogs(),
+      debugUrl,
+      sessionUrl,
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/vanta_h.ts b/packages/evals/tasks/vanta_h.ts
new file mode 100644
index 000000000..e15f40c77
--- /dev/null
+++ b/packages/evals/tasks/vanta_h.ts
@@ -0,0 +1,36 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const vanta_h: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://www.vanta.com/");
+
+    const observations = await v3.observe(
+      "click the buy now button if it is available",
+    );
+
+    // we should have no saved observation since the element shouldn't exist
+    return {
+      _success: observations.length === 0,
+      observations,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/vantechjournal.ts b/packages/evals/tasks/vantechjournal.ts
new file mode 100644
index 000000000..37624d77f
--- /dev/null
+++ b/packages/evals/tasks/vantechjournal.ts
@@ -0,0 +1,37 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const vantechjournal: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto("https://vantechjournal.com");
+
+    await v3.act("click on page 'recommendations'");
+
+    const expectedUrl = "https://vantechjournal.com/recommendations";
+    const currentUrl = page.url();
+
+    return {
+      _success: currentUrl === expectedUrl,
+      currentUrl,
+      expectedUrl,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/wichita.ts b/packages/evals/tasks/wichita.ts
new file mode 100644
index 000000000..ae479f582
--- /dev/null
+++ b/packages/evals/tasks/wichita.ts
@@ -0,0 +1,72 @@
+import { EvalFunction } from "../types/evals.js";
+import { z } from "zod";
+
+export const wichita: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(
+      "https://browserbase.github.io/stagehand-eval-sites/sites/wichita/",
+    );
+
+    await v3.act('Click on "Show Closed/Awarded/Cancelled bids"');
+
+    const result = await v3.extract(
+      "Extract the total number of bids that the search produced.",
+      z.object({
+        total_results: z.number(),
+      }),
+    );
+
+    const { total_results } = result;
+
+    const expectedNumber = 430;
+
+    if (total_results !== expectedNumber) {
+      logger.error({
+        message: "Total number of results does not match expected",
+        level: 0,
+        auxiliary: {
+          expected: {
+            value: expectedNumber.toString(),
+            type: "integer",
+          },
+          actual: {
+            value: total_results.toString(),
+            type: "integer",
+          },
+        },
+      });
+      return {
+        _success: false,
+        error: "Total number of results does not match expected",
+        total_results,
+        debugUrl,
+        sessionUrl,
+        logs: logger.getLogs(),
+      };
+    }
+
+    return {
+      _success: true,
+      total_results,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tasks/wikipedia.ts b/packages/evals/tasks/wikipedia.ts
new file mode 100644
index 000000000..a629f8e25
--- /dev/null
+++ b/packages/evals/tasks/wikipedia.ts
@@ -0,0 +1,38 @@
+import { EvalFunction } from "../types/evals.js";
+
+export const wikipedia: EvalFunction = async ({
+  debugUrl,
+  sessionUrl,
+  v3,
+  logger,
+}) => {
+  try {
+    const page = v3.context.pages()[0];
+    await page.goto(`https://en.wikipedia.org/wiki/Baseball`);
+    await v3.act('click the "hit and run" link in this article', {
+      timeout: 360_000,
+    });
+
+    const url = "https://en.wikipedia.org/wiki/Hit_and_run_(baseball)";
+    const currentUrl = page.url();
+
+    return {
+      _success: currentUrl === url,
+      expected: url,
+      actual: currentUrl,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } catch (error) {
+    return {
+      _success: false,
+      error: error,
+      debugUrl,
+      sessionUrl,
+      logs: logger.getLogs(),
+    };
+  } finally {
+    await v3.close();
+  }
+};
diff --git a/packages/evals/tsconfig.json b/packages/evals/tsconfig.json
new file mode 100644
index 000000000..ad62bdae9
--- /dev/null
+++ b/packages/evals/tsconfig.json
@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "rootDir": ".",
+    "outDir": "dist/esm",
+    "noEmit": false,
+    "paths": {
+      "@browserbasehq/stagehand": ["../core/dist/esm/index.d.ts"]
+    }
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}
diff --git a/types/evals.ts b/packages/evals/types/evals.ts
similarity index 51%
rename from types/evals.ts
rename to packages/evals/types/evals.ts
index dc672550b..deadad8b3 100644
--- a/types/evals.ts
+++ b/packages/evals/types/evals.ts
@@ -1,21 +1,24 @@
 import { z } from "zod";
-import type { AvailableModel } from "../types/model";
-import type { LogLine } from "../types/log";
+import type { AvailableModel } from "@browserbasehq/stagehand";
+import type { LogLine } from "@browserbasehq/stagehand";
+import type { AgentInstance } from "@browserbasehq/stagehand";
 import type { EvalCase } from "braintrust";
-import { Stagehand } from "@/dist";
-import { ConstructorParams } from "@/dist";
-import { EvalLogger } from "@/evals/logger";
+import type { V3 } from "@browserbasehq/stagehand";
+import { EvalLogger } from "../logger.js";
 
 export type StagehandInitResult = {
-  stagehand: Stagehand;
+  v3?: V3;
+  v3Agent?: AgentInstance;
   logger: EvalLogger;
   debugUrl: string;
   sessionUrl: string;
-  useTextExtract: boolean;
-  stagehandConfig: ConstructorParams;
+  modelName: AvailableModel;
+  agent: AgentInstance;
 };
 
-export type EvalFunction = (taskInput: StagehandInitResult) => Promise<{
+export type EvalFunction = (
+  taskInput: StagehandInitResult & { input: EvalInput },
+) => Promise<{
   _success: boolean;
   logs: LogLine[];
   debugUrl: string;
@@ -29,29 +32,52 @@ export const EvalCategorySchema = z.enum([
   "combination",
   "extract",
   "experimental",
-  "text_extract",
   "targeted_extract",
   "regression",
   "regression_llm_providers",
   "llm_clients",
+  "agent",
+  "external_agent_benchmarks",
 ]);
 
 export type EvalCategory = z.infer<typeof EvalCategorySchema>;
 export interface EvalInput {
   name: string;
   modelName: AvailableModel;
+  isCUA?: boolean;
+  // Optional per-test parameters, used by data-driven tasks
+  params?: Record<string, unknown>;
 }
 
 export interface Testcase
   extends EvalCase<
     EvalInput,
     unknown,
-    { model: AvailableModel; test: string }
+    {
+      model: AvailableModel;
+      test: string;
+      categories?: string[];
+      category?: string;
+      dataset?: string;
+      task_id?: string;
+      website?: string;
+      difficulty?: string;
+    }
   > {
   input: EvalInput;
   name: string;
   tags: string[];
-  metadata: { model: AvailableModel; test: string };
+  metadata: {
+    model: AvailableModel;
+    test: string;
+    categories?: string[];
+    category?: string;
+    dataset?: string;
+    task_id?: string;
+    website?: string;
+    difficulty?: string;
+    task_category?: string;
+  };
   expected: unknown;
 }
 
@@ -77,3 +103,8 @@ export interface EvalResult {
 export type LogLineEval = LogLine & {
   parsedAuxiliary?: string | object;
 };
+
+export type AgentModelEntry = {
+  modelName: string;
+  cua: boolean;
+};
diff --git a/packages/evals/types/screenshotCollector.ts b/packages/evals/types/screenshotCollector.ts
new file mode 100644
index 000000000..afd874444
--- /dev/null
+++ b/packages/evals/types/screenshotCollector.ts
@@ -0,0 +1,16 @@
+export interface ScreenshotCollectorOptions {
+  /**
+   * Interval in ms for polling-based screenshot capture.
+   * If provided, start() will begin polling at this interval.
+   * If omitted, use addScreenshot() via the V3 event bus for event-driven collection.
+   */
+  interval?: number;
+  maxScreenshots?: number;
+}
+
+// Minimal page-like interface: supports screenshot() and optional event hooks
+export type ScreenshotCapablePage = {
+  screenshot: (...args: []) => Promise<Buffer | string>;
+  on?: (event: string, listener: (...args: []) => void) => void;
+  off?: (event: string, listener: (...args: []) => void) => void;
+};
diff --git a/evals/utils.ts b/packages/evals/utils.ts
similarity index 62%
rename from evals/utils.ts
rename to packages/evals/utils.ts
index a573d1729..a52768aae 100644
--- a/evals/utils.ts
+++ b/packages/evals/utils.ts
@@ -7,8 +7,8 @@
  * - Generation of unique experiment names based on the current timestamp, environment,
  *   and eval name or category.
  */
-
-import { LogLine } from "@/dist";
+import fs from "fs";
+import { LogLine } from "@browserbasehq/stagehand";
 import stringComparison from "string-comparison";
 const { jaroWinkler } = stringComparison;
 
@@ -109,7 +109,10 @@ export function logLineToString(logLine: LogLine): string {
   try {
     const timestamp = logLine.timestamp || new Date().toISOString();
     if (logLine.auxiliary?.error) {
-      return `${timestamp}::[stagehand:${logLine.category}] ${logLine.message}\n ${logLine.auxiliary.error.value}\n ${logLine.auxiliary.trace.value}`;
+      const errorValue = logLine.auxiliary.error?.value ?? "";
+      const traceValue = logLine.auxiliary.trace?.value ?? "";
+      const traceSuffix = traceValue ? `\n ${traceValue}` : "";
+      return `${timestamp}::[stagehand:${logLine.category}] ${logLine.message}\n ${errorValue}${traceSuffix}`;
     }
     return `${timestamp}::[stagehand:${logLine.category}] ${logLine.message} ${
       logLine.auxiliary ? JSON.stringify(logLine.auxiliary) : ""
@@ -119,3 +122,87 @@ export function logLineToString(logLine: LogLine): string {
     return "error logging line";
   }
 }
+
+export function dedent(
+  strings: TemplateStringsArray,
+  ...values: unknown[]
+): string {
+  // Interleave raw strings with substitution values
+  const raw = strings.raw;
+  let result = "";
+
+  for (let i = 0; i < raw.length; i++) {
+    result += raw[i]
+      // replace newline + any mix of spaces/tabs with “\n”
+      .replace(/\n[ \t]+/g, "\n")
+      .replace(/^\n/, ""); // remove leading newline
+    if (i < values.length) result += values[i];
+  }
+
+  // trim trailing/leading blank lines
+  return result.trimEnd();
+}
+
+// Dataset helpers shared by suites
+
+export function sampleUniform<T>(arr: T[], k: number): T[] {
+  const n = arr.length;
+  if (k >= n) return arr.slice();
+  const copy = arr.slice();
+  for (let i = n - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    const tmp = copy[i];
+    copy[i] = copy[j];
+    copy[j] = tmp;
+  }
+  return copy.slice(0, k);
+}
+
+export function readJsonlFile(filePath: string): string[] {
+  let lines: string[];
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    lines = content.split(/\r?\n/).filter((l) => l.trim().length > 0);
+  } catch (e) {
+    console.warn(
+      `Could not read file at ${filePath}. Error: ${e instanceof Error ? e.message : String(e)}`,
+    );
+    lines = [];
+  }
+  return lines;
+}
+
+export function parseJsonlRows<T>(
+  lines: string[],
+  validator: (parsed: unknown) => parsed is T,
+): T[] {
+  const candidates: T[] = [];
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      if (validator(parsed)) {
+        candidates.push(parsed);
+      }
+    } catch {
+      // skip invalid lines
+    }
+  }
+  return candidates;
+}
+
+export function applySampling<T>(
+  candidates: T[],
+  sampleCount?: number,
+  maxCases: number = 25,
+): T[] {
+  if (sampleCount && sampleCount > 0) {
+    return sampleUniform(candidates, sampleCount);
+  } else {
+    const result: T[] = [];
+    for (const candidate of candidates) {
+      result.push(candidate);
+      if (result.length >= maxCases) break;
+    }
+    return result;
+  }
+}
diff --git a/packages/evals/utils/ScreenshotCollector.ts b/packages/evals/utils/ScreenshotCollector.ts
new file mode 100644
index 000000000..149e0f401
--- /dev/null
+++ b/packages/evals/utils/ScreenshotCollector.ts
@@ -0,0 +1,262 @@
+import { V3 } from "@browserbasehq/stagehand";
+import sharp from "sharp";
+import { ScreenshotCollectorOptions } from "../types/screenshotCollector.js";
+
+export class ScreenshotCollector {
+  private screenshots: Buffer[] = [];
+  private v3: V3;
+  private interval?: number;
+  private maxScreenshots: number;
+  private intervalId?: NodeJS.Timeout;
+  private isCapturing: boolean = false;
+  private lastScreenshot?: Buffer;
+  private ssimThreshold: number = 0.75;
+  private mseThreshold: number = 30;
+  private stopped: boolean = false;
+
+  constructor(v3: V3, options: ScreenshotCollectorOptions = {}) {
+    this.v3 = v3;
+    this.interval = options.interval; // undefined means event-driven mode
+    this.maxScreenshots = options.maxScreenshots || 10;
+  }
+
+  /**
+   * Start interval-based screenshot capture.
+   * Only activates if interval option was provided in constructor.
+   * For event-driven collection, use addScreenshot() directly via the V3 event bus.
+   */
+  start(): void {
+    // Only start interval if interval was provided
+    if (!this.interval) {
+      return;
+    }
+
+    if (this.intervalId) {
+      return;
+    }
+
+    // Set up time-based screenshot capture
+    this.intervalId = setInterval(() => {
+      this.captureScreenshot("interval").catch((error) => {
+        console.error("Interval screenshot failed:", error);
+      });
+    }, this.interval);
+
+    // Capture initial screenshot without blocking
+    this.captureScreenshot("initial").catch((error) => {
+      console.error("Failed to capture initial screenshot:", error);
+    });
+  }
+
+  async stop(): Promise<Buffer[]> {
+    // Mark as stopped first to prevent any new operations
+    this.stopped = true;
+
+    // Clear interval if running
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = undefined;
+    }
+
+    // Reset capturing flag to unblock any pending state
+    this.isCapturing = false;
+
+    // Try to capture final screenshot, but don't fail if CDP is disconnected
+    try {
+      await this.captureScreenshot("final");
+    } catch {
+      // Ignore errors - CDP may be disconnected
+    }
+
+    // Return a copy and clear internal state to free memory
+    const result = [...this.screenshots];
+    this.screenshots = [];
+    this.lastScreenshot = undefined;
+
+    return result;
+  }
+
+  private async captureScreenshot(trigger: string): Promise<void> {
+    // Don't capture if stopped (unless it's the final capture) or already capturing
+    if ((this.stopped && trigger !== "final") || this.isCapturing) {
+      return;
+    }
+    this.isCapturing = true;
+
+    try {
+      const page = await this.v3.context.awaitActivePage();
+      const screenshot = await page.screenshot({ fullPage: false });
+
+      // If stopped while awaiting screenshot (and not final), don't process further
+      if (this.stopped && trigger !== "final") {
+        return;
+      }
+
+      // Check if we should keep this screenshot based on image diff
+      let shouldKeep = true;
+      if (this.lastScreenshot && trigger !== "initial" && trigger !== "final") {
+        try {
+          // First do a quick MSE check
+          const mse = await this.calculateMSE(this.lastScreenshot, screenshot);
+          if (mse < this.mseThreshold) {
+            // Very similar, skip
+            shouldKeep = false;
+          } else {
+            // Significant difference detected, verify with SSIM
+            const ssim = await this.calculateSSIM(
+              this.lastScreenshot,
+              screenshot,
+            );
+            shouldKeep = ssim < this.ssimThreshold;
+          }
+        } catch (error) {
+          // If comparison fails, keep the screenshot
+          console.error("Image comparison failed:", error);
+          shouldKeep = true;
+        }
+      }
+
+      if (shouldKeep) {
+        this.screenshots.push(screenshot);
+        this.lastScreenshot = screenshot;
+
+        if (this.screenshots.length > this.maxScreenshots) {
+          this.screenshots.shift();
+        }
+      }
+    } catch (error) {
+      console.error(`Failed to capture screenshot (${trigger}):`, error);
+    } finally {
+      this.isCapturing = false;
+    }
+  }
+
+  getScreenshots(): Buffer[] {
+    return [...this.screenshots];
+  }
+
+  getScreenshotCount(): number {
+    return this.screenshots.length;
+  }
+
+  clear(): void {
+    this.screenshots = [];
+  }
+
+  /**
+   * Manually add a screenshot to the collection.
+   * Use this with the V3 event bus for event-driven screenshot collection.
+   * @param screenshot The screenshot buffer to add
+   */
+  async addScreenshot(screenshot: Buffer): Promise<void> {
+    // Don't add if stopped or already capturing
+    if (this.stopped || this.isCapturing) {
+      return;
+    }
+    this.isCapturing = true;
+
+    try {
+      // Apply MSE/SSIM logic to decide if we should keep this screenshot
+      let shouldKeep = true;
+      if (this.lastScreenshot) {
+        try {
+          // First do a quick MSE check
+          const mse = await this.calculateMSE(this.lastScreenshot, screenshot);
+          if (mse < this.mseThreshold) {
+            // Very similar, skip
+            shouldKeep = false;
+          } else {
+            // Significant difference detected, verify with SSIM
+            const ssim = await this.calculateSSIM(
+              this.lastScreenshot,
+              screenshot,
+            );
+            shouldKeep = ssim < this.ssimThreshold;
+          }
+        } catch (error) {
+          // If comparison fails, keep the screenshot
+          console.error("Image comparison failed:", error);
+          shouldKeep = true;
+        }
+      }
+
+      if (shouldKeep) {
+        this.screenshots.push(screenshot);
+        this.lastScreenshot = screenshot;
+
+        if (this.screenshots.length > this.maxScreenshots) {
+          this.screenshots.shift();
+        }
+      }
+    } finally {
+      this.isCapturing = false;
+    }
+  }
+
+  private async calculateMSE(img1: Buffer, img2: Buffer): Promise<number> {
+    try {
+      // Resize images for faster comparison
+      const size = { width: 400, height: 300 };
+      const data1 = await sharp(img1).resize(size).raw().toBuffer();
+      const data2 = await sharp(img2).resize(size).raw().toBuffer();
+
+      if (data1.length !== data2.length) return Number.MAX_SAFE_INTEGER;
+
+      let sum = 0;
+      for (let i = 0; i < data1.length; i++) {
+        const diff = data1[i] - data2[i];
+        sum += diff * diff;
+      }
+
+      return sum / data1.length;
+    } catch {
+      // If sharp is not available, assume images are different
+      return Number.MAX_SAFE_INTEGER;
+    }
+  }
+
+  private async calculateSSIM(img1: Buffer, img2: Buffer): Promise<number> {
+    try {
+      // Resize and convert to grayscale for SSIM calculation
+      const size = { width: 400, height: 300 };
+      const gray1 = await sharp(img1).resize(size).grayscale().raw().toBuffer();
+      const gray2 = await sharp(img2).resize(size).grayscale().raw().toBuffer();
+
+      if (gray1.length !== gray2.length) return 0;
+
+      // Simplified SSIM calculation
+      const c1 = 0.01 * 0.01;
+      const c2 = 0.03 * 0.03;
+
+      let sum1 = 0,
+        sum2 = 0,
+        sum1_sq = 0,
+        sum2_sq = 0,
+        sum12 = 0;
+      const N = gray1.length;
+
+      for (let i = 0; i < N; i++) {
+        sum1 += gray1[i];
+        sum2 += gray2[i];
+        sum1_sq += gray1[i] * gray1[i];
+        sum2_sq += gray2[i] * gray2[i];
+        sum12 += gray1[i] * gray2[i];
+      }
+
+      const mean1 = sum1 / N;
+      const mean2 = sum2 / N;
+      const var1 = sum1_sq / N - mean1 * mean1;
+      const var2 = sum2_sq / N - mean2 * mean2;
+      const cov12 = sum12 / N - mean1 * mean2;
+
+      const numerator = (2 * mean1 * mean2 + c1) * (2 * cov12 + c2);
+      const denominator =
+        (mean1 * mean1 + mean2 * mean2 + c1) * (var1 + var2 + c2);
+
+      return numerator / denominator;
+    } catch {
+      // If sharp is not available, assume images are different
+      return 0;
+    }
+  }
+}
diff --git a/packages/evals/utils/imageResize.ts b/packages/evals/utils/imageResize.ts
new file mode 100644
index 000000000..51522c87d
--- /dev/null
+++ b/packages/evals/utils/imageResize.ts
@@ -0,0 +1,23 @@
+import sharp from "sharp";
+
+export async function imageResize(
+  img: Buffer,
+  scaleFactor: number,
+): Promise<Buffer> {
+  const metadata = await sharp(img).metadata();
+
+  if (metadata.width && metadata.height) {
+    const width = Math.round(metadata.width * scaleFactor);
+    const height = Math.round(metadata.height * scaleFactor);
+    return await sharp(img)
+      .resize(width, height, { fit: "inside", kernel: sharp.kernel.lanczos3 })
+      .png({
+        compressionLevel: 9,
+        adaptiveFiltering: true,
+        palette: true,
+      })
+      .toBuffer();
+  }
+
+  return img;
+}
diff --git a/packages/server-v3/CHANGELOG.md b/packages/server-v3/CHANGELOG.md
new file mode 100644
index 000000000..eb431c129
--- /dev/null
+++ b/packages/server-v3/CHANGELOG.md
@@ -0,0 +1,51 @@
+# @browserbasehq/stagehand-server-v3
+
+## 3.6.0
+
+### Minor Changes
+
+- [#1611](https://github.com/browserbase/stagehand/pull/1611) [`8a3c066`](https://github.com/browserbase/stagehand/commit/8a3c06600a9ba98485db7e9ed5c3cc43ea180334) Thanks [@monadoid](https://github.com/monadoid)! - Using `mode` enum instead of old `cua` boolean in openapi spec
+
+### Patch Changes
+
+- [#1604](https://github.com/browserbase/stagehand/pull/1604) [`4753078`](https://github.com/browserbase/stagehand/commit/4753078cc9d37cbdb8d1a63dfdb53ccc4b4c2bd2) Thanks [@miguelg719](https://github.com/miguelg719)! - Enable bedrock
+
+- [#1636](https://github.com/browserbase/stagehand/pull/1636) [`ea33052`](https://github.com/browserbase/stagehand/commit/ea330520a325583b71b87d85beb740df4bdb9b2d) Thanks [@miguelg719](https://github.com/miguelg719)! - Include executionModel on the AgentConfigSchema
+
+- [#1602](https://github.com/browserbase/stagehand/pull/1602) [`22a0502`](https://github.com/browserbase/stagehand/commit/22a0502e8b042bef0cfafa32901984a8be9529d8) Thanks [@miguelg719](https://github.com/miguelg719)! - Include vertex as a supported provider
+
+- Updated dependencies [[`7584f3e`](https://github.com/browserbase/stagehand/commit/7584f3e92e60a557d2b3e0e0d2a2af04c3527523), [`1e1c9c1`](https://github.com/browserbase/stagehand/commit/1e1c9c15773e49d5c3cd36021dbc1d23495c1bce), [`6bef890`](https://github.com/browserbase/stagehand/commit/6bef89090ebd231e77d8092b2c32a0f06303d5a9), [`ffd4b33`](https://github.com/browserbase/stagehand/commit/ffd4b335a873d0f4dcd76ea22d44f47919bf8e49), [`677bff5`](https://github.com/browserbase/stagehand/commit/677bff5834c879a2d95f7dbff918b8e1510516b3), [`65ff464`](https://github.com/browserbase/stagehand/commit/65ff464bc13388eb109eba0a2cf533c1cc202854), [`101bcf2`](https://github.com/browserbase/stagehand/commit/101bcf2da8b527fd6ace6aa291ada5d0f2d90344), [`0a94301`](https://github.com/browserbase/stagehand/commit/0a94301caa991d1aa4cdade6e28a065b1aefb3e2), [`b27c04d`](https://github.com/browserbase/stagehand/commit/b27c04d278c290364347acd0c354a878ea9b7c2d), [`afbd08b`](https://github.com/browserbase/stagehand/commit/afbd08bb6367a9c9f65f67e453667987e4659918), [`e3db9aa`](https://github.com/browserbase/stagehand/commit/e3db9aa863f44270792215801fe6e3a02a1321aa), [`0e8d569`](https://github.com/browserbase/stagehand/commit/0e8d5695f662040f7384e64f46301152802e3c62), [`ff0f979`](https://github.com/browserbase/stagehand/commit/ff0f9795f3b2c1cf4f2610a80ebcb3341a24f987), [`2d89d2b`](https://github.com/browserbase/stagehand/commit/2d89d2b35ce812431956b28e0c8b52d32ddc7a27), [`aac9a19`](https://github.com/browserbase/stagehand/commit/aac9a19bdfbe62e4508631337ab0bfbcf8ae62b2), [`06de50f`](https://github.com/browserbase/stagehand/commit/06de50ff377fd31f1b0fcf79adb996d04562d2c0), [`aa4d981`](https://github.com/browserbase/stagehand/commit/aa4d981e440bdd0e3d3f42ccc310d5958aa25cc6), [`18b1e3b`](https://github.com/browserbase/stagehand/commit/18b1e3bd2b16b721845d52fcf1a45c6158e2403f), [`957d82b`](https://github.com/browserbase/stagehand/commit/957d82b9845b4413b123539e81a2e4a490e74a8a), [`b65756e`](https://github.com/browserbase/stagehand/commit/b65756e9e85643055446aa4a51956f7d6627c89f), [`22e371a`](https://github.com/browserbase/stagehand/commit/22e371ae4c25deb6350328fe02832bf2b2197b94), [`d29b91f`](https://github.com/browserbase/stagehand/commit/d29b91fa506636ca36f724fcf106320de54ec3f3), [`7b4f817`](https://github.com/browserbase/stagehand/commit/7b4f817cafb9829ac81c4b5890c318c7f9521fe4), [`176d420`](https://github.com/browserbase/stagehand/commit/176d42002cc0a2c7d13b4c0ffbbd56b70fdc49e8), [`3f9ca4d`](https://github.com/browserbase/stagehand/commit/3f9ca4d9acc109101357378d29cf969168991608), [`8a3c066`](https://github.com/browserbase/stagehand/commit/8a3c06600a9ba98485db7e9ed5c3cc43ea180334), [`49ead1e`](https://github.com/browserbase/stagehand/commit/49ead1e1e8678a8da0f87ad2042491dacc6b01d7), [`3673369`](https://github.com/browserbase/stagehand/commit/36733691f90c15386cf2a7b47d04ef429b7195ae), [`c465e87`](https://github.com/browserbase/stagehand/commit/c465e87ab41942435132c76338518fb3fa8e7896), [`ae533e4`](https://github.com/browserbase/stagehand/commit/ae533e40195181b53833f8055b1259fb360a927b), [`ea33052`](https://github.com/browserbase/stagehand/commit/ea330520a325583b71b87d85beb740df4bdb9b2d), [`5764ede`](https://github.com/browserbase/stagehand/commit/5764edee7aab00ef1aafafb68fc56eb26c0a70b2), [`f09b184`](https://github.com/browserbase/stagehand/commit/f09b184cc5e774736280ae8c94ba3f4f13adda80), [`a7d29de`](https://github.com/browserbase/stagehand/commit/a7d29decee0f7d12e2437267b9eef1795d3b4e3a), [`d334399`](https://github.com/browserbase/stagehand/commit/d3343990041bf9cd5613569840afb0c17131e33c), [`44416da`](https://github.com/browserbase/stagehand/commit/44416da7ff33301bb32d3811e6c3be8782a7d168), [`bdd8b4e`](https://github.com/browserbase/stagehand/commit/bdd8b4ee3c697a02728375510ab7fae764990576)]:
+  - @browserbasehq/stagehand@3.1.0
+
+## 3.5.0
+
+### Minor Changes
+
+- [#1578](https://github.com/browserbase/stagehand/pull/1578) [`a5074bd`](https://github.com/browserbase/stagehand/commit/a5074bdda0811140ba7847065c26ac72175cef98) Thanks [@monadoid](https://github.com/monadoid)! - /end endpoint no longer takes an empty object - instead, no request body is required.
+
+### Patch Changes
+
+- Updated dependencies [[`40ce5cc`](https://github.com/browserbase/stagehand/commit/40ce5cc83ec758f4e8c37132a7f4ac8eeea7ca34), [`5506f41`](https://github.com/browserbase/stagehand/commit/5506f416d2609d112b553263984e21d7a30e32b1), [`84c05ca`](https://github.com/browserbase/stagehand/commit/84c05ca8de4587181faf128e5c7464fd960caacc), [`692ffa0`](https://github.com/browserbase/stagehand/commit/692ffa0346ad3d121686aba503c0a22844293efa), [`1ef8901`](https://github.com/browserbase/stagehand/commit/1ef8901e1314e90f43b36be20192e652d3b5598f), [`72ac775`](https://github.com/browserbase/stagehand/commit/72ac775a831d6f0f376ceda4426525f93cc21452), [`3d5af07`](https://github.com/browserbase/stagehand/commit/3d5af07f66d6d26d1f5ac4bd9be7183c3381dd92), [`40e1d80`](https://github.com/browserbase/stagehand/commit/40e1d80776b9216422a25a81070ccb3105e56ec2), [`56c0d24`](https://github.com/browserbase/stagehand/commit/56c0d244f9b2431218bfa832ddfc0587930ae038), [`16d72fb`](https://github.com/browserbase/stagehand/commit/16d72fb4c4081dd33bf45605d75c27644ea4c00e), [`088c4cc`](https://github.com/browserbase/stagehand/commit/088c4cc31dc924bb232a9d5a09ab42cd961c2d36), [`4276f4a`](https://github.com/browserbase/stagehand/commit/4276f4abc8bbde215faac6c0321bf243484c376b), [`6005786`](https://github.com/browserbase/stagehand/commit/600578637e65f6fd18b0cdb322b9e0b857708b2f), [`6fbf5fc`](https://github.com/browserbase/stagehand/commit/6fbf5fc811e5e5d9d22f10c5309fbd336892263a), [`704cf18`](https://github.com/browserbase/stagehand/commit/704cf18cb2bdd187ba06c35f05ccb47317a7668c), [`091296e`](https://github.com/browserbase/stagehand/commit/091296e438bb2374c8bb10ef6c08283978145ebf), [`e56c6eb`](https://github.com/browserbase/stagehand/commit/e56c6eb139bf3aad37e98b16626fff13a6c671d0), [`2cb78d0`](https://github.com/browserbase/stagehand/commit/2cb78d0f5ddef9f7337a9a2fe3137f1421df700a), [`5dad639`](https://github.com/browserbase/stagehand/commit/5dad63938f08d968d434bb1ee2804f1e54fb836a), [`b7c2571`](https://github.com/browserbase/stagehand/commit/b7c2571ad4ac563f3ca0518e1f29a40da93e33bc), [`4c69117`](https://github.com/browserbase/stagehand/commit/4c6911748953199dc9aad3eabe98bcf325f871e4)]:
+  - @browserbasehq/stagehand@3.0.8
+
+## 3.2.0
+
+### Minor Changes
+
+- [#1459](https://github.com/browserbase/stagehand/pull/1459) [`abb3469`](https://github.com/browserbase/stagehand/commit/abb3469f51627b318a856fafe6047ff24e681666) Thanks [@monadoid](https://github.com/monadoid)! - Added building of binaries
+
+- [#1457](https://github.com/browserbase/stagehand/pull/1457) [`5fc1281`](https://github.com/browserbase/stagehand/commit/5fc12817a6529d4c59f2e32db92c916095a9a81e) Thanks [@monadoid](https://github.com/monadoid)! - First changeset for stagehand-server
+
+- [#1469](https://github.com/browserbase/stagehand/pull/1469) [`d634d45`](https://github.com/browserbase/stagehand/commit/d634d45a0dbc3a4c876413d94cf4aedace1f56d7) Thanks [@monadoid](https://github.com/monadoid)! - Bump to test binary builds
+
+### Patch Changes
+
+- Updated dependencies [[`0f3991e`](https://github.com/browserbase/stagehand/commit/0f3991eedc0aaff72ef718dda3ddb0839cf4a464), [`e0e22e0`](https://github.com/browserbase/stagehand/commit/e0e22e06bc752a8ffde30f3dbfa58d91e24e6c09), [`f261051`](https://github.com/browserbase/stagehand/commit/f2610517d74774374de9ee93191e663439ef55e5), [`e021674`](https://github.com/browserbase/stagehand/commit/e021674f9641c1c5f9d0c1817c3fdf599eea124d), [`6a5496f`](https://github.com/browserbase/stagehand/commit/6a5496f17dbb716be1ee1aaa4e5ba9d8c723b30b), [`fea1700`](https://github.com/browserbase/stagehand/commit/fea1700552af3319052f463685752501c8e71de3), [`5b288d9`](https://github.com/browserbase/stagehand/commit/5b288d9ac37406ff22460ac8050bea26b87a378e), [`e822f5a`](https://github.com/browserbase/stagehand/commit/e822f5a8898df9eb48ca32c321025f0c74b638f0), [`638efc7`](https://github.com/browserbase/stagehand/commit/638efc7fea401bc43dd05dceedf4c13a3495a728), [`a890f16`](https://github.com/browserbase/stagehand/commit/a890f16fa3a752f308f858e5ab9c9a0faf6b3b34), [`934f492`](https://github.com/browserbase/stagehand/commit/934f492ec587bef81f0ce75b45a35b44ab545712), [`bd2db92`](https://github.com/browserbase/stagehand/commit/bd2db925f66a826d61d58be1611d55646cbdb560), [`51e0170`](https://github.com/browserbase/stagehand/commit/51e01709ce1c947c1947b4e2cb0b1f4f97b77182), [`05f5580`](https://github.com/browserbase/stagehand/commit/05f5580937c3c157550e3c25ae6671f44f562211), [`f56a9c2`](https://github.com/browserbase/stagehand/commit/f56a9c296d4ddce25a405358c66837f8ce4d679f), [`b40ae11`](https://github.com/browserbase/stagehand/commit/b40ae11391af49c3581fce27faa1b7483fc4a169), [`0d2b398`](https://github.com/browserbase/stagehand/commit/0d2b398cd40b32a9ecaf28ede70853036b7c91bd), [`cd01f29`](https://github.com/browserbase/stagehand/commit/cd01f290578eac703521f801ba3712f5332918f3), [`a734fca`](https://github.com/browserbase/stagehand/commit/a734fca0b4573753767d3ebc48ec414baf4f23e1), [`b342acf`](https://github.com/browserbase/stagehand/commit/b342acfaae058127fb57664644c5fd965db02bf2), [`2987cd1`](https://github.com/browserbase/stagehand/commit/2987cd1e5ffabefa9411936609635d4a638faed5), [`dfab1d5`](https://github.com/browserbase/stagehand/commit/dfab1d566299c8c5a63f20565a6da07dc8f61ccd), [`4d71162`](https://github.com/browserbase/stagehand/commit/4d71162beb119635b69b17637564a2bbd0e373e7)]:
+  - @browserbasehq/stagehand@3.0.7
+
+## 3.0.6
+
+### Patch Changes
+
+- Updated dependencies [[`605ed6b`](https://github.com/browserbase/stagehand/commit/605ed6b81a3ff8f25d4022f1e5fce6b42aecfc19), [`34e7e5b`](https://github.com/browserbase/stagehand/commit/34e7e5b292f5e6af6efc0da60118663310c5f718), [`943d2d7`](https://github.com/browserbase/stagehand/commit/943d2d79d0f289ac41c9164578f2f1dd876058f2), [`0e95cd2`](https://github.com/browserbase/stagehand/commit/0e95cd2f67672f64f0017024fd47d8b3aef59a95), [`d4237e4`](https://github.com/browserbase/stagehand/commit/d4237e40951ecd10abfdbe766672d498f8806484), [`86975e7`](https://github.com/browserbase/stagehand/commit/86975e795db7505804949a267b20509bd16b5256), [`d5e119b`](https://github.com/browserbase/stagehand/commit/d5e119be5eec84915a79f8d611b6ba0546f48c99), [`4e051b2`](https://github.com/browserbase/stagehand/commit/4e051b23add7ae276b0dbead38b4587838cfc1c1), [`6b5a3c9`](https://github.com/browserbase/stagehand/commit/6b5a3c9035654caaed2da375085b465edda97de4), [`bb85ad9`](https://github.com/browserbase/stagehand/commit/bb85ad912738623a7a866f0cb6e8d5807c6c2738), [`88d28cc`](https://github.com/browserbase/stagehand/commit/88d28cc6f31058d1cf6ec6dc948a4ae77a926b3c), [`45bcef0`](https://github.com/browserbase/stagehand/commit/45bcef0e5788b083f9e38dfd7c3bc63afcd4b6dd), [`6aa9d45`](https://github.com/browserbase/stagehand/commit/6aa9d455aa5836ec2ee8ab2e8b9df3fb218e5381), [`d382084`](https://github.com/browserbase/stagehand/commit/d382084745fff98c3e71413371466394a2625429), [`1df08cc`](https://github.com/browserbase/stagehand/commit/1df08ccb0a2cf73b5c37a91c129721114ff6371c), [`2b56600`](https://github.com/browserbase/stagehand/commit/2b566009606fcbba987260f21b075b318690ce99)]:
+  - @browserbasehq/stagehand@3.0.6
diff --git a/packages/server-v3/README.md b/packages/server-v3/README.md
new file mode 100644
index 000000000..699fafdc5
--- /dev/null
+++ b/packages/server-v3/README.md
@@ -0,0 +1,36 @@
+# Stagehand API
+
+The Stagehand  is a powerful service that provides a RESTful interface for browser automation and session management using the Browserbase platform. It enables recording, playback, and manipulation of browser sessions with a focus on reliability and performance.
+
+## 📋 Prerequisites
+
+To run the Stagehand API locally, ensure you have the following installed:
+
+- Node.js
+- pnpm
+
+## 🛠 Installation
+
+1. Clone the repository:
+
+```bash
+git clone https://github.com/browserbase/stagehand/
+cd stagehand/packages/server-v3
+```
+
+2. Install dependencies:
+
+```bash
+pnpm install
+```
+
+3. Set up environment variables:
+
+```bash
+cp .env.example .env
+```
+
+4. Configure your `.env` file with the environment variables required by `src/lib/env.ts` (BB environment, API base URLs, etc.).
+
+5. `pnpm dev`
+
diff --git a/packages/server-v3/SDK_RELEASE_WORKFLOW.md b/packages/server-v3/SDK_RELEASE_WORKFLOW.md
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/server-v3/openapi.v3.yaml b/packages/server-v3/openapi.v3.yaml
new file mode 100644
index 000000000..98f26f365
--- /dev/null
+++ b/packages/server-v3/openapi.v3.yaml
@@ -0,0 +1,2157 @@
+openapi: "3.1.0"
+info:
+  title: Stagehand API
+  version: "3.1.0"
+  description: >-
+    Stagehand SDK for AI browser automation [ALPHA]. This API allows clients to
+
+    execute browser automation tasks remotely on the Browserbase cloud.
+
+    All endpoints except /sessions/start require an active session ID.
+
+    Responses are streamed using Server-Sent Events (SSE) when the
+
+    `x-stream-response: true` header is provided.
+
+
+    This SDK is currently ALPHA software and is not production ready!
+
+    Please try it and give us your feedback, stay tuned for upcoming release
+    announcements!
+  contact:
+    name: Browserbase
+    url: https://browserbase.com
+components:
+  securitySchemes:
+    BrowserbaseApiKey:
+      type: apiKey
+      in: header
+      name: x-bb-api-key
+      description: Browserbase API key for authentication
+    BrowserbaseProjectId:
+      type: apiKey
+      in: header
+      name: x-bb-project-id
+      description: Browserbase project ID
+    ModelApiKey:
+      type: apiKey
+      in: header
+      name: x-model-api-key
+      description: API key for the AI model provider (OpenAI, Anthropic, etc.)
+  links:
+    SessionAct:
+      operationId: SessionAct
+      parameters:
+        id: $response.body#/data/sessionId
+      description: Perform an action on the session
+    SessionExtract:
+      operationId: SessionExtract
+      parameters:
+        id: $response.body#/data/sessionId
+      description: Extract data from the session
+    SessionObserve:
+      operationId: SessionObserve
+      parameters:
+        id: $response.body#/data/sessionId
+      description: Observe available actions on the session
+    SessionNavigate:
+      operationId: SessionNavigate
+      parameters:
+        id: $response.body#/data/sessionId
+      description: Navigate to a URL in the session
+    SessionAgentExecute:
+      operationId: SessionAgentExecute
+      parameters:
+        id: $response.body#/data/sessionId
+      description: Execute an agent on the session
+    SessionReplay:
+      operationId: SessionReplay
+      parameters:
+        id: $response.body#/data/sessionId
+      description: Replay session metrics
+    SessionEnd:
+      operationId: SessionEnd
+      parameters:
+        id: $response.body#/data/sessionId
+      description: End the session and release resources
+  schemas:
+    AgentCacheEntry:
+      type: object
+      properties:
+        cacheKey:
+          description: Opaque cache identifier computed from instruction, URL, options,
+            and config
+          type: string
+        entry:
+          description: Serialized cache entry that can be written to disk
+      required:
+        - cacheKey
+        - entry
+    BrowserbaseRegion:
+      type: string
+      enum:
+        - us-west-2
+        - us-east-1
+        - eu-central-1
+        - ap-southeast-1
+    LocalBrowserLaunchOptions:
+      type: object
+      properties:
+        args:
+          type: array
+          items:
+            type: string
+        executablePath:
+          type: string
+        port:
+          type: number
+        userDataDir:
+          type: string
+        preserveUserDataDir:
+          type: boolean
+        headless:
+          type: boolean
+        devtools:
+          type: boolean
+        chromiumSandbox:
+          type: boolean
+        ignoreDefaultArgs:
+          anyOf:
+            - type: boolean
+            - type: array
+              items:
+                type: string
+        proxy:
+          type: object
+          properties:
+            server:
+              type: string
+            bypass:
+              type: string
+            username:
+              type: string
+            password:
+              type: string
+          required:
+            - server
+        locale:
+          type: string
+        viewport:
+          type: object
+          properties:
+            width:
+              type: number
+            height:
+              type: number
+          required:
+            - width
+            - height
+        deviceScaleFactor:
+          type: number
+        hasTouch:
+          type: boolean
+        ignoreHTTPSErrors:
+          type: boolean
+        cdpUrl:
+          type: string
+        cdpHeaders:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties:
+            type: string
+        connectTimeoutMs:
+          type: number
+        downloadsPath:
+          type: string
+        acceptDownloads:
+          type: boolean
+      additionalProperties: false
+    ModelConfigObject:
+      type: object
+      properties:
+        provider:
+          description: AI provider for the model (or provide a baseURL endpoint instead)
+          example: openai
+          type: string
+          enum:
+            - openai
+            - anthropic
+            - google
+            - microsoft
+            - bedrock
+        modelName:
+          description: Model name string with provider prefix (e.g., 'openai/gpt-5-nano')
+          example: openai/gpt-5-nano
+          type: string
+        apiKey:
+          description: API key for the model provider
+          example: sk-some-openai-api-key
+          type: string
+        baseURL:
+          description: Base URL for the model provider
+          example: https://api.openai.com/v1
+          type: string
+          format: uri
+      required:
+        - modelName
+    ModelConfig:
+      $ref: "#/components/schemas/ModelConfigObject"
+    Action:
+      description: Action object returned by observe and used by act
+      type: object
+      properties:
+        selector:
+          description: CSS selector or XPath for the element
+          example: "[data-testid='submit-button']"
+          type: string
+        description:
+          description: Human-readable description of the action
+          example: Click the submit button
+          type: string
+        backendNodeId:
+          description: Backend node ID for the element
+          type: number
+        method:
+          description: The method to execute (click, fill, etc.)
+          example: click
+          type: string
+        arguments:
+          description: Arguments to pass to the method
+          example:
+            - Hello World
+          type: array
+          items:
+            type: string
+      required:
+        - selector
+        - description
+    BrowserConfig:
+      type: object
+      properties:
+        type:
+          description: Browser type to use
+          example: local
+          type: string
+          enum:
+            - local
+            - browserbase
+        cdpUrl:
+          description: Chrome DevTools Protocol URL for connecting to existing browser
+          example: ws://localhost:9222
+          type: string
+        launchOptions:
+          $ref: "#/components/schemas/LocalBrowserLaunchOptions"
+    BrowserbaseViewport:
+      type: object
+      properties:
+        width:
+          type: number
+        height:
+          type: number
+    BrowserbaseFingerprintScreen:
+      type: object
+      properties:
+        maxHeight:
+          type: number
+        maxWidth:
+          type: number
+        minHeight:
+          type: number
+        minWidth:
+          type: number
+    BrowserbaseFingerprint:
+      type: object
+      properties:
+        browsers:
+          type: array
+          items:
+            type: string
+            enum:
+              - chrome
+              - edge
+              - firefox
+              - safari
+        devices:
+          type: array
+          items:
+            type: string
+            enum:
+              - desktop
+              - mobile
+        httpVersion:
+          type: string
+          enum:
+            - "1"
+            - "2"
+        locales:
+          type: array
+          items:
+            type: string
+        operatingSystems:
+          type: array
+          items:
+            type: string
+            enum:
+              - android
+              - ios
+              - linux
+              - macos
+              - windows
+        screen:
+          $ref: "#/components/schemas/BrowserbaseFingerprintScreen"
+    BrowserbaseContext:
+      type: object
+      properties:
+        id:
+          type: string
+        persist:
+          type: boolean
+      required:
+        - id
+    BrowserbaseBrowserSettings:
+      type: object
+      properties:
+        advancedStealth:
+          type: boolean
+        blockAds:
+          type: boolean
+        context:
+          $ref: "#/components/schemas/BrowserbaseContext"
+        extensionId:
+          type: string
+        fingerprint:
+          $ref: "#/components/schemas/BrowserbaseFingerprint"
+        logSession:
+          type: boolean
+        recordSession:
+          type: boolean
+        solveCaptchas:
+          type: boolean
+        viewport:
+          $ref: "#/components/schemas/BrowserbaseViewport"
+    BrowserbaseProxyGeolocation:
+      type: object
+      properties:
+        country:
+          type: string
+        city:
+          type: string
+        state:
+          type: string
+      required:
+        - country
+    BrowserbaseProxyConfig:
+      type: object
+      properties:
+        type:
+          type: string
+          const: browserbase
+        domainPattern:
+          type: string
+        geolocation:
+          $ref: "#/components/schemas/BrowserbaseProxyGeolocation"
+      required:
+        - type
+    ExternalProxyConfig:
+      type: object
+      properties:
+        type:
+          type: string
+          const: external
+        server:
+          type: string
+        domainPattern:
+          type: string
+        username:
+          type: string
+        password:
+          type: string
+      required:
+        - type
+        - server
+    ProxyConfig:
+      oneOf:
+        - $ref: "#/components/schemas/BrowserbaseProxyConfig"
+        - $ref: "#/components/schemas/ExternalProxyConfig"
+      type: object
+      discriminator:
+        propertyName: type
+        mapping:
+          browserbase: "#/components/schemas/BrowserbaseProxyConfig"
+          external: "#/components/schemas/ExternalProxyConfig"
+    BrowserbaseSessionCreateParams:
+      type: object
+      properties:
+        projectId:
+          type: string
+        browserSettings:
+          $ref: "#/components/schemas/BrowserbaseBrowserSettings"
+        extensionId:
+          type: string
+        keepAlive:
+          type: boolean
+        proxies:
+          anyOf:
+            - type: boolean
+            - type: array
+              items:
+                $ref: "#/components/schemas/ProxyConfig"
+        region:
+          $ref: "#/components/schemas/BrowserbaseRegion"
+        timeout:
+          type: number
+        userMetadata:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+    SessionStartRequest:
+      type: object
+      properties:
+        modelName:
+          description: Model name to use for AI operations
+          example: openai/gpt-4o
+          type: string
+        domSettleTimeoutMs:
+          description: Timeout in ms to wait for DOM to settle
+          example: 5000
+          type: number
+        verbose:
+          description: Logging verbosity level (0=quiet, 1=normal, 2=debug)
+          example: 1
+          type: number
+          enum:
+            - 0
+            - 1
+            - 2
+        systemPrompt:
+          description: Custom system prompt for AI operations
+          type: string
+        browserbaseSessionCreateParams:
+          $ref: "#/components/schemas/BrowserbaseSessionCreateParams"
+        browser:
+          $ref: "#/components/schemas/BrowserConfig"
+        selfHeal:
+          description: Enable self-healing for failed actions
+          example: true
+          type: boolean
+        browserbaseSessionID:
+          description: Existing Browserbase session ID to resume
+          type: string
+        experimental:
+          type: boolean
+        waitForCaptchaSolves:
+          description: Wait for captcha solves (deprecated, v2 only)
+          type: boolean
+        actTimeoutMs:
+          description: Timeout in ms for act operations (deprecated, v2 only)
+          type: number
+      required:
+        - modelName
+    SessionStartResult:
+      type: object
+      properties:
+        sessionId:
+          description: Unique Browserbase session identifier
+          example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+          type: string
+        cdpUrl:
+          description: CDP WebSocket URL for connecting to the Browserbase cloud browser
+            (present when available)
+          example: wss://connect.browserbase.com/?signingKey=abc123
+          anyOf:
+            - type: string
+            - type: "null"
+        available:
+          type: boolean
+      required:
+        - sessionId
+        - available
+    ActOptions:
+      type: object
+      properties:
+        model:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano')
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfig"
+            - type: string
+        variables:
+          description: Variables to substitute in the action instruction
+          example:
+            username: john_doe
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties:
+            type: string
+        timeout:
+          description: Timeout in ms for the action
+          example: 30000
+          type: number
+    ActRequest:
+      type: object
+      properties:
+        input:
+          description: Natural language instruction or Action object
+          example: Click the login button
+          anyOf:
+            - type: string
+            - $ref: "#/components/schemas/Action"
+        options:
+          $ref: "#/components/schemas/ActOptions"
+        frameId:
+          description: Target frame ID for the action
+          anyOf:
+            - type: string
+            - type: "null"
+        streamResponse:
+          description: Whether to stream the response via SSE
+          example: true
+          type: boolean
+      required:
+        - input
+    ActResultData:
+      type: object
+      properties:
+        success:
+          description: Whether the action completed successfully
+          example: true
+          type: boolean
+        message:
+          description: Human-readable result message
+          example: Successfully clicked the login button
+          type: string
+        actionDescription:
+          description: Description of the action that was performed
+          example: Clicked button with text 'Login'
+          type: string
+        actions:
+          description: List of actions that were executed
+          type: array
+          items:
+            $ref: "#/components/schemas/Action"
+      required:
+        - success
+        - message
+        - actionDescription
+        - actions
+    ActResult:
+      type: object
+      properties:
+        result:
+          $ref: "#/components/schemas/ActResultData"
+        actionId:
+          description: Action ID for tracking
+          type: string
+      required:
+        - result
+    ExtractOptions:
+      type: object
+      properties:
+        model:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano')
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfig"
+            - type: string
+        timeout:
+          description: Timeout in ms for the extraction
+          example: 30000
+          type: number
+        selector:
+          description: CSS selector to scope extraction to a specific element
+          example: "#main-content"
+          type: string
+    ExtractRequest:
+      type: object
+      properties:
+        instruction:
+          description: Natural language instruction for what to extract
+          example: Extract all product names and prices from the page
+          type: string
+        schema:
+          description: JSON Schema defining the structure of data to extract
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+        options:
+          $ref: "#/components/schemas/ExtractOptions"
+        frameId:
+          description: Target frame ID for the extraction
+          anyOf:
+            - type: string
+            - type: "null"
+        streamResponse:
+          description: Whether to stream the response via SSE
+          example: true
+          type: boolean
+    ExtractResult:
+      type: object
+      properties:
+        result:
+          description: Extracted data matching the requested schema
+          x-stainless-any: true
+        actionId:
+          description: Action ID for tracking
+          type: string
+      required:
+        - result
+    ObserveOptions:
+      type: object
+      properties:
+        model:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano')
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfig"
+            - type: string
+        timeout:
+          description: Timeout in ms for the observation
+          example: 30000
+          type: number
+        selector:
+          description: CSS selector to scope observation to a specific element
+          example: nav
+          type: string
+    ObserveRequest:
+      type: object
+      properties:
+        instruction:
+          description: Natural language instruction for what actions to find
+          example: Find all clickable navigation links
+          type: string
+        options:
+          $ref: "#/components/schemas/ObserveOptions"
+        frameId:
+          description: Target frame ID for the observation
+          anyOf:
+            - type: string
+            - type: "null"
+        streamResponse:
+          description: Whether to stream the response via SSE
+          example: true
+          type: boolean
+    ObserveResult:
+      type: object
+      properties:
+        result:
+          type: array
+          items:
+            $ref: "#/components/schemas/Action"
+        actionId:
+          description: Action ID for tracking
+          type: string
+      required:
+        - result
+    AgentConfig:
+      type: object
+      properties:
+        provider:
+          description: "AI provider for the agent (legacy, use model: openai/gpt-5-nano
+            instead)"
+          example: openai
+          type: string
+          enum:
+            - openai
+            - anthropic
+            - google
+            - microsoft
+            - bedrock
+        model:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano')
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfig"
+            - type: string
+        systemPrompt:
+          description: Custom system prompt for the agent
+          type: string
+        cua:
+          description: "Deprecated. Use mode: 'cua' instead. If both are provided, mode
+            takes precedence."
+          example: true
+          type: boolean
+        mode:
+          description: Tool mode for the agent (dom, hybrid, cua). If set, overrides cua.
+          example: cua
+          type: string
+          enum:
+            - dom
+            - hybrid
+            - cua
+        executionModel:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano') for tool execution (observe/act calls within
+            agent tools). If not specified, inherits from the main model
+            configuration.
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfig"
+            - type: string
+    AgentAction:
+      type: object
+      properties:
+        type:
+          description: Type of action taken
+          example: click
+          type: string
+        reasoning:
+          description: Agent's reasoning for taking this action
+          type: string
+        taskCompleted:
+          type: boolean
+        action:
+          type: string
+        timeMs:
+          description: Time taken for this action in ms
+          type: number
+        pageText:
+          type: string
+        pageUrl:
+          type: string
+        instruction:
+          type: string
+      required:
+        - type
+      additionalProperties: {}
+    AgentUsage:
+      type: object
+      properties:
+        input_tokens:
+          example: 1500
+          type: number
+        output_tokens:
+          example: 250
+          type: number
+        reasoning_tokens:
+          type: number
+        cached_input_tokens:
+          type: number
+        inference_time_ms:
+          example: 2500
+          type: number
+      required:
+        - input_tokens
+        - output_tokens
+        - inference_time_ms
+    AgentResultData:
+      type: object
+      properties:
+        success:
+          description: Whether the agent completed successfully
+          example: true
+          type: boolean
+        message:
+          description: Summary of what the agent accomplished
+          example: Successfully logged in and navigated to dashboard
+          type: string
+        actions:
+          type: array
+          items:
+            $ref: "#/components/schemas/AgentAction"
+        completed:
+          description: Whether the agent finished its task
+          example: true
+          type: boolean
+        metadata:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+        usage:
+          $ref: "#/components/schemas/AgentUsage"
+      required:
+        - success
+        - message
+        - actions
+        - completed
+    AgentExecuteOptions:
+      type: object
+      properties:
+        instruction:
+          description: Natural language instruction for the agent
+          example: Log in with username 'demo' and password 'test123', then navigate to
+            settings
+          type: string
+        maxSteps:
+          description: Maximum number of steps the agent can take
+          example: 20
+          type: number
+        highlightCursor:
+          description: Whether to visually highlight the cursor during execution
+          example: true
+          type: boolean
+      required:
+        - instruction
+    AgentExecuteRequest:
+      type: object
+      properties:
+        agentConfig:
+          $ref: "#/components/schemas/AgentConfig"
+        executeOptions:
+          $ref: "#/components/schemas/AgentExecuteOptions"
+        frameId:
+          description: Target frame ID for the agent
+          anyOf:
+            - type: string
+            - type: "null"
+        streamResponse:
+          description: Whether to stream the response via SSE
+          example: true
+          type: boolean
+        shouldCache:
+          description: If true, the server captures a cache entry and returns it to the
+            client
+          type: boolean
+      required:
+        - agentConfig
+        - executeOptions
+    AgentExecuteResult:
+      type: object
+      properties:
+        result:
+          $ref: "#/components/schemas/AgentResultData"
+        cacheEntry:
+          $ref: "#/components/schemas/AgentCacheEntry"
+      required:
+        - result
+    NavigateOptions:
+      type: object
+      properties:
+        referer:
+          description: Referer header to send with the request
+          type: string
+        timeout:
+          description: Timeout in ms for the navigation
+          example: 30000
+          type: number
+        waitUntil:
+          description: When to consider navigation complete
+          example: networkidle
+          type: string
+          enum:
+            - load
+            - domcontentloaded
+            - networkidle
+    NavigateRequest:
+      type: object
+      properties:
+        url:
+          description: URL to navigate to
+          example: https://example.com
+          type: string
+        options:
+          $ref: "#/components/schemas/NavigateOptions"
+        frameId:
+          description: Target frame ID for the navigation
+          anyOf:
+            - type: string
+            - type: "null"
+        streamResponse:
+          description: Whether to stream the response via SSE
+          example: true
+          type: boolean
+      required:
+        - url
+    NavigateResult:
+      type: object
+      properties:
+        result:
+          description: Navigation response (Playwright Response object or null)
+          anyOf:
+            - {}
+            - type: "null"
+          x-stainless-any: true
+        actionId:
+          description: Action ID for tracking
+          type: string
+      required:
+        - result
+    TokenUsage:
+      type: object
+      properties:
+        inputTokens:
+          type: number
+        outputTokens:
+          type: number
+        timeMs:
+          type: number
+        cost:
+          type: number
+    ReplayAction:
+      type: object
+      properties:
+        method:
+          type: string
+        parameters:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+        result:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+        timestamp:
+          type: number
+        endTime:
+          type: number
+        tokenUsage:
+          $ref: "#/components/schemas/TokenUsage"
+      required:
+        - method
+        - parameters
+        - result
+        - timestamp
+    ReplayPage:
+      type: object
+      properties:
+        url:
+          type: string
+        timestamp:
+          type: number
+        duration:
+          type: number
+        actions:
+          type: array
+          items:
+            $ref: "#/components/schemas/ReplayAction"
+      required:
+        - url
+        - timestamp
+        - duration
+        - actions
+    ReplayResult:
+      type: object
+      properties:
+        pages:
+          type: array
+          items:
+            $ref: "#/components/schemas/ReplayPage"
+        clientLanguage:
+          type: string
+      required:
+        - pages
+    StreamEventStatus:
+      description: Current status of the streaming operation
+      type: string
+      enum:
+        - starting
+        - connected
+        - running
+        - finished
+        - error
+    StreamEventType:
+      description: Type of stream event - system events or log messages
+      type: string
+      enum:
+        - system
+        - log
+    StreamEventSystemData:
+      type: object
+      properties:
+        status:
+          $ref: "#/components/schemas/StreamEventStatus"
+        result:
+          description: Operation result (present when status is 'finished')
+          x-stainless-any: true
+        error:
+          description: Error message (present when status is 'error')
+          type: string
+      required:
+        - status
+    StreamEventLogData:
+      type: object
+      properties:
+        status:
+          type: string
+          const: running
+        message:
+          description: Log message from the operation
+          type: string
+      required:
+        - status
+        - message
+    SessionStartResponse:
+      type: object
+      properties:
+        success:
+          description: Indicates whether the request was successful
+          type: boolean
+        data:
+          $ref: "#/components/schemas/SessionStartResultOutput"
+      required:
+        - success
+        - data
+      additionalProperties: false
+    SessionEndResponse:
+      type: object
+      properties:
+        success:
+          description: Indicates whether the request was successful
+          type: boolean
+      required:
+        - success
+      additionalProperties: false
+    ActResponse:
+      type: object
+      properties:
+        success:
+          description: Indicates whether the request was successful
+          type: boolean
+        data:
+          $ref: "#/components/schemas/ActResultOutput"
+      required:
+        - success
+        - data
+      additionalProperties: false
+    ExtractResponse:
+      type: object
+      properties:
+        success:
+          description: Indicates whether the request was successful
+          type: boolean
+        data:
+          $ref: "#/components/schemas/ExtractResultOutput"
+      required:
+        - success
+        - data
+      additionalProperties: false
+    ObserveResponse:
+      type: object
+      properties:
+        success:
+          description: Indicates whether the request was successful
+          type: boolean
+        data:
+          $ref: "#/components/schemas/ObserveResultOutput"
+      required:
+        - success
+        - data
+      additionalProperties: false
+    AgentExecuteResponse:
+      type: object
+      properties:
+        success:
+          description: Indicates whether the request was successful
+          type: boolean
+        data:
+          $ref: "#/components/schemas/AgentExecuteResultOutput"
+      required:
+        - success
+        - data
+      additionalProperties: false
+    NavigateResponse:
+      type: object
+      properties:
+        success:
+          description: Indicates whether the request was successful
+          type: boolean
+        data:
+          $ref: "#/components/schemas/NavigateResultOutput"
+      required:
+        - success
+        - data
+      additionalProperties: false
+    ReplayResponse:
+      type: object
+      properties:
+        success:
+          description: Indicates whether the request was successful
+          type: boolean
+        data:
+          $ref: "#/components/schemas/ReplayResultOutput"
+      required:
+        - success
+        - data
+      additionalProperties: false
+    AgentCacheEntryOutput:
+      type: object
+      properties:
+        cacheKey:
+          description: Opaque cache identifier computed from instruction, URL, options,
+            and config
+          type: string
+        entry:
+          description: Serialized cache entry that can be written to disk
+      required:
+        - cacheKey
+        - entry
+      additionalProperties: false
+    LocalBrowserLaunchOptionsOutput:
+      type: object
+      properties:
+        args:
+          type: array
+          items:
+            type: string
+        executablePath:
+          type: string
+        port:
+          type: number
+        userDataDir:
+          type: string
+        preserveUserDataDir:
+          type: boolean
+        headless:
+          type: boolean
+        devtools:
+          type: boolean
+        chromiumSandbox:
+          type: boolean
+        ignoreDefaultArgs:
+          anyOf:
+            - type: boolean
+            - type: array
+              items:
+                type: string
+        proxy:
+          type: object
+          properties:
+            server:
+              type: string
+            bypass:
+              type: string
+            username:
+              type: string
+            password:
+              type: string
+          required:
+            - server
+          additionalProperties: false
+        locale:
+          type: string
+        viewport:
+          type: object
+          properties:
+            width:
+              type: number
+            height:
+              type: number
+          required:
+            - width
+            - height
+          additionalProperties: false
+        deviceScaleFactor:
+          type: number
+        hasTouch:
+          type: boolean
+        ignoreHTTPSErrors:
+          type: boolean
+        cdpUrl:
+          type: string
+        cdpHeaders:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties:
+            type: string
+        connectTimeoutMs:
+          type: number
+        downloadsPath:
+          type: string
+        acceptDownloads:
+          type: boolean
+      additionalProperties: false
+    ModelConfigObjectOutput:
+      type: object
+      properties:
+        provider:
+          description: AI provider for the model (or provide a baseURL endpoint instead)
+          example: openai
+          type: string
+          enum:
+            - openai
+            - anthropic
+            - google
+            - microsoft
+            - bedrock
+        modelName:
+          description: Model name string with provider prefix (e.g., 'openai/gpt-5-nano')
+          example: openai/gpt-5-nano
+          type: string
+        apiKey:
+          description: API key for the model provider
+          example: sk-some-openai-api-key
+          type: string
+        baseURL:
+          description: Base URL for the model provider
+          example: https://api.openai.com/v1
+          type: string
+          format: uri
+      required:
+        - modelName
+      additionalProperties: false
+    ModelConfigOutput:
+      $ref: "#/components/schemas/ModelConfigObjectOutput"
+    ActionOutput:
+      description: Action object returned by observe and used by act
+      type: object
+      properties:
+        selector:
+          description: CSS selector or XPath for the element
+          example: "[data-testid='submit-button']"
+          type: string
+        description:
+          description: Human-readable description of the action
+          example: Click the submit button
+          type: string
+        backendNodeId:
+          description: Backend node ID for the element
+          type: number
+        method:
+          description: The method to execute (click, fill, etc.)
+          example: click
+          type: string
+        arguments:
+          description: Arguments to pass to the method
+          example:
+            - Hello World
+          type: array
+          items:
+            type: string
+      required:
+        - selector
+        - description
+      additionalProperties: false
+    BrowserConfigOutput:
+      type: object
+      properties:
+        type:
+          description: Browser type to use
+          example: local
+          type: string
+          enum:
+            - local
+            - browserbase
+        cdpUrl:
+          description: Chrome DevTools Protocol URL for connecting to existing browser
+          example: ws://localhost:9222
+          type: string
+        launchOptions:
+          $ref: "#/components/schemas/LocalBrowserLaunchOptionsOutput"
+      additionalProperties: false
+    BrowserbaseViewportOutput:
+      type: object
+      properties:
+        width:
+          type: number
+        height:
+          type: number
+      additionalProperties: false
+    BrowserbaseFingerprintScreenOutput:
+      type: object
+      properties:
+        maxHeight:
+          type: number
+        maxWidth:
+          type: number
+        minHeight:
+          type: number
+        minWidth:
+          type: number
+      additionalProperties: false
+    BrowserbaseFingerprintOutput:
+      type: object
+      properties:
+        browsers:
+          type: array
+          items:
+            type: string
+            enum:
+              - chrome
+              - edge
+              - firefox
+              - safari
+        devices:
+          type: array
+          items:
+            type: string
+            enum:
+              - desktop
+              - mobile
+        httpVersion:
+          type: string
+          enum:
+            - "1"
+            - "2"
+        locales:
+          type: array
+          items:
+            type: string
+        operatingSystems:
+          type: array
+          items:
+            type: string
+            enum:
+              - android
+              - ios
+              - linux
+              - macos
+              - windows
+        screen:
+          $ref: "#/components/schemas/BrowserbaseFingerprintScreenOutput"
+      additionalProperties: false
+    BrowserbaseContextOutput:
+      type: object
+      properties:
+        id:
+          type: string
+        persist:
+          type: boolean
+      required:
+        - id
+      additionalProperties: false
+    BrowserbaseBrowserSettingsOutput:
+      type: object
+      properties:
+        advancedStealth:
+          type: boolean
+        blockAds:
+          type: boolean
+        context:
+          $ref: "#/components/schemas/BrowserbaseContextOutput"
+        extensionId:
+          type: string
+        fingerprint:
+          $ref: "#/components/schemas/BrowserbaseFingerprintOutput"
+        logSession:
+          type: boolean
+        recordSession:
+          type: boolean
+        solveCaptchas:
+          type: boolean
+        viewport:
+          $ref: "#/components/schemas/BrowserbaseViewportOutput"
+      additionalProperties: false
+    BrowserbaseProxyGeolocationOutput:
+      type: object
+      properties:
+        country:
+          type: string
+        city:
+          type: string
+        state:
+          type: string
+      required:
+        - country
+      additionalProperties: false
+    BrowserbaseProxyConfigOutput:
+      type: object
+      properties:
+        type:
+          type: string
+          const: browserbase
+        domainPattern:
+          type: string
+        geolocation:
+          $ref: "#/components/schemas/BrowserbaseProxyGeolocationOutput"
+      required:
+        - type
+      additionalProperties: false
+    ExternalProxyConfigOutput:
+      type: object
+      properties:
+        type:
+          type: string
+          const: external
+        server:
+          type: string
+        domainPattern:
+          type: string
+        username:
+          type: string
+        password:
+          type: string
+      required:
+        - type
+        - server
+      additionalProperties: false
+    ProxyConfigOutput:
+      oneOf:
+        - $ref: "#/components/schemas/BrowserbaseProxyConfigOutput"
+        - $ref: "#/components/schemas/ExternalProxyConfigOutput"
+      type: object
+      discriminator:
+        propertyName: type
+        mapping:
+          browserbase: "#/components/schemas/BrowserbaseProxyConfigOutput"
+          external: "#/components/schemas/ExternalProxyConfigOutput"
+    BrowserbaseSessionCreateParamsOutput:
+      type: object
+      properties:
+        projectId:
+          type: string
+        browserSettings:
+          $ref: "#/components/schemas/BrowserbaseBrowserSettingsOutput"
+        extensionId:
+          type: string
+        keepAlive:
+          type: boolean
+        proxies:
+          anyOf:
+            - type: boolean
+            - type: array
+              items:
+                $ref: "#/components/schemas/ProxyConfigOutput"
+        region:
+          $ref: "#/components/schemas/BrowserbaseRegion"
+        timeout:
+          type: number
+        userMetadata:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+      additionalProperties: false
+    SessionStartResultOutput:
+      type: object
+      properties:
+        sessionId:
+          description: Unique Browserbase session identifier
+          example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+          type: string
+        cdpUrl:
+          description: CDP WebSocket URL for connecting to the Browserbase cloud browser
+            (present when available)
+          example: wss://connect.browserbase.com/?signingKey=abc123
+          anyOf:
+            - type: string
+            - type: "null"
+        available:
+          type: boolean
+      required:
+        - sessionId
+        - available
+      additionalProperties: false
+    ActOptionsOutput:
+      type: object
+      properties:
+        model:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano')
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfigOutput"
+            - type: string
+        variables:
+          description: Variables to substitute in the action instruction
+          example:
+            username: john_doe
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties:
+            type: string
+        timeout:
+          description: Timeout in ms for the action
+          example: 30000
+          type: number
+      additionalProperties: false
+    ActResultDataOutput:
+      type: object
+      properties:
+        success:
+          description: Whether the action completed successfully
+          example: true
+          type: boolean
+        message:
+          description: Human-readable result message
+          example: Successfully clicked the login button
+          type: string
+        actionDescription:
+          description: Description of the action that was performed
+          example: Clicked button with text 'Login'
+          type: string
+        actions:
+          description: List of actions that were executed
+          type: array
+          items:
+            $ref: "#/components/schemas/ActionOutput"
+      required:
+        - success
+        - message
+        - actionDescription
+        - actions
+      additionalProperties: false
+    ActResultOutput:
+      type: object
+      properties:
+        result:
+          $ref: "#/components/schemas/ActResultDataOutput"
+        actionId:
+          description: Action ID for tracking
+          type: string
+      required:
+        - result
+      additionalProperties: false
+    ExtractOptionsOutput:
+      type: object
+      properties:
+        model:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano')
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfigOutput"
+            - type: string
+        timeout:
+          description: Timeout in ms for the extraction
+          example: 30000
+          type: number
+        selector:
+          description: CSS selector to scope extraction to a specific element
+          example: "#main-content"
+          type: string
+      additionalProperties: false
+    ExtractResultOutput:
+      type: object
+      properties:
+        result:
+          description: Extracted data matching the requested schema
+          x-stainless-any: true
+        actionId:
+          description: Action ID for tracking
+          type: string
+      required:
+        - result
+      additionalProperties: false
+    ObserveOptionsOutput:
+      type: object
+      properties:
+        model:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano')
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfigOutput"
+            - type: string
+        timeout:
+          description: Timeout in ms for the observation
+          example: 30000
+          type: number
+        selector:
+          description: CSS selector to scope observation to a specific element
+          example: nav
+          type: string
+      additionalProperties: false
+    ObserveResultOutput:
+      type: object
+      properties:
+        result:
+          type: array
+          items:
+            $ref: "#/components/schemas/ActionOutput"
+        actionId:
+          description: Action ID for tracking
+          type: string
+      required:
+        - result
+      additionalProperties: false
+    AgentConfigOutput:
+      type: object
+      properties:
+        provider:
+          description: "AI provider for the agent (legacy, use model: openai/gpt-5-nano
+            instead)"
+          example: openai
+          type: string
+          enum:
+            - openai
+            - anthropic
+            - google
+            - microsoft
+            - bedrock
+        model:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano')
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfigOutput"
+            - type: string
+        systemPrompt:
+          description: Custom system prompt for the agent
+          type: string
+        cua:
+          description: "Deprecated. Use mode: 'cua' instead. If both are provided, mode
+            takes precedence."
+          example: true
+          type: boolean
+        mode:
+          description: Tool mode for the agent (dom, hybrid, cua). If set, overrides cua.
+          example: cua
+          type: string
+          enum:
+            - dom
+            - hybrid
+            - cua
+        executionModel:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano') for tool execution (observe/act calls within
+            agent tools). If not specified, inherits from the main model
+            configuration.
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfigOutput"
+            - type: string
+      additionalProperties: false
+    AgentUsageOutput:
+      type: object
+      properties:
+        input_tokens:
+          example: 1500
+          type: number
+        output_tokens:
+          example: 250
+          type: number
+        reasoning_tokens:
+          type: number
+        cached_input_tokens:
+          type: number
+        inference_time_ms:
+          example: 2500
+          type: number
+      required:
+        - input_tokens
+        - output_tokens
+        - inference_time_ms
+      additionalProperties: false
+    AgentResultDataOutput:
+      type: object
+      properties:
+        success:
+          description: Whether the agent completed successfully
+          example: true
+          type: boolean
+        message:
+          description: Summary of what the agent accomplished
+          example: Successfully logged in and navigated to dashboard
+          type: string
+        actions:
+          type: array
+          items:
+            $ref: "#/components/schemas/AgentAction"
+        completed:
+          description: Whether the agent finished its task
+          example: true
+          type: boolean
+        metadata:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+        usage:
+          $ref: "#/components/schemas/AgentUsageOutput"
+      required:
+        - success
+        - message
+        - actions
+        - completed
+      additionalProperties: false
+    AgentExecuteOptionsOutput:
+      type: object
+      properties:
+        instruction:
+          description: Natural language instruction for the agent
+          example: Log in with username 'demo' and password 'test123', then navigate to
+            settings
+          type: string
+        maxSteps:
+          description: Maximum number of steps the agent can take
+          example: 20
+          type: number
+        highlightCursor:
+          description: Whether to visually highlight the cursor during execution
+          example: true
+          type: boolean
+      required:
+        - instruction
+      additionalProperties: false
+    AgentExecuteResultOutput:
+      type: object
+      properties:
+        result:
+          $ref: "#/components/schemas/AgentResultDataOutput"
+        cacheEntry:
+          $ref: "#/components/schemas/AgentCacheEntryOutput"
+      required:
+        - result
+      additionalProperties: false
+    NavigateOptionsOutput:
+      type: object
+      properties:
+        referer:
+          description: Referer header to send with the request
+          type: string
+        timeout:
+          description: Timeout in ms for the navigation
+          example: 30000
+          type: number
+        waitUntil:
+          description: When to consider navigation complete
+          example: networkidle
+          type: string
+          enum:
+            - load
+            - domcontentloaded
+            - networkidle
+      additionalProperties: false
+    NavigateResultOutput:
+      type: object
+      properties:
+        result:
+          description: Navigation response (Playwright Response object or null)
+          anyOf:
+            - {}
+            - type: "null"
+          x-stainless-any: true
+        actionId:
+          description: Action ID for tracking
+          type: string
+      required:
+        - result
+      additionalProperties: false
+    TokenUsageOutput:
+      type: object
+      properties:
+        inputTokens:
+          type: number
+        outputTokens:
+          type: number
+        timeMs:
+          type: number
+        cost:
+          type: number
+      additionalProperties: false
+    ReplayActionOutput:
+      type: object
+      properties:
+        method:
+          type: string
+        parameters:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+        result:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+        timestamp:
+          type: number
+        endTime:
+          type: number
+        tokenUsage:
+          $ref: "#/components/schemas/TokenUsageOutput"
+      required:
+        - method
+        - parameters
+        - result
+        - timestamp
+      additionalProperties: false
+    ReplayPageOutput:
+      type: object
+      properties:
+        url:
+          type: string
+        timestamp:
+          type: number
+        duration:
+          type: number
+        actions:
+          type: array
+          items:
+            $ref: "#/components/schemas/ReplayActionOutput"
+      required:
+        - url
+        - timestamp
+        - duration
+        - actions
+      additionalProperties: false
+    ReplayResultOutput:
+      type: object
+      properties:
+        pages:
+          type: array
+          items:
+            $ref: "#/components/schemas/ReplayPageOutput"
+        clientLanguage:
+          type: string
+      required:
+        - pages
+      additionalProperties: false
+    StreamEventSystemDataOutput:
+      type: object
+      properties:
+        status:
+          $ref: "#/components/schemas/StreamEventStatus"
+        result:
+          description: Operation result (present when status is 'finished')
+          x-stainless-any: true
+        error:
+          description: Error message (present when status is 'error')
+          type: string
+      required:
+        - status
+      additionalProperties: false
+    StreamEventLogDataOutput:
+      type: object
+      properties:
+        status:
+          type: string
+          const: running
+        message:
+          description: Log message from the operation
+          type: string
+      required:
+        - status
+        - message
+      additionalProperties: false
+    SessionIdParams:
+      type: object
+      properties:
+        id:
+          description: Unique session identifier
+          example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+          type: string
+      required:
+        - id
+      additionalProperties: false
+    SessionHeaders:
+      type: object
+      properties:
+        x-stream-response:
+          description: Whether to stream the response via SSE
+          example: "true"
+          type: string
+          enum:
+            - "true"
+            - "false"
+      additionalProperties: false
+    ErrorResponse:
+      type: object
+      properties:
+        success:
+          type: boolean
+          const: false
+        error:
+          type: string
+        code:
+          type: string
+      required:
+        - success
+        - error
+      additionalProperties: false
+    SessionEndResult:
+      type: object
+      properties: {}
+      additionalProperties: false
+    StreamEvent:
+      description: "Server-Sent Event emitted during streaming responses. Events are
+        sent as `data: <JSON>\\n\\n`. Key order: data (with status first), type,
+        id."
+      type: object
+      properties:
+        data:
+          anyOf:
+            - $ref: "#/components/schemas/StreamEventSystemDataOutput"
+            - $ref: "#/components/schemas/StreamEventLogDataOutput"
+        type:
+          $ref: "#/components/schemas/StreamEventType"
+        id:
+          description: Unique identifier for this event
+          example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+          type: string
+          format: uuid
+          pattern: ^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$
+      required:
+        - data
+        - type
+        - id
+      additionalProperties: false
+paths:
+  /v1/sessions/{id}/act:
+    post:
+      operationId: SessionAct
+      summary: Perform an action
+      description: Executes a browser action using natural language instructions or a
+        predefined Action object.
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/ActRequest"
+        required: true
+      parameters:
+        - schema:
+            description: Unique session identifier
+            example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+            type: string
+          in: path
+          name: id
+          required: true
+          description: Unique session identifier
+        - schema:
+            description: Whether to stream the response via SSE
+            example: "true"
+            type: string
+            enum:
+              - "true"
+              - "false"
+          in: header
+          name: x-stream-response
+          description: Whether to stream the response via SSE
+      responses:
+        "200":
+          description: Default Response
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ActResponse"
+  /v1/sessions/{id}/end:
+    post:
+      operationId: SessionEnd
+      summary: End a browser session
+      description: Terminates the browser session and releases all associated resources.
+      parameters:
+        - schema:
+            description: Unique session identifier
+            example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+            type: string
+          in: path
+          name: id
+          required: true
+          description: Unique session identifier
+        - schema:
+            description: Whether to stream the response via SSE
+            example: "true"
+            type: string
+            enum:
+              - "true"
+              - "false"
+          in: header
+          name: x-stream-response
+          description: Whether to stream the response via SSE
+      responses:
+        "200":
+          description: Default Response
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/SessionEndResponse"
+  /v1/sessions/{id}/extract:
+    post:
+      operationId: SessionExtract
+      summary: Extract data from the page
+      description: Extracts structured data from the current page using AI-powered analysis.
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/ExtractRequest"
+        required: true
+      parameters:
+        - schema:
+            description: Unique session identifier
+            example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+            type: string
+          in: path
+          name: id
+          required: true
+          description: Unique session identifier
+        - schema:
+            description: Whether to stream the response via SSE
+            example: "true"
+            type: string
+            enum:
+              - "true"
+              - "false"
+          in: header
+          name: x-stream-response
+          description: Whether to stream the response via SSE
+      responses:
+        "200":
+          description: Default Response
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ExtractResponse"
+  /v1/sessions/{id}/navigate:
+    post:
+      operationId: SessionNavigate
+      summary: Navigate to a URL
+      description: Navigates the browser to the specified URL.
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/NavigateRequest"
+        required: true
+      parameters:
+        - schema:
+            description: Unique session identifier
+            example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+            type: string
+          in: path
+          name: id
+          required: true
+          description: Unique session identifier
+        - schema:
+            description: Whether to stream the response via SSE
+            example: "true"
+            type: string
+            enum:
+              - "true"
+              - "false"
+          in: header
+          name: x-stream-response
+          description: Whether to stream the response via SSE
+      responses:
+        "200":
+          description: Default Response
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/NavigateResponse"
+  /v1/sessions/{id}/observe:
+    post:
+      operationId: SessionObserve
+      summary: Observe available actions
+      description: Identifies and returns available actions on the current page that
+        match the given instruction.
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/ObserveRequest"
+        required: true
+      parameters:
+        - schema:
+            description: Unique session identifier
+            example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+            type: string
+          in: path
+          name: id
+          required: true
+          description: Unique session identifier
+        - schema:
+            description: Whether to stream the response via SSE
+            example: "true"
+            type: string
+            enum:
+              - "true"
+              - "false"
+          in: header
+          name: x-stream-response
+          description: Whether to stream the response via SSE
+      responses:
+        "200":
+          description: Default Response
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ObserveResponse"
+  /v1/sessions/{id}/replay:
+    get:
+      operationId: SessionReplay
+      summary: Replay session metrics
+      description: Retrieves replay metrics for a session.
+      parameters:
+        - schema:
+            description: Unique session identifier
+            example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+            type: string
+          in: path
+          name: id
+          required: true
+          description: Unique session identifier
+        - schema:
+            description: Whether to stream the response via SSE
+            example: "true"
+            type: string
+            enum:
+              - "true"
+              - "false"
+          in: header
+          name: x-stream-response
+          description: Whether to stream the response via SSE
+      responses:
+        "200":
+          description: Default Response
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ReplayResponse"
+  /v1/sessions/start:
+    post:
+      operationId: SessionStart
+      summary: Start a new browser session
+      description: Creates a new browser session with the specified configuration.
+        Returns a session ID used for all subsequent operations.
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/SessionStartRequest"
+        required: true
+      parameters:
+        - schema:
+            description: Whether to stream the response via SSE
+            example: "true"
+            type: string
+            enum:
+              - "true"
+              - "false"
+          in: header
+          name: x-stream-response
+          description: Whether to stream the response via SSE
+      responses:
+        "200":
+          description: Default Response
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/SessionStartResponse"
+  /v1/sessions/{id}/agentExecute:
+    post:
+      operationId: SessionAgentExecute
+      summary: Execute an AI agent
+      description: Runs an autonomous AI agent that can perform complex multi-step
+        browser tasks.
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/AgentExecuteRequest"
+        required: true
+      parameters:
+        - schema:
+            description: Unique session identifier
+            example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+            type: string
+          in: path
+          name: id
+          required: true
+          description: Unique session identifier
+        - schema:
+            description: Whether to stream the response via SSE
+            example: "true"
+            type: string
+            enum:
+              - "true"
+              - "false"
+          in: header
+          name: x-stream-response
+          description: Whether to stream the response via SSE
+      responses:
+        "200":
+          description: Default Response
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/AgentExecuteResponse"
+servers:
+  - url: https://api.stagehand.browserbase.com
+security:
+  - BrowserbaseApiKey: []
+    BrowserbaseProjectId: []
+    ModelApiKey: []
diff --git a/packages/server-v3/package.json b/packages/server-v3/package.json
new file mode 100644
index 000000000..dd5a8da6e
--- /dev/null
+++ b/packages/server-v3/package.json
@@ -0,0 +1,62 @@
+{
+  "name": "@browserbasehq/stagehand-server-v3",
+  "version": "3.6.0",
+  "description": "Stagehand API server v3",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "build": "pnpm --filter @browserbasehq/stagehand-server-v3 run --parallel \"/^(build:esm-tests|build:server:dist|gen:openapi|build:sea:esm)$/\"",
+    "dev": "tsx watch src/server.ts",
+    "build:esm-tests": "pnpm -w --dir ../.. exec tsc -p packages/server-v3/tsconfig.tests.json",
+    "build:server:dist": "pnpm -w --dir ../.. exec tsc -p packages/server-v3/tsconfig.json && pnpm -w --dir ../.. exec tsc-alias -p packages/server-v3/tsconfig.json",
+    "build:sea:esm": "tsx scripts/build-sea.ts --mode=esm",
+    "build:sea:cjs": "tsx scripts/build-sea.ts --mode=cjs",
+    "lint": "cd ../.. && prettier --check packages/server-v3 && cd packages/server-v3 && eslint . && pnpm run typecheck",
+    "typecheck": "pnpm -w --dir ../.. exec tsc -p packages/server-v3/tsconfig.json --noEmit",
+    "test": "pnpm -w --dir ../.. exec turbo run test:server --filter=@browserbasehq/stagehand-server-v3 --",
+    "test:server": "tsx scripts/test-server.ts",
+    "test:integration": "pnpm run test:server -- packages/server-v3/dist/tests/integration",
+    "test:integration:local": "STAGEHAND_SERVER_TARGET=local pnpm run test:server -- packages/server-v3/dist/tests/integration",
+    "test:integration:sea": "STAGEHAND_SERVER_TARGET=sea pnpm run test:server -- packages/server-v3/dist/tests/integration",
+    "gen:openapi": "tsx scripts/gen-openapi.ts"
+  },
+  "dependencies": {
+    "@browserbasehq/sdk": "^2.7.0",
+    "@browserbasehq/stagehand": "workspace:*",
+    "@fastify/cors": "^11.0.1",
+    "@fastify/swagger": "^9.6.1",
+    "@fastify/swagger-ui": "^5.2.3",
+    "@t3-oss/env-core": "^0.13.8",
+    "fastify": "^5.3.2",
+    "fastify-metrics": "^12.1.0",
+    "fastify-plugin": "^4.5.1",
+    "fastify-zod-openapi": "^5.5.0",
+    "http-status-codes": "^2.3.0",
+    "pino": "^9.7.0",
+    "pino-pretty": "^11.3.0",
+    "playwright": "1.52.0",
+    "uuid": "^11.0.5",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "@types/node": "22.13.1",
+    "eslint": "10.0.2",
+    "eslint-plugin-security": "^3.0.1",
+    "openai": "4.87.1",
+    "postject": "1.0.0-alpha.6",
+    "prettier": "^3.2.5",
+    "source-map": "^0.7.4",
+    "tsc-alias": "^1.8.10",
+    "tsx": "*",
+    "vitest": "^4.0.8"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/browserbase/stagehand.git",
+    "directory": "packages/server-v3"
+  },
+  "bugs": {
+    "url": "https://github.com/browserbase/stagehand/issues"
+  },
+  "homepage": "https://stagehand.dev"
+}
diff --git a/packages/server-v3/scripts/build-sea.ts b/packages/server-v3/scripts/build-sea.ts
new file mode 100644
index 000000000..70b3d2c6a
--- /dev/null
+++ b/packages/server-v3/scripts/build-sea.ts
@@ -0,0 +1,497 @@
+#!/usr/bin/env node
+/**
+ * Build SEA binary from ESM (test) or CJS (release) bundles.
+ *
+ * Prereqs:
+ * - CJS mode: runs core CJS build via Turbo if dist is missing.
+ * - ESM mode: core dist/esm available (pnpm run build:esm).
+ * - postject installed; tar available for non-Windows downloads.
+ *
+ * Args: --mode=esm|cjs --target-platform=<platform> --target-arch=<arch> --binary-name=<name>
+ * Env: SEA_BUILD_MODE, SEA_TARGET_PLATFORM, SEA_TARGET_ARCH, SEA_BINARY_NAME,
+ *      SEA_INCLUDE_SOURCEMAPS.
+ * Example: pnpm run build:sea:cjs -- --target-platform=linux --target-arch=arm64
+ */
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import https from "node:https";
+import { pathToFileURL } from "node:url";
+import esbuild from "esbuild";
+import { getRepoRootDir } from "./runtimePaths.js";
+
+const repoDir = getRepoRootDir();
+
+const argValue = (name: string) => {
+  const prefix = `--${name}=`;
+  for (let i = 0; i < process.argv.length; i++) {
+    const arg = process.argv[i];
+    if (arg === `--${name}` && process.argv[i + 1]) return process.argv[i + 1];
+    if (arg.startsWith(prefix)) return arg.slice(prefix.length);
+  }
+  return undefined;
+};
+
+const mode = (
+  argValue("mode") ??
+  process.env.SEA_BUILD_MODE ??
+  "esm"
+).toLowerCase();
+const parseBoolean = (
+  value: string | undefined,
+  fallback: boolean,
+): boolean => {
+  if (value === undefined) return fallback;
+
+  const normalized = value.toLowerCase();
+  if (
+    normalized === "1" ||
+    normalized === "true" ||
+    normalized === "yes" ||
+    normalized === "on"
+  ) {
+    return true;
+  }
+  if (
+    normalized === "0" ||
+    normalized === "false" ||
+    normalized === "no" ||
+    normalized === "off"
+  ) {
+    return false;
+  }
+
+  throw new Error(
+    `Invalid boolean value "${value}" for --include-sourcemaps / SEA_INCLUDE_SOURCEMAPS`,
+  );
+};
+const targetPlatform =
+  argValue("target-platform") ??
+  argValue("platform") ??
+  process.env.SEA_TARGET_PLATFORM ??
+  process.platform;
+const targetArch =
+  argValue("target-arch") ??
+  argValue("arch") ??
+  process.env.SEA_TARGET_ARCH ??
+  process.arch;
+const binaryName =
+  argValue("binary-name") ??
+  process.env.SEA_BINARY_NAME ??
+  `stagehand-server-v3-${targetPlatform}-${targetArch}${targetPlatform === "win32" ? ".exe" : ""}`;
+const includeSourcemaps = parseBoolean(
+  argValue("include-sourcemaps") ?? process.env.SEA_INCLUDE_SOURCEMAPS,
+  false,
+);
+
+const run = (cmd: string, args: string[], opts: { cwd?: string } = {}) => {
+  const result = spawnSync(cmd, args, { stdio: "inherit", ...opts });
+  if (result.error) {
+    throw new Error(
+      `Command failed to start: ${cmd} ${args.join(" ")}\n${String(result.error)}`,
+    );
+  }
+  if (result.status !== 0) {
+    throw new Error(`Command failed: ${cmd} ${args.join(" ")}`);
+  }
+};
+
+const runNodeScript = (
+  scriptPath: string,
+  args: string[],
+  opts: { cwd?: string } = {},
+) => run(process.execPath, [scriptPath, ...args], opts);
+
+const resolveFirstExisting = (paths: string[]): string => {
+  for (const candidate of paths) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  throw new Error(`Missing tool script. Tried: ${paths.join(", ")}`);
+};
+
+const runOptional = (
+  cmd: string,
+  args: string[],
+  opts: { cwd?: string } = {},
+) => {
+  spawnSync(cmd, args, { stdio: "ignore", ...opts });
+};
+
+const download = (url: string, dest: string): Promise<void> =>
+  new Promise((resolve, reject) => {
+    https
+      .get(url, (res) => {
+        if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400) {
+          const location = res.headers.location;
+          if (!location) {
+            reject(new Error(`Redirect without location: ${url}`));
+            return;
+          }
+          res.resume();
+          download(location, dest).then(resolve, reject);
+          return;
+        }
+        if (res.statusCode !== 200) {
+          reject(new Error(`Download failed (${res.statusCode}) ${url}`));
+          res.resume();
+          return;
+        }
+
+        const file = fs.createWriteStream(dest);
+        const fail = (error: Error) => {
+          file.destroy();
+          reject(error);
+        };
+
+        res.on("error", fail);
+        file.on("error", fail);
+        file.on("finish", () => {
+          file.close((closeError) => {
+            if (closeError) {
+              reject(closeError);
+              return;
+            }
+            resolve();
+          });
+        });
+        res.pipe(file);
+      })
+      .on("error", reject);
+  });
+
+const resolveNodeBinary = async (): Promise<string> => {
+  if (targetPlatform !== process.platform) {
+    throw new Error(
+      `Cross-platform builds are not supported. Host=${process.platform}, target=${targetPlatform}`,
+    );
+  }
+  if (targetArch === process.arch) {
+    return process.execPath;
+  }
+
+  const version = process.version;
+  const distPlatform = targetPlatform === "win32" ? "win" : targetPlatform;
+  const archiveBase = `node-${version}-${distPlatform}-${targetArch}`;
+  const archiveExt = distPlatform === "win" ? "zip" : "tar.xz";
+  const tmpRoot = `${os.tmpdir()}/stagehand-sea/${archiveBase}`;
+  const archivePath = `${tmpRoot}/${archiveBase}.${archiveExt}`;
+  const extractRoot = `${tmpRoot}/${archiveBase}`;
+  const binaryPath =
+    distPlatform === "win"
+      ? `${extractRoot}/node.exe`
+      : `${extractRoot}/bin/node`;
+
+  if (fs.existsSync(binaryPath)) {
+    return binaryPath;
+  }
+
+  fs.mkdirSync(tmpRoot, { recursive: true });
+  if (!fs.existsSync(archivePath)) {
+    const url = `https://nodejs.org/dist/${version}/${archiveBase}.${archiveExt}`;
+    await download(url, archivePath);
+  }
+
+  if (archiveExt === "zip") {
+    if (process.platform !== "win32") {
+      throw new Error("Windows binaries must be built on Windows runners.");
+    }
+    run("powershell", [
+      "-Command",
+      `Expand-Archive -Path '${archivePath}' -DestinationPath '${tmpRoot}' -Force`,
+    ]);
+  } else {
+    run("tar", ["-xf", archivePath, "-C", tmpRoot]);
+  }
+
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(`Missing Node binary at ${binaryPath}`);
+  }
+  return binaryPath;
+};
+
+const writeSeaConfig = (
+  mainPath: string,
+  outputPath: string,
+  execArgvExtension?: string,
+) => {
+  const configPath = `${repoDir}/packages/server-v3/dist/sea/sea-config-${mode}.json`;
+  const config = {
+    main: path
+      .relative(`${repoDir}/packages/server-v3`, mainPath)
+      .replaceAll("\\", "/"),
+    output: path
+      .relative(`${repoDir}/packages/server-v3`, outputPath)
+      .replaceAll("\\", "/"),
+    ...(execArgvExtension ? { execArgvExtension } : {}),
+  };
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  return configPath;
+};
+
+const buildCjsBundle = () => {
+  const turboBin = resolveFirstExisting([
+    `${repoDir}/node_modules/turbo/bin/turbo`,
+  ]);
+  runNodeScript(
+    turboBin,
+    ["run", "build:cjs", "--filter", "@browserbasehq/stagehand"],
+    {
+      cwd: repoDir,
+    },
+  );
+  fs.mkdirSync(`${repoDir}/packages/server-v3/dist/sea`, { recursive: true });
+  const bundlePath = `${repoDir}/packages/server-v3/dist/sea/bundle.cjs`;
+  esbuild.buildSync({
+    entryPoints: ["packages/server-v3/src/sea-entry.ts"],
+    bundle: true,
+    platform: "node",
+    format: "cjs",
+    outfile: bundlePath,
+    logLevel: "warning",
+    absWorkingDir: repoDir,
+  });
+  return bundlePath;
+};
+
+const buildEsmBundle = () => {
+  if (!fs.existsSync(`${repoDir}/packages/core/dist/esm/index.js`)) {
+    throw new Error(
+      `Missing ${repoDir}/packages/core/dist/esm/index.js. Run pnpm run build:esm first.`,
+    );
+  }
+
+  fs.mkdirSync(`${repoDir}/packages/server-v3/dist/sea`, { recursive: true });
+  const appBundlePath = `${repoDir}/packages/server-v3/dist/app.mjs`;
+  esbuild.buildSync({
+    entryPoints: ["packages/server-v3/src/sea-entry.ts"],
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    treeShaking: false,
+    outfile: appBundlePath,
+    alias: {
+      "@browserbasehq/stagehand": `${repoDir}/packages/core/dist/esm/index.js`,
+    },
+    sourcemap: includeSourcemaps ? "inline" : false,
+    sourcesContent: includeSourcemaps,
+    ...(includeSourcemaps ? { sourceRoot: repoDir } : {}),
+    banner: {
+      js: 'import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);',
+    },
+    logLevel: "warning",
+    absWorkingDir: repoDir,
+  });
+
+  const appSource = fs.readFileSync(appBundlePath, "utf8");
+  let finalAppSource = appSource;
+
+  if (includeSourcemaps) {
+    const mapMatch = appSource.match(
+      /sourceMappingURL=data:application\/json;base64,([A-Za-z0-9+/=]+)\s*$/,
+    );
+    if (!mapMatch) {
+      throw new Error("Missing inline sourcemap in dist/app.mjs");
+    }
+    const mapJson = Buffer.from(mapMatch[1], "base64").toString("utf8");
+    const map = JSON.parse(mapJson) as {
+      sourceRoot?: string;
+      sources: string[];
+      sourcesContent?: string[];
+    };
+    const toPosix = (value: string) => value.replaceAll("\\", "/");
+    const fileUrlToPathSafe = (value: string) => {
+      const parsed = new URL(value);
+      let pathname = decodeURIComponent(parsed.pathname);
+      if (/^\/[A-Za-z]:/.test(pathname)) {
+        pathname = pathname.slice(1);
+      }
+      return pathname;
+    };
+    const toRepoRelative = (source: string) => {
+      let sourcePath = source;
+      if (source.startsWith("file://")) {
+        sourcePath = fileUrlToPathSafe(source);
+      }
+
+      if (path.isAbsolute(sourcePath)) {
+        const normalizedSourcePath = toPosix(sourcePath);
+        if (normalizedSourcePath.startsWith(`${repoDir}/`)) {
+          return toPosix(path.relative(repoDir, normalizedSourcePath));
+        }
+        return normalizedSourcePath;
+      }
+
+      if (sourcePath.startsWith("../src/")) {
+        const rel = sourcePath.slice("../src/".length);
+        return `packages/server-v3/src/${rel}`;
+      }
+      if (sourcePath.startsWith("../../core/")) {
+        const rel = sourcePath.slice("../../core/".length);
+        return `packages/core/${rel}`;
+      }
+      if (sourcePath.startsWith("../../../node_modules/")) {
+        const rel = sourcePath.slice("../../../node_modules/".length);
+        return `node_modules/${rel}`;
+      }
+      if (sourcePath.startsWith("src/")) {
+        const rel = sourcePath.slice("src/".length);
+        return `packages/server-v3/src/${rel}`;
+      }
+      if (sourcePath.startsWith("../node_modules/")) {
+        const rel = sourcePath.slice("../node_modules/".length);
+        return `node_modules/${rel}`;
+      }
+      if (sourcePath.startsWith("../core/")) {
+        const rel = sourcePath.slice("../core/".length);
+        return `packages/core/${rel}`;
+      }
+      if (sourcePath.startsWith("core/")) {
+        return `packages/core/${sourcePath.slice("core/".length)}`;
+      }
+      if (
+        sourcePath.startsWith("packages/") ||
+        sourcePath.startsWith("node_modules/")
+      ) {
+        return toPosix(sourcePath);
+      }
+
+      const resolved = toPosix(
+        path.resolve(`${repoDir}/packages/server-v3`, sourcePath),
+      );
+      if (resolved.startsWith(`${repoDir}/`)) {
+        return toPosix(path.relative(repoDir, resolved));
+      }
+
+      return toPosix(sourcePath);
+    };
+
+    map.sourceRoot = pathToFileURL(`${repoDir}/`).href;
+    map.sources = map.sources.map(toRepoRelative);
+    const updatedMap = Buffer.from(JSON.stringify(map)).toString("base64");
+    finalAppSource = appSource.replace(mapMatch[1], updatedMap);
+    fs.writeFileSync(appBundlePath, finalAppSource);
+  }
+
+  const appBytes = Buffer.from(finalAppSource);
+  const bundleHash = createHash("sha256")
+    .update(appBytes)
+    .digest("hex")
+    .slice(0, 12);
+  const bootstrapPath = `${repoDir}/packages/server-v3/dist/sea/sea-bootstrap.cjs`;
+  const bootstrap = `/* eslint-disable */
+const fs = require("node:fs");
+const os = require("node:os");
+const { pathToFileURL } = require("node:url");
+
+const bundleBase64 = ${JSON.stringify(appBytes.toString("base64"))};
+const bundleLength = ${appBytes.length};
+const bundleHash = ${JSON.stringify(bundleHash)};
+
+const cacheRoot =
+  process.env.STAGEHAND_SEA_CACHE_DIR ||
+  \`\${os.tmpdir()}/stagehand-server-v3-sea\`;
+const cacheDir = \`\${cacheRoot}/\${bundleHash}\`;
+const appPath = \`\${cacheDir}/app.mjs\`;
+
+fs.mkdirSync(cacheDir, { recursive: true });
+let needsWrite = true;
+try {
+  const stat = fs.statSync(appPath);
+  needsWrite = stat.size !== bundleLength;
+} catch {}
+
+if (needsWrite) {
+  const tmpPath =
+    \`\${cacheDir}/app.mjs.tmp-\${process.pid}-\${Date.now().toString(16)}\`;
+  fs.writeFileSync(tmpPath, Buffer.from(bundleBase64, "base64"));
+  try {
+    fs.renameSync(tmpPath, appPath);
+  } catch (err) {
+    if (!fs.existsSync(appPath)) throw err;
+  }
+  try {
+    fs.chmodSync(appPath, 0o500);
+  } catch {}
+}
+
+(async () => {
+  await import(pathToFileURL(appPath).href);
+})().catch((err) => {
+  console.error(err);
+  process.exitCode = 1;
+});
+`;
+  fs.writeFileSync(bootstrapPath, bootstrap);
+  return bootstrapPath;
+};
+
+const main = async () => {
+  fs.mkdirSync(`${repoDir}/packages/server-v3/dist/sea`, { recursive: true });
+
+  let mainPath: string;
+  let execArgvExtension: string | undefined;
+
+  if (mode === "cjs") {
+    mainPath = buildCjsBundle();
+  } else if (mode === "esm") {
+    mainPath = buildEsmBundle();
+    execArgvExtension = "cli";
+  } else {
+    throw new Error(`Unknown SEA build mode: ${mode}`);
+  }
+
+  const seaConfigPath = writeSeaConfig(
+    mainPath,
+    `${repoDir}/packages/server-v3/dist/sea/sea-prep.blob`,
+    execArgvExtension,
+  );
+
+  run("node", ["--experimental-sea-config", seaConfigPath], {
+    cwd: `${repoDir}/packages/server-v3`,
+  });
+  if (!fs.existsSync(`${repoDir}/packages/server-v3/dist/sea/sea-prep.blob`)) {
+    throw new Error(
+      `Missing ${repoDir}/packages/server-v3/dist/sea/sea-prep.blob; SEA blob generation failed.`,
+    );
+  }
+
+  const nodeBinary = await resolveNodeBinary();
+  const outPath = `${repoDir}/packages/server-v3/dist/sea/${binaryName}`;
+  fs.copyFileSync(nodeBinary, outPath);
+  if (targetPlatform !== "win32") {
+    fs.chmodSync(outPath, 0o755);
+  }
+
+  if (targetPlatform === "darwin") {
+    runOptional("codesign", ["--remove-signature", outPath]);
+  }
+
+  const postjectCliPath = resolveFirstExisting([
+    `${repoDir}/packages/server-v3/node_modules/postject/dist/cli.js`,
+    `${repoDir}/node_modules/postject/dist/cli.js`,
+  ]);
+  const postjectArgs = [
+    outPath,
+    "NODE_SEA_BLOB",
+    `${repoDir}/packages/server-v3/dist/sea/sea-prep.blob`,
+    "--sentinel-fuse",
+    "NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2",
+  ];
+  if (targetPlatform === "darwin") {
+    postjectArgs.push("--macho-segment-name", "NODE_SEA");
+  }
+  runNodeScript(postjectCliPath, postjectArgs, {
+    cwd: `${repoDir}/packages/server-v3`,
+  });
+
+  if (targetPlatform === "darwin") {
+    runOptional("codesign", ["--sign", "-", outPath]);
+  }
+};
+
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});
diff --git a/packages/server-v3/scripts/gen-openapi.ts b/packages/server-v3/scripts/gen-openapi.ts
new file mode 100644
index 000000000..c9e421187
--- /dev/null
+++ b/packages/server-v3/scripts/gen-openapi.ts
@@ -0,0 +1,187 @@
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getCurrentDirPath } from "./runtimePaths.js";
+
+import fastify from "fastify";
+import fastifySwagger from "@fastify/swagger";
+import {
+  fastifyZodOpenApiPlugin,
+  fastifyZodOpenApiTransformers,
+  serializerCompiler,
+  validatorCompiler,
+  type FastifyZodOpenApiTypeProvider,
+} from "fastify-zod-openapi";
+import { Api } from "@browserbasehq/stagehand";
+
+// Routes
+import actRoute from "../src/routes/v1/sessions/_id/act.js";
+import agentExecuteRoute from "../src/routes/v1/sessions/_id/agentExecute.js";
+import endRoute from "../src/routes/v1/sessions/_id/end.js";
+import extractRoute from "../src/routes/v1/sessions/_id/extract.js";
+import navigateRoute from "../src/routes/v1/sessions/_id/navigate.js";
+import observeRoute from "../src/routes/v1/sessions/_id/observe.js";
+import replayRoute from "../src/routes/v1/sessions/_id/replay.js";
+import startRoute from "../src/routes/v1/sessions/start.js";
+import healthcheckRoute from "../src/routes/healthcheck.js";
+import readinessRoute from "../src/routes/readiness.js";
+
+const OUTPUT_PATH = path.resolve(getCurrentDirPath(), "../openapi.v3.yaml");
+
+async function main() {
+  const app = fastify({
+    logger: false,
+  }).withTypeProvider<FastifyZodOpenApiTypeProvider>();
+
+  app.setValidatorCompiler(validatorCompiler);
+  app.setSerializerCompiler(serializerCompiler);
+
+  // Register all API schemas as components so fastify-zod-openapi can create $ref links
+  const components = {
+    schemas: {
+      // Region support
+      BrowserbaseRegion: Api.BrowserbaseRegionSchema,
+      // Shared components
+      LocalBrowserLaunchOptions: Api.LocalBrowserLaunchOptionsSchema,
+      ModelConfigObject: Api.ModelConfigObjectSchema,
+      ModelConfig: Api.ModelConfigSchema,
+      Action: Api.ActionSchema,
+      SessionIdParams: Api.SessionIdParamsSchema,
+      BrowserConfig: Api.BrowserConfigSchema,
+      SessionHeaders: Api.SessionHeadersSchema,
+      ErrorResponse: Api.ErrorResponseSchema,
+      // Browserbase schemas
+      BrowserbaseViewport: Api.BrowserbaseViewportSchema,
+      BrowserbaseFingerprintScreen: Api.BrowserbaseFingerprintScreenSchema,
+      BrowserbaseFingerprint: Api.BrowserbaseFingerprintSchema,
+      BrowserbaseContext: Api.BrowserbaseContextSchema,
+      BrowserbaseBrowserSettings: Api.BrowserbaseBrowserSettingsSchema,
+      BrowserbaseProxyGeolocation: Api.BrowserbaseProxyGeolocationSchema,
+      BrowserbaseProxyConfig: Api.BrowserbaseProxyConfigSchema,
+      ExternalProxyConfig: Api.ExternalProxyConfigSchema,
+      ProxyConfig: Api.ProxyConfigSchema,
+      BrowserbaseSessionCreateParams: Api.BrowserbaseSessionCreateParamsSchema,
+      // Session Start
+      SessionStartRequest: Api.SessionStartRequestSchema,
+      SessionStartResult: Api.SessionStartResultSchema,
+      SessionStartResponse: Api.SessionStartResponseSchema,
+      // Session End
+      SessionEndResult: Api.SessionEndResultSchema,
+      SessionEndResponse: Api.SessionEndResponseSchema,
+      // Act
+      ActOptions: Api.ActOptionsSchema,
+      ActRequest: Api.ActRequestSchema,
+      ActResultData: Api.ActResultDataSchema,
+      ActResult: Api.ActResultSchema,
+      ActResponse: Api.ActResponseSchema,
+      // Extract
+      ExtractOptions: Api.ExtractOptionsSchema,
+      ExtractRequest: Api.ExtractRequestSchema,
+      ExtractResult: Api.ExtractResultSchema,
+      ExtractResponse: Api.ExtractResponseSchema,
+      // Observe
+      ObserveOptions: Api.ObserveOptionsSchema,
+      ObserveRequest: Api.ObserveRequestSchema,
+      ObserveResult: Api.ObserveResultSchema,
+      ObserveResponse: Api.ObserveResponseSchema,
+      // Agent Execute
+      AgentConfig: Api.AgentConfigSchema,
+      AgentAction: Api.AgentActionSchema,
+      AgentUsage: Api.AgentUsageSchema,
+      AgentResultData: Api.AgentResultDataSchema,
+      AgentExecuteOptions: Api.AgentExecuteOptionsSchema,
+      AgentExecuteRequest: Api.AgentExecuteRequestSchema,
+      AgentExecuteResult: Api.AgentExecuteResultSchema,
+      AgentExecuteResponse: Api.AgentExecuteResponseSchema,
+      // Navigate
+      NavigateOptions: Api.NavigateOptionsSchema,
+      NavigateRequest: Api.NavigateRequestSchema,
+      NavigateResult: Api.NavigateResultSchema,
+      NavigateResponse: Api.NavigateResponseSchema,
+      // Replay
+      TokenUsage: Api.TokenUsageSchema,
+      ReplayAction: Api.ReplayActionSchema,
+      ReplayPage: Api.ReplayPageSchema,
+      ReplayResult: Api.ReplayResultSchema,
+      ReplayResponse: Api.ReplayResponseSchema,
+      // SSE Stream Events
+      StreamEventStatus: Api.StreamEventStatusSchema,
+      StreamEventType: Api.StreamEventTypeSchema,
+      StreamEventSystemData: Api.StreamEventSystemDataSchema,
+      StreamEventLogData: Api.StreamEventLogDataSchema,
+      StreamEvent: Api.StreamEventSchema,
+    },
+  };
+
+  await app.register(fastifyZodOpenApiPlugin, { components });
+
+  await app.register(fastifySwagger, {
+    openapi: {
+      info: {
+        title: "Stagehand API",
+        version: "3.1.0",
+        description: `Stagehand SDK for AI browser automation [ALPHA]. This API allows clients to
+execute browser automation tasks remotely on the Browserbase cloud.
+All endpoints except /sessions/start require an active session ID.
+Responses are streamed using Server-Sent Events (SSE) when the
+\`x-stream-response: true\` header is provided.
+
+This SDK is currently ALPHA software and is not production ready!
+Please try it and give us your feedback, stay tuned for upcoming release announcements!`,
+        contact: {
+          name: "Browserbase",
+          url: "https://browserbase.com",
+        },
+      },
+      openapi: "3.1.0",
+      servers: [
+        {
+          url: "https://api.stagehand.browserbase.com",
+        },
+      ],
+      components: {
+        securitySchemes: Api.openApiSecuritySchemes,
+        links: Api.openApiLinks,
+      },
+      security: [
+        { BrowserbaseApiKey: [], BrowserbaseProjectId: [], ModelApiKey: [] },
+      ],
+    },
+    ...fastifyZodOpenApiTransformers,
+  });
+
+  await app.register(
+    (instance, _opts, done) => {
+      instance.route(actRoute);
+      instance.route(endRoute);
+      instance.route(extractRoute);
+      instance.route(navigateRoute);
+      instance.route(observeRoute);
+      instance.route(replayRoute);
+      instance.route(startRoute);
+      instance.route(agentExecuteRoute);
+      done();
+    },
+    { prefix: "/v1" },
+  );
+
+  app.route(healthcheckRoute);
+  app.route(readinessRoute);
+
+  await app.ready();
+
+  const yaml = app.swagger({ yaml: true });
+  // Mintlify expects OpenAPI version fields to be strings, so quote them here.
+  const fixedYaml = yaml
+    .replace(/^openapi:\s*(?!['"])([^#\s]+)\s*$/m, 'openapi: "$1"')
+    .replace(/^ {2}version:\s*(?!['"])([^#\s]+)\s*$/m, '  version: "$1"');
+
+  await writeFile(OUTPUT_PATH, fixedYaml, "utf8");
+
+  await app.close();
+  console.log(`OpenAPI spec written to ${OUTPUT_PATH}`);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
diff --git a/packages/server-v3/scripts/runtimePaths.ts b/packages/server-v3/scripts/runtimePaths.ts
new file mode 100644
index 000000000..b150fc2b7
--- /dev/null
+++ b/packages/server-v3/scripts/runtimePaths.ts
@@ -0,0 +1,122 @@
+/**
+ * Keep this file in sync with:
+ * - /packages/core/lib/v3/runtimePaths.ts
+ * - /packages/server-v3/scripts/runtimePaths.ts
+ * - /packages/evals/runtimePaths.ts
+ * - /packages/docs/scripts/runtimePaths.js
+ */
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+
+const PACKAGE_SEGMENT = "/packages/server-v3/";
+const EVAL_FRAMES = new Set(["[eval]", "[eval]-wrapper"]);
+const INTERNAL_FRAME_NAMES = new Set([
+  "readCallsites",
+  "readCallsitePath",
+  "resolveCallerFilePath",
+  "getCurrentFilePath",
+  "getCurrentDirPath",
+  "getRepoRootDir",
+  "getPackageRootDir",
+  "createRequireFromCaller",
+  "isMainModule",
+]);
+
+const normalizePath = (value: string): string => {
+  const input = value.startsWith("file://") ? fileURLToPath(value) : value;
+  return path.resolve(input).replaceAll("\\", "/");
+};
+
+const readCallsites = (): NodeJS.CallSite[] => {
+  const previousPrepare = Error.prepareStackTrace;
+  try {
+    Error.prepareStackTrace = (_, stack) => stack;
+    return (
+      (new Error().stack as unknown as NodeJS.CallSite[] | undefined) ?? []
+    );
+  } finally {
+    Error.prepareStackTrace = previousPrepare;
+  }
+};
+
+type CallSiteWithScriptName = NodeJS.CallSite & {
+  getScriptNameOrSourceURL?: () => string | null;
+};
+
+const readCallsitePath = (callsite: NodeJS.CallSite): string | null => {
+  const callsiteWithScript = callsite as CallSiteWithScriptName;
+  const rawPath =
+    callsite.getFileName() ?? callsiteWithScript.getScriptNameOrSourceURL?.();
+  if (!rawPath) return null;
+  if (rawPath.startsWith("node:")) return null;
+  if (EVAL_FRAMES.has(rawPath)) return null;
+  return normalizePath(rawPath);
+};
+
+const isInternalCallsite = (callsite: NodeJS.CallSite): boolean => {
+  const functionName = callsite.getFunctionName();
+  if (functionName && INTERNAL_FRAME_NAMES.has(functionName)) return true;
+
+  const methodName = callsite.getMethodName();
+  if (methodName && INTERNAL_FRAME_NAMES.has(methodName)) return true;
+
+  const callsiteString = callsite.toString();
+  for (const frameName of INTERNAL_FRAME_NAMES) {
+    if (callsiteString.includes(`${frameName} (`)) return true;
+    if (callsiteString.includes(`.${frameName} (`)) return true;
+  }
+  return false;
+};
+
+const resolveCallerFilePath = (): string => {
+  const packageCandidates: string[] = [];
+  const fallbackCandidates: string[] = [];
+
+  for (const callsite of readCallsites()) {
+    const filePath = readCallsitePath(callsite);
+    if (!filePath) continue;
+    if (isInternalCallsite(callsite)) continue;
+    if (filePath.includes(PACKAGE_SEGMENT)) {
+      packageCandidates.push(filePath);
+      continue;
+    }
+    fallbackCandidates.push(filePath);
+  }
+
+  const packageCandidate = packageCandidates[0];
+  if (packageCandidate) return packageCandidate;
+
+  const fallbackCandidate = fallbackCandidates[0];
+  if (fallbackCandidate) return fallbackCandidate;
+
+  throw new Error("Unable to resolve caller file path.");
+};
+
+export const getCurrentFilePath = (): string => resolveCallerFilePath();
+
+export const getCurrentDirPath = (): string =>
+  path.dirname(getCurrentFilePath());
+
+export const getRepoRootDir = (): string => {
+  const currentFilePath = getCurrentFilePath();
+  const index = currentFilePath.lastIndexOf(PACKAGE_SEGMENT);
+  if (index === -1) {
+    throw new Error(
+      `Unable to determine repo root from ${currentFilePath} (missing ${PACKAGE_SEGMENT}).`,
+    );
+  }
+  return currentFilePath.slice(0, index);
+};
+
+export const getPackageRootDir = (): string =>
+  `${getRepoRootDir()}${PACKAGE_SEGMENT.slice(0, -1)}`;
+
+export const createRequireFromCaller = () =>
+  createRequire(getCurrentFilePath());
+
+export const isMainModule = (): boolean => {
+  const entryScript = process.argv.at(1);
+  if (!entryScript) return false;
+  return normalizePath(entryScript) === getCurrentFilePath();
+};
diff --git a/packages/server-v3/scripts/test-server.ts b/packages/server-v3/scripts/test-server.ts
new file mode 100644
index 000000000..bd967da9a
--- /dev/null
+++ b/packages/server-v3/scripts/test-server.ts
@@ -0,0 +1,399 @@
+/**
+ * Server unit + integration tests on dist/esm + SEA/local server targets.
+ *
+ * Prereqs:
+ * - pnpm run build (packages/server-v3/dist/tests + packages/server-v3/dist/server.js).
+ * - SEA integration still requires build:sea when STAGEHAND_SERVER_TARGET=sea.
+ *
+ * Args: [test paths...] -- [node --test args...] | --list (prints JSON matrix)
+ * Env: STAGEHAND_SERVER_TARGET=sea|local|remote, STAGEHAND_BASE_URL, SEA_BINARY_NAME,
+ *      NODE_TEST_CONSOLE_REPORTER, NODE_TEST_REPORTER, NODE_TEST_REPORTER_DESTINATION,
+ *      NODE_V8_COVERAGE; writes CTRF to ctrf/node-test-*.xml by default.
+ * Example: STAGEHAND_SERVER_TARGET=sea pnpm run test:server -- packages/server-v3/dist/tests/integration/v3/start.test.js
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+import { getRepoRootDir } from "./runtimePaths.js";
+
+const ensureParentDir = (filePath: string) => {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+};
+
+const splitArgs = (args: string[]) => {
+  const tokens = [...args];
+  while (tokens[0] === "--") {
+    tokens.shift();
+  }
+
+  const leadingExtra: string[] = [];
+  while (tokens.length > 0 && tokens[0].startsWith("-")) {
+    const arg = tokens.shift();
+    if (!arg) break;
+    if (arg === "--") break;
+    leadingExtra.push(arg);
+    if (
+      !arg.includes("=") &&
+      tokens[0] &&
+      tokens[0] !== "--" &&
+      !tokens[0].startsWith("-")
+    ) {
+      leadingExtra.push(tokens.shift() as string);
+    }
+  }
+
+  while (tokens[0] === "--") {
+    tokens.shift();
+  }
+
+  const separatorIndex = tokens.indexOf("--");
+  return {
+    paths: separatorIndex === -1 ? tokens : tokens.slice(0, separatorIndex),
+    extra: [
+      ...leadingExtra,
+      ...(separatorIndex === -1 ? [] : tokens.slice(separatorIndex + 1)),
+    ],
+  };
+};
+
+const toSafeName = (name: string) => name.replace(/[\\/]/g, "-");
+
+const collectFiles = (dir: string, suffix: string) => {
+  const results: string[] = [];
+  const walk = (current: string) => {
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const full = `${current}/${entry.name}`;
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile() && entry.name.endsWith(suffix)) {
+        results.push(full);
+      }
+    }
+  };
+  if (fs.existsSync(dir)) walk(dir);
+  return results.sort();
+};
+
+const repoRoot = getRepoRootDir();
+
+const writeCtrfFromJunit = (junitPath: string, tool: string) => {
+  if (!fs.existsSync(junitPath)) return;
+  const stat = fs.statSync(junitPath);
+  if (stat.size === 0) return;
+  const ctrfPath = junitPath.match(/\.xml$/i)
+    ? junitPath.replace(/\.xml$/i, ".json")
+    : `${junitPath}.json`;
+  const result = spawnSync(
+    "pnpm",
+    ["exec", "junit-to-ctrf", junitPath, "-o", ctrfPath, "-t", tool],
+    { stdio: "inherit", cwd: repoRoot },
+  );
+  if (result.status !== 0) {
+    console.warn(`CTRF conversion failed for ${junitPath}.`);
+  }
+};
+
+const sourceTestsDir = `${repoRoot}/packages/server-v3/test`;
+const sourceUnitDir = `${sourceTestsDir}/unit`;
+const sourceIntegrationDir = `${sourceTestsDir}/integration`;
+const unitDir = `${repoRoot}/packages/server-v3/dist/tests/unit`;
+const integrationDir = `${repoRoot}/packages/server-v3/dist/tests/integration`;
+const allTestsDir = `${repoRoot}/packages/server-v3/dist/tests`;
+
+const resolveRepoRelative = (value: string) =>
+  path.isAbsolute(value) ? value : path.resolve(repoRoot, value);
+
+const stripNodeReporterArgs = (argsList: string[]) => {
+  const filtered: string[] = [];
+  let removed = false;
+  for (let i = 0; i < argsList.length; i++) {
+    const arg = argsList[i];
+    if (
+      arg === "--test-reporter" ||
+      arg.startsWith("--test-reporter=") ||
+      arg === "--test-reporter-destination" ||
+      arg.startsWith("--test-reporter-destination=")
+    ) {
+      removed = true;
+      if (
+        (arg === "--test-reporter" || arg === "--test-reporter-destination") &&
+        argsList[i + 1]
+      ) {
+        i += 1;
+      }
+      continue;
+    }
+    filtered.push(arg);
+  }
+  return { filtered, removed };
+};
+
+const toTestName = (testPath: string, root: string) => {
+  const abs = resolveRepoRelative(testPath);
+  const rel = path.relative(root, abs).replaceAll("\\", "/");
+  if (!rel.startsWith("..")) {
+    return rel.replace(/\.test\.js$/i, "");
+  }
+  return path.basename(abs).replace(/\.test\.js$/i, "");
+};
+
+const rawArgs = process.argv.slice(2);
+const listRequested = rawArgs.includes("--list");
+
+if (listRequested) {
+  const unitTests = collectFiles(sourceUnitDir, ".test.ts").map((file) => {
+    const relSource = path.relative(sourceTestsDir, file).replaceAll("\\", "/");
+    const distPath = `${repoRoot}/packages/server-v3/dist/tests/${relSource.replace(/\.test\.ts$/, ".test.js")}`;
+    const name = path.basename(file, ".test.ts");
+    return {
+      path: path.relative(repoRoot, distPath).replaceAll("\\", "/"),
+      name,
+      safe_name: toSafeName(name),
+    };
+  });
+  const integrationTests = collectFiles(sourceIntegrationDir, ".test.ts").map(
+    (file) => {
+      const relSource = path
+        .relative(sourceTestsDir, file)
+        .replaceAll("\\", "/");
+      const distPath = `${repoRoot}/packages/server-v3/dist/tests/${relSource.replace(/\.test\.ts$/, ".test.js")}`;
+      const rel = path
+        .relative(sourceIntegrationDir, file)
+        .replaceAll("\\", "/")
+        .replace(/\.test\.ts$/, "");
+      return {
+        path: path.relative(repoRoot, distPath).replaceAll("\\", "/"),
+        name: rel,
+        safe_name: toSafeName(rel),
+      };
+    },
+  );
+  console.log(JSON.stringify([...unitTests, ...integrationTests]));
+  process.exit(0);
+}
+
+const { paths, extra } = splitArgs(rawArgs);
+const { filtered: extraArgs, removed: removedReporterOverride } =
+  stripNodeReporterArgs(extra);
+if (removedReporterOverride) {
+  console.warn(
+    "Ignoring node --test reporter overrides to preserve console + JUnit output.",
+  );
+}
+
+if (!fs.existsSync(allTestsDir)) {
+  console.error(
+    "Missing packages/server-v3/dist/tests. Run pnpm run build first.",
+  );
+  process.exit(1);
+}
+
+const serverTarget = (
+  process.env.STAGEHAND_SERVER_TARGET ?? "sea"
+).toLowerCase();
+const explicitBaseUrl = process.env.STAGEHAND_BASE_URL;
+const baseUrl = explicitBaseUrl ?? "http://stagehand-api.localhost:3107";
+
+if (serverTarget === "remote" && !explicitBaseUrl) {
+  console.error("Missing STAGEHAND_BASE_URL for remote server target.");
+  process.exit(1);
+}
+
+if (
+  serverTarget === "local" &&
+  !fs.existsSync(`${repoRoot}/packages/server-v3/dist/server.js`)
+) {
+  console.error(
+    "Missing packages/server-v3/dist/server.js. Run pnpm run build first.",
+  );
+  process.exit(1);
+}
+
+const parsedBaseUrl = new URL(baseUrl);
+const port =
+  parsedBaseUrl.port || (parsedBaseUrl.protocol === "https:" ? "443" : "80");
+
+process.env.PORT = port;
+process.env.STAGEHAND_API_URL = baseUrl;
+process.env.BB_ENV = process.env.BB_ENV ?? "local";
+
+const baseNodeOptions = "--enable-source-maps";
+const nodeOptions = [process.env.NODE_OPTIONS, baseNodeOptions]
+  .filter(Boolean)
+  .join(" ");
+
+const allPaths =
+  paths.length > 0
+    ? paths.map(resolveRepoRelative)
+    : [
+        ...collectFiles(unitDir, ".test.js"),
+        ...collectFiles(integrationDir, ".test.js"),
+      ];
+
+const unitPaths = allPaths.filter((p) =>
+  p.replaceAll("\\", "/").includes("/packages/server-v3/dist/tests/unit/"),
+);
+const integrationPaths = allPaths.filter((p) =>
+  p
+    .replaceAll("\\", "/")
+    .includes("/packages/server-v3/dist/tests/integration/"),
+);
+
+const singlePath = allPaths.length === 1 ? allPaths[0] : null;
+const coverageSuffix =
+  singlePath &&
+  singlePath.startsWith(`${repoRoot}/packages/server-v3/dist/tests/unit/`)
+    ? `server-unit/${path.basename(singlePath).replace(/\.test\.js$/, "")}`
+    : singlePath &&
+        singlePath.startsWith(
+          `${repoRoot}/packages/server-v3/dist/tests/integration/`,
+        )
+      ? `server-integration/${path
+          .relative(integrationDir, singlePath)
+          .replace(/\.test\.js$/, "")
+          .replaceAll("\\", "/")}`
+      : "server";
+
+const coverageRoot = resolveRepoRelative(
+  process.env.NODE_V8_COVERAGE ?? `${repoRoot}/coverage/${coverageSuffix}`,
+);
+const testsCoverage = `${coverageRoot}/tests`;
+const serverCoverage = `${coverageRoot}/server`;
+fs.mkdirSync(testsCoverage, { recursive: true });
+fs.mkdirSync(serverCoverage, { recursive: true });
+
+const consoleReporter = process.env.NODE_TEST_CONSOLE_REPORTER ?? "spec";
+const defaultReporter = process.env.NODE_TEST_REPORTER ?? "junit";
+const envDestination = process.env.NODE_TEST_REPORTER_DESTINATION
+  ? resolveRepoRelative(process.env.NODE_TEST_REPORTER_DESTINATION)
+  : null;
+
+const reporterArgsFor = (kind: "unit" | "integration", testName?: string) => {
+  const destination =
+    envDestination ??
+    `${repoRoot}/ctrf/${kind === "unit" ? "server-unit" : "server-integration"}/${testName ? `${testName}.xml` : "all.xml"}`;
+  ensureParentDir(destination);
+  return {
+    args: [
+      `--test-reporter=${consoleReporter}`,
+      `--test-reporter=${defaultReporter}`,
+      "--test-reporter-destination=stdout",
+      `--test-reporter-destination=${destination}`,
+    ],
+    destination,
+  };
+};
+
+const runNodeTests = (files: string[], reporterArgs: string[]) =>
+  spawnSync(
+    process.execPath,
+    ["--test", ...extraArgs, ...reporterArgs, ...files],
+    {
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        NODE_OPTIONS: nodeOptions,
+        NODE_V8_COVERAGE: testsCoverage,
+      },
+    },
+  );
+
+const waitForServer = async (url: string, timeoutMs = 30_000) => {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 2_000);
+      const res = await fetch(url, { signal: controller.signal });
+      clearTimeout(timer);
+      if (res.ok) return true;
+    } catch {
+      // retry
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1_000));
+  }
+  return false;
+};
+
+const startServer = async () => {
+  if (serverTarget === "remote") return null;
+  if (serverTarget === "local") {
+    return spawn(
+      process.execPath,
+      [`${repoRoot}/packages/server-v3/dist/server.js`],
+      {
+        stdio: "inherit",
+        env: {
+          ...process.env,
+          NODE_ENV: "development",
+          NODE_OPTIONS: nodeOptions,
+          NODE_V8_COVERAGE: serverCoverage,
+        },
+      },
+    );
+  }
+
+  const defaultName = `stagehand-server-v3-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`;
+  const seaBinary = `${repoRoot}/packages/server-v3/dist/sea/${process.env.SEA_BINARY_NAME ?? defaultName}`;
+
+  if (!fs.existsSync(seaBinary)) {
+    console.error(`SEA binary not found at ${seaBinary}`);
+    process.exit(1);
+  }
+
+  return spawn(seaBinary, ["--node-options=--no-lazy --enable-source-maps"], {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      NODE_ENV: "production",
+      NODE_V8_COVERAGE: serverCoverage,
+      STAGEHAND_SEA_CACHE_DIR:
+        process.env.STAGEHAND_SEA_CACHE_DIR ?? `${repoRoot}/.stagehand-sea`,
+    },
+  });
+};
+
+let serverProc: ReturnType<typeof spawn> | null = null;
+let status = 0;
+
+if (unitPaths.length > 0) {
+  const unitName =
+    unitPaths.length === 1 ? toTestName(unitPaths[0], unitDir) : undefined;
+  const reporter = reporterArgsFor("unit", unitName);
+  const result = runNodeTests(unitPaths, reporter.args);
+  status = result.status ?? 1;
+  writeCtrfFromJunit(reporter.destination, "node-test");
+}
+
+if (status === 0 && integrationPaths.length > 0) {
+  serverProc = await startServer();
+  const ready = await waitForServer(`${process.env.STAGEHAND_API_URL}/healthz`);
+  if (!ready) {
+    console.error("Server failed to start within 30 seconds.");
+    status = 1;
+  } else {
+    const integrationName =
+      integrationPaths.length === 1
+        ? toTestName(integrationPaths[0], integrationDir)
+        : undefined;
+    const reporter = reporterArgsFor("integration", integrationName);
+    const result = runNodeTests(integrationPaths, reporter.args);
+    status = result.status ?? 1;
+    writeCtrfFromJunit(reporter.destination, "node-test");
+  }
+}
+
+if (serverProc) {
+  serverProc.kill("SIGTERM");
+  await new Promise<void>((resolve) => {
+    if (serverProc?.exitCode !== null) return resolve();
+    const timer = setTimeout(resolve, 10_000);
+    serverProc?.once("exit", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+  await new Promise((resolve) => setTimeout(resolve, 5_000));
+}
+
+process.exit(status);
diff --git a/packages/server-v3/src/lib/InMemorySessionStore.ts b/packages/server-v3/src/lib/InMemorySessionStore.ts
new file mode 100644
index 000000000..5c8be3e86
--- /dev/null
+++ b/packages/server-v3/src/lib/InMemorySessionStore.ts
@@ -0,0 +1,366 @@
+import { randomUUID } from "crypto";
+import type { V3Options, LogLine } from "@browserbasehq/stagehand";
+import { V3 } from "@browserbasehq/stagehand";
+import type {
+  SessionStore,
+  CreateSessionParams,
+  RequestContext,
+  SessionCacheConfig,
+  SessionStartResult,
+} from "./SessionStore.js";
+
+const DEFAULT_MAX_CAPACITY = 100;
+const DEFAULT_TTL_MS = 0; // 0 = infinite (no TTL-based eviction)
+
+/**
+ * Internal node for LRU linked list
+ */
+interface LruNode {
+  sessionId: string;
+  params: CreateSessionParams;
+  stagehand: V3 | null;
+  loggerRef: { current?: (message: LogLine) => void };
+  expiry: number;
+  prev: LruNode | null;
+  next: LruNode | null;
+}
+
+/**
+ * In-memory implementation of SessionStore with full caching support.
+ *
+ * Features:
+ * - LRU eviction when at capacity
+ * - TTL-based expiration
+ * - Lazy V3 instance creation
+ * - Dynamic logger updates for streaming
+ * - Automatic cleanup of evicted sessions
+ *
+ * This is the default implementation used when no custom store is provided.
+ * For stateless pod architectures, use a database-backed implementation.
+ */
+export class InMemorySessionStore implements SessionStore {
+  private first: LruNode | null = null;
+  private last: LruNode | null = null;
+  private items: Map<string, LruNode> = new Map();
+  private maxCapacity: number;
+  private ttlMs: number;
+  private cleanupInterval: NodeJS.Timeout | null = null;
+
+  constructor(config?: SessionCacheConfig) {
+    this.maxCapacity = config?.maxCapacity ?? DEFAULT_MAX_CAPACITY;
+    this.ttlMs = config?.ttlMs ?? DEFAULT_TTL_MS;
+    this.startCleanupInterval();
+  }
+
+  /**
+   * Start periodic cleanup of expired sessions
+   */
+  private startCleanupInterval(): void {
+    // Run cleanup every minute
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupExpired();
+    }, 60_000);
+    // Allow process to exit gracefully even if this timer is still active
+    this.cleanupInterval.unref();
+  }
+
+  /**
+   * Cleanup expired sessions
+   */
+  private async cleanupExpired(): Promise<void> {
+    const now = Date.now();
+    const expiredIds: string[] = [];
+
+    for (const [sessionId, node] of this.items.entries()) {
+      if (this.ttlMs > 0 && node.expiry <= now) {
+        expiredIds.push(sessionId);
+      }
+    }
+
+    for (const sessionId of expiredIds) {
+      await this.deleteSession(sessionId);
+    }
+  }
+
+  /**
+   * Bump a node to the end of the LRU list (most recently used)
+   */
+  private bumpNode(node: LruNode): void {
+    // Update expiry
+    node.expiry = this.ttlMs > 0 ? Date.now() + this.ttlMs : Infinity;
+
+    if (this.last === node) {
+      return; // Already most recent
+    }
+
+    const { prev, next } = node;
+
+    // Unlink from current position
+    if (prev) prev.next = next;
+    if (next) next.prev = prev;
+    if (this.first === node) this.first = next;
+
+    // Link to end
+    node.prev = this.last;
+    node.next = null;
+    if (this.last) this.last.next = node;
+    this.last = node;
+
+    if (!this.first) this.first = node;
+  }
+
+  /**
+   * Evict the least recently used session
+   */
+  private async evictLru(): Promise<void> {
+    const lruNode = this.first;
+    if (!lruNode) return;
+
+    await this.deleteSession(lruNode.sessionId);
+  }
+
+  async startSession(params: CreateSessionParams): Promise<SessionStartResult> {
+    // Generate session ID or use provided browserbase session ID
+    const sessionId = params.browserbaseSessionID ?? randomUUID();
+
+    // Store the session
+    await this.createSession(sessionId, params);
+
+    return {
+      sessionId,
+      cdpUrl: params.connectUrl ?? "",
+      available: true,
+    };
+  }
+
+  async endSession(sessionId: string): Promise<void> {
+    await this.deleteSession(sessionId);
+  }
+
+  async hasSession(sessionId: string): Promise<boolean> {
+    const node = this.items.get(sessionId);
+    if (!node) return false;
+
+    // Check if expired
+    if (this.ttlMs > 0 && node.expiry <= Date.now()) {
+      await this.deleteSession(sessionId);
+      return false;
+    }
+
+    return true;
+  }
+
+  async getOrCreateStagehand(
+    sessionId: string,
+    ctx: RequestContext,
+  ): Promise<V3> {
+    const node = this.items.get(sessionId);
+
+    if (!node) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    // Check if expired
+    if (this.ttlMs > 0 && node.expiry <= Date.now()) {
+      await this.deleteSession(sessionId);
+      throw new Error(`Session expired: ${sessionId}`);
+    }
+
+    // Bump to most recently used
+    this.bumpNode(node);
+
+    // Update logger reference for this request
+    if (ctx.logger) {
+      node.loggerRef.current = ctx.logger;
+    }
+
+    // If V3 instance exists, return it
+    if (node.stagehand) {
+      return node.stagehand;
+    }
+
+    // Create V3 instance (lazy initialization)
+    const options = this.buildV3Options(node.params, ctx, node.loggerRef);
+    const stagehand = new V3(options);
+    try {
+      await stagehand.init();
+    } catch (error) {
+      try {
+        await stagehand.close();
+      } catch {
+        // best-effort cleanup for failed init attempts
+      }
+      throw error;
+    }
+    node.stagehand = stagehand;
+    return stagehand;
+  }
+
+  /**
+   * Build V3Options from stored params and request context
+   */
+  private buildV3Options(
+    params: CreateSessionParams,
+    ctx: RequestContext,
+    loggerRef: { current?: (message: LogLine) => void },
+  ): V3Options {
+    const isBrowserbase = params.browserType === "browserbase";
+
+    const options: V3Options = {
+      env: isBrowserbase ? "BROWSERBASE" : "LOCAL",
+      model: {
+        modelName: params.modelName,
+        apiKey: ctx.modelApiKey,
+      },
+      verbose: params.verbose,
+      systemPrompt: params.systemPrompt,
+      selfHeal: params.selfHeal,
+      domSettleTimeout: params.domSettleTimeoutMs,
+      experimental: params.experimental,
+      // Wrap logger to use the ref so it can be updated per-request
+      logger: (message: LogLine) => {
+        if (loggerRef.current) {
+          loggerRef.current(message);
+        }
+      },
+    };
+
+    if (isBrowserbase) {
+      options.apiKey = params.browserbaseApiKey;
+      options.projectId = params.browserbaseProjectId;
+
+      if (params.browserbaseSessionID) {
+        options.browserbaseSessionID = params.browserbaseSessionID;
+      }
+
+      if (params.browserbaseSessionCreateParams) {
+        options.browserbaseSessionCreateParams =
+          params.browserbaseSessionCreateParams;
+      }
+    } else if (params.localBrowserLaunchOptions) {
+      options.localBrowserLaunchOptions = params.localBrowserLaunchOptions;
+    }
+
+    return options;
+  }
+
+  async createSession(
+    sessionId: string,
+    params: CreateSessionParams,
+  ): Promise<void> {
+    // Check if already exists
+    if (this.items.has(sessionId)) {
+      throw new Error(`Session already exists: ${sessionId}`);
+    }
+
+    // Evict LRU if at capacity
+    if (this.maxCapacity > 0 && this.items.size >= this.maxCapacity) {
+      await this.evictLru();
+    }
+
+    // Create new node
+    const node: LruNode = {
+      sessionId,
+      params,
+      stagehand: null, // Lazy initialization
+      loggerRef: {},
+      expiry: this.ttlMs > 0 ? Date.now() + this.ttlMs : Infinity,
+      prev: this.last,
+      next: null,
+    };
+
+    this.items.set(sessionId, node);
+
+    // Link to end of list
+    if (this.last) this.last.next = node;
+    this.last = node;
+    if (!this.first) this.first = node;
+  }
+
+  async deleteSession(sessionId: string): Promise<void> {
+    const node = this.items.get(sessionId);
+    if (!node) return;
+
+    // Close V3 instance if it exists
+    if (node.stagehand) {
+      try {
+        await node.stagehand.close();
+      } catch (error) {
+        console.error(
+          `Error closing stagehand for session ${sessionId}:`,
+          error,
+        );
+      }
+    }
+
+    // Remove from map
+    this.items.delete(sessionId);
+
+    // Unlink from list
+    const { prev, next } = node;
+    if (prev) prev.next = next;
+    if (next) next.prev = prev;
+    if (this.first === node) this.first = next;
+    if (this.last === node) this.last = prev;
+  }
+
+  async getSessionConfig(sessionId: string): Promise<CreateSessionParams> {
+    const node = this.items.get(sessionId);
+
+    if (!node) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    // Return the stored params (contains browser metadata needed downstream)
+    return node.params;
+  }
+
+  updateCacheConfig(config: SessionCacheConfig): void {
+    if (config.maxCapacity !== undefined) {
+      if (config.maxCapacity <= 0) {
+        throw new Error("Max capacity must be greater than 0");
+      }
+      const previousCapacity = this.maxCapacity;
+      this.maxCapacity = config.maxCapacity;
+
+      // Evict excess if new capacity is smaller
+      if (this.maxCapacity < previousCapacity) {
+        const excess = this.items.size - this.maxCapacity;
+        for (let i = 0; i < excess; i++) {
+          // Fire and forget - don't await to match cloud behavior
+          this.evictLru().catch(console.error);
+        }
+      }
+    }
+
+    if (config.ttlMs !== undefined) {
+      this.ttlMs = config.ttlMs;
+    }
+  }
+
+  getCacheConfig(): SessionCacheConfig {
+    return {
+      maxCapacity: this.maxCapacity,
+      ttlMs: this.ttlMs,
+    };
+  }
+
+  async destroy(): Promise<void> {
+    // Stop cleanup interval
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+
+    // Close all V3 instances
+    const sessionIds = Array.from(this.items.keys());
+    await Promise.all(sessionIds.map((id) => this.deleteSession(id)));
+  }
+
+  /**
+   * Get the number of cached sessions
+   */
+  get size(): number {
+    return this.items.size;
+  }
+}
diff --git a/packages/server-v3/src/lib/SessionStore.ts b/packages/server-v3/src/lib/SessionStore.ts
new file mode 100644
index 000000000..387cb856f
--- /dev/null
+++ b/packages/server-v3/src/lib/SessionStore.ts
@@ -0,0 +1,184 @@
+import type {
+  Api,
+  LocalBrowserLaunchOptions,
+  LogLine,
+  V3,
+} from "@browserbasehq/stagehand";
+
+/**
+ * Result from SessionStore.startSession().
+ */
+export type SessionStartResult = Api.SessionStartResult;
+
+/**
+ * Parameters for creating a new session.
+ * This is what gets persisted - a subset of StartSessionParams
+ * that excludes runtime-only values like modelApiKey.
+ *
+ * Includes cloud-specific fields that pass through to cloud implementations.
+ * The library ignores fields it doesn't need, but they're available to SessionStore.
+ */
+export interface CreateSessionParams {
+  /** Browser choice for this session */
+  browserType: "local" | "browserbase";
+  /** Model name (e.g., "openai/gpt-4o") */
+  modelName: string;
+  /** Verbosity level */
+  verbose?: 0 | 1 | 2;
+  /** Custom system prompt */
+  systemPrompt?: string;
+  /** Enable self-healing for failed actions */
+  selfHeal?: boolean;
+  /** DOM settle timeout in milliseconds */
+  domSettleTimeoutMs?: number;
+  /** Enable experimental features */
+  experimental?: boolean;
+
+  // Browserbase-specific (used by cloud implementations)
+  /** Browserbase API key */
+  browserbaseApiKey?: string;
+  /** Browserbase project ID */
+  browserbaseProjectId?: string;
+  /** Existing Browserbase session ID to connect to */
+  browserbaseSessionID?: string;
+  /** Wait for captcha solves */
+  waitForCaptchaSolves?: boolean;
+  /** Browserbase session creation params */
+  browserbaseSessionCreateParams?: Record<string, unknown>;
+  /** Local browser launch overrides when browserType is local */
+  localBrowserLaunchOptions?: LocalBrowserLaunchOptions;
+
+  /** WebSocket URL for connecting to the browser (returned to client) */
+  connectUrl?: string;
+
+  // Cloud-specific metadata fields
+  /** Act timeout in milliseconds */
+  actTimeoutMs?: number;
+  /** Client language (typescript, python, playground) */
+  clientLanguage?: string;
+  /** SDK version */
+  sdkVersion?: string;
+}
+
+/**
+ * Request-time context passed when resolving a session.
+ * Contains values that come from request headers rather than storage.
+ */
+export interface RequestContext {
+  /** Model API key (from x-model-api-key header) */
+  modelApiKey?: string;
+  /** Logger function for this request */
+  logger?: (message: LogLine) => void;
+}
+
+/**
+ * Configuration options for session cache behavior.
+ */
+export interface SessionCacheConfig {
+  /** Maximum number of sessions to cache. Default: 100 */
+  maxCapacity?: number;
+  /** TTL for cached sessions in milliseconds. Default: 300000 (5 minutes) */
+  ttlMs?: number;
+}
+
+/**
+ * SessionStore interface for managing session lifecycle and V3 instances.
+ *
+ * The library provides an InMemorySessionStore as the default implementation
+ * with full caching support (TTL, LRU eviction, etc.).
+ *
+ * Cloud environments can implement this interface to:
+ * - Persist session config to a database
+ * - Use custom caching strategies (e.g., LaunchDarkly-driven config)
+ * - Add eviction hooks for cleanup
+ * - Handle platform-specific session lifecycle (e.g., Browserbase)
+ *
+ * This enables stateless pod architectures where any pod can handle any request.
+ */
+export interface SessionStore {
+  /**
+   * Start a new session.
+   *
+   * This is the main entry point for session creation. Implementations can:
+   * - Create platform-specific resources (e.g., Browserbase session)
+   * - Persist session config to storage
+   * - Check feature flags for availability
+   *
+   * @param params - Session configuration
+   * @returns Session ID and availability status
+   */
+  startSession(params: CreateSessionParams): Promise<SessionStartResult>;
+
+  /**
+   * End a session and cleanup all resources.
+   *
+   * This is the main entry point for session cleanup. Implementations can:
+   * - Close platform-specific resources (e.g., Browserbase session)
+   * - Evict V3 instance from cache
+   * - Update session status in storage
+   *
+   * @param sessionId - The session identifier
+   */
+  endSession(sessionId: string): Promise<void>;
+
+  /**
+   * Check if a session exists.
+   * @param sessionId - The session identifier
+   * @returns true if the session exists
+   */
+  hasSession(sessionId: string): Promise<boolean>;
+
+  /**
+   * Get or create a V3 instance for a session.
+   *
+   * This method handles:
+   * - Checking the cache for an existing V3 instance
+   * - On cache miss: loading config, creating V3, caching it
+   * - Updating the logger reference for streaming
+   *
+   * @param sessionId - The session identifier
+   * @param ctx - Request-time context containing values from headers
+   * @returns The V3 instance ready for use
+   * @throws Error if session not found
+   */
+  getOrCreateStagehand(sessionId: string, ctx: RequestContext): Promise<V3>;
+
+  /**
+   * Create a new session with the given parameters.
+   * Lower-level than startSession - just stores the config.
+   * @param sessionId - The session identifier
+   * @param params - Session configuration to persist
+   */
+  createSession(sessionId: string, params: CreateSessionParams): Promise<void>;
+
+  /**
+   * Delete a session from cache and close V3 instance.
+   * Lower-level than endSession - just handles cache cleanup.
+   * @param sessionId - The session identifier
+   */
+  deleteSession(sessionId: string): Promise<void>;
+
+  /**
+   * Retrieve the stored session configuration for a given session.
+   * @param sessionId - The session identifier
+   */
+  getSessionConfig(sessionId: string): Promise<CreateSessionParams>;
+
+  /**
+   * Update cache configuration dynamically.
+   * @param config - New cache configuration values
+   */
+  updateCacheConfig?(config: SessionCacheConfig): void;
+
+  /**
+   * Get current cache configuration.
+   * @returns Current cache config
+   */
+  getCacheConfig?(): SessionCacheConfig;
+
+  /**
+   * Cleanup all resources (close all V3 instances, stop timers).
+   * Called when shutting down the server.
+   */
+  destroy(): Promise<void>;
+}
diff --git a/packages/server-v3/src/lib/auth.ts b/packages/server-v3/src/lib/auth.ts
new file mode 100644
index 000000000..9eb7428b7
--- /dev/null
+++ b/packages/server-v3/src/lib/auth.ts
@@ -0,0 +1,14 @@
+import type { FastifyRequest } from "fastify";
+
+export const authMiddleware = async (
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  request: FastifyRequest,
+): Promise<boolean> => {
+  // Authentication is currently disabled; we may re-enable when a real auth backend is wired up.
+  return await isAuthenticated();
+};
+
+// TODO: Temporarily disable auth until setup in supabase
+const isAuthenticated = async (): Promise<boolean> => {
+  return true;
+};
diff --git a/packages/server-v3/src/lib/env.ts b/packages/server-v3/src/lib/env.ts
new file mode 100644
index 000000000..919732532
--- /dev/null
+++ b/packages/server-v3/src/lib/env.ts
@@ -0,0 +1,18 @@
+import { createEnv } from "@t3-oss/env-core";
+import { z } from "zod/v4";
+
+// Temporarily defining here until browserbase zod package is updated to 3.25.0+
+const bbEnvSchema = z.enum(["local", "dev", "prod"]);
+
+export const env = createEnv({
+  server: {
+    NODE_ENV: z.enum(["development", "production", "staging", "test"]),
+    BB_ENV: bbEnvSchema,
+  },
+  client: {},
+  clientPrefix: "PUBLIC_",
+  runtimeEnv: {
+    NODE_ENV: process.env.NODE_ENV ?? "production",
+    BB_ENV: process.env.BB_ENV ?? "local",
+  },
+});
diff --git a/packages/server-v3/src/lib/errorHandler.ts b/packages/server-v3/src/lib/errorHandler.ts
new file mode 100644
index 000000000..1e533fe03
--- /dev/null
+++ b/packages/server-v3/src/lib/errorHandler.ts
@@ -0,0 +1,70 @@
+import type {
+  FastifyReply,
+  FastifyRequest,
+  RouteGenericInterface,
+} from "fastify";
+import { StatusCodes } from "http-status-codes";
+
+import { error } from "./response.js";
+
+export class AppError extends Error {
+  statusCode: number;
+  isInternal: boolean;
+
+  constructor(
+    message: string,
+    statusCode = StatusCodes.BAD_REQUEST,
+    isInternal = false,
+  ) {
+    super(message);
+    this.statusCode = statusCode;
+    this.isInternal = isInternal;
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+  }
+
+  /**
+   * Get the message safe to send to clients.
+   * For internal errors (5xx), returns generic message.
+   * For client errors (4xx), returns actual message.
+   */
+  getClientMessage(): string {
+    if (this.isInternal) {
+      return this.statusCode >= StatusCodes.INTERNAL_SERVER_ERROR
+        ? "An internal server error occurred"
+        : "An error occurred while processing your request";
+    }
+    return this.message;
+  }
+}
+
+/**
+ * Wraps a route handler with error handling
+ * @param handler The route handler to wrap
+ * @returns A wrapped route handler that catches errors
+ */
+export function withErrorHandling<
+  T extends RouteGenericInterface = RouteGenericInterface,
+  R = unknown,
+>(handler: (request: FastifyRequest<T>, reply: FastifyReply) => Promise<R>) {
+  return async (
+    request: FastifyRequest<T>,
+    reply: FastifyReply,
+  ): Promise<R | FastifyReply> => {
+    try {
+      return await handler(request, reply);
+    } catch (err) {
+      request.log.error(err);
+
+      if (err instanceof AppError) {
+        return error(reply, err.getClientMessage(), err.statusCode);
+      }
+
+      return error(
+        reply,
+        "An internal server error occurred",
+        StatusCodes.INTERNAL_SERVER_ERROR,
+      );
+    }
+  };
+}
diff --git a/packages/server-v3/src/lib/header.ts b/packages/server-v3/src/lib/header.ts
new file mode 100644
index 000000000..daf1f6b62
--- /dev/null
+++ b/packages/server-v3/src/lib/header.ts
@@ -0,0 +1,99 @@
+import type { FastifyRequest } from "fastify";
+
+import { MissingHeaderError } from "../types/error.js";
+
+export const dangerouslyGetHeader = (
+  request: FastifyRequest,
+  header: string,
+): string => {
+  const headerValue = request.headers[header];
+
+  if (!headerValue) {
+    throw new MissingHeaderError(header);
+  }
+  if (Array.isArray(headerValue)) {
+    const [value] = headerValue;
+    if (!value) {
+      throw new MissingHeaderError(header);
+    }
+    return value;
+  }
+  return headerValue;
+};
+
+export const getOptionalHeader = (
+  request: FastifyRequest,
+  header: string,
+): string | undefined => {
+  const headerValue = request.headers[header];
+  if (!headerValue) {
+    return undefined;
+  }
+  if (Array.isArray(headerValue)) {
+    const [value] = headerValue;
+    if (!value) {
+      return undefined;
+    }
+    return value;
+  }
+  return headerValue;
+};
+
+/**
+ * Extracts model name from request body, supporting V3 structure.
+ * - V3: body.options.model.modelName
+ */
+export function getModelName(request: FastifyRequest): string | undefined {
+  const body = request.body as Record<string, unknown> | undefined;
+  const options = body?.options as Record<string, unknown> | undefined;
+  const model = options?.model as Record<string, unknown> | undefined;
+
+  if (typeof model?.modelName === "string" && model.modelName) {
+    return model.modelName;
+  }
+
+  if (typeof body?.modelName === "string" && body.modelName) {
+    return body.modelName;
+  }
+
+  return undefined;
+}
+
+/**
+ * Extracts the model API key with precedence:
+ * 1. Per-request body apiKey (V3: body.options.model.apiKey)
+ * 2. Per-request header x-model-api-key
+ */
+export function getModelApiKey(request: FastifyRequest): string | undefined {
+  const body = request.body as Record<string, unknown> | undefined;
+  const options = body?.options as Record<string, unknown> | undefined;
+  const model = options?.model as Record<string, unknown> | undefined;
+
+  if (typeof model?.apiKey === "string" && model.apiKey) {
+    return model.apiKey;
+  }
+
+  return getOptionalHeader(request, "x-model-api-key");
+}
+
+/**
+ * Extracts the stream response value from either the request header or body.
+ * Body parameter takes precedence over header.
+ * Defaults to false (non-streaming) if neither is provided.
+ */
+export function shouldRespondWithSSE(request: FastifyRequest): boolean {
+  const body = request.body as Record<string, unknown> | undefined;
+  if (typeof body?.streamResponse === "boolean") {
+    return body.streamResponse;
+  }
+  if (typeof body?.streamResponse === "string") {
+    return body.streamResponse.toLowerCase() === "true";
+  }
+
+  const streamHeader = getOptionalHeader(request, "x-stream-response");
+  if (streamHeader) {
+    return streamHeader.toLowerCase() === "true";
+  }
+
+  return false;
+}
diff --git a/packages/server-v3/src/lib/logging/index.ts b/packages/server-v3/src/lib/logging/index.ts
new file mode 100644
index 000000000..c680c1bf0
--- /dev/null
+++ b/packages/server-v3/src/lib/logging/index.ts
@@ -0,0 +1,59 @@
+import { FastifyInstance } from "fastify";
+
+import { env } from "../../lib/env.js";
+
+// List of routes to ignore for request logging in local environments
+const ignoredRoutes = ["/healthz", "/readyz"];
+
+// Helper function to determine if a request should be logged
+const shouldLog = (url: string) => {
+  return env.BB_ENV !== "local" || !ignoredRoutes.includes(url);
+};
+
+const logging = (app: FastifyInstance) => {
+  // Add request logging hooks
+  app.addHook("onRequest", (req, _reply, done) => {
+    // Add request ID to response headers
+    if (shouldLog(req.url)) {
+      req.log.info(
+        {
+          req: {
+            host: req.hostname,
+            method: req.method,
+            remoteAddress: req.ip,
+            remotePort: req.socket.remotePort,
+            url: req.url,
+          },
+          reqId: req.id,
+        },
+        "incoming request",
+      );
+    }
+    done();
+  });
+
+  app.addHook("onResponse", (req, reply, done) => {
+    if (shouldLog(req.url)) {
+      req.log.info(
+        {
+          reqId: req.id,
+          req: {
+            host: req.hostname,
+            method: req.method,
+            remoteAddress: req.ip,
+            remotePort: req.socket.remotePort,
+            url: req.url,
+          },
+          res: {
+            statusCode: reply.statusCode,
+          },
+          responseTime: reply.elapsedTime,
+        },
+        "request completed",
+      );
+    }
+    done();
+  });
+};
+
+export { logging };
diff --git a/packages/server-v3/src/lib/response.ts b/packages/server-v3/src/lib/response.ts
new file mode 100644
index 000000000..94bd2aeb3
--- /dev/null
+++ b/packages/server-v3/src/lib/response.ts
@@ -0,0 +1,48 @@
+import type { FastifyReply } from "fastify";
+import { StatusCodes } from "http-status-codes";
+
+interface SuccessResponse<T> {
+  success: true;
+  data: T;
+}
+
+interface ErrorResponse {
+  success: false;
+  message: string;
+}
+
+type ApiResponse<T> = SuccessResponse<T> | ErrorResponse;
+
+export function success<T>(
+  reply: FastifyReply,
+  data: T,
+  status = StatusCodes.OK,
+): FastifyReply {
+  return reply.status(status).send({
+    success: true,
+    data,
+  });
+}
+
+export function error(
+  reply: FastifyReply,
+  message: string,
+  status = StatusCodes.BAD_REQUEST,
+): FastifyReply {
+  return reply.status(status).send({
+    success: false,
+    message,
+  });
+}
+
+export function isSuccessResponse<T>(
+  response: ApiResponse<T>,
+): response is SuccessResponse<T> {
+  return response.success;
+}
+
+export function isErrorResponse(
+  response: ApiResponse<unknown>,
+): response is ErrorResponse {
+  return !response.success;
+}
diff --git a/packages/server-v3/src/lib/sessionStoreManager.ts b/packages/server-v3/src/lib/sessionStoreManager.ts
new file mode 100644
index 000000000..1bd840e21
--- /dev/null
+++ b/packages/server-v3/src/lib/sessionStoreManager.ts
@@ -0,0 +1,27 @@
+import { InMemorySessionStore } from "./InMemorySessionStore.js";
+import type { SessionCacheConfig, SessionStore } from "./SessionStore.js";
+
+let sessionStore: SessionStore | null = null;
+
+export function initializeSessionStore(
+  config?: SessionCacheConfig,
+): SessionStore {
+  if (!sessionStore) {
+    sessionStore = new InMemorySessionStore(config);
+  }
+  return sessionStore;
+}
+
+export function getSessionStore(): SessionStore {
+  if (!sessionStore) {
+    throw new Error("Session store has not been initialized");
+  }
+  return sessionStore;
+}
+
+export async function destroySessionStore(): Promise<void> {
+  if (sessionStore) {
+    await sessionStore.destroy();
+    sessionStore = null;
+  }
+}
diff --git a/packages/server-v3/src/lib/stream.ts b/packages/server-v3/src/lib/stream.ts
new file mode 100644
index 000000000..4866e41f1
--- /dev/null
+++ b/packages/server-v3/src/lib/stream.ts
@@ -0,0 +1,195 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import type { Stagehand as V3Stagehand } from "@browserbasehq/stagehand";
+import { v4 } from "uuid";
+import { z } from "zod/v4";
+
+import { AppError } from "./errorHandler.js";
+import {
+  getModelApiKey,
+  getOptionalHeader,
+  shouldRespondWithSSE,
+} from "./header.js";
+import { error, success } from "./response.js";
+import { getSessionStore } from "./sessionStoreManager.js";
+import type { RequestContext } from "./SessionStore.js";
+
+interface StreamingResponseOptions<TV3> {
+  sessionId: string;
+  request: FastifyRequest;
+  reply: FastifyReply;
+  schema: z.ZodType<TV3>;
+  handler: (ctx: {
+    stagehand: V3Stagehand;
+    data: TV3;
+  }) => Promise<{ result: unknown; actionId?: string }>;
+  operation?: string;
+}
+
+export async function createStreamingResponse<TV3>({
+  sessionId,
+  request,
+  reply,
+  schema,
+  handler,
+  operation,
+}: StreamingResponseOptions<TV3>) {
+  const shouldStreamResponse = shouldRespondWithSSE(request);
+  const modelApiKey = getModelApiKey(request);
+
+  const sessionStore = getSessionStore();
+  const sessionConfig = await sessionStore.getSessionConfig(sessionId);
+  const browserType = sessionConfig.browserType ?? "local";
+
+  let browserbaseApiKey = sessionConfig.browserbaseApiKey;
+  let browserbaseProjectId = sessionConfig.browserbaseProjectId;
+
+  if (browserType === "browserbase") {
+    browserbaseApiKey =
+      browserbaseApiKey ?? getOptionalHeader(request, "x-bb-api-key");
+    browserbaseProjectId =
+      browserbaseProjectId ?? getOptionalHeader(request, "x-bb-project-id");
+
+    if (!browserbaseApiKey || !browserbaseProjectId) {
+      return reply.status(StatusCodes.BAD_REQUEST).send({
+        error:
+          "Browserbase API key and project ID are required for browserbase sessions",
+      });
+    }
+  }
+
+  // Parse data using V3 schema
+  let parsedData: TV3;
+
+  try {
+    const json: unknown = request.body;
+    parsedData = await schema.parseAsync(json);
+  } catch (err) {
+    const parseError = err as Error | z.ZodError;
+
+    if (parseError instanceof z.ZodError) {
+      return reply.status(StatusCodes.BAD_REQUEST).send({
+        error: parseError.issues.map((issue) => ({
+          path: issue.path[0],
+          message: issue.message,
+        })),
+      });
+    }
+
+    return reply
+      .status(StatusCodes.BAD_REQUEST)
+      .send({ error: parseError.message });
+  }
+
+  if (shouldStreamResponse) {
+    try {
+      reply.raw.writeHead(StatusCodes.OK, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+        "Transfer-Encoding": "chunked",
+        "X-Accel-Buffering": "no",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers": "*",
+      });
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (_err) {
+      return error(
+        reply,
+        "Failed to write head",
+        StatusCodes.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
+  const sendData = (type: string, data: object) => {
+    if (!shouldStreamResponse) {
+      return;
+    }
+
+    reply.raw.write(`data: ${JSON.stringify({ data, type, id: v4() })}\n\n`);
+  };
+
+  const actionId = v4();
+
+  sendData("system", { status: "starting" });
+
+  const requestContext: RequestContext = {
+    modelApiKey,
+    logger: shouldStreamResponse
+      ? (message) => {
+          sendData("log", { status: "running", message });
+        }
+      : undefined,
+  };
+
+  let stagehand: V3Stagehand;
+  try {
+    stagehand = (await sessionStore.getOrCreateStagehand(
+      sessionId,
+      requestContext,
+    )) as V3Stagehand;
+  } catch (err) {
+    const loadError = err instanceof Error ? err : new Error(String(err));
+
+    sendData("system", { status: "error", error: loadError.message });
+
+    if (shouldStreamResponse) {
+      reply.raw.end();
+      return reply;
+    }
+
+    return error(
+      reply,
+      loadError.message,
+      loadError instanceof AppError
+        ? loadError.statusCode
+        : StatusCodes.INTERNAL_SERVER_ERROR,
+    );
+  }
+
+  sendData("system", { status: "connected" });
+
+  let result: Awaited<ReturnType<typeof handler>> | null = null;
+  let handlerError: Error | null = null;
+
+  try {
+    result = await handler({ stagehand, data: parsedData });
+  } catch (err) {
+    handlerError = err instanceof Error ? err : new Error("Unknown error");
+  }
+
+  if (handlerError) {
+    const clientMessage =
+      handlerError instanceof AppError
+        ? handlerError.getClientMessage()
+        : `${operation ?? "operation"} failed`;
+
+    sendData("system", { status: "error", error: clientMessage });
+
+    if (shouldStreamResponse) {
+      reply.raw.end();
+      return reply;
+    }
+
+    const statusCode =
+      handlerError instanceof AppError
+        ? handlerError.statusCode
+        : StatusCodes.INTERNAL_SERVER_ERROR;
+    return error(reply, clientMessage, statusCode);
+  }
+
+  sendData("system", {
+    status: "finished",
+    result: result?.result,
+    actionId,
+  });
+
+  if (shouldStreamResponse) {
+    reply.raw.end();
+    return reply;
+  }
+
+  return success(reply, { result: result?.result, actionId });
+}
diff --git a/packages/server-v3/src/lib/utils.ts b/packages/server-v3/src/lib/utils.ts
new file mode 100644
index 000000000..c736adc64
--- /dev/null
+++ b/packages/server-v3/src/lib/utils.ts
@@ -0,0 +1,220 @@
+import { StatusCodes } from "http-status-codes";
+import { z } from "zod/v3";
+import type { ZodTypeAny } from "zod/v3";
+
+import { LegacyModel, LegacyProvider } from "../types/model.js";
+import { AppError } from "./errorHandler.js";
+
+interface JSONSchema {
+  type?: string | string[];
+  properties?: Record<string, JSONSchema>;
+  required?: string[];
+  description?: string;
+  items?: JSONSchema;
+  enum?: string[];
+  minimum?: number;
+  maximum?: number;
+  format?: "uri" | "url" | "email" | "uuid";
+  anyOf?: JSONSchema[];
+  oneOf?: JSONSchema[];
+  allOf?: JSONSchema[];
+}
+
+/**
+ * Converts a JSON Schema object to a Zod schema.
+ * @param schema The JSON Schema object to convert
+ * @returns A Zod schema equivalent to the input JSON Schema
+ */
+export function jsonSchemaToZod(schema: JSONSchema): ZodTypeAny {
+  if (Array.isArray(schema.type)) {
+    const subSchemas = schema.type.map((singleType) => {
+      const sub = { ...schema, type: singleType };
+      return jsonSchemaToZod(sub);
+    });
+
+    if (subSchemas.length === 0) {
+      return z.any();
+    } else if (subSchemas.length === 1) {
+      const [subSchema] = subSchemas;
+      if (!subSchema) {
+        return z.any();
+      }
+      return subSchema;
+    }
+    return z.union(subSchemas as [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]);
+  }
+
+  if (schema.anyOf && Array.isArray(schema.anyOf)) {
+    const subSchemas = schema.anyOf.map((sub) => jsonSchemaToZod(sub));
+    if (subSchemas.length === 0) {
+      return z.any();
+    } else if (subSchemas.length === 1) {
+      const [subSchema] = subSchemas;
+      if (!subSchema) {
+        return z.any();
+      }
+      return subSchema;
+    }
+    return z.union(subSchemas as [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]);
+  }
+
+  if (schema.oneOf && Array.isArray(schema.oneOf)) {
+    const subSchemas = schema.oneOf.map((sub) => jsonSchemaToZod(sub));
+    if (subSchemas.length === 0) {
+      return z.any();
+    } else if (subSchemas.length === 1) {
+      const [subSchema] = subSchemas;
+      if (!subSchema) {
+        return z.any();
+      }
+      return subSchema;
+    }
+    return z.union(subSchemas as [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]);
+  }
+
+  switch (schema.type) {
+    case "object":
+      if (schema.properties) {
+        const shape: Record<string, ZodTypeAny> = {};
+        for (const key in schema.properties) {
+          const subSchema = schema.properties[key];
+          if (!subSchema) {
+            throw new AppError(
+              `Property ${key} is not defined in the schema`,
+              StatusCodes.BAD_REQUEST,
+            );
+          }
+          shape[key] = jsonSchemaToZod(subSchema);
+        }
+        let zodObject = z.object(shape);
+
+        if (schema.required && Array.isArray(schema.required)) {
+          const requiredFields = schema.required.reduce<Record<string, true>>(
+            (acc, key) => {
+              acc[key] = true;
+              return acc;
+            },
+            {},
+          );
+          zodObject = zodObject.partial().required(requiredFields);
+        }
+
+        if (schema.description) {
+          zodObject = zodObject.describe(schema.description);
+        }
+        return zodObject;
+      }
+
+      return z.object({});
+
+    case "array":
+      if (schema.items) {
+        let zodArray = z.array(jsonSchemaToZod(schema.items));
+        if (schema.description) {
+          zodArray = zodArray.describe(schema.description);
+        }
+        return zodArray;
+      }
+      return z.array(z.any());
+
+    case "string": {
+      if (schema.enum) {
+        return z.string().refine((val) => schema.enum?.includes(val) ?? false);
+      }
+      let zodString = z.string();
+
+      switch (schema.format) {
+        case "uri":
+        case "url":
+          zodString = zodString.url();
+          break;
+        case "email":
+          zodString = zodString.email();
+          break;
+        case "uuid":
+          zodString = zodString.uuid();
+          break;
+        default:
+      }
+
+      if (schema.description) {
+        zodString = zodString.describe(schema.description);
+      }
+      return zodString;
+    }
+
+    case "integer": // integer is a subset of number
+    case "number": {
+      let zodNumber = z.number();
+      if (schema.minimum !== undefined) {
+        zodNumber = zodNumber.min(schema.minimum);
+      }
+      if (schema.maximum !== undefined) {
+        zodNumber = zodNumber.max(schema.maximum);
+      }
+      if (schema.description) {
+        zodNumber = zodNumber.describe(schema.description);
+      }
+      return zodNumber;
+    }
+
+    case "boolean": {
+      let zodBoolean = z.boolean();
+      if (schema.description) {
+        zodBoolean = zodBoolean.describe(schema.description);
+      }
+      return zodBoolean;
+    }
+
+    case "null": {
+      let zodNull = z.null();
+      if (schema.description) {
+        zodNull = zodNull.describe(schema.description);
+      }
+      return zodNull;
+    }
+
+    default:
+      // fallback if no recognized schema.type is present
+      return z.any();
+  }
+}
+
+// This function is legacy and will not be required after complete AISDK migration
+export function mapModelToProvider(model: LegacyModel): LegacyProvider {
+  switch (model) {
+    case "gpt-4o":
+    case "gpt-4o-mini":
+    case "gpt-4o-2024-08-06":
+    case "gpt-4o-2024-05-13":
+    case "o1-mini":
+    case "o1-preview":
+    case "gpt-4.5-preview":
+    case "o3-mini":
+      return "openai";
+    case "gemini-1.5-flash":
+    case "gemini-1.5-pro":
+    case "gemini-1.5-flash-8b":
+    case "gemini-2.0-flash-lite":
+    case "gemini-2.0-flash":
+    case "gemini-2.5-pro-preview-03-25":
+    case "gemini-2.5-flash-preview-04-17":
+      return "google";
+    case "cerebras-llama-3.3-70b":
+    case "cerebras-llama-3.1-8b":
+      throw new AppError(
+        "Cerebras models are not supported yet",
+        StatusCodes.BAD_REQUEST,
+      );
+    case "groq-llama-3.3-70b-specdec":
+    case "groq-llama-3.3-70b-versatile":
+      throw new AppError(
+        "Groq models are not supported yet",
+        StatusCodes.BAD_REQUEST,
+      );
+    default: {
+      const errorMessage = `Unknown model: ${String(model)}`;
+      throw new AppError(errorMessage, StatusCodes.BAD_REQUEST);
+    }
+  }
+}
diff --git a/packages/server-v3/src/routes/healthcheck.ts b/packages/server-v3/src/routes/healthcheck.ts
new file mode 100644
index 000000000..0864cfb13
--- /dev/null
+++ b/packages/server-v3/src/routes/healthcheck.ts
@@ -0,0 +1,30 @@
+import type { RouteOptions } from "fastify";
+import { z } from "zod/v4";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+
+import { withErrorHandling } from "../lib/errorHandler.js";
+
+const healthcheckRoute: RouteOptions = {
+  method: "GET",
+  url: "/healthz",
+  logLevel: "silent",
+  schema: {
+    hide: true, // Hide from OpenAPI spec - utility endpoint
+    response: {
+      200: z
+        .object({
+          status: z.string(),
+          timestamp: z.string(),
+        })
+        .strict(),
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: withErrorHandling(async () => {
+    return {
+      status: "ok",
+      timestamp: new Date().toISOString(),
+    };
+  }),
+};
+
+export default healthcheckRoute;
diff --git a/packages/server-v3/src/routes/readiness.ts b/packages/server-v3/src/routes/readiness.ts
new file mode 100644
index 000000000..d602e9a0e
--- /dev/null
+++ b/packages/server-v3/src/routes/readiness.ts
@@ -0,0 +1,55 @@
+import type { RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import { z } from "zod/v4";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+
+import { withErrorHandling } from "../lib/errorHandler.js";
+
+// Server readiness state management
+let isReady = false;
+
+/**
+ * Get the current readiness state of the server
+ * @returns {boolean} Whether the server is ready to accept requests
+ */
+export const getIsReady = (): boolean => {
+  return isReady;
+};
+
+/**
+ * Mark the server as ready to accept requests
+ */
+export const setReady = (): void => {
+  isReady = true;
+};
+
+/**
+ * Mark the server as not ready to accept requests
+ * Used during graceful shutdown to stop accepting new requests
+ */
+export const setUnready = (): void => {
+  isReady = false;
+};
+
+const readinessRoute: RouteOptions = {
+  method: "GET",
+  url: "/readyz",
+  logLevel: "silent",
+  schema: {
+    hide: true, // Hide from OpenAPI spec - utility endpoint
+    response: {
+      200: z.string(),
+      503: z.string(),
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: withErrorHandling(async (_request, reply) => {
+    if (!isReady) {
+      return reply
+        .code(StatusCodes.SERVICE_UNAVAILABLE)
+        .send("Service Unavailable");
+    }
+    return reply.code(StatusCodes.OK).send("Ready");
+  }),
+};
+
+export default readinessRoute;
diff --git a/packages/server-v3/src/routes/v1/sessions/_id/act.ts b/packages/server-v3/src/routes/v1/sessions/_id/act.ts
new file mode 100644
index 000000000..3a64c8336
--- /dev/null
+++ b/packages/server-v3/src/routes/v1/sessions/_id/act.ts
@@ -0,0 +1,97 @@
+import type { RouteHandlerMethod, RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import type { ActResult, Action } from "@browserbasehq/stagehand";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+import { Api } from "@browserbasehq/stagehand";
+
+import { authMiddleware } from "../../../../lib/auth.js";
+import { AppError, withErrorHandling } from "../../../../lib/errorHandler.js";
+import { createStreamingResponse } from "../../../../lib/stream.js";
+import { getSessionStore } from "../../../../lib/sessionStoreManager.js";
+
+const actRouteHandler: RouteHandlerMethod = withErrorHandling(
+  async (request, reply) => {
+    if (!(await authMiddleware(request))) {
+      return reply
+        .status(StatusCodes.UNAUTHORIZED)
+        .send({ error: "Unauthorized" });
+    }
+
+    const { id } = request.params as Api.SessionIdParams;
+
+    if (!id.length) {
+      return reply.status(StatusCodes.BAD_REQUEST).send({
+        message: "Missing session id",
+      });
+    }
+
+    const sessionStore = getSessionStore();
+    const hasSession = await sessionStore.hasSession(id);
+    if (!hasSession) {
+      return reply.status(StatusCodes.NOT_FOUND).send({
+        message: "Session not found",
+      });
+    }
+
+    return createStreamingResponse<Api.ActRequest>({
+      sessionId: id,
+      request,
+      reply,
+      schema: Api.ActRequestSchema,
+      handler: async ({ stagehand, data }) => {
+        const { frameId } = data;
+        const page = frameId
+          ? stagehand.context.resolvePageByMainFrameId(frameId)
+          : await stagehand.context.awaitActivePage();
+
+        if (!page) {
+          throw new AppError(
+            "Page not found",
+            StatusCodes.INTERNAL_SERVER_ERROR,
+          );
+        }
+
+        const modelOpt = data.options?.model;
+        const normalizedModel =
+          typeof modelOpt === "string"
+            ? { modelName: modelOpt }
+            : modelOpt
+              ? { ...modelOpt, modelName: modelOpt.modelName ?? "gpt-4o" }
+              : undefined;
+
+        const safeOptions = {
+          ...data.options,
+          model: normalizedModel,
+          page,
+        };
+
+        let result: ActResult;
+        if (typeof data.input === "string") {
+          result = await stagehand.act(data.input, safeOptions);
+        } else {
+          result = await stagehand.act(data.input as Action, safeOptions);
+        }
+
+        return { result };
+      },
+      operation: "act",
+    });
+  },
+);
+
+const actRoute: RouteOptions = {
+  method: "POST",
+  url: "/sessions/:id/act",
+  schema: {
+    ...Api.Operations.SessionAct,
+    headers: Api.SessionHeadersSchema,
+    params: Api.SessionIdParamsSchema,
+    body: Api.ActRequestSchema,
+    response: {
+      200: Api.ActResponseSchema,
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: actRouteHandler,
+};
+
+export default actRoute;
diff --git a/packages/server-v3/src/routes/v1/sessions/_id/agentExecute.ts b/packages/server-v3/src/routes/v1/sessions/_id/agentExecute.ts
new file mode 100644
index 000000000..8e16f71fb
--- /dev/null
+++ b/packages/server-v3/src/routes/v1/sessions/_id/agentExecute.ts
@@ -0,0 +1,103 @@
+import type { RouteHandlerMethod, RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+import { Api } from "@browserbasehq/stagehand";
+
+import { authMiddleware } from "../../../../lib/auth.js";
+import { AppError, withErrorHandling } from "../../../../lib/errorHandler.js";
+import { createStreamingResponse } from "../../../../lib/stream.js";
+import { getSessionStore } from "../../../../lib/sessionStoreManager.js";
+
+const agentExecuteRouteHandler: RouteHandlerMethod = withErrorHandling(
+  async (request, reply) => {
+    if (!(await authMiddleware(request))) {
+      return reply
+        .status(StatusCodes.UNAUTHORIZED)
+        .send({ error: "Unauthorized" });
+    }
+
+    const { id } = request.params as Api.SessionIdParams;
+
+    if (!id.length) {
+      return reply.status(StatusCodes.BAD_REQUEST).send({
+        message: "Missing session id",
+      });
+    }
+
+    const sessionStore = getSessionStore();
+    const hasSession = await sessionStore.hasSession(id);
+    if (!hasSession) {
+      return reply.status(StatusCodes.NOT_FOUND).send({
+        message: "Session not found",
+      });
+    }
+
+    return createStreamingResponse<Api.AgentExecuteRequest>({
+      sessionId: id,
+      request,
+      reply,
+      schema: Api.AgentExecuteRequestSchema,
+      handler: async ({ stagehand, data }) => {
+        const { agentConfig, executeOptions } = data;
+        const { frameId } = data;
+        const page = frameId
+          ? stagehand.context.resolvePageByMainFrameId(frameId)
+          : await stagehand.context.awaitActivePage();
+        if (!page) {
+          throw new AppError(
+            "Page not found",
+            StatusCodes.INTERNAL_SERVER_ERROR,
+          );
+        }
+        const normalizedAgentConfig = {
+          ...agentConfig,
+          model:
+            typeof agentConfig.model === "string"
+              ? { modelName: agentConfig.model }
+              : agentConfig.model
+                ? {
+                    ...agentConfig.model,
+                    modelName: agentConfig.model.modelName ?? "gpt-4o",
+                  }
+                : undefined,
+        };
+
+        const { instruction, ...restExecuteOptions } = executeOptions;
+        const fullExecuteOptions = {
+          instruction,
+          ...restExecuteOptions,
+          page,
+        };
+        let result;
+        try {
+          result = await stagehand
+            .agent(normalizedAgentConfig)
+            .execute(fullExecuteOptions);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          throw new AppError(message, StatusCodes.UNPROCESSABLE_ENTITY);
+        }
+
+        return { result };
+      },
+      operation: "agentExecute",
+    });
+  },
+);
+
+const agentExecuteRoute: RouteOptions = {
+  method: "POST",
+  url: "/sessions/:id/agentExecute",
+  schema: {
+    ...Api.Operations.SessionAgentExecute,
+    headers: Api.SessionHeadersSchema,
+    params: Api.SessionIdParamsSchema,
+    body: Api.AgentExecuteRequestSchema,
+    response: {
+      200: Api.AgentExecuteResponseSchema,
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: agentExecuteRouteHandler,
+};
+
+export default agentExecuteRoute;
diff --git a/packages/server-v3/src/routes/v1/sessions/_id/end.ts b/packages/server-v3/src/routes/v1/sessions/_id/end.ts
new file mode 100644
index 000000000..3e4c634bf
--- /dev/null
+++ b/packages/server-v3/src/routes/v1/sessions/_id/end.ts
@@ -0,0 +1,64 @@
+import type { RouteHandlerMethod, RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+import { Api } from "@browserbasehq/stagehand";
+
+import { authMiddleware } from "../../../../lib/auth.js";
+import { withErrorHandling } from "../../../../lib/errorHandler.js";
+import { error } from "../../../../lib/response.js";
+import { getSessionStore } from "../../../../lib/sessionStoreManager.js";
+
+const endRouteHandler: RouteHandlerMethod = withErrorHandling(
+  async (request, reply) => {
+    if (!(await authMiddleware(request))) {
+      return error(reply, "Unauthorized", StatusCodes.UNAUTHORIZED);
+    }
+
+    // This endpoint intentionally has no request body. Reject unexpected bodies to
+    // catch misconfigured clients, while still allowing empty JSON bodies.
+    const body = (request as { body?: unknown }).body;
+    if (body != null) {
+      if (typeof body !== "object" || Buffer.isBuffer(body)) {
+        return error(
+          reply,
+          "Request body must be empty",
+          StatusCodes.BAD_REQUEST,
+        );
+      }
+
+      if (Object.keys(body as Record<string, unknown>).length > 0) {
+        return error(
+          reply,
+          "Request body must be empty",
+          StatusCodes.BAD_REQUEST,
+        );
+      }
+    }
+
+    const { id: sessionId } = request.params as Api.SessionIdParams;
+    const sessionStore = getSessionStore();
+    const hasSession = await sessionStore.hasSession(sessionId);
+    if (!hasSession) {
+      return error(reply, "Session not found", StatusCodes.NOT_FOUND);
+    }
+    await sessionStore.endSession(sessionId);
+
+    return reply.status(StatusCodes.OK).send({ success: true });
+  },
+);
+
+const endRoute: RouteOptions = {
+  method: "POST",
+  url: "/sessions/:id/end",
+  schema: {
+    ...Api.Operations.SessionEnd,
+    headers: Api.SessionHeadersSchema,
+    params: Api.SessionIdParamsSchema,
+    response: {
+      200: Api.SessionEndResponseSchema,
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: endRouteHandler,
+};
+
+export default endRoute;
diff --git a/packages/server-v3/src/routes/v1/sessions/_id/extract.ts b/packages/server-v3/src/routes/v1/sessions/_id/extract.ts
new file mode 100644
index 000000000..47e54d77c
--- /dev/null
+++ b/packages/server-v3/src/routes/v1/sessions/_id/extract.ts
@@ -0,0 +1,106 @@
+import type { RouteHandlerMethod, RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import type { ZodTypeAny } from "zod/v3";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+import { Api } from "@browserbasehq/stagehand";
+
+import { authMiddleware } from "../../../../lib/auth.js";
+import { AppError, withErrorHandling } from "../../../../lib/errorHandler.js";
+import { createStreamingResponse } from "../../../../lib/stream.js";
+import { jsonSchemaToZod } from "../../../../lib/utils.js";
+import { getSessionStore } from "../../../../lib/sessionStoreManager.js";
+
+const extractRouteHandler: RouteHandlerMethod = withErrorHandling(
+  async (request, reply) => {
+    if (!(await authMiddleware(request))) {
+      return reply
+        .status(StatusCodes.UNAUTHORIZED)
+        .send({ error: "Unauthorized" });
+    }
+
+    const { id } = request.params as Api.SessionIdParams;
+
+    if (!id.length) {
+      return reply.status(StatusCodes.BAD_REQUEST).send({
+        message: "Missing session id",
+      });
+    }
+
+    const sessionStore = getSessionStore();
+    const hasSession = await sessionStore.hasSession(id);
+    if (!hasSession) {
+      return reply.status(StatusCodes.NOT_FOUND).send({
+        message: "Session not found",
+      });
+    }
+
+    return createStreamingResponse<Api.ExtractRequest>({
+      sessionId: id,
+      request,
+      reply,
+      schema: Api.ExtractRequestSchema,
+      handler: async ({ stagehand, data }) => {
+        const { frameId } = data;
+        const page = frameId
+          ? stagehand.context.resolvePageByMainFrameId(frameId)
+          : await stagehand.context.awaitActivePage();
+
+        if (!page) {
+          throw new AppError(
+            "Page not found",
+            StatusCodes.INTERNAL_SERVER_ERROR,
+          );
+        }
+
+        const modelOpt = data.options?.model;
+        const normalizedModel =
+          typeof modelOpt === "string"
+            ? { modelName: modelOpt }
+            : modelOpt
+              ? { ...modelOpt, modelName: modelOpt.modelName ?? "gpt-4o" }
+              : undefined;
+
+        const safeOptions = {
+          ...data.options,
+          model: normalizedModel,
+          page,
+        };
+
+        const extractFn = stagehand.extract.bind(stagehand);
+
+        let result: unknown;
+
+        if (data.instruction) {
+          if (data.schema) {
+            const zodSchema = jsonSchemaToZod(data.schema) as ZodTypeAny;
+            result = await extractFn(data.instruction, zodSchema, safeOptions);
+          } else {
+            result = await extractFn(data.instruction, safeOptions);
+          }
+        } else {
+          result = await extractFn(safeOptions);
+        }
+
+        return { result };
+      },
+      operation: "extract",
+    });
+  },
+);
+
+const extractRoute: RouteOptions = {
+  method: "POST",
+  url: "/sessions/:id/extract",
+  schema: {
+    ...Api.Operations.SessionExtract,
+    headers: Api.SessionHeadersSchema,
+    params: Api.SessionIdParamsSchema,
+    body: Api.ExtractRequestSchema,
+    response: {
+      200: Api.ExtractResponseSchema,
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: extractRouteHandler,
+};
+
+export default extractRoute;
diff --git a/packages/server-v3/src/routes/v1/sessions/_id/navigate.ts b/packages/server-v3/src/routes/v1/sessions/_id/navigate.ts
new file mode 100644
index 000000000..5b9131ff4
--- /dev/null
+++ b/packages/server-v3/src/routes/v1/sessions/_id/navigate.ts
@@ -0,0 +1,73 @@
+import type { RouteHandlerMethod, RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+import { Api } from "@browserbasehq/stagehand";
+
+import { authMiddleware } from "../../../../lib/auth.js";
+import { AppError, withErrorHandling } from "../../../../lib/errorHandler.js";
+import { createStreamingResponse } from "../../../../lib/stream.js";
+import { getSessionStore } from "../../../../lib/sessionStoreManager.js";
+
+const navigateRouteHandler: RouteHandlerMethod = withErrorHandling(
+  async (request, reply) => {
+    if (!(await authMiddleware(request))) {
+      return reply
+        .status(StatusCodes.UNAUTHORIZED)
+        .send({ error: "Unauthorized" });
+    }
+
+    const { id } = request.params as Api.SessionIdParams;
+
+    if (!id.length) {
+      return reply.status(StatusCodes.BAD_REQUEST).send({
+        message: "Missing session id",
+      });
+    }
+
+    const sessionStore = getSessionStore();
+    const hasSession = await sessionStore.hasSession(id);
+    if (!hasSession) {
+      return reply.status(StatusCodes.NOT_FOUND).send({
+        message: "Session not found",
+      });
+    }
+
+    return createStreamingResponse<Api.NavigateRequest>({
+      sessionId: id,
+      request,
+      reply,
+      schema: Api.NavigateRequestSchema,
+      handler: async ({ stagehand, data }) => {
+        const page = data.frameId
+          ? stagehand.context.resolvePageByMainFrameId(data.frameId)
+          : await stagehand.context.awaitActivePage();
+
+        if (!page) {
+          throw new AppError("Page not found", StatusCodes.NOT_FOUND);
+        }
+
+        const result = await page.goto(data.url, data.options);
+
+        return { result };
+      },
+      operation: "navigate",
+    });
+  },
+);
+
+const navigateRoute: RouteOptions = {
+  method: "POST",
+  url: "/sessions/:id/navigate",
+  schema: {
+    ...Api.Operations.SessionNavigate,
+    headers: Api.SessionHeadersSchema,
+    params: Api.SessionIdParamsSchema,
+    body: Api.NavigateRequestSchema,
+    response: {
+      200: Api.NavigateResponseSchema,
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: navigateRouteHandler,
+};
+
+export default navigateRoute;
diff --git a/packages/server-v3/src/routes/v1/sessions/_id/observe.ts b/packages/server-v3/src/routes/v1/sessions/_id/observe.ts
new file mode 100644
index 000000000..84fd0a3ec
--- /dev/null
+++ b/packages/server-v3/src/routes/v1/sessions/_id/observe.ts
@@ -0,0 +1,98 @@
+import type { RouteHandlerMethod, RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import type { Action } from "@browserbasehq/stagehand";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+import { Api } from "@browserbasehq/stagehand";
+
+import { authMiddleware } from "../../../../lib/auth.js";
+import { AppError, withErrorHandling } from "../../../../lib/errorHandler.js";
+import { createStreamingResponse } from "../../../../lib/stream.js";
+import { getSessionStore } from "../../../../lib/sessionStoreManager.js";
+
+const observeRouteHandler: RouteHandlerMethod = withErrorHandling(
+  async (request, reply) => {
+    if (!(await authMiddleware(request))) {
+      return reply
+        .status(StatusCodes.UNAUTHORIZED)
+        .send({ error: "Unauthorized" });
+    }
+
+    const { id } = request.params as Api.SessionIdParams;
+
+    if (!id.length) {
+      return reply.status(StatusCodes.BAD_REQUEST).send({
+        message: "Missing session id",
+      });
+    }
+
+    const sessionStore = getSessionStore();
+    const hasSession = await sessionStore.hasSession(id);
+    if (!hasSession) {
+      return reply.status(StatusCodes.NOT_FOUND).send({
+        message: "Session not found",
+      });
+    }
+
+    return createStreamingResponse<Api.ObserveRequest>({
+      sessionId: id,
+      request,
+      reply,
+      schema: Api.ObserveRequestSchema,
+      handler: async ({ stagehand, data }) => {
+        const { frameId } = data;
+        const page = frameId
+          ? stagehand.context.resolvePageByMainFrameId(frameId)
+          : await stagehand.context.awaitActivePage();
+
+        if (!page) {
+          throw new AppError(
+            "Page not found",
+            StatusCodes.INTERNAL_SERVER_ERROR,
+          );
+        }
+
+        const safeOptions = {
+          ...data.options,
+          model:
+            typeof data.options?.model === "string"
+              ? { modelName: data.options.model }
+              : data.options?.model
+                ? {
+                    ...data.options.model,
+                    modelName: data.options.model.modelName ?? "gpt-4o",
+                  }
+                : undefined,
+          page,
+        };
+
+        let result: Action[];
+
+        if (data.instruction) {
+          result = await stagehand.observe(data.instruction, safeOptions);
+        } else {
+          result = await stagehand.observe(safeOptions);
+        }
+
+        return { result };
+      },
+      operation: "observe",
+    });
+  },
+);
+
+const observeRoute: RouteOptions = {
+  method: "POST",
+  url: "/sessions/:id/observe",
+  schema: {
+    ...Api.Operations.SessionObserve,
+    headers: Api.SessionHeadersSchema,
+    params: Api.SessionIdParamsSchema,
+    body: Api.ObserveRequestSchema,
+    response: {
+      200: Api.ObserveResponseSchema,
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: observeRouteHandler,
+};
+
+export default observeRoute;
diff --git a/packages/server-v3/src/routes/v1/sessions/_id/replay.ts b/packages/server-v3/src/routes/v1/sessions/_id/replay.ts
new file mode 100644
index 000000000..bf5318f7e
--- /dev/null
+++ b/packages/server-v3/src/routes/v1/sessions/_id/replay.ts
@@ -0,0 +1,40 @@
+import type { RouteHandlerMethod, RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+import { Api } from "@browserbasehq/stagehand";
+
+import { authMiddleware } from "../../../../lib/auth.js";
+import { withErrorHandling } from "../../../../lib/errorHandler.js";
+import { error, success } from "../../../../lib/response.js";
+
+const replayRouteHandler: RouteHandlerMethod = withErrorHandling(
+  async (request, reply) => {
+    if (!(await authMiddleware(request))) {
+      return error(reply, "Unauthorized", StatusCodes.UNAUTHORIZED);
+    }
+
+    reply.log.warn("Replay endpoint not implemented for local server.");
+
+    const replay: Api.ReplayResult = {
+      pages: [],
+    };
+
+    return success(reply, replay);
+  },
+);
+
+const replayRoute: RouteOptions = {
+  method: "GET",
+  url: "/sessions/:id/replay",
+  schema: {
+    ...Api.Operations.SessionReplay,
+    headers: Api.SessionHeadersSchema,
+    params: Api.SessionIdParamsSchema,
+    response: {
+      200: Api.ReplayResponseSchema,
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: replayRouteHandler,
+};
+
+export default replayRoute;
diff --git a/packages/server-v3/src/routes/v1/sessions/start.ts b/packages/server-v3/src/routes/v1/sessions/start.ts
new file mode 100644
index 000000000..6aa022175
--- /dev/null
+++ b/packages/server-v3/src/routes/v1/sessions/start.ts
@@ -0,0 +1,258 @@
+import type { RouteHandler, RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import Browserbase from "@browserbasehq/sdk";
+import { Api } from "@browserbasehq/stagehand";
+import type { SessionRetrieveResponse } from "@browserbasehq/sdk/resources/sessions/sessions";
+import { type FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+import { z } from "zod/v4";
+
+import { authMiddleware } from "../../../lib/auth.js";
+import { withErrorHandling } from "../../../lib/errorHandler.js";
+import { getModelApiKey, getOptionalHeader } from "../../../lib/header.js";
+import { error, success } from "../../../lib/response.js";
+import { getSessionStore } from "../../../lib/sessionStoreManager.js";
+import { AISDK_PROVIDERS } from "../../../types/model.js";
+
+// Extended schema with custom refinement for local browser validation
+const startBodySchema = z
+  .preprocess((value) => {
+    if (!value || typeof value !== "object") {
+      return value;
+    }
+    const record = value as Record<string, unknown>;
+    if (
+      typeof record.verbose === "string" &&
+      ["0", "1", "2"].includes(record.verbose)
+    ) {
+      return { ...record, verbose: Number(record.verbose) };
+    }
+    return value;
+  }, Api.SessionStartRequestSchema)
+  .superRefine((value, ctx) => {
+    if (value.browser?.type === "local") {
+      const hasConnect = Boolean(value.browser.cdpUrl);
+      const hasLaunch = Boolean(value.browser.launchOptions);
+      if (!hasConnect && !hasLaunch) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["browser"],
+          message:
+            "When browser.type is 'local', provide either browser.cdpUrl or browser.launchOptions.",
+        });
+      }
+    }
+  });
+
+const startRouteHandler: RouteHandler = withErrorHandling(
+  async (request, reply) => {
+    if (!(await authMiddleware(request))) {
+      return error(reply, "Unauthorized", StatusCodes.UNAUTHORIZED);
+    }
+
+    const sdkVersion = getOptionalHeader(request, "x-sdk-version");
+
+    const clientLanguage = request.headers["x-language"] as string | undefined;
+    if (
+      clientLanguage &&
+      !["typescript", "python", "playground"].includes(clientLanguage)
+    ) {
+      return error(
+        reply,
+        "Invalid client language header",
+        StatusCodes.BAD_REQUEST,
+      );
+    }
+
+    // Use the validated request body directly - fields come from Api.SessionStartRequestSchema
+    const body = request.body as Api.SessionStartRequest;
+    const {
+      modelName,
+      domSettleTimeoutMs,
+      verbose,
+      systemPrompt,
+      browserbaseSessionCreateParams,
+      selfHeal,
+      waitForCaptchaSolves,
+      browserbaseSessionID,
+      experimental,
+      browser,
+    } = body;
+    if (!modelName) {
+      return error(reply, "Missing required model name");
+    }
+
+    // TODO: Remove this after complete AISDK migration. Validation should be done stagehand-side
+    if (modelName.includes("/")) {
+      const [providerName] = modelName.split("/", 1);
+      if (!providerName) {
+        return error(
+          reply,
+          `Invalid model: ${modelName}`,
+          StatusCodes.BAD_REQUEST,
+        );
+      }
+      if (!(AISDK_PROVIDERS as readonly string[]).includes(providerName)) {
+        return error(
+          reply,
+          `Invalid provider: ${providerName}`,
+          StatusCodes.BAD_REQUEST,
+        );
+      }
+    }
+
+    const browserType = browser?.type ?? "browserbase";
+
+    let bbApiKey: string | undefined;
+    let bbProjectId: string | undefined;
+    let browserbaseSessionId: string | undefined;
+    let connectUrl: string | undefined;
+
+    if (browserType === "browserbase") {
+      bbApiKey = getOptionalHeader(request, "x-bb-api-key");
+      bbProjectId = getOptionalHeader(request, "x-bb-project-id");
+
+      if (!bbApiKey) {
+        return error(
+          reply,
+          "Missing required headers for browserbase sessions",
+        );
+      }
+
+      const bb = new Browserbase({ apiKey: bbApiKey });
+
+      if (browserbaseSessionID) {
+        const existing = await bb.sessions.retrieve(browserbaseSessionID);
+        browserbaseSessionId = existing?.id;
+        connectUrl = existing?.connectUrl;
+        if (!browserbaseSessionId) {
+          return error(reply, "Failed to retrieve browserbase session");
+        }
+        if (!connectUrl) {
+          return error(reply, "Browserbase session missing connectUrl");
+        }
+      } else {
+        const resolvedProjectId =
+          browserbaseSessionCreateParams?.projectId ?? bbProjectId;
+        const createPayload = {
+          ...(resolvedProjectId ? { projectId: resolvedProjectId } : {}),
+          ...browserbaseSessionCreateParams,
+          browserSettings: {
+            ...(browserbaseSessionCreateParams?.browserSettings ?? {}),
+            viewport: browserbaseSessionCreateParams?.browserSettings
+              ?.viewport ?? {
+              width: 1288,
+              height: 711,
+            },
+          },
+          userMetadata: {
+            ...(browserbaseSessionCreateParams?.userMetadata ?? {}),
+            stagehand: "true",
+          },
+        } satisfies Browserbase.Sessions.SessionCreateParams;
+
+        const created = (await bb.sessions.create(
+          createPayload,
+        )) as SessionRetrieveResponse;
+
+        browserbaseSessionId = created?.id;
+        connectUrl = created?.connectUrl;
+        if (!browserbaseSessionId) {
+          return error(reply, "Failed to create browserbase session");
+        }
+        if (!connectUrl) {
+          return error(reply, "Browserbase session missing connectUrl");
+        }
+      }
+    }
+
+    const sessionStore = getSessionStore();
+
+    // For local browsers without a connectUrl, get it from browser.connectUrl
+    if (browserType === "local") {
+      connectUrl = browser?.cdpUrl;
+    }
+
+    const session = await sessionStore.startSession({
+      browserType,
+      connectUrl,
+      browserbaseSessionID:
+        browserType === "browserbase"
+          ? (browserbaseSessionId ?? browserbaseSessionID)
+          : undefined,
+      browserbaseApiKey: bbApiKey,
+      browserbaseProjectId: bbProjectId,
+      modelName,
+      domSettleTimeoutMs,
+      verbose,
+      systemPrompt,
+      browserbaseSessionCreateParams,
+      selfHeal,
+      waitForCaptchaSolves,
+      clientLanguage,
+      sdkVersion,
+      experimental,
+      localBrowserLaunchOptions:
+        browserType === "local" && (browser?.launchOptions || browser?.cdpUrl)
+          ? {
+              cdpUrl: browser?.cdpUrl,
+              ...(browser?.launchOptions ?? {}),
+            }
+          : undefined,
+    });
+
+    // For local browsers with launchOptions (no explicit cdpUrl), eagerly
+    // initialize the browser so we can return the actual CDP URL
+    let finalCdpUrl = connectUrl ?? session.cdpUrl ?? "";
+    if (browserType === "local" && browser?.launchOptions && !browser?.cdpUrl) {
+      const modelApiKey = getModelApiKey(request);
+      try {
+        const stagehand = await sessionStore.getOrCreateStagehand(
+          session.sessionId,
+          { modelApiKey },
+        );
+        finalCdpUrl = stagehand.connectURL();
+      } catch (err) {
+        request.log.error(
+          {
+            err,
+            sessionId: session.sessionId,
+            browserType,
+            chromePathEnv: process.env.CHROME_PATH,
+            launchOptions: {
+              executablePath: browser.launchOptions.executablePath,
+              argsCount: browser.launchOptions.args?.length ?? 0,
+              headless: browser.launchOptions.headless,
+              hasUserDataDir: Boolean(browser.launchOptions.userDataDir),
+              port: browser.launchOptions.port,
+              connectTimeoutMs: browser.launchOptions.connectTimeoutMs,
+            },
+          },
+          "Failed to initialize local browser session in /v1/sessions/start",
+        );
+        throw err;
+      }
+    }
+
+    return success(reply, {
+      sessionId: session.sessionId,
+      available: session.available,
+      cdpUrl: finalCdpUrl,
+    });
+  },
+);
+
+const startRoute: RouteOptions = {
+  method: "POST",
+  url: "/sessions/start",
+  schema: {
+    ...Api.Operations.SessionStart,
+    headers: Api.SessionHeadersSchema,
+    body: startBodySchema,
+    response: {
+      200: Api.SessionStartResponseSchema,
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: startRouteHandler,
+};
+
+export default startRoute;
diff --git a/packages/server-v3/src/sea-entry.ts b/packages/server-v3/src/sea-entry.ts
new file mode 100644
index 000000000..27ccaedf8
--- /dev/null
+++ b/packages/server-v3/src/sea-entry.ts
@@ -0,0 +1,13 @@
+import { __internalMaybeRunShutdownSupervisorFromArgv } from "@browserbasehq/stagehand";
+
+// if SEA binary is launched with --supervisor, it will run the shutdown supervisor only
+const argv = process.argv.slice(1);
+const normalizedArgv = argv[0]?.startsWith("--") ? argv : argv.slice(1);
+
+// otherwise, start the stagehand/server
+if (!__internalMaybeRunShutdownSupervisorFromArgv(normalizedArgv)) {
+  void import("./server.js").catch((err) => {
+    console.error("Failed to start server:", err);
+    process.exit(1);
+  });
+}
diff --git a/packages/server-v3/src/server.ts b/packages/server-v3/src/server.ts
new file mode 100644
index 000000000..5c897a6b9
--- /dev/null
+++ b/packages/server-v3/src/server.ts
@@ -0,0 +1,278 @@
+import { randomUUID } from "crypto";
+
+import cors from "@fastify/cors";
+import fastify from "fastify";
+import metricsPlugin from "fastify-metrics";
+import fastifySwagger from "@fastify/swagger";
+import fastifySwaggerUI from "@fastify/swagger-ui";
+import {
+  fastifyZodOpenApiPlugin,
+  fastifyZodOpenApiTransformers,
+  serializerCompiler,
+  validatorCompiler,
+  type FastifyZodOpenApiTypeProvider,
+  RequestValidationError,
+  ResponseSerializationError,
+} from "fastify-zod-openapi";
+import { StatusCodes } from "http-status-codes";
+
+import { logging } from "./lib/logging/index.js";
+import {
+  destroySessionStore,
+  initializeSessionStore,
+} from "./lib/sessionStoreManager.js";
+import healthcheckRoute from "./routes/healthcheck.js";
+import readinessRoute, { setReady, setUnready } from "./routes/readiness.js";
+import actRoute from "./routes/v1/sessions/_id/act.js";
+import agentExecuteRoute from "./routes/v1/sessions/_id/agentExecute.js";
+import endRoute from "./routes/v1/sessions/_id/end.js";
+import extractRoute from "./routes/v1/sessions/_id/extract.js";
+import navigateRoute from "./routes/v1/sessions/_id/navigate.js";
+import observeRoute from "./routes/v1/sessions/_id/observe.js";
+import replayRoute from "./routes/v1/sessions/_id/replay.js";
+import startRoute from "./routes/v1/sessions/start.js";
+
+// Constants for graceful shutdown
+const READY_WAIT_PERIOD = 10_000; // 10 seconds
+const GRACEFUL_SHUTDOWN_PERIOD = 30_000; // 30 seconds
+
+const usePrettyLogs = process.env.NODE_ENV === "development" && !process.env.CI;
+
+const app = fastify({
+  disableRequestLogging: true,
+
+  genReqId: () => {
+    return randomUUID();
+  },
+
+  logger: {
+    formatters: {
+      level(label: string) {
+        return { level: label };
+      },
+    },
+
+    level: process.env.NODE_ENV === "production" ? "info" : "trace",
+
+    ...(usePrettyLogs && {
+      transport: {
+        options: {
+          colorize: true,
+          ignore: "pid,hostname",
+        },
+        target: "pino-pretty",
+      },
+    }),
+  },
+
+  return503OnClosing: false,
+});
+
+export const logger = app.log;
+
+// Allow requests with `Content-Type: application/json` and an empty body (0 bytes).
+// Some clients always send the header even when there is no request body (e.g. /end).
+const defaultJsonParser = app.getDefaultJsonParser("error", "error");
+app.addContentTypeParser<string>(
+  "application/json",
+  { parseAs: "string" },
+  (request, body, done) => {
+    if (body === "" || (Buffer.isBuffer(body) && body.length === 0)) {
+      done(null, {});
+      return;
+    }
+
+    void defaultJsonParser(request, body, done);
+  },
+);
+
+process.on("uncaughtException", (error) => {
+  app.log.error(error, "Uncaught Exception:");
+});
+
+process.on("unhandledRejection", (reason, promise) => {
+  app.log.error(
+    reason instanceof Error ? reason : new Error(String(reason)),
+    "Unhandled Rejection at:",
+    promise,
+    "reason:",
+    reason,
+  );
+});
+
+// Graceful shutdown handler
+const gracefulShutdown = async () => {
+  app.log.info("gracefulShutdown");
+
+  setUnready();
+
+  await new Promise((resolve) => setTimeout(resolve, READY_WAIT_PERIOD));
+
+  const timeout = setTimeout(() => {
+    app.log.warn("forcefully shutting down after 30 seconds");
+    process.exit(1);
+  }, GRACEFUL_SHUTDOWN_PERIOD);
+
+  timeout.unref();
+
+  await app.close();
+  await destroySessionStore();
+  clearTimeout(timeout);
+
+  app.log.info("gracefulShutdown complete");
+  process.exit(0);
+};
+
+// Handle termination signals
+process.on("SIGTERM", () => {
+  gracefulShutdown().catch((err: unknown) => {
+    app.log.error(err, "error gracefully shutting down");
+  });
+});
+
+process.on("SIGINT", () => {
+  gracefulShutdown().catch((err: unknown) => {
+    app.log.error(err, "error gracefully shutting down");
+  });
+});
+
+const start = async () => {
+  try {
+    if (process.env.NODE_ENV === "development") {
+      await app.register(cors, {
+        origin: ["http://localhost:3000"],
+        methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+        allowedHeaders: ["*"],
+        credentials: true,
+      });
+    }
+
+    app.setValidatorCompiler(validatorCompiler);
+    app.setSerializerCompiler(serializerCompiler);
+
+    await app.register(fastifyZodOpenApiPlugin);
+
+    await app.register(fastifySwagger, {
+      openapi: {
+        info: {
+          title: "Stagehand API",
+          version: "3.0.5",
+        },
+        openapi: "3.1.0",
+      },
+      ...fastifyZodOpenApiTransformers,
+    });
+
+    // Only register Swagger UI in development - SEA binaries can't load static files
+    if (process.env.NODE_ENV === "development") {
+      await app.register(fastifySwaggerUI, {
+        routePrefix: "/documentation",
+      });
+    }
+
+    app.setSchemaErrorFormatter(function (errors, dataVar) {
+      const zodIssues = errors
+        .filter((err) => err instanceof RequestValidationError)
+        .map((err) => err.params.issue);
+      this.log.warn({ dataVar, zodIssues }, "request validation failed");
+      return new Error(`${dataVar} validation failed`);
+    });
+
+    app.setErrorHandler((error, request, reply) => {
+      if ((error as { validation?: unknown }).validation) {
+        const zodIssues = (error as { validation: unknown[] }).validation
+          .filter((err) => err instanceof RequestValidationError)
+          .map((err) => (err as RequestValidationError).params.issue);
+
+        request.log.warn({ zodIssues }, "request validation failed");
+        return reply.status(StatusCodes.BAD_REQUEST).send({
+          error: "Request validation failed",
+          issues: zodIssues,
+        });
+      }
+
+      if (error instanceof ResponseSerializationError) {
+        request.log.error({ err: error }, "response serialization failed");
+        return reply
+          .status(StatusCodes.INTERNAL_SERVER_ERROR)
+          .send({ error: "Response validation failed" });
+      }
+
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      request.log.error(`Server error: ${errorMessage}`);
+
+      const statusCode =
+        (error as { statusCode?: number }).statusCode ??
+        StatusCodes.INTERNAL_SERVER_ERROR;
+
+      reply.status(statusCode).send({
+        error:
+          statusCode === Number(StatusCodes.INTERNAL_SERVER_ERROR)
+            ? "Internal Server Error"
+            : errorMessage,
+        statusCode,
+      });
+    });
+
+    await app.register(metricsPlugin, {
+      defaultMetrics: {
+        enabled: true,
+        prefix: "stagehand_api_",
+      },
+      routeMetrics: {
+        overrides: {
+          histogram: {
+            name: "stagehand_api_http_request_duration_seconds",
+          },
+          summary: {
+            name: "stagehand_api_http_request_summary_seconds",
+          },
+        },
+      },
+    });
+
+    initializeSessionStore();
+
+    const appWithTypes = app.withTypeProvider<FastifyZodOpenApiTypeProvider>();
+
+    await appWithTypes.register(
+      (instance, _opts, done) => {
+        instance.route(actRoute);
+        instance.route(endRoute);
+        instance.route(extractRoute);
+        instance.route(navigateRoute);
+        instance.route(observeRoute);
+        instance.route(replayRoute);
+        instance.route(startRoute);
+        instance.route(agentExecuteRoute);
+        done();
+      },
+      { prefix: "/v1" },
+    );
+
+    logging(app);
+
+    // Register health and readiness routes at the root level
+    appWithTypes.route(healthcheckRoute);
+    appWithTypes.route(readinessRoute);
+    await app.ready();
+
+    await app.listen({
+      host: "0.0.0.0",
+      port: parseInt(process.env.PORT ?? "3000", 10),
+    });
+    console.log("Routes registered:", app.printRoutes());
+
+    // Mark the server as ready after it's started
+    setReady();
+  } catch (err) {
+    console.error("Failed to start server:", err);
+    process.exit(1);
+  }
+};
+
+start().catch((err: unknown) => {
+  console.error("Failed to start server:", err);
+  process.exit(1);
+});
diff --git a/packages/server-v3/src/types/error.ts b/packages/server-v3/src/types/error.ts
new file mode 100644
index 000000000..a970f9651
--- /dev/null
+++ b/packages/server-v3/src/types/error.ts
@@ -0,0 +1,101 @@
+import { StatusCodes } from "http-status-codes";
+
+import { AppError } from "../lib/errorHandler.js";
+
+export class UnknownModelError extends AppError {
+  constructor(model: string) {
+    super(`Unknown model: ${model}`, StatusCodes.BAD_REQUEST);
+  }
+}
+export class InvalidProviderError extends AppError {
+  constructor(provider: string) {
+    super(`Invalid provider: ${provider}`, StatusCodes.BAD_REQUEST);
+  }
+}
+
+export class InvalidModelError extends AppError {
+  constructor(model: string) {
+    super(`Invalid model: ${model}`, StatusCodes.BAD_REQUEST);
+  }
+}
+
+export class UnauthorizedError extends AppError {
+  constructor() {
+    super("Unauthorized", StatusCodes.UNAUTHORIZED);
+  }
+}
+
+export class MissingHeaderError extends AppError {
+  constructor(header: string) {
+    super(`Missing required header: ${header}`, StatusCodes.BAD_REQUEST);
+  }
+}
+
+export class InvalidAPIKeyError extends AppError {
+  constructor(provider: string) {
+    super(`Invalid API key for provider: ${provider}`, StatusCodes.BAD_REQUEST);
+  }
+}
+
+export class AttemptedCloseOnNonActiveSessionError extends AppError {
+  constructor() {
+    super(
+      "Attempted to close session that is not currently active",
+      StatusCodes.CONFLICT,
+    );
+  }
+}
+
+interface BrowserbaseError {
+  status?: number;
+  statusCode?: number;
+  message?: string;
+  response?: {
+    status?: number;
+    data?: {
+      message?: string;
+    };
+  };
+}
+
+export class BrowserbaseSDKError extends AppError {
+  constructor(error: unknown, defaultMessage: string) {
+    const browserbaseError = error as BrowserbaseError;
+    const {
+      message: errMessage,
+      status,
+      statusCode: errStatusCode,
+      response,
+    } = browserbaseError;
+
+    let message = defaultMessage;
+    let finalStatusCode = StatusCodes.BAD_REQUEST;
+
+    // Extract message from error
+    if (errMessage) {
+      message = errMessage;
+    } else if (response?.data?.message) {
+      ({ message } = response.data);
+    }
+
+    // Extract status code from error
+    if (status && typeof status === "number") {
+      finalStatusCode = status as StatusCodes;
+    } else if (errStatusCode && typeof errStatusCode === "number") {
+      finalStatusCode = errStatusCode as StatusCodes;
+    } else if (response?.status && typeof response.status === "number") {
+      finalStatusCode = response.status as StatusCodes;
+    }
+
+    // Check for specific session error
+    if (message.includes("is not running")) {
+      throw new AttemptedCloseOnNonActiveSessionError();
+    }
+
+    // Mark 5xx errors as internal to sanitize sensitive details
+    const isInternal =
+      Number(finalStatusCode) >= Number(StatusCodes.INTERNAL_SERVER_ERROR);
+
+    super(message, finalStatusCode, isInternal);
+  }
+}
diff --git a/packages/server-v3/src/types/fastify.d.ts b/packages/server-v3/src/types/fastify.d.ts
new file mode 100644
index 000000000..0fe0694eb
--- /dev/null
+++ b/packages/server-v3/src/types/fastify.d.ts
@@ -0,0 +1,9 @@
+import "fastify";
+
+declare module "fastify" {
+  interface FastifyRequest {
+    metrics: {
+      startTime: number;
+    };
+  }
+}
diff --git a/packages/server-v3/src/types/model.ts b/packages/server-v3/src/types/model.ts
new file mode 100644
index 000000000..491b699b6
--- /dev/null
+++ b/packages/server-v3/src/types/model.ts
@@ -0,0 +1,40 @@
+export const AISDK_PROVIDERS = [
+  "openai",
+  "anthropic",
+  "google",
+  "xai",
+  "azure",
+  "groq",
+  "cerebras",
+  "togetherai",
+  "mistral",
+  "deepseek",
+  "perplexity",
+  "ollama",
+  "vertex",
+  "bedrock",
+] as const;
+export type AISDKProvider = (typeof AISDK_PROVIDERS)[number];
+
+export type LegacyModel =
+  | "gpt-4o"
+  | "gpt-4o-mini"
+  | "gpt-4o-2024-08-06"
+  | "gpt-4o-2024-05-13"
+  | "cerebras-llama-3.3-70b"
+  | "cerebras-llama-3.1-8b"
+  | "o1-mini"
+  | "o1-preview"
+  | "o3-mini"
+  | "gpt-4.5-preview"
+  | "groq-llama-3.3-70b-specdec"
+  | "groq-llama-3.3-70b-versatile"
+  | "gemini-1.5-flash"
+  | "gemini-1.5-pro"
+  | "gemini-1.5-flash-8b"
+  | "gemini-2.0-flash-lite"
+  | "gemini-2.0-flash"
+  | "gemini-2.5-pro-preview-03-25"
+  | "gemini-2.5-flash-preview-04-17";
+
+export type LegacyProvider = "openai" | "anthropic" | "google";
diff --git a/packages/server-v3/src/types/rrweb.ts b/packages/server-v3/src/types/rrweb.ts
new file mode 100644
index 000000000..e2aaf9828
--- /dev/null
+++ b/packages/server-v3/src/types/rrweb.ts
@@ -0,0 +1,21 @@
+export interface Node {
+  type: string;
+  tagName?: string;
+  attributes?: Record<string, string>;
+  childNodes?: Node[];
+  textContent?: string;
+  id: number;
+}
+
+export interface Event {
+  type: number;
+  /*
+  The data object is different for each event type
+  but we're only accessing it when the data follows
+  this structure, so we can just type this way.
+  */
+  data: { node: Node };
+  sessionId?: string;
+  timestamp: Date;
+  actionId: string;
+}
diff --git a/packages/server-v3/test/integration/api-server-cache.test.ts b/packages/server-v3/test/integration/api-server-cache.test.ts
new file mode 100644
index 000000000..0cd113642
--- /dev/null
+++ b/packages/server-v3/test/integration/api-server-cache.test.ts
@@ -0,0 +1,123 @@
+import assert from "node:assert/strict";
+import { after, before, describe, it } from "node:test";
+
+import {
+  assertFetchOk,
+  assertFetchStatus,
+  createSession,
+  endSession,
+  fetchWithContext,
+  getBaseUrl,
+  getHeaders,
+  HTTP_OK,
+  navigateSession,
+} from "./utils.js";
+
+// Shared read-only session — extract is safe to re-use across tests.
+let sessionId: string;
+
+before(async () => {
+  sessionId = await createSession(getHeaders("3.0.0"));
+  const nav = await navigateSession(
+    sessionId,
+    "https://example.com",
+    getHeaders("3.0.0"),
+  );
+  assert.equal(nav.status, HTTP_OK, "Navigate should succeed");
+});
+
+after(async () => {
+  await endSession(sessionId, getHeaders("3.0.0"));
+});
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function extractUrl() {
+  return `${getBaseUrl()}/v1/sessions/${sessionId}/extract`;
+}
+
+function extractBody(instruction = "extract the page title") {
+  return JSON.stringify({ instruction });
+}
+
+// ---------------------------------------------------------------------------
+// browserbase-cache-bypass request header
+// ---------------------------------------------------------------------------
+
+describe("browserbase-cache-bypass request header", () => {
+  it("request with bypass header does not return cache HIT", async () => {
+    const ctx = await fetchWithContext(extractUrl(), {
+      method: "POST",
+      headers: {
+        ...getHeaders("3.0.0"),
+        "browserbase-cache-bypass": "true",
+      },
+      body: extractBody(),
+    });
+
+    assertFetchStatus(ctx, HTTP_OK, "Extract with bypass should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+
+    const cacheStatus = ctx.headers.get("browserbase-cache-status");
+    assert.notEqual(
+      cacheStatus,
+      "HIT",
+      "A bypassed request must not return a cache HIT",
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// browserbase-cache-status response header
+// ---------------------------------------------------------------------------
+
+describe("browserbase-cache-status response header", () => {
+  it("returns HIT or MISS when the header is present", async () => {
+    const ctx = await fetchWithContext(extractUrl(), {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: extractBody(),
+    });
+
+    assertFetchStatus(ctx, HTTP_OK, "Extract should succeed");
+
+    const cacheStatus = ctx.headers.get("browserbase-cache-status");
+    if (cacheStatus !== null) {
+      assert.ok(
+        cacheStatus === "HIT" || cacheStatus === "MISS",
+        `browserbase-cache-status must be HIT or MISS, got: ${cacheStatus}`,
+      );
+    }
+  });
+
+  it("returns HIT on a repeated identical request when caching is active", async () => {
+    const body = extractBody("count the number of links");
+
+    // First call — warms the cache.
+    const first = await fetchWithContext(extractUrl(), {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body,
+    });
+    assertFetchStatus(first, HTTP_OK, "First extract should succeed");
+
+    // Second call — should be a HIT if server-side caching is enabled.
+    const second = await fetchWithContext(extractUrl(), {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body,
+    });
+    assertFetchStatus(second, HTTP_OK, "Second extract should succeed");
+
+    const cacheStatus = second.headers.get("browserbase-cache-status");
+    if (cacheStatus !== null) {
+      assert.equal(
+        cacheStatus,
+        "HIT",
+        "Repeated identical request should be a cache HIT",
+      );
+    }
+  });
+});
diff --git a/packages/server-v3/test/integration/utils.ts b/packages/server-v3/test/integration/utils.ts
new file mode 100644
index 000000000..affda41f1
--- /dev/null
+++ b/packages/server-v3/test/integration/utils.ts
@@ -0,0 +1,690 @@
+import fs from "node:fs";
+import path from "node:path";
+import { chromium } from "playwright";
+
+// =============================================================================
+// HTTP Status Codes
+// =============================================================================
+
+export const HTTP_OK = 200;
+export const HTTP_BAD_REQUEST = 400;
+export const HTTP_NOT_FOUND = 404;
+export const HTTP_GONE = 410;
+export const HTTP_UNPROCESSABLE_ENTITY = 422;
+export const HTTP_INTERNAL_SERVER_ERROR = 500;
+
+// =============================================================================
+// Timing Constants
+// =============================================================================
+
+export const SESSION_CLOSE_WAIT_MS = 2000;
+
+// =============================================================================
+// Environment Variables
+// =============================================================================
+
+export const {
+  STAGEHAND_API_URL,
+  OPENAI_API_KEY,
+  GEMINI_API_KEY,
+  ANTHROPIC_API_KEY,
+} = process.env;
+
+// =============================================================================
+// Utility Functions
+// =============================================================================
+
+export function requireEnv(name: string, value: string | undefined): string {
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
+}
+
+export function getBaseUrl(): string {
+  return STAGEHAND_API_URL ?? "http://127.0.0.1:3107";
+}
+
+// =============================================================================
+// Header Generators
+// =============================================================================
+
+export function getHeaders(
+  sdkVersion: string,
+  language: string = "typescript",
+): Record<string, string> {
+  return {
+    "Content-Type": "application/json",
+    "x-model-api-key": requireEnv("OPENAI_API_KEY", OPENAI_API_KEY),
+    "x-language": language,
+    "x-sdk-version": sdkVersion,
+  };
+}
+
+// =============================================================================
+// Session Management
+// =============================================================================
+
+export interface StartSessionResponse {
+  success: boolean;
+  message?: string;
+  data?: {
+    sessionId: string;
+    cdpUrl: string;
+    available: boolean;
+  };
+}
+
+const SESSION_READY_DELAY_MS = 250;
+const LOCAL_CONNECT_TIMEOUT_MS = (() => {
+  const parsed = Number(process.env.STAGEHAND_TEST_LOCAL_CONNECT_TIMEOUT_MS);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 60_000;
+})();
+
+export interface SessionInfo {
+  sessionId: string;
+  cdpUrl: string;
+}
+
+function createLocalBrowserBody() {
+  const resolveChromePath = (): string => {
+    const explicit = process.env.CHROME_PATH;
+    if (explicit && fs.existsSync(explicit)) {
+      return explicit;
+    }
+    if (explicit) {
+      throw new Error(`CHROME_PATH does not exist: ${explicit}`);
+    }
+
+    const playwrightPath = chromium.executablePath();
+    if (playwrightPath && fs.existsSync(playwrightPath)) {
+      return playwrightPath;
+    }
+
+    throw new Error(
+      "Unable to locate a Chrome executable. Set CHROME_PATH in the test environment.",
+    );
+  };
+
+  return {
+    browser: {
+      type: "local",
+      launchOptions: {
+        headless: true,
+        executablePath: resolveChromePath(),
+        args: process.env.CI ? ["--no-sandbox"] : undefined,
+        connectTimeoutMs: LOCAL_CONNECT_TIMEOUT_MS,
+      },
+    },
+  };
+}
+
+export const LOCAL_BROWSER_BODY = createLocalBrowserBody();
+
+function readLaunchDiagnostics(launchOptions?: {
+  executablePath?: string;
+  args?: string[];
+  headless?: boolean;
+  userDataDir?: string;
+  port?: number;
+  connectTimeoutMs?: number;
+}): string {
+  const diagnostics: string[] = [];
+  const userDataDir = launchOptions?.userDataDir;
+  diagnostics.push("--- launch diagnostics ---");
+  diagnostics.push(`CHROME_PATH env: ${process.env.CHROME_PATH ?? "<unset>"}`);
+  diagnostics.push(`CI env: ${process.env.CI ?? "<unset>"}`);
+  diagnostics.push(`userDataDir: ${userDataDir ?? "<auto>"}`);
+  if (!userDataDir) {
+    diagnostics.push(
+      "chrome stdout/stderr logs unavailable (profile dir auto-managed by server launch)",
+    );
+  } else {
+    diagnostics.push(`userDataDir exists: ${fs.existsSync(userDataDir)}`);
+    if (fs.existsSync(userDataDir)) {
+      const outPath = path.join(userDataDir, "chrome-out.log");
+      const errPath = path.join(userDataDir, "chrome-err.log");
+      if (fs.existsSync(outPath)) {
+        diagnostics.push(
+          `--- chrome stdout ---\n${fs.readFileSync(outPath, "utf8")}`,
+        );
+      }
+      if (fs.existsSync(errPath)) {
+        diagnostics.push(
+          `--- chrome stderr ---\n${fs.readFileSync(errPath, "utf8")}`,
+        );
+      }
+    }
+  }
+  if (launchOptions) {
+    diagnostics.push(
+      `launch.executablePath: ${launchOptions.executablePath ?? "<unset>"}`,
+    );
+    diagnostics.push(
+      `launch.executablePath exists: ${
+        launchOptions.executablePath
+          ? fs.existsSync(launchOptions.executablePath)
+          : false
+      }`,
+    );
+    diagnostics.push(`launch.headless: ${String(launchOptions.headless)}`);
+    diagnostics.push(
+      `launch.args: ${JSON.stringify(launchOptions.args ?? [])}`,
+    );
+    diagnostics.push(`launch.port: ${launchOptions.port ?? "<auto>"}`);
+    diagnostics.push(
+      `launch.connectTimeoutMs: ${launchOptions.connectTimeoutMs ?? "<default>"}`,
+    );
+  }
+  return diagnostics.join("\n");
+}
+
+export async function createSession(
+  headers: Record<string, string>,
+): Promise<string> {
+  const info = await createSessionWithCdp(headers);
+  return info.sessionId;
+}
+
+export async function createSessionWithCdp(
+  headers: Record<string, string>,
+): Promise<SessionInfo> {
+  const url = getBaseUrl();
+  const startPayload = {
+    modelName: "gpt-4.1-nano",
+    ...createLocalBrowserBody(),
+  };
+
+  const response = await fetch(`${url}/v1/sessions/start`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(startPayload),
+  });
+
+  const responseText = await response.text();
+  let parsedBody: unknown;
+  try {
+    parsedBody = responseText ? JSON.parse(responseText) : null;
+  } catch {
+    parsedBody = responseText;
+  }
+  const body = parsedBody as StartSessionResponse;
+
+  if (!response.ok || !body?.success) {
+    const launchDiagnostics = readLaunchDiagnostics(
+      startPayload.browser?.launchOptions,
+    );
+    throw new Error(
+      `Failed to create session (status=${response.status}): ${JSON.stringify(
+        parsedBody,
+      )}\n${launchDiagnostics}`,
+    );
+  }
+  if (!body.data?.available) {
+    throw new Error(`Session not available`);
+  }
+  if (!body.data.sessionId) {
+    throw new Error("No sessionId returned");
+  }
+  if (!body.data.cdpUrl) {
+    throw new Error("No cdpUrl returned");
+  }
+
+  // Wait for session to be fully ready before returning
+  await new Promise((resolve) => setTimeout(resolve, SESSION_READY_DELAY_MS));
+
+  return {
+    sessionId: body.data.sessionId,
+    cdpUrl: body.data.cdpUrl,
+  };
+}
+
+export async function endSession(
+  sessionId: string,
+  headers: Record<string, string>,
+): Promise<void> {
+  const url = getBaseUrl();
+
+  await fetch(`${url}/v1/sessions/${sessionId}/end`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({}),
+  });
+}
+
+// =============================================================================
+// Navigation Helper
+// =============================================================================
+
+export async function navigateSession(
+  sessionId: string,
+  targetUrl: string,
+  headers: Record<string, string>,
+): Promise<Response> {
+  const url = getBaseUrl();
+
+  return fetch(`${url}/v1/sessions/${sessionId}/navigate`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ url: targetUrl, frameId: "" }),
+  });
+}
+
+/**
+ * Gets the main frame ID from a CDP session
+ */
+export async function getMainFrameId(cdpUrl: string): Promise<string> {
+  const browser = await chromium.connectOverCDP(cdpUrl);
+  try {
+    const contexts = browser.contexts();
+    if (contexts.length === 0) {
+      throw new Error("No browser contexts found");
+    }
+    const pages = contexts[0]!.pages();
+    if (pages.length === 0) {
+      throw new Error("No pages found");
+    }
+    const page = pages[0]!;
+
+    // Use CDP to get the frame tree and extract the main frame ID
+    const cdpSession = await page.context().newCDPSession(page);
+    const { frameTree } = await cdpSession.send("Page.getFrameTree");
+    await cdpSession.detach();
+
+    return frameTree.frame.id;
+  } finally {
+    await browser.close();
+  }
+}
+
+// =============================================================================
+// SSE Stream Reader
+// =============================================================================
+
+// Legacy SSE event interface (generic)
+export interface SSEEvent {
+  event?: string;
+  data?: string;
+  parsed?: unknown;
+}
+
+export async function readSSEStream(response: Response): Promise<SSEEvent[]> {
+  const reader = response.body?.getReader() as
+    | ReadableStreamDefaultReader<Uint8Array>
+    | undefined;
+  if (!reader) {
+    throw new Error("No response body reader available");
+  }
+
+  const decoder = new TextDecoder();
+  let fullResponse = "";
+
+  for (;;) {
+    const result = await reader.read();
+    if (result.done) break;
+    fullResponse += decoder.decode(result.value, { stream: true });
+  }
+
+  // Parse SSE events
+  const events: SSEEvent[] = [];
+  const rawEvents = fullResponse.split("\n\n").filter((e) => e.trim());
+
+  for (const rawEvent of rawEvents) {
+    const event: SSEEvent = {};
+    const lines = rawEvent.split("\n");
+
+    for (const line of lines) {
+      if (line.startsWith("event:")) {
+        event.event = line.slice(6).trim();
+      } else if (line.startsWith("data:")) {
+        event.data = line.slice(5).trim();
+        try {
+          event.parsed = JSON.parse(event.data);
+        } catch {
+          // Keep as string if not valid JSON
+        }
+      }
+    }
+
+    if (event.data || event.event) {
+      events.push(event);
+    }
+  }
+
+  return events;
+}
+
+// =============================================================================
+// Typed SSE Event Helpers (for stagehand-api backend format)
+// =============================================================================
+
+// Actual SSE event format from backend (see stream.ts):
+// { data: { status: "starting" | "connected" | "finished", result?: ... }, type: "system" | "log", id: "<uuid>" }
+export interface TypedSSEEvent<TResult = unknown> {
+  data: {
+    status: string;
+    result?: TResult;
+    message?: string;
+    error?: string;
+  };
+  type: string;
+  id: string;
+}
+
+/**
+ * Read SSE stream from response and return raw string
+ */
+export async function readSSEStreamRaw(response: Response): Promise<string> {
+  const reader = response.body?.getReader() as
+    | ReadableStreamDefaultReader<Uint8Array>
+    | undefined;
+  if (!reader) throw new Error("No response body reader");
+
+  const decoder = new TextDecoder();
+  let fullResponse = "";
+
+  for (;;) {
+    const result = await reader.read();
+    if (result.done) break;
+    fullResponse += decoder.decode(result.value, { stream: true });
+  }
+
+  return fullResponse;
+}
+
+/**
+ * Parse raw SSE response string into typed events
+ */
+export function parseTypedSSEEvents<TResult = unknown>(
+  rawResponse: string,
+): TypedSSEEvent<TResult>[] {
+  const events = rawResponse.split("\n\n").filter((e) => e.trim());
+  return events
+    .map((event) => {
+      const dataMatch = event.match(/data: (.+)/);
+      if (dataMatch?.[1]) {
+        return JSON.parse(dataMatch[1]) as TypedSSEEvent<TResult>;
+      }
+      return null;
+    })
+    .filter((e): e is TypedSSEEvent<TResult> => e !== null);
+}
+
+/**
+ * Result of reading an SSE stream with full context for debugging
+ */
+export interface SSEStreamResult<TResult = unknown> {
+  /** HTTP status code */
+  status: number;
+  /** HTTP status text */
+  statusText: string;
+  /** Raw response body */
+  raw: string;
+  /** Parsed SSE events */
+  events: TypedSSEEvent<TResult>[];
+  /** Get debug summary for error messages */
+  debugSummary(): string;
+}
+
+/**
+ * Read SSE stream and parse into typed events (legacy - no debug context)
+ */
+export async function readTypedSSEStream<TResult = unknown>(
+  response: Response,
+): Promise<TypedSSEEvent<TResult>[]> {
+  const raw = await readSSEStreamRaw(response);
+  return parseTypedSSEEvents<TResult>(raw);
+}
+
+/**
+ * Read SSE stream with full context for debugging test failures.
+ * Use this instead of readTypedSSEStream when you need better error messages.
+ */
+export async function readTypedSSEStreamWithContext<TResult = unknown>(
+  response: Response,
+): Promise<SSEStreamResult<TResult>> {
+  const status = response.status;
+  const statusText = response.statusText;
+  const raw = await readSSEStreamRaw(response);
+  const events = parseTypedSSEEvents<TResult>(raw);
+
+  return {
+    status,
+    statusText,
+    raw,
+    events,
+    debugSummary() {
+      const eventStatuses = events.map((e) => e.data.status).join(" → ");
+      const errorEvents = events.filter((e) => e.data.status === "error");
+      const errorMessages = errorEvents
+        .map((e) => e.data.error ?? "unknown error")
+        .join(", ");
+
+      let summary = `HTTP ${status} ${statusText}`;
+      if (events.length === 0) {
+        summary += `\n  No SSE events received`;
+        summary += `\n  Raw response: ${raw.slice(0, 500)}${raw.length > 500 ? "..." : ""}`;
+      } else {
+        summary += `\n  Events (${events.length}): ${eventStatuses}`;
+        if (errorMessages) {
+          summary += `\n  Errors: ${errorMessages}`;
+        }
+      }
+      return summary;
+    },
+  };
+}
+
+/**
+ * Assert with debug context - includes SSE stream info on failure
+ */
+export function assertWithContext(
+  condition: boolean,
+  message: string,
+  context: SSEStreamResult<unknown>,
+): asserts condition {
+  if (!condition) {
+    throw new Error(`${message}\n\nDebug context:\n${context.debugSummary()}`);
+  }
+}
+
+/**
+ * Assert SSE event exists with debug context on failure, returns the found event
+ */
+export function assertEventExists<TResult>(
+  events: TypedSSEEvent<TResult>[],
+  status: string,
+  context: SSEStreamResult<TResult>,
+): TypedSSEEvent<TResult> {
+  const found = events.find((e) => e.data.status === status);
+  assertWithContext(
+    found !== undefined,
+    `Should have a "${status}" event`,
+    context,
+  );
+  return found;
+}
+
+/**
+ * Assert HTTP status with debug context on failure
+ */
+export function assertHttpStatus(
+  context: SSEStreamResult<unknown>,
+  expectedStatus: number,
+  message?: string,
+): void {
+  assertWithContext(
+    context.status === expectedStatus,
+    message ?? `Expected HTTP ${expectedStatus}, got ${context.status}`,
+    context,
+  );
+}
+
+// =============================================================================
+// JSON Response Debug Utilities (for non-SSE tests)
+// =============================================================================
+
+/**
+ * Result of a fetch request with full context for debugging
+ */
+export interface FetchResult<T = unknown> {
+  /** HTTP status code */
+  status: number;
+  /** HTTP status text */
+  statusText: string;
+  /** Parsed JSON body (if parseable) */
+  body: T | null;
+  /** Raw response text */
+  raw: string;
+  /** Request duration in ms */
+  durationMs: number;
+  /** Response headers */
+  headers: Headers;
+  /** Get debug summary for error messages */
+  debugSummary(): string;
+}
+
+/**
+ * Fetch with full context for debugging test failures.
+ * Captures timing, status, and response body.
+ */
+export async function fetchWithContext<T = unknown>(
+  url: string,
+  options: RequestInit,
+): Promise<FetchResult<T>> {
+  const startTime = Date.now();
+  let response: Response;
+
+  try {
+    response = await fetch(url, options);
+  } catch (err) {
+    const durationMs = Date.now() - startTime;
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    return {
+      status: 0,
+      statusText: "FETCH_ERROR",
+      body: null,
+      raw: errorMsg,
+      durationMs,
+      headers: new Headers(),
+      debugSummary() {
+        return `Fetch failed after ${durationMs}ms: ${errorMsg}`;
+      },
+    };
+  }
+
+  const durationMs = Date.now() - startTime;
+  const status = response.status;
+  const statusText = response.statusText;
+  const headers = response.headers;
+  const raw = await response.text();
+
+  let body: T | null = null;
+  try {
+    body = JSON.parse(raw) as T;
+  } catch {
+    // Keep body as null if not valid JSON
+  }
+
+  return {
+    status,
+    statusText,
+    body,
+    raw,
+    durationMs,
+    headers,
+    debugSummary() {
+      const seconds = (durationMs / 1000).toFixed(1);
+      let summary = `HTTP ${status} ${statusText} (${seconds}s)`;
+
+      if (body && typeof body === "object") {
+        const b = body as Record<string, unknown>;
+        if (b.success === false && typeof b.message === "string") {
+          summary += `\n  Error: ${b.message}`;
+        }
+        if (typeof b.error === "string") {
+          summary += `\n  Error: ${b.error}`;
+        }
+      }
+
+      // Show raw response if it's an error or unexpected
+      if (status >= 400 || !body) {
+        const truncated = raw.slice(0, 500);
+        summary += `\n  Response: ${truncated}${raw.length > 500 ? "..." : ""}`;
+      }
+
+      return summary;
+    },
+  };
+}
+
+/**
+ * Assert with fetch context - includes response info on failure
+ */
+export function assertFetchOk<T>(
+  condition: boolean,
+  message: string,
+  context: FetchResult<T>,
+): asserts condition {
+  if (!condition) {
+    throw new Error(`${message}\n\nDebug context:\n${context.debugSummary()}`);
+  }
+}
+
+/**
+ * Assert fetch succeeded with expected status
+ */
+export function assertFetchStatus<T>(
+  context: FetchResult<T>,
+  expectedStatus: number,
+  message?: string,
+): void {
+  assertFetchOk(
+    context.status === expectedStatus,
+    message ?? `Expected HTTP ${expectedStatus}, got ${context.status}`,
+    context,
+  );
+}
+
+// =============================================================================
+// Test Context Manager
+// =============================================================================
+
+export class TestSession {
+  public sessionId: string | null = null;
+  private headers: Record<string, string>;
+
+  constructor(headers: Record<string, string>) {
+    this.headers = headers;
+  }
+
+  async start(): Promise<string> {
+    this.sessionId = await createSession(this.headers);
+    return this.sessionId;
+  }
+
+  async navigate(targetUrl: string): Promise<Response> {
+    if (!this.sessionId) {
+      throw new Error("Session not started");
+    }
+    return navigateSession(this.sessionId, targetUrl, this.headers);
+  }
+
+  async end(): Promise<void> {
+    if (this.sessionId) {
+      try {
+        await endSession(this.sessionId, this.headers);
+      } catch {
+        // Ignore errors when ending session
+      }
+      this.sessionId = null;
+    }
+  }
+
+  getSessionId(): string {
+    if (!this.sessionId) {
+      throw new Error("Session not started");
+    }
+    return this.sessionId;
+  }
+}
diff --git a/packages/server-v3/test/integration/v3/act.test.ts b/packages/server-v3/test/integration/v3/act.test.ts
new file mode 100644
index 000000000..32384776f
--- /dev/null
+++ b/packages/server-v3/test/integration/v3/act.test.ts
@@ -0,0 +1,461 @@
+import assert from "node:assert/strict";
+import { after, before, beforeEach, describe, it } from "node:test";
+
+import { chromium } from "playwright";
+
+import {
+  assertEventExists,
+  assertFetchOk,
+  assertFetchStatus,
+  assertWithContext,
+  createSessionWithCdp,
+  endSession,
+  fetchWithContext,
+  GEMINI_API_KEY,
+  getBaseUrl,
+  getHeaders,
+  getMainFrameId,
+  HTTP_OK,
+  navigateSession,
+  OPENAI_API_KEY,
+  readTypedSSEStreamWithContext,
+  requireEnv,
+} from "../utils.js";
+
+interface ActResponse {
+  success: boolean;
+  data?: {
+    result: { success: boolean; message?: string };
+    actionId?: string;
+  };
+}
+
+/** Result type for act SSE events */
+interface ActResult {
+  success: boolean;
+  message?: string;
+  action?: string;
+}
+
+// Module-level session variable shared across all describe blocks
+let sessionId: string;
+let cdpUrl: string;
+
+// Single session creation for all tests
+before(async () => {
+  ({ sessionId, cdpUrl } = await createSessionWithCdp(getHeaders("3.0.0")));
+});
+
+// Navigate back to example.com before each test since act() may navigate away
+beforeEach(async () => {
+  const navResponse = await navigateSession(
+    sessionId,
+    "https://example.com",
+    getHeaders("3.0.0"),
+  );
+  assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+});
+
+// Single session cleanup after all tests
+after(async () => {
+  await endSession(sessionId, getHeaders("3.0.0"));
+});
+
+// =============================================================================
+// POST /v1/sessions/:id/act (V3 Format)
+// =============================================================================
+
+describe("POST /v1/sessions/:id/act (V3)", () => {
+  // ===========================================================================
+  // V3 Format Tests
+  // ===========================================================================
+
+  it("should perform an action using string input format", async () => {
+    const url = getBaseUrl();
+    const frameId = await getMainFrameId(cdpUrl);
+
+    const ctx = await fetchWithContext<ActResponse>(
+      `${url}/v1/sessions/${sessionId}/act`,
+      {
+        method: "POST",
+        headers: {
+          ...getHeaders("3.0.0"),
+        },
+        body: JSON.stringify({
+          input: "click the Learn more link",
+          frameId,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "act should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result.success,
+      "boolean",
+      "Result should have success boolean",
+    );
+
+    // Verify navigation via CDP
+    const browser = await chromium.connectOverCDP(cdpUrl);
+    const contexts = browser.contexts();
+    assert.ok(contexts.length > 0, "Should have at least one browser context");
+    const pages = contexts[0]!.pages();
+    assert.ok(pages.length > 0, "Should have at least one page");
+    const pageUrl = pages[0]!.url();
+    assert.ok(
+      pageUrl.includes("iana.org/help/example-domains"),
+      `Page URL should be iana.org/help/example-domains, got: ${pageUrl}`,
+    );
+    await browser.close();
+  });
+
+  it("should perform an action using object input format", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<ActResponse>(
+      `${url}/v1/sessions/${sessionId}/act`,
+      {
+        method: "POST",
+        headers: {
+          ...getHeaders("3.0.0"),
+        },
+        body: JSON.stringify({
+          input: {
+            selector: "a",
+            description: "Click a link on the page",
+            method: "click",
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "act with object input should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result.success,
+      "boolean",
+      "Result should have success boolean",
+    );
+  });
+
+  it("should accept options with string input", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<ActResponse>(
+      `${url}/v1/sessions/${sessionId}/act`,
+      {
+        method: "POST",
+        headers: {
+          ...getHeaders("3.0.0"),
+        },
+        body: JSON.stringify({
+          input: "click the Learn more link",
+          options: {
+            timeout: 30000,
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "act with options should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result.success,
+      "boolean",
+      "Result should have success boolean",
+    );
+  });
+
+  // ===========================================================================
+  // V3 Inline Model Configuration Tests
+  // ===========================================================================
+
+  it("should perform action with inline model config (modelName + apiKey)", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const ctx = await fetchWithContext<ActResponse>(
+      `${url}/v1/sessions/${sessionId}/act`,
+      {
+        method: "POST",
+        headers: {
+          ...getHeaders("3.0.0"),
+          "x-model-api-key": "", // Clear the header to ensure body config is used
+        },
+        body: JSON.stringify({
+          input: "click the Learn more link",
+          options: {
+            model: {
+              modelName: "openai/gpt-4.1-nano",
+              apiKey: openaiApiKey,
+            },
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "act with inline model config should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result.success,
+      "boolean",
+      "Result should have success boolean",
+    );
+  });
+
+  it("should perform action with inline model config and options", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const ctx = await fetchWithContext<ActResponse>(
+      `${url}/v1/sessions/${sessionId}/act`,
+      {
+        method: "POST",
+        headers: {
+          ...getHeaders("3.0.0"),
+          "x-model-api-key": "", // Clear the header to ensure body config is used
+        },
+        body: JSON.stringify({
+          input: "click the Learn more link",
+          options: {
+            model: {
+              modelName: "openai/gpt-4.1-nano",
+              apiKey: openaiApiKey,
+            },
+            timeout: 30000,
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "act with inline model config and options should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result.success,
+      "boolean",
+      "Result should have success boolean",
+    );
+  });
+
+  it("should perform action with object input and inline model config", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const ctx = await fetchWithContext<ActResponse>(
+      `${url}/v1/sessions/${sessionId}/act`,
+      {
+        method: "POST",
+        headers: {
+          ...getHeaders("3.0.0"),
+          "x-model-api-key": "", // Clear the header to ensure body config is used
+        },
+        body: JSON.stringify({
+          input: {
+            selector: "a",
+            description: "Click a link on the page",
+            method: "click",
+          },
+          options: {
+            model: {
+              modelName: "openai/gpt-4.1-nano",
+              apiKey: openaiApiKey,
+            },
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "act with object input and inline model config should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result.success,
+      "boolean",
+      "Result should have success boolean",
+    );
+  });
+
+  it("should perform action with google/gemini-2.5-flash-lite model", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    const ctx = await fetchWithContext<ActResponse>(
+      `${url}/v1/sessions/${sessionId}/act`,
+      {
+        method: "POST",
+        headers: {
+          ...getHeaders("3.0.0"),
+          "x-model-api-key": "", // Clear the header to ensure body config is used
+        },
+        body: JSON.stringify({
+          input: "click the Learn more link",
+          options: {
+            model: {
+              modelName: "google/gemini-2.5-flash-lite",
+              apiKey: geminiApiKey,
+            },
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "act with google/gemini-2.5-flash-lite model should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result.success,
+      "boolean",
+      "Result should have success boolean",
+    );
+  });
+});
+
+// =============================================================================
+// SSE Streaming Tests (V3)
+// =============================================================================
+
+describe("POST /v1/sessions/:id/act with SSE streaming (V3)", () => {
+  it("should stream valid SSE events with correct structure", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v1/sessions/${sessionId}/act`, {
+      method: "POST",
+      headers: {
+        ...getHeaders("3.0.0"),
+      },
+      body: JSON.stringify({
+        input: "click the Learn more link",
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ActResult>(response);
+    const { events } = ctx;
+
+    assertWithContext(
+      events.length >= 2,
+      "Should have at least starting and finished events",
+      ctx,
+    );
+
+    // Verify starting event
+    const startingEvent = assertEventExists(events, "starting", ctx);
+    assert.equal(
+      startingEvent.type,
+      "system",
+      "Starting event should be system type",
+    );
+
+    // Verify finished event with result
+    const finishedEvent = assertEventExists(events, "finished", ctx);
+    assert.equal(
+      finishedEvent.type,
+      "system",
+      "Finished event should be system type",
+    );
+    assertWithContext(
+      !!finishedEvent.data.result,
+      "Finished event must have result",
+      ctx,
+    );
+    assert.equal(
+      typeof finishedEvent.data.result.success,
+      "boolean",
+      "Result.success must be a boolean",
+    );
+  });
+
+  it("should stream SSE events with inline model config", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const response = await fetch(`${url}/v1/sessions/${sessionId}/act`, {
+      method: "POST",
+      headers: {
+        ...getHeaders("3.0.0"),
+        "x-model-api-key": "", // Clear the header to ensure body config is used
+      },
+      body: JSON.stringify({
+        input: "click the Learn more link",
+        options: {
+          model: {
+            modelName: "openai/gpt-4.1-nano",
+            apiKey: openaiApiKey,
+          },
+        },
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ActResult>(response);
+    const { events } = ctx;
+
+    assertWithContext(
+      events.length >= 2,
+      "Should have at least starting and finished events",
+      ctx,
+    );
+
+    // Verify starting event
+    const startingEvent = assertEventExists(events, "starting", ctx);
+    assert.equal(
+      startingEvent.type,
+      "system",
+      "Starting event should be system type",
+    );
+
+    // Verify finished event with result
+    const finishedEvent = assertEventExists(events, "finished", ctx);
+    assert.equal(
+      finishedEvent.type,
+      "system",
+      "Finished event should be system type",
+    );
+    assertWithContext(
+      !!finishedEvent.data.result,
+      "Finished event must have result",
+      ctx,
+    );
+    assert.equal(
+      typeof finishedEvent.data.result.success,
+      "boolean",
+      "Result.success must be a boolean",
+    );
+  });
+});
diff --git a/packages/server-v3/test/integration/v3/agentExecute.test.ts b/packages/server-v3/test/integration/v3/agentExecute.test.ts
new file mode 100644
index 000000000..3c984d650
--- /dev/null
+++ b/packages/server-v3/test/integration/v3/agentExecute.test.ts
@@ -0,0 +1,1220 @@
+import assert from "node:assert/strict";
+import { after, before, beforeEach, describe, it } from "node:test";
+
+import {
+  assertFetchOk,
+  assertFetchStatus,
+  assertWithContext,
+  createSession,
+  createSessionWithCdp,
+  endSession,
+  fetchWithContext,
+  GEMINI_API_KEY,
+  getBaseUrl,
+  getHeaders,
+  getMainFrameId,
+  HTTP_BAD_REQUEST,
+  HTTP_OK,
+  HTTP_UNPROCESSABLE_ENTITY,
+  navigateSession,
+  OPENAI_API_KEY,
+  readTypedSSEStreamWithContext,
+  requireEnv,
+} from "../utils.js";
+
+// =============================================================================
+// POST /v1/sessions/:id/agentExecute (V3 Format)
+// =============================================================================
+
+describe("POST /v1/sessions/:id/agentExecute (V3) - Basic Config", () => {
+  let sessionId: string;
+  let cdpUrl: string;
+  const headers = getHeaders("3.0.0");
+
+  before(async () => {
+    ({ sessionId, cdpUrl } = await createSessionWithCdp(headers));
+  });
+
+  beforeEach(async () => {
+    // Navigate to example.com before each test (including first)
+    const navResponse = await navigateSession(
+      sessionId,
+      "https://example.com",
+      headers,
+    );
+    assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+  });
+
+  after(async () => {
+    if (sessionId) {
+      await endSession(sessionId, headers);
+      sessionId = "";
+    }
+  });
+
+  it("should execute agent with basic config (empty agentConfig)", async () => {
+    const url = getBaseUrl();
+    const frameId = await getMainFrameId(cdpUrl);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {},
+        executeOptions: {
+          instruction: "Describe the main heading on this page",
+          frameId,
+        },
+      }),
+    });
+
+    assertFetchStatus(ctx, HTTP_OK, "V3 agent execute should succeed");
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with string agentConfig.model", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          model: "gpt-4.1-nano",
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with string model should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with object model config (provider + modelName)", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          model: {
+            provider: "openai",
+            modelName: "gpt-4.1-nano",
+          },
+        },
+        executeOptions: {
+          instruction: "Describe the page content",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with object model should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with systemPrompt and maxSteps", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          systemPrompt: "You are a helpful web browsing assistant.",
+        },
+        executeOptions: {
+          instruction: "Find and describe the main content",
+          maxSteps: 3,
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with systemPrompt and maxSteps should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+});
+
+// ===========================================================================
+// V3 Format Tests with model: {modelName, apiKey} format - Google Gemini
+// ===========================================================================
+
+describe("POST /v1/sessions/:id/agentExecute (V3) - Google Gemini with API key", () => {
+  let sessionId: string;
+  const headers = getHeaders("3.0.0");
+
+  before(async () => {
+    sessionId = await createSession(headers);
+  });
+
+  beforeEach(async () => {
+    // Navigate to example.com before each test (including first)
+    const navResponse = await navigateSession(
+      sessionId,
+      "https://example.com",
+      headers,
+    );
+    assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+  });
+
+  after(async () => {
+    if (sessionId) {
+      await endSession(sessionId, headers);
+      sessionId = "";
+    }
+  });
+
+  it("should execute agent with Google model object containing modelName and apiKey", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          model: {
+            modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+            apiKey: geminiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with Google model object should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with Google model object, systemPrompt, and maxSteps", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          model: {
+            modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+            apiKey: geminiApiKey,
+          },
+          systemPrompt: "You are a helpful web browsing assistant.",
+        },
+        executeOptions: {
+          instruction: "Find and read the main heading",
+          maxSteps: 3,
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with Google model, systemPrompt and maxSteps should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+});
+
+// ===========================================================================
+// V3 Format Tests with OpenAI model: {modelName, apiKey} format
+// ===========================================================================
+
+describe("POST /v1/sessions/:id/agentExecute (V3) - OpenAI with API key", () => {
+  let sessionId: string;
+  const headers = getHeaders("3.0.0");
+
+  before(async () => {
+    sessionId = await createSession(headers);
+  });
+
+  beforeEach(async () => {
+    // Navigate to example.com before each test (including first)
+    const navResponse = await navigateSession(
+      sessionId,
+      "https://example.com",
+      headers,
+    );
+    assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+  });
+
+  after(async () => {
+    if (sessionId) {
+      await endSession(sessionId, headers);
+      sessionId = "";
+    }
+  });
+
+  it("should execute agent with OpenAI model object containing modelName and apiKey", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          model: {
+            modelName: "openai/gpt-4.1-nano",
+            apiKey: openaiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with OpenAI model object should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+});
+
+// ===========================================================================
+// V3 CUA Mode Tests - Testing explicit cua flag with model compatibility
+// ===========================================================================
+
+describe("POST /v1/sessions/:id/agentExecute (V3) - CUA flag compatibility", () => {
+  let sessionId: string;
+  const headers = getHeaders("3.0.0");
+
+  before(async () => {
+    sessionId = await createSession(headers);
+  });
+
+  beforeEach(async () => {
+    // Navigate to example.com before each test (including first)
+    const navResponse = await navigateSession(
+      sessionId,
+      "https://example.com",
+      headers,
+    );
+    assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+  });
+
+  after(async () => {
+    if (sessionId) {
+      await endSession(sessionId, headers);
+      sessionId = "";
+    }
+  });
+
+  it("should execute agent with cua: true and CUA model (valid combination)", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          cua: true,
+          model: {
+            modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+            apiKey: geminiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with cua: true and CUA model should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with cua: false and non-CUA model (valid combination)", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          cua: false,
+          model: {
+            modelName: "openai/gpt-4.1-nano",
+            apiKey: openaiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with cua: false and non-CUA model should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with cua: false and CUA model (works in non-CUA mode)", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      message?: string;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          cua: false,
+          model: {
+            modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+            apiKey: geminiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with cua: false and Google CUA model should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should fail with cua: true and non-CUA model (invalid combination)", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      message?: string;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          cua: true,
+          model: {
+            modelName: "google/gemini-2.5-flash-lite",
+            apiKey: geminiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_UNPROCESSABLE_ENTITY,
+      "V3 agent execute with cua: true and non-CUA model should fail",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(!ctx.body.success, "Response should indicate failure", ctx);
+  });
+
+  it("should prefer mode over cua when both are provided", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          cua: true,
+          mode: "dom",
+          model: {
+            modelName: "openai/gpt-4.1-nano",
+            apiKey: openaiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with mode: dom and cua: true should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+});
+
+// =============================================================================
+// V3 executionModel Tests - Testing agentConfig.executionModel serialization
+// =============================================================================
+
+describe("POST /v1/sessions/:id/agentExecute (V3) - executionModel serialization", () => {
+  let sessionId: string;
+  const headers = getHeaders("3.0.0");
+
+  before(async () => {
+    sessionId = await createSession(headers);
+  });
+
+  beforeEach(async () => {
+    // Navigate to example.com before each test (including first)
+    const navResponse = await navigateSession(
+      sessionId,
+      "https://example.com",
+      headers,
+    );
+    assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+  });
+
+  after(async () => {
+    if (sessionId) {
+      await endSession(sessionId, headers);
+      sessionId = "";
+    }
+  });
+
+  it("should execute agent with string executionModel", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          executionModel: "gpt-4.1-nano",
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with string executionModel should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with object executionModel (modelName and apiKey)", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          executionModel: {
+            modelName: "openai/gpt-4.1-nano",
+            apiKey: openaiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "Describe the main content of this page",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with object executionModel should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with both model and executionModel", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          model: {
+            modelName: "openai/gpt-4.1-nano",
+            apiKey: openaiApiKey,
+          },
+          executionModel: {
+            modelName: "openai/gpt-4.1-nano",
+            apiKey: openaiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with both model and executionModel should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+});
+
+// =============================================================================
+// V3 Mode Tests - Testing agentConfig.mode field (dom, hybrid, cua)
+// =============================================================================
+
+describe("POST /v1/sessions/:id/agentExecute - agentConfig.mode (V3)", () => {
+  let sessionId: string;
+  const headers = getHeaders("3.0.0");
+
+  before(async () => {
+    sessionId = await createSession(headers);
+  });
+
+  beforeEach(async () => {
+    // Navigate to example.com before each test (including first)
+    const navResponse = await navigateSession(
+      sessionId,
+      "https://example.com",
+      headers,
+    );
+    assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+  });
+
+  after(async () => {
+    if (sessionId) {
+      await endSession(sessionId, headers);
+      sessionId = "";
+    }
+  });
+
+  it("should execute agent with mode: dom", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          mode: "dom",
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with mode: dom should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with mode: hybrid", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          mode: "hybrid",
+          model: {
+            provider: "google", // bonus: test split provider/modelName format
+            modelName: "gemini-2.5-flash-preview-04-17",
+            apiKey: geminiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "Describe the main heading on this page",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with mode: hybrid should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with mode: cua and CUA model", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          mode: "cua",
+          model: {
+            modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+            apiKey: geminiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is visible on this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with mode: cua and CUA model should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+});
+
+// =============================================================================
+// SSE Streaming Tests (V3)
+// =============================================================================
+
+describe("POST /v1/sessions/:id/agentExecute with SSE streaming (V3)", () => {
+  let sessionId: string;
+  const headers = getHeaders("3.0.0");
+
+  before(async () => {
+    sessionId = await createSession(headers);
+  });
+
+  beforeEach(async () => {
+    // Navigate to example.com before each test (including first)
+    const navResponse = await navigateSession(
+      sessionId,
+      "https://example.com",
+      headers,
+    );
+    assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+  });
+
+  after(async () => {
+    if (sessionId) {
+      await endSession(sessionId, headers);
+      sessionId = "";
+    }
+  });
+
+  it("should stream SSE events with valid structure, sequence, and UUIDs", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(
+      `${url}/v1/sessions/${sessionId}/agentExecute`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          agentConfig: {},
+          executeOptions: {
+            instruction: "Describe the main content on the page",
+          },
+          streamResponse: true,
+        }),
+      },
+    );
+
+    const ctx = await readTypedSSEStreamWithContext(response);
+
+    // Verify event count
+    assertWithContext(
+      ctx.events.length >= 2,
+      "Should have at least starting and finished events",
+      ctx,
+    );
+
+    // Verify event sequence
+    const startingIndex = ctx.events.findIndex(
+      (e) => e.data.status === "starting",
+    );
+    const connectedIndex = ctx.events.findIndex(
+      (e) => e.data.status === "connected",
+    );
+    const finishedIndex = ctx.events.findIndex(
+      (e) => e.data.status === "finished",
+    );
+
+    assertWithContext(
+      startingIndex !== -1,
+      "Should have a starting event",
+      ctx,
+    );
+    assertWithContext(
+      connectedIndex !== -1,
+      "Should have a connected event",
+      ctx,
+    );
+    assertWithContext(
+      finishedIndex !== -1,
+      "Should have a finished event",
+      ctx,
+    );
+    assertWithContext(
+      startingIndex < connectedIndex,
+      "Starting event must come before connected event",
+      ctx,
+    );
+    assertWithContext(
+      connectedIndex < finishedIndex,
+      "Connected event must come before finished event",
+      ctx,
+    );
+
+    // Verify event types
+    const startingEvent = ctx.events[startingIndex];
+    const finishedEvent = ctx.events[finishedIndex];
+
+    assertWithContext(
+      startingEvent !== undefined,
+      "Starting event should exist",
+      ctx,
+    );
+    assertWithContext(
+      finishedEvent !== undefined,
+      "Finished event should exist",
+      ctx,
+    );
+    assertWithContext(
+      startingEvent.type === "system",
+      "Starting event should be system type",
+      ctx,
+    );
+    assertWithContext(
+      finishedEvent.type === "system",
+      "Finished event should be system type",
+      ctx,
+    );
+    assertWithContext(
+      finishedEvent.data.result !== undefined,
+      "Finished event must have result",
+      ctx,
+    );
+
+    // Verify UUID format
+    const uuidRegex =
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+    for (const event of ctx.events) {
+      assertWithContext(
+        uuidRegex.test(event.id),
+        `Event id should be a valid UUID format, got: ${event.id}`,
+        ctx,
+      );
+    }
+  });
+});
+
+// =============================================================================
+// Validation Error Tests (V3)
+// =============================================================================
+
+describe("POST /v1/sessions/:id/agentExecute - validation errors (V3)", () => {
+  let sessionId: string;
+  const headers = getHeaders("3.0.0");
+
+  before(async () => {
+    sessionId = await createSession(headers);
+  });
+
+  beforeEach(async () => {
+    // Navigate to example.com before each test (including first)
+    const navResponse = await navigateSession(
+      sessionId,
+      "https://example.com",
+      headers,
+    );
+    assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+  });
+
+  after(async () => {
+    if (sessionId) {
+      await endSession(sessionId, headers);
+      sessionId = "";
+    }
+  });
+
+  it("should return 400 when agentConfig is missing", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success?: boolean;
+      error?: string;
+      message?: string;
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        executeOptions: {
+          instruction: "Do something",
+        },
+      }),
+    });
+
+    assertFetchStatus(ctx, HTTP_BAD_REQUEST);
+    assertFetchOk(
+      !ctx.body?.success || ctx.body.error !== undefined,
+      "Response should indicate failure",
+      ctx,
+    );
+  });
+
+  it("should return 400 when executeOptions is missing", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success?: boolean;
+      error?: string;
+      message?: string;
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          model: {
+            modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+          },
+        },
+      }),
+    });
+
+    assertFetchStatus(ctx, HTTP_BAD_REQUEST);
+    assertFetchOk(
+      !ctx.body?.success || ctx.body.error !== undefined,
+      "Response should indicate failure",
+      ctx,
+    );
+  });
+
+  it("should return 400 when instruction is missing", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success?: boolean;
+      error?: string;
+      message?: string;
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          model: {
+            modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+          },
+        },
+        executeOptions: {
+          maxSteps: 5,
+        },
+      }),
+    });
+
+    assertFetchStatus(ctx, HTTP_BAD_REQUEST);
+    assertFetchOk(
+      !ctx.body?.success || ctx.body.error !== undefined,
+      "Response should indicate failure",
+      ctx,
+    );
+  });
+
+  it("should return 400 for invalid agentConfig.mode", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success?: boolean;
+      error?: string;
+      message?: string;
+    }>(`${url}/v1/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          mode: "invalid-mode",
+        },
+        executeOptions: {
+          instruction: "Do something",
+        },
+      }),
+    });
+
+    assertFetchStatus(ctx, HTTP_BAD_REQUEST);
+    assertFetchOk(
+      !ctx.body?.success || ctx.body.error !== undefined,
+      "Response should indicate failure",
+      ctx,
+    );
+  });
+});
diff --git a/packages/server-v3/test/integration/v3/end.test.ts b/packages/server-v3/test/integration/v3/end.test.ts
new file mode 100644
index 000000000..cd330be05
--- /dev/null
+++ b/packages/server-v3/test/integration/v3/end.test.ts
@@ -0,0 +1,182 @@
+import { after, before, describe, it } from "node:test";
+
+import assert from "node:assert/strict";
+
+import {
+  assertFetchOk,
+  assertFetchStatus,
+  createSession,
+  endSession,
+  fetchWithContext,
+  getBaseUrl,
+  getHeaders,
+  HTTP_BAD_REQUEST,
+  HTTP_NOT_FOUND,
+  HTTP_INTERNAL_SERVER_ERROR,
+  HTTP_OK,
+} from "../utils.js";
+
+// =============================================================================
+// POST /v1/sessions/:id/end (V3 Format)
+// =============================================================================
+
+describe("POST /v1/sessions/:id/end (V3)", () => {
+  const headers = getHeaders("3.0.0");
+  let sessionId: string;
+
+  before(async () => {
+    sessionId = await createSession(headers);
+  });
+
+  after(async () => {
+    // Try to clean up in case test didn't end the session
+    try {
+      await endSession(sessionId, headers);
+    } catch {
+      // Ignore - session may already be ended
+    }
+  });
+
+  it("should return 200 if JSON content-type has an empty body", async () => {
+    const url = getBaseUrl();
+    // Create a fresh session for this test since we need to test error cases
+    const testSessionId = await createSession(headers);
+
+    const response = await fetch(`${url}/v1/sessions/${testSessionId}/end`, {
+      method: "POST",
+      headers: {
+        ...headers,
+        "Content-Type": "application/json",
+      },
+      body: "",
+    });
+
+    // Empty body should be accepted
+    assertFetchStatus(
+      {
+        status: response.status,
+        statusText: response.statusText,
+        body: null,
+        raw: "",
+        durationMs: 0,
+        headers: response.headers,
+        debugSummary: () => `HTTP ${response.status}`,
+      },
+      HTTP_OK,
+      "Should return 200 for empty body with JSON content-type",
+    );
+
+    // Clean up
+    await endSession(testSessionId, headers);
+  });
+
+  it("should return 400 if body contains extra keys", async () => {
+    const url = getBaseUrl();
+    const testSessionId = await createSession(headers);
+
+    const ctx = await fetchWithContext<{ success?: boolean; message?: string }>(
+      `${url}/v1/sessions/${testSessionId}/end`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ unexpected: true }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_BAD_REQUEST,
+      "Should return 400 for extra keys",
+    );
+
+    // Clean up
+    await endSession(testSessionId, headers);
+  });
+
+  it("should return 200 when body is {}", async () => {
+    const url = getBaseUrl();
+    const testSessionId = await createSession(headers);
+
+    const ctx = await fetchWithContext<{ success: boolean }>(
+      `${url}/v1/sessions/${testSessionId}/end`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({}),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Should return 200 for empty object body");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(ctx.body.success === true, "Should indicate success", ctx);
+  });
+
+  it("should return 200 when body is 0 bytes (no body)", async () => {
+    const url = getBaseUrl();
+    const testSessionId = await createSession(headers);
+
+    // Send request with no body at all
+    const response = await fetch(`${url}/v1/sessions/${testSessionId}/end`, {
+      method: "POST",
+      headers: {
+        ...headers,
+        // Don't set Content-Type to application/json when there's no body
+      },
+    });
+
+    // Should succeed with 200 for no body
+    assert.equal(
+      response.status,
+      HTTP_OK,
+      `Should return 200 for 0-byte body, got ${response.status}`,
+    );
+
+    const body = await response.json();
+    assert.equal(body.success, true, "Should indicate success");
+  });
+
+  it("should end session successfully", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{ success: boolean }>(
+      `${url}/v1/sessions/${sessionId}/end`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({}),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "End session should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(ctx.body.success === true, "Should indicate success", ctx);
+  });
+
+  it("should return error for non-existent session", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{ success?: boolean; message?: string }>(
+      `${url}/v1/sessions/non-existent-session-id/end`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({}),
+      },
+    );
+
+    // Server returns 404 or 500 for non-existent sessions
+    assert.ok(
+      [HTTP_NOT_FOUND, HTTP_INTERNAL_SERVER_ERROR].includes(ctx.status),
+      `Expected 404 or 500, got ${ctx.status}`,
+    );
+
+    if (ctx.status === HTTP_INTERNAL_SERVER_ERROR) {
+      assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+      assertFetchOk(
+        ctx.body.message === "An internal server error occurred",
+        "500 responses should return a generic internal error message",
+        ctx,
+      );
+    }
+  });
+});
diff --git a/packages/server-v3/test/integration/v3/extract.test.ts b/packages/server-v3/test/integration/v3/extract.test.ts
new file mode 100644
index 000000000..b0b71674a
--- /dev/null
+++ b/packages/server-v3/test/integration/v3/extract.test.ts
@@ -0,0 +1,511 @@
+import assert from "node:assert/strict";
+import { after, before, describe, it } from "node:test";
+
+import {
+  assertEventExists,
+  assertFetchOk,
+  assertFetchStatus,
+  assertWithContext,
+  createSessionWithCdp,
+  endSession,
+  fetchWithContext,
+  GEMINI_API_KEY,
+  getBaseUrl,
+  getHeaders,
+  getMainFrameId,
+  HTTP_OK,
+  navigateSession,
+  readTypedSSEStreamWithContext,
+  requireEnv,
+} from "../utils.js";
+
+/** Result type for extract SSE events */
+type ExtractResult = Record<string, unknown>;
+
+// Shared session for all extract tests (extract is read-only, safe to share)
+let sessionId: string;
+let cdpUrl: string;
+
+before(async () => {
+  ({ sessionId, cdpUrl } = await createSessionWithCdp(getHeaders("3.0.0")));
+  const navResponse = await navigateSession(
+    sessionId,
+    "https://example.com",
+    getHeaders("3.0.0"),
+  );
+  assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+});
+
+after(async () => {
+  await endSession(sessionId, getHeaders("3.0.0"));
+});
+
+// =============================================================================
+// POST /v1/sessions/:id/extract - V3 Format Tests
+// =============================================================================
+
+describe("POST /v1/sessions/:id/extract (V3)", () => {
+  it("should extract data with instruction and schema", async () => {
+    const url = getBaseUrl();
+    const frameId = await getMainFrameId(cdpUrl);
+
+    interface ExtractResponse {
+      success: boolean;
+      data?: { result: Record<string, unknown>; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ExtractResponse>(
+      `${url}/v1/sessions/${sessionId}/extract`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "extract the page title",
+          schema: {
+            type: "object",
+            properties: {
+              title: { type: "string" },
+            },
+            required: ["title"],
+          },
+          frameId,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Extract should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result,
+      "object",
+      "Result should be an object",
+    );
+    assertFetchOk(
+      "title" in ctx.body.data.result,
+      "Result should have title property",
+      ctx,
+    );
+  });
+
+  it("should extract with instruction and options", async () => {
+    const url = getBaseUrl();
+
+    interface ExtractResponse {
+      success: boolean;
+      data?: { result: Record<string, unknown>; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ExtractResponse>(
+      `${url}/v1/sessions/${sessionId}/extract`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "extract the page title",
+          schema: {
+            type: "object",
+            properties: {
+              title: { type: "string" },
+            },
+          },
+          options: {
+            timeout: 30000,
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Extract with options should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result,
+      "object",
+      "Result should be an object",
+    );
+  });
+
+  it("should extract with CSS selector in options", async () => {
+    const url = getBaseUrl();
+
+    interface ExtractResponse {
+      success: boolean;
+      data?: { result: Record<string, unknown>; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ExtractResponse>(
+      `${url}/v1/sessions/${sessionId}/extract`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "extract the link information",
+          schema: {
+            type: "object",
+            properties: {
+              href: { type: "string" },
+              text: { type: "string" },
+            },
+          },
+          options: {
+            selector: "a", // CSS selector
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Extract with CSS selector should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result,
+      "object",
+      "Result should be an object",
+    );
+  });
+
+  it("should extract with XPath selector in options", async () => {
+    const url = getBaseUrl();
+
+    interface ExtractResponse {
+      success: boolean;
+      data?: { result: Record<string, unknown>; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ExtractResponse>(
+      `${url}/v1/sessions/${sessionId}/extract`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "extract the link information",
+          schema: {
+            type: "object",
+            properties: {
+              href: { type: "string" },
+              text: { type: "string" },
+            },
+          },
+          options: {
+            selector: "//a", // XPath selector
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "Extract with XPath selector should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result,
+      "object",
+      "Result should be an object",
+    );
+  });
+
+  it("should extract with instruction only (no schema)", async () => {
+    const url = getBaseUrl();
+
+    interface ExtractResponse {
+      success: boolean;
+      data?: { result: Record<string, unknown>; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ExtractResponse>(
+      `${url}/v1/sessions/${sessionId}/extract`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "extract the main content from the page",
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Extract without schema should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result,
+      "object",
+      "Result should be an object",
+    );
+  });
+
+  it("should extract without instruction (extract all)", async () => {
+    const url = getBaseUrl();
+
+    interface ExtractResponse {
+      success: boolean;
+      data?: { result: Record<string, unknown>; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ExtractResponse>(
+      `${url}/v1/sessions/${sessionId}/extract`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          options: {
+            timeout: 30000,
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "Extract without instruction should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result,
+      "object",
+      "Result should be an object",
+    );
+  });
+
+  it("should extract with google/gemini-2.5-flash-lite model", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    interface ExtractResponse {
+      success: boolean;
+      data?: { result: Record<string, unknown>; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ExtractResponse>(
+      `${url}/v1/sessions/${sessionId}/extract`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "extract the page title",
+          schema: {
+            type: "object",
+            properties: {
+              title: { type: "string" },
+            },
+            required: ["title"],
+          },
+          options: {
+            model: {
+              modelName: "google/gemini-2.5-flash-lite",
+              apiKey: geminiApiKey,
+            },
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Extract with Gemini model should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result,
+      "object",
+      "Result should be an object",
+    );
+    assertFetchOk(
+      "title" in ctx.body.data.result,
+      "Result should have title property",
+      ctx,
+    );
+  });
+});
+
+// =============================================================================
+// SSE Streaming Tests - V3
+// =============================================================================
+
+describe("POST /v1/sessions/:id/extract with SSE streaming (V3)", () => {
+  it("should stream valid SSE events with correct structure", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v1/sessions/${sessionId}/extract`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        instruction: "extract the page title",
+        schema: {
+          type: "object",
+          properties: {
+            title: { type: "string" },
+          },
+          required: ["title"],
+        },
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ExtractResult>(response);
+    const { events } = ctx;
+
+    assertWithContext(
+      events.length >= 2,
+      "Should have at least starting and finished events",
+      ctx,
+    );
+
+    // Verify starting event
+    const startingEvent = assertEventExists(events, "starting", ctx);
+    assert.equal(
+      startingEvent.type,
+      "system",
+      "Starting event should be system type",
+    );
+
+    // Verify finished event with result
+    const finishedEvent = assertEventExists(events, "finished", ctx);
+    assert.equal(
+      finishedEvent.type,
+      "system",
+      "Finished event should be system type",
+    );
+    assertWithContext(
+      !!finishedEvent.data.result,
+      "Finished event must have result",
+      ctx,
+    );
+    assert.equal(
+      typeof finishedEvent.data.result,
+      "object",
+      "Result must be an object",
+    );
+    assertWithContext(
+      "title" in finishedEvent.data.result,
+      "Result should have title property",
+      ctx,
+    );
+  });
+
+  it("should have correct event sequence: starting -> connected -> finished", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v1/sessions/${sessionId}/extract`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        instruction: "extract the page title",
+        schema: {
+          type: "object",
+          properties: {
+            title: { type: "string" },
+          },
+        },
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ExtractResult>(response);
+    const { events } = ctx;
+
+    assertEventExists(events, "starting", ctx);
+    assertEventExists(events, "connected", ctx);
+    assertEventExists(events, "finished", ctx);
+
+    const startingIndex = events.findIndex((e) => e.data.status === "starting");
+    const connectedIndex = events.findIndex(
+      (e) => e.data.status === "connected",
+    );
+    const finishedIndex = events.findIndex((e) => e.data.status === "finished");
+
+    assertWithContext(
+      startingIndex < connectedIndex,
+      "Starting event must come before connected event",
+      ctx,
+    );
+    assertWithContext(
+      connectedIndex < finishedIndex,
+      "Connected event must come before finished event",
+      ctx,
+    );
+  });
+
+  it("should have valid UUID for each event id", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v1/sessions/${sessionId}/extract`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        instruction: "extract the page title",
+        schema: {
+          type: "object",
+          properties: {
+            title: { type: "string" },
+          },
+        },
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ExtractResult>(response);
+    const { events } = ctx;
+
+    const uuidRegex =
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+    for (const event of events) {
+      assertWithContext(
+        uuidRegex.test(event.id),
+        `Event id should be a valid UUID format, got: ${event.id}`,
+        ctx,
+      );
+    }
+  });
+
+  it("should extract data matching the provided schema", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v1/sessions/${sessionId}/extract`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        instruction: "extract the page title",
+        schema: {
+          type: "object",
+          properties: {
+            title: { type: "string" },
+          },
+          required: ["title"],
+        },
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ExtractResult>(response);
+    const { events } = ctx;
+
+    const finishedEvent = assertEventExists(events, "finished", ctx);
+    assertWithContext(!!finishedEvent.data.result, "Should have result", ctx);
+
+    // Verify the extracted data has the expected shape
+    assert.equal(
+      typeof finishedEvent.data.result.title,
+      "string",
+      "Extracted title should be a string",
+    );
+  });
+});
diff --git a/packages/server-v3/test/integration/v3/multiRegion.test.ts b/packages/server-v3/test/integration/v3/multiRegion.test.ts
new file mode 100644
index 000000000..d05ca900c
--- /dev/null
+++ b/packages/server-v3/test/integration/v3/multiRegion.test.ts
@@ -0,0 +1,277 @@
+import { describe, it } from "node:test";
+
+import {
+  assertFetchOk,
+  assertFetchStatus,
+  endSession,
+  fetchWithContext,
+  getBaseUrl,
+  getHeaders,
+  HTTP_OK,
+  LOCAL_BROWSER_BODY,
+} from "../utils.js";
+
+// =============================================================================
+// Response Type Definitions
+// =============================================================================
+
+interface StartSuccessResponse {
+  success: true;
+  data: {
+    sessionId: string;
+    cdpUrl: string;
+    available: boolean;
+  };
+}
+
+interface StartErrorResponse {
+  success: false;
+  message: string;
+}
+
+type StartResponse = StartSuccessResponse | StartErrorResponse;
+
+function isSuccessResponse(
+  response: StartResponse,
+): response is StartSuccessResponse {
+  return response.success && response.data.sessionId !== null;
+}
+
+// =============================================================================
+// Multi-Region Integration Tests
+// =============================================================================
+// These tests verify that the API client correctly handles multi-region
+// configuration. Prior to the multi-region feature, non-us-west-2 regions
+// would be rejected with { available: false }. Now all supported regions
+// are accepted.
+// =============================================================================
+
+describe("POST /v1/sessions/start - Multi-region support", () => {
+  const headers = getHeaders("3.0.0");
+  const localBrowser = LOCAL_BROWSER_BODY;
+
+  it("should start session with us-west-2 region (default)", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v1/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browserbaseSessionCreateParams: {
+            region: "us-west-2",
+          },
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+
+    try {
+      assertFetchOk(
+        ctx.body.data.available,
+        "Session should be available",
+        ctx,
+      );
+      assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+    } finally {
+      await endSession(ctx.body.data.sessionId, headers);
+    }
+  });
+
+  it("should start session with us-east-1 region", async () => {
+    const url = getBaseUrl();
+
+    // This test verifies that non-us-west-2 regions are now accepted.
+    // Previously, this would have returned { available: false }.
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v1/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browserbaseSessionCreateParams: {
+            region: "us-east-1",
+          },
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+
+    try {
+      assertFetchOk(
+        ctx.body.data.available,
+        "Session should be available",
+        ctx,
+      );
+      assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+    } finally {
+      await endSession(ctx.body.data.sessionId, headers);
+    }
+  });
+
+  it("should start session with eu-central-1 region", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v1/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browserbaseSessionCreateParams: {
+            region: "eu-central-1",
+          },
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+
+    try {
+      assertFetchOk(
+        ctx.body.data.available,
+        "Session should be available",
+        ctx,
+      );
+      assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+    } finally {
+      await endSession(ctx.body.data.sessionId, headers);
+    }
+  });
+
+  it("should start session with ap-southeast-1 region", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v1/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browserbaseSessionCreateParams: {
+            region: "ap-southeast-1",
+          },
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+
+    try {
+      assertFetchOk(
+        ctx.body.data.available,
+        "Session should be available",
+        ctx,
+      );
+      assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+    } finally {
+      await endSession(ctx.body.data.sessionId, headers);
+    }
+  });
+
+  it("should start session without region (defaults to us-west-2)", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v1/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browserbaseSessionCreateParams: {},
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+
+    try {
+      assertFetchOk(
+        ctx.body.data.available,
+        "Session should be available",
+        ctx,
+      );
+      assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+    } finally {
+      await endSession(ctx.body.data.sessionId, headers);
+    }
+  });
+
+  it("should start session without browserbaseSessionCreateParams", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v1/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+
+    try {
+      assertFetchOk(
+        ctx.body.data.available,
+        "Session should be available",
+        ctx,
+      );
+      assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+    } finally {
+      await endSession(ctx.body.data.sessionId, headers);
+    }
+  });
+});
diff --git a/packages/server-v3/test/integration/v3/navigate.test.ts b/packages/server-v3/test/integration/v3/navigate.test.ts
new file mode 100644
index 000000000..0e4c74339
--- /dev/null
+++ b/packages/server-v3/test/integration/v3/navigate.test.ts
@@ -0,0 +1,143 @@
+import assert from "node:assert/strict";
+import { after, before, describe, it } from "node:test";
+
+import { chromium } from "playwright";
+
+import {
+  assertFetchOk,
+  assertFetchStatus,
+  createSessionWithCdp,
+  endSession,
+  fetchWithContext,
+  getBaseUrl,
+  getHeaders,
+  HTTP_BAD_REQUEST,
+  HTTP_OK,
+} from "../utils.js";
+
+// =============================================================================
+// POST /v1/sessions/:id/navigate (V3 Format)
+// =============================================================================
+
+describe("POST /v1/sessions/:id/navigate (V3)", () => {
+  let sessionId: string;
+  let cdpUrl: string;
+
+  before(async () => {
+    ({ sessionId, cdpUrl } = await createSessionWithCdp(getHeaders("3.0.0")));
+  });
+
+  after(async () => {
+    await endSession(sessionId, getHeaders("3.0.0"));
+  });
+
+  it("should navigate to a URL successfully and verify via CDP", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/navigate`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({ url: "https://example.com", frameId: "" }),
+    });
+
+    assertFetchStatus(ctx, HTTP_OK, "Navigate should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      typeof ctx.body.data.actionId === "string",
+      "Response should have actionId",
+      ctx,
+    );
+
+    // Verify navigation via CDP
+    const browser = await chromium.connectOverCDP(cdpUrl);
+    const contexts = browser.contexts();
+    assert.ok(contexts.length > 0, "Should have at least one browser context");
+    const pages = contexts[0]!.pages();
+    assert.ok(pages.length > 0, "Should have at least one page");
+    const page = pages[0]!;
+    await page
+      .waitForLoadState("domcontentloaded", { timeout: 15_000 })
+      .catch(() => {});
+    await page
+      .waitForURL("**example.com**", { timeout: 15_000 })
+      .catch(() => {});
+    const pageUrl = page.url();
+    assert.ok(
+      pageUrl.includes("example.com"),
+      `Page URL should be example.com, got: ${pageUrl}`,
+    );
+    await browser.close();
+  });
+
+  it("should navigate with options", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v1/sessions/${sessionId}/navigate`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        url: "https://example.com",
+        frameId: "",
+        options: {
+          waitUntil: "networkidle",
+          timeout: 30000,
+        },
+      }),
+    });
+
+    assertFetchStatus(ctx, HTTP_OK, "Navigate with options should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      typeof ctx.body.data.actionId === "string",
+      "Response should have actionId",
+      ctx,
+    );
+  });
+
+  // ===========================================================================
+  // Validation Tests
+  // ===========================================================================
+
+  it("should return 400 when url is missing", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success?: boolean;
+      message?: string;
+      error?: string;
+    }>(`${url}/v1/sessions/${sessionId}/navigate`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({ frameId: "" }), // Missing url
+    });
+
+    assertFetchStatus(ctx, HTTP_BAD_REQUEST);
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    // Fastify validation errors may have different format than our custom errors
+    assertFetchOk(
+      !ctx.body.success ||
+        ctx.body.error !== undefined ||
+        ctx.body.message !== undefined,
+      "Response should indicate failure",
+      ctx,
+    );
+  });
+});
diff --git a/packages/server-v3/test/integration/v3/observe.test.ts b/packages/server-v3/test/integration/v3/observe.test.ts
new file mode 100644
index 000000000..1e0651060
--- /dev/null
+++ b/packages/server-v3/test/integration/v3/observe.test.ts
@@ -0,0 +1,407 @@
+import assert from "node:assert/strict";
+import { after, before, describe, it } from "node:test";
+
+import {
+  assertEventExists,
+  assertFetchOk,
+  assertFetchStatus,
+  assertWithContext,
+  createSessionWithCdp,
+  endSession,
+  fetchWithContext,
+  GEMINI_API_KEY,
+  getBaseUrl,
+  getHeaders,
+  getMainFrameId,
+  HTTP_OK,
+  navigateSession,
+  readTypedSSEStreamWithContext,
+  requireEnv,
+} from "../utils.js";
+
+/** Result type for observe SSE events */
+type ObserveResult = unknown[];
+
+// Shared session for all observe tests (observe is read-only, safe to share)
+let sessionId: string;
+let cdpUrl: string;
+
+before(async () => {
+  ({ sessionId, cdpUrl } = await createSessionWithCdp(getHeaders("3.0.0")));
+  // Navigate to a page first
+  const navResponse = await navigateSession(
+    sessionId,
+    "https://example.com",
+    getHeaders("3.0.0"),
+  );
+  assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+});
+
+after(async () => {
+  await endSession(sessionId, getHeaders("3.0.0"));
+});
+
+// =============================================================================
+// POST /v1/sessions/:id/observe - V3 Format Tests
+// =============================================================================
+
+describe("POST /v1/sessions/:id/observe (V3)", () => {
+  it("should observe elements with instruction", async () => {
+    const url = getBaseUrl();
+    const frameId = await getMainFrameId(cdpUrl);
+
+    interface ObserveResponse {
+      success: boolean;
+      data?: { result: unknown[]; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ObserveResponse>(
+      `${url}/v1/sessions/${sessionId}/observe`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "Find any link on the page",
+          frameId,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Observe should succeed");
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      Array.isArray(ctx.body.data.result),
+      "Result should be an array of observed elements",
+      ctx,
+    );
+  });
+
+  it("should observe with instruction and options", async () => {
+    const url = getBaseUrl();
+
+    interface ObserveResponse {
+      success: boolean;
+      data?: { result: unknown[]; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ObserveResponse>(
+      `${url}/v1/sessions/${sessionId}/observe`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "Find any link on the page",
+          options: {
+            timeout: 30000,
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Observe with options should succeed");
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      Array.isArray(ctx.body.data.result),
+      "Result should be an array of observed elements",
+      ctx,
+    );
+  });
+
+  it("should observe with selector option", async () => {
+    const url = getBaseUrl();
+
+    interface ObserveResponse {
+      success: boolean;
+      data?: { result: unknown[]; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ObserveResponse>(
+      `${url}/v1/sessions/${sessionId}/observe`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "Find any link on the page",
+          options: {
+            selector: "a",
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Observe with selector should succeed");
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      Array.isArray(ctx.body.data.result),
+      "Result should be an array of observed elements",
+      ctx,
+    );
+  });
+
+  it("should observe without instruction (observe all)", async () => {
+    const url = getBaseUrl();
+
+    interface ObserveResponse {
+      success: boolean;
+      data?: { result: unknown[]; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ObserveResponse>(
+      `${url}/v1/sessions/${sessionId}/observe`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          options: {
+            timeout: 30000,
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "Observe without instruction should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      Array.isArray(ctx.body.data.result),
+      "Result should be an array of observed elements",
+      ctx,
+    );
+  });
+
+  it("should observe with google/gemini-2.5-flash-lite model", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    interface ObserveResponse {
+      success: boolean;
+      data?: { result: unknown[]; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ObserveResponse>(
+      `${url}/v1/sessions/${sessionId}/observe`,
+      {
+        method: "POST",
+        headers: {
+          ...getHeaders("3.0.0"),
+          "x-model-api-key": "", // Clear the header to ensure body config is used
+        },
+        body: JSON.stringify({
+          instruction: "Find any link on the page",
+          options: {
+            model: {
+              modelName: "google/gemini-2.5-flash-lite",
+              apiKey: geminiApiKey,
+            },
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "Observe with google/gemini-2.5-flash-lite model should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      Array.isArray(ctx.body.data.result),
+      "Result should be an array of observed elements",
+      ctx,
+    );
+  });
+});
+
+// =============================================================================
+// SSE Streaming Tests - V3
+// =============================================================================
+
+describe("POST /v1/sessions/:id/observe with SSE streaming (V3)", () => {
+  it("should stream valid SSE events with correct structure", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v1/sessions/${sessionId}/observe`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        instruction: "Find any link on the page",
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ObserveResult>(response);
+    const { events } = ctx;
+
+    assertWithContext(
+      events.length >= 2,
+      "Should have at least starting and finished events",
+      ctx,
+    );
+
+    // Verify starting event
+    const startingEvent = assertEventExists(events, "starting", ctx);
+    assertWithContext(
+      startingEvent.type === "system",
+      "Starting event should be system type",
+      ctx,
+    );
+
+    // Verify finished event with result
+    const finishedEvent = assertEventExists(events, "finished", ctx);
+    assertWithContext(
+      finishedEvent.type === "system",
+      "Finished event should be system type",
+      ctx,
+    );
+    assertWithContext(
+      !!finishedEvent.data.result,
+      "Finished event must have result",
+      ctx,
+    );
+    assertWithContext(
+      Array.isArray(finishedEvent.data.result),
+      "Result must be an array of observed elements",
+      ctx,
+    );
+  });
+
+  it("should have correct event sequence: starting -> connected -> finished", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v1/sessions/${sessionId}/observe`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        instruction: "Find any link on the page",
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ObserveResult>(response);
+    const { events } = ctx;
+
+    assertEventExists(events, "starting", ctx);
+    assertEventExists(events, "connected", ctx);
+    assertEventExists(events, "finished", ctx);
+
+    const startingIndex = events.findIndex((e) => e.data.status === "starting");
+    const connectedIndex = events.findIndex(
+      (e) => e.data.status === "connected",
+    );
+    const finishedIndex = events.findIndex((e) => e.data.status === "finished");
+
+    assertWithContext(
+      startingIndex < connectedIndex,
+      "Starting event must come before connected event",
+      ctx,
+    );
+    assertWithContext(
+      connectedIndex < finishedIndex,
+      "Connected event must come before finished event",
+      ctx,
+    );
+  });
+
+  it("should have valid UUID for each event id", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v1/sessions/${sessionId}/observe`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        instruction: "Find any link on the page",
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ObserveResult>(response);
+    const { events } = ctx;
+
+    const uuidRegex =
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+    for (const event of events) {
+      assertWithContext(
+        uuidRegex.test(event.id),
+        `Event id should be a valid UUID format, got: ${event.id}`,
+        ctx,
+      );
+    }
+  });
+
+  it("should return observed elements with expected properties", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v1/sessions/${sessionId}/observe`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        instruction: "Find any link on the page",
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ObserveResult>(response);
+    const { events } = ctx;
+
+    const finishedEvent = assertEventExists(events, "finished", ctx);
+    assertWithContext(!!finishedEvent.data.result, "Should have result", ctx);
+    assertWithContext(
+      Array.isArray(finishedEvent.data.result),
+      "Result should be an array",
+      ctx,
+    );
+
+    // If there are observed elements, verify they have expected structure
+    if (finishedEvent.data.result.length > 0) {
+      const firstElement = finishedEvent.data.result[0] as Record<
+        string,
+        unknown
+      >;
+      assertWithContext(
+        typeof firstElement === "object",
+        "Each observed element should be an object",
+        ctx,
+      );
+      // Observed elements typically have selector and description
+      assertWithContext(
+        "selector" in firstElement || "description" in firstElement,
+        "Observed element should have selector or description",
+        ctx,
+      );
+    }
+  });
+});
diff --git a/packages/server-v3/test/integration/v3/replay.test.ts b/packages/server-v3/test/integration/v3/replay.test.ts
new file mode 100644
index 000000000..241f40815
--- /dev/null
+++ b/packages/server-v3/test/integration/v3/replay.test.ts
@@ -0,0 +1,59 @@
+import { describe, it } from "node:test";
+import { Api } from "@browserbasehq/stagehand";
+
+import {
+  assertFetchOk,
+  assertFetchStatus,
+  fetchWithContext,
+  getBaseUrl,
+  getHeaders,
+  HTTP_OK,
+} from "../utils.js";
+
+describe("GET /v1/sessions/:id/replay (V3)", () => {
+  it("should return an empty replay result for local server", async () => {
+    const url = getBaseUrl();
+    const headers = getHeaders("3.0.0");
+
+    const ctx = await fetchWithContext<unknown>(
+      `${url}/v1/sessions/test-session-id/replay`,
+      {
+        method: "GET",
+        headers,
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Replay should return 200");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    const parsedBody = Api.ReplayResponseSchema.safeParse(ctx.body);
+    assertFetchOk(
+      parsedBody.success,
+      "Replay response should match schema",
+      ctx,
+    );
+    if (!parsedBody.success) {
+      return;
+    }
+
+    assertFetchOk(
+      parsedBody.data.success,
+      "Response should indicate success",
+      ctx,
+    );
+    assertFetchOk(
+      parsedBody.data.data !== undefined,
+      "Response should include data",
+      ctx,
+    );
+    assertFetchOk(
+      Array.isArray(parsedBody.data.data.pages),
+      "Replay pages should be an array",
+      ctx,
+    );
+    assertFetchOk(
+      parsedBody.data.data.pages.length === 0,
+      "Replay pages should be empty on local server",
+      ctx,
+    );
+  });
+});
diff --git a/packages/server-v3/test/integration/v3/start.test.ts b/packages/server-v3/test/integration/v3/start.test.ts
new file mode 100644
index 000000000..e2a496b2f
--- /dev/null
+++ b/packages/server-v3/test/integration/v3/start.test.ts
@@ -0,0 +1,931 @@
+import { spawn } from "node:child_process";
+import { execFileSync } from "node:child_process";
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
+import net from "node:net";
+import { fileURLToPath } from "node:url";
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import Browserbase from "@browserbasehq/sdk";
+import { chromium } from "playwright";
+
+import {
+  assertFetchOk,
+  assertFetchStatus,
+  endSession,
+  fetchWithContext,
+  getBaseUrl,
+  getHeaders,
+  LOCAL_BROWSER_BODY,
+  HTTP_BAD_REQUEST,
+  HTTP_OK,
+} from "../utils.js";
+import type { BrowserbaseRegion } from "@browserbasehq/stagehand";
+
+// =============================================================================
+// Response Type Definitions
+// =============================================================================
+
+interface StartSuccessResponse {
+  success: true;
+  data: {
+    sessionId: string;
+    cdpUrl: string;
+    available: boolean;
+  };
+}
+
+interface StartUnavailableResponse {
+  success: true;
+  data: {
+    sessionId: null;
+    available: false;
+  };
+}
+
+interface StartErrorResponse {
+  success: false;
+  message: string;
+}
+
+type StartResponse =
+  | StartSuccessResponse
+  | StartUnavailableResponse
+  | StartErrorResponse;
+
+function isSuccessResponse(
+  response: StartResponse,
+): response is StartSuccessResponse {
+  return response.success && response.data.sessionId !== null;
+}
+
+type SeaHandle = {
+  proc: ChildProcessWithoutNullStreams;
+  baseUrl: string;
+  logs: string[];
+};
+
+type SupervisorInfo = {
+  pid: number;
+  args: string;
+  chromePid?: number;
+};
+
+const repoRoot = (() => {
+  const value = fileURLToPath(import.meta.url).replaceAll("\\", "/");
+  const root = value.split("/packages/server-v3/")[0];
+  if (root === value) {
+    throw new Error(`Unable to determine repo root from ${value}`);
+  }
+  return root;
+})();
+
+const defaultSeaBinaryName = `stagehand-server-v3-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`;
+const seaBinaryPath = `${repoRoot}/packages/server-v3/dist/sea/${process.env.SEA_BINARY_NAME ?? defaultSeaBinaryName}`;
+const bbApiKey = process.env.BROWSERBASE_API_KEY;
+const bbProjectId = process.env.BROWSERBASE_PROJECT_ID;
+const activeSea = new Set<SeaHandle>();
+
+afterEach(async () => {
+  await Promise.all(
+    [...activeSea].map(async (handle) => {
+      await stopSeaServer(handle);
+      activeSea.delete(handle);
+    }),
+  );
+});
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function getFreePort(): Promise<number> {
+  return await new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("Failed to allocate an ephemeral port"));
+        return;
+      }
+      const { port } = addr;
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(port);
+      });
+    });
+    server.on("error", reject);
+  });
+}
+
+function listProcesses(): Array<{ pid: number; args: string }> {
+  const output = execFileSync("ps", ["-axo", "pid=,args="], {
+    encoding: "utf8",
+  });
+  return output
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const firstSpace = line.indexOf(" ");
+      if (firstSpace === -1) {
+        return { pid: Number(line), args: "" };
+      }
+      return {
+        pid: Number(line.slice(0, firstSpace)),
+        args: line.slice(firstSpace + 1),
+      };
+    })
+    .filter((entry) => Number.isFinite(entry.pid) && entry.pid > 0);
+}
+
+function parseSupervisorConfigArg(args: string): {
+  kind?: string;
+  pid?: number;
+  parentPid?: number;
+} | null {
+  const prefix = "--supervisor-config=";
+  const index = args.indexOf(prefix);
+  if (index === -1) return null;
+  const raw = args.slice(index + prefix.length).trim();
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw) as {
+      kind?: string;
+      pid?: number;
+      parentPid?: number;
+    };
+  } catch {
+    return null;
+  }
+}
+
+function findLocalSupervisorByParentPid(
+  parentPid: number,
+): SupervisorInfo | null {
+  const candidates = listProcesses()
+    .map((entry) => ({
+      ...entry,
+      config: parseSupervisorConfigArg(entry.args),
+    }))
+    .filter(
+      (entry) =>
+        entry.config?.kind === "LOCAL" && entry.config.parentPid === parentPid,
+    )
+    .sort((a, b) => b.pid - a.pid);
+
+  const entry = candidates[0];
+  if (!entry) return null;
+
+  return {
+    pid: entry.pid,
+    args: entry.args,
+    chromePid:
+      typeof entry.config?.pid === "number" && Number.isFinite(entry.config.pid)
+        ? entry.config.pid
+        : undefined,
+  };
+}
+
+function isPidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const err = error as NodeJS.ErrnoException;
+    if (err.code === "ESRCH") return false;
+    return true;
+  }
+}
+
+async function waitForValue<T>(
+  read: () => T | null,
+  timeoutMs: number,
+  intervalMs = 200,
+): Promise<T> {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const value = read();
+    if (value !== null) return value;
+    await sleep(intervalMs);
+  }
+  throw new Error(`Timed out after ${timeoutMs}ms`);
+}
+
+async function waitForPidState(
+  pid: number,
+  shouldBeAlive: boolean,
+  timeoutMs: number,
+): Promise<void> {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (isPidAlive(pid) === shouldBeAlive) return;
+    await sleep(200);
+  }
+  const entry = listProcesses().find((candidate) => candidate.pid === pid);
+  const details = entry ? ` args=${entry.args}` : "";
+  throw new Error(
+    `PID ${pid} did not become ${shouldBeAlive ? "alive" : "dead"} within ${timeoutMs}ms${details}`,
+  );
+}
+
+async function waitForServerReady(baseUrl: string, timeoutMs = 30_000) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    try {
+      const response = await fetch(`${baseUrl}/healthz`);
+      if (response.ok) return;
+    } catch {
+      // retry
+    }
+    await sleep(500);
+  }
+  throw new Error(
+    `Server did not become ready at ${baseUrl} within ${timeoutMs}ms`,
+  );
+}
+
+async function waitForProcessExit(
+  proc: ChildProcessWithoutNullStreams,
+  timeoutMs: number,
+): Promise<boolean> {
+  if (proc.exitCode !== null) {
+    return true;
+  }
+  return await new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(false), timeoutMs);
+    proc.once("exit", () => {
+      clearTimeout(timer);
+      resolve(true);
+    });
+  });
+}
+
+async function startSeaServer(
+  envOverrides: Record<string, string> = {},
+): Promise<SeaHandle> {
+  const port = await getFreePort();
+  const baseUrl = `http://127.0.0.1:${port}`;
+  const logs: string[] = [];
+  const proc = spawn(
+    seaBinaryPath,
+    ["--node-options=--no-lazy --enable-source-maps"],
+    {
+      env: {
+        ...process.env,
+        ...envOverrides,
+        NODE_ENV: "production",
+        PORT: String(port),
+        STAGEHAND_SEA_CACHE_DIR:
+          process.env.STAGEHAND_SEA_CACHE_DIR ?? `${repoRoot}/.stagehand-sea`,
+      },
+      stdio: ["ignore", "pipe", "pipe"],
+    },
+  );
+
+  proc.stdout.on("data", (chunk: Buffer) => {
+    const value = chunk.toString().trim();
+    if (value) logs.push(value);
+  });
+  proc.stderr.on("data", (chunk: Buffer) => {
+    const value = chunk.toString().trim();
+    if (value) logs.push(value);
+  });
+
+  if (!proc.pid) {
+    throw new Error("SEA process did not provide a PID");
+  }
+
+  const handle: SeaHandle = { proc, baseUrl, logs };
+  activeSea.add(handle);
+
+  try {
+    await waitForServerReady(baseUrl);
+    return handle;
+  } catch (error) {
+    await stopSeaServer(handle);
+    const tail = logs.slice(-30).join("\n");
+    throw new Error(
+      `Failed to start SEA server at ${baseUrl}: ${(error as Error).message}\n${tail}`,
+      {
+        cause: error,
+      },
+    );
+  }
+}
+
+async function stopSeaServer(handle: SeaHandle): Promise<void> {
+  const { proc } = handle;
+  if (proc.exitCode !== null) return;
+  try {
+    proc.kill("SIGTERM");
+  } catch {
+    // ignore
+  }
+  const exited = await waitForProcessExit(proc, 5_000);
+  if (!exited) {
+    try {
+      proc.kill("SIGKILL");
+    } catch {
+      // ignore
+    }
+    await waitForProcessExit(proc, 5_000);
+  }
+}
+
+async function forceKillSeaServer(handle: SeaHandle): Promise<void> {
+  const { proc } = handle;
+  if (proc.exitCode !== null) return;
+  try {
+    proc.kill("SIGKILL");
+  } catch {
+    // ignore
+  }
+  await waitForProcessExit(proc, 5_000);
+}
+
+async function startKeepAliveFalseLocalSession(baseUrl: string): Promise<{
+  sessionId: string;
+  cdpUrl: string;
+}> {
+  const headers = getHeaders("3.0.0");
+  const ctx = await fetchWithContext<StartResponse>(
+    `${baseUrl}/v1/sessions/start`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        modelName: "gpt-4.1-nano",
+        keepAlive: false,
+        ...LOCAL_BROWSER_BODY,
+      }),
+    },
+  );
+
+  assert.equal(
+    ctx.status,
+    HTTP_OK,
+    `Expected local /start to succeed, got ${ctx.status}\n${ctx.debugSummary()}`,
+  );
+  assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+  assertFetchOk(
+    isSuccessResponse(ctx.body),
+    "Should return a successful start response",
+    ctx,
+  );
+  return {
+    sessionId: ctx.body.data.sessionId,
+    cdpUrl: ctx.body.data.cdpUrl,
+  };
+}
+
+async function startKeepAliveFalseBrowserbaseSession(
+  baseUrl: string,
+): Promise<string> {
+  assert.ok(bbApiKey, "BROWSERBASE_API_KEY must be set");
+  assert.ok(bbProjectId, "BROWSERBASE_PROJECT_ID must be set");
+  const headers = {
+    ...getHeaders("3.0.0"),
+    "x-bb-api-key": bbApiKey,
+    "x-bb-project-id": bbProjectId,
+  };
+  const ctx = await fetchWithContext<StartResponse>(
+    `${baseUrl}/v1/sessions/start`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        modelName: "gpt-4.1-nano",
+        keepAlive: false,
+        experimental: true,
+        browser: { type: "browserbase" },
+      }),
+    },
+  );
+
+  assert.equal(
+    ctx.status,
+    HTTP_OK,
+    `Expected browserbase /start to succeed, got ${ctx.status}\n${ctx.debugSummary()}`,
+  );
+  assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+  assertFetchOk(
+    isSuccessResponse(ctx.body),
+    "Should return a successful start response",
+    ctx,
+  );
+  const sessionId = ctx.body.data.sessionId;
+
+  // Browserbase Stagehand init is lazy; navigate once to ensure supervisor is running.
+  const navigateCtx = await fetchWithContext<{ success?: boolean }>(
+    `${baseUrl}/v1/sessions/${sessionId}/navigate`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ url: "https://example.com", frameId: "" }),
+    },
+  );
+  assert.equal(
+    navigateCtx.status,
+    HTTP_OK,
+    `Expected browserbase /navigate to succeed, got ${navigateCtx.status}\n${navigateCtx.debugSummary()}`,
+  );
+
+  return sessionId;
+}
+
+async function closeLocalBrowserViaCdp(cdpUrl: string): Promise<void> {
+  const browser = await chromium.connectOverCDP(cdpUrl);
+  try {
+    const context = browser.contexts()[0];
+    if (!context) return;
+    const page = context.pages()[0] ?? (await context.newPage());
+    const cdp = await context.newCDPSession(page);
+    await cdp.send("Browser.close");
+  } finally {
+    await browser.close().catch(() => {
+      // best-effort close of Playwright transport
+    });
+  }
+}
+
+async function waitForBrowserbaseNotRunning(
+  sessionId: string,
+  timeoutMs: number,
+): Promise<string> {
+  assert.ok(bbApiKey, "BROWSERBASE_API_KEY must be set");
+  const bb = new Browserbase({ apiKey: bbApiKey });
+
+  let lastStatus = "UNKNOWN";
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    try {
+      const snapshot = (await bb.sessions.retrieve(sessionId)) as {
+        status?: string;
+      };
+      lastStatus = snapshot.status ?? "UNKNOWN";
+      if (lastStatus !== "RUNNING") {
+        return lastStatus;
+      }
+    } catch {
+      return "RETRIEVE_FAILED";
+    }
+    await sleep(1000);
+  }
+  throw new Error(
+    `Browserbase session ${sessionId} stayed RUNNING for ${timeoutMs}ms (last status=${lastStatus})`,
+  );
+}
+
+async function requestBrowserbaseReleaseBestEffort(sessionId: string) {
+  if (!bbApiKey || !bbProjectId) return;
+  const bb = new Browserbase({ apiKey: bbApiKey });
+  try {
+    await bb.sessions.update(sessionId, {
+      status: "REQUEST_RELEASE",
+      projectId: bbProjectId,
+    });
+  } catch {
+    // best-effort cleanup
+  }
+}
+
+// =============================================================================
+// V3 Format Tests (x-sdk-version: 3.x.x header)
+// =============================================================================
+
+describe("POST /v1/sessions/start - V3 format", () => {
+  const headers = getHeaders("3.0.0");
+  const localBrowser = LOCAL_BROWSER_BODY;
+
+  it("should start session with modelName string and V3 header", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v1/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ modelName: "gpt-4.1-nano", ...localBrowser }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+    assertFetchOk(ctx.body.data.available, "Session should be available", ctx);
+    assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+    assertFetchOk(!!ctx.body.data.cdpUrl, "Should have cdpUrl", ctx);
+
+    await endSession(ctx.body.data.sessionId, headers);
+  });
+
+  it("should start session with experimental flag", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v1/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          experimental: true,
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+
+    await endSession(ctx.body.data.sessionId, headers);
+  });
+
+  it("should accept x-language header for python V3", async () => {
+    const url = getBaseUrl();
+    const pythonHeaders = getHeaders("1.0.0", "python");
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v1/sessions/start`,
+      {
+        method: "POST",
+        headers: pythonHeaders,
+        body: JSON.stringify({ modelName: "gpt-4.1-nano", ...localBrowser }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+
+    await endSession(ctx.body.data.sessionId, pythonHeaders);
+  });
+
+  it("should start session with extended options (timeouts, verbose)", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v1/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          actTimeoutMs: 30000,
+          domSettleTimeoutMs: 5000,
+          verbose: "2",
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+    assertFetchOk(ctx.body.data.available, "Session should be available", ctx);
+    assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+
+    await endSession(ctx.body.data.sessionId, headers);
+  });
+
+  it("should return cdpUrl as a valid WebSocket URL for local browser", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v1/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ modelName: "gpt-4.1-nano", ...localBrowser }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+    // cdpUrl should not be empty since we eagerly launch the browser
+    assertFetchOk(
+      ctx.body.data.cdpUrl !== "",
+      "cdpUrl should not be empty",
+      ctx,
+    );
+    // cdpUrl should be a valid WebSocket URL
+    assertFetchOk(
+      ctx.body.data.cdpUrl.startsWith("ws://"),
+      "cdpUrl should be a WebSocket URL",
+      ctx,
+    );
+
+    await endSession(ctx.body.data.sessionId, headers);
+  });
+
+  it("should return provided cdpUrl when explicit cdpUrl is passed", async () => {
+    const url = getBaseUrl();
+    const providedCdpUrl = "ws://localhost:9222/devtools/browser/test";
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v1/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browser: { type: "local", cdpUrl: providedCdpUrl },
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.cdpUrl === providedCdpUrl,
+      "cdpUrl should match provided value",
+      ctx,
+    );
+
+    await endSession(ctx.body.data.sessionId, headers);
+  });
+
+  it("should return error for browserbase requests without API key", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v1/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browser: { type: "browserbase" },
+        }),
+      },
+    );
+
+    // Should fail because browserbase requires x-bb-api-key header
+    assertFetchStatus(ctx, HTTP_BAD_REQUEST, "Request should fail with 400");
+  });
+
+  it("should start browserbase session with API key but no project ID", async () => {
+    if (!bbApiKey) return; // skip when credentials unavailable
+
+    const url = getBaseUrl();
+    const bbHeaders = {
+      ...getHeaders("3.0.0"),
+      "x-bb-api-key": bbApiKey,
+      // intentionally omitting x-bb-project-id
+    };
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v1/sessions/start`,
+      {
+        method: "POST",
+        headers: bbHeaders,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browser: { type: "browserbase" },
+        }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "Request should succeed without project ID",
+    );
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should return a successful start response",
+      ctx,
+    );
+
+    await endSession(ctx.body.data.sessionId, bbHeaders);
+  });
+
+  // =============================================================================
+  // Multi-Region Support Tests
+  // =============================================================================
+
+  it("should accept non-default region in browserbaseSessionCreateParams", async () => {
+    const url = getBaseUrl();
+
+    // Test with us-east-1 region - server should accept this request
+    // Note: Local browser sessions don't actually use the region, but the server
+    // should still accept the parameter without returning { available: false }
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v1/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browserbaseSessionCreateParams: {
+            region: "us-east-1" as BrowserbaseRegion,
+          },
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+    // The key assertion: non-default regions should NOT return available: false
+    assertFetchOk(
+      ctx.body.data.available === true,
+      "Session should be available for non-default regions",
+      ctx,
+    );
+    assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+
+    await endSession(ctx.body.data.sessionId, headers);
+  });
+
+  it("should accept eu-central-1 region in browserbaseSessionCreateParams", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v1/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browserbaseSessionCreateParams: {
+            region: "eu-central-1" as BrowserbaseRegion,
+          },
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.available === true,
+      "Session should be available for eu-central-1 region",
+      ctx,
+    );
+    assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+
+    await endSession(ctx.body.data.sessionId, headers);
+  });
+
+  it("should accept ap-southeast-1 region in browserbaseSessionCreateParams", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v1/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browserbaseSessionCreateParams: {
+            region: "ap-southeast-1" as BrowserbaseRegion,
+          },
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.available === true,
+      "Session should be available for ap-southeast-1 region",
+      ctx,
+    );
+    assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+
+    await endSession(ctx.body.data.sessionId, headers);
+  });
+});
+
+describe("POST /v1/sessions/start - keepAlive=false supervision in SEA", () => {
+  it("spawns a supervisor and exits it when chrome dies", async () => {
+    const handle = await startSeaServer();
+    const seaPid = handle.proc.pid;
+    assert.ok(seaPid, "SEA server must have a PID");
+
+    const { cdpUrl } = await startKeepAliveFalseLocalSession(handle.baseUrl);
+    const supervisor = await waitForValue(
+      () => findLocalSupervisorByParentPid(seaPid),
+      10_000,
+    );
+
+    assert.ok(
+      supervisor.chromePid,
+      `Expected local supervisor to include --chrome-pid. args=${supervisor.args}`,
+    );
+    assert.ok(
+      isPidAlive(supervisor.pid),
+      `Supervisor PID ${supervisor.pid} should be alive`,
+    );
+    assert.ok(
+      isPidAlive(supervisor.chromePid),
+      `Chrome PID ${supervisor.chromePid} should be alive`,
+    );
+
+    await closeLocalBrowserViaCdp(cdpUrl);
+
+    await waitForPidState(supervisor.chromePid, false, 10_000);
+    await waitForPidState(supervisor.pid, false, 10_000);
+    assert.ok(
+      isPidAlive(seaPid),
+      "SEA process should stay alive after chrome dies",
+    );
+  });
+
+  it("force-killing SEA kills local chrome and exits supervisor within 10s", async () => {
+    const handle = await startSeaServer();
+    const seaPid = handle.proc.pid;
+    assert.ok(seaPid, "SEA server must have a PID");
+
+    await startKeepAliveFalseLocalSession(handle.baseUrl);
+    const supervisor = await waitForValue(
+      () => findLocalSupervisorByParentPid(seaPid),
+      10_000,
+    );
+
+    assert.ok(
+      supervisor.chromePid,
+      `Expected local supervisor to include --chrome-pid. args=${supervisor.args}`,
+    );
+    assert.ok(
+      isPidAlive(supervisor.pid),
+      `Supervisor PID ${supervisor.pid} should be alive`,
+    );
+    assert.ok(
+      isPidAlive(supervisor.chromePid),
+      `Chrome PID ${supervisor.chromePid} should be alive`,
+    );
+
+    await forceKillSeaServer(handle);
+
+    await waitForPidState(supervisor.pid, false, 10_000);
+    await waitForPidState(supervisor.chromePid, false, 10_000);
+  });
+
+  it("force-killing SEA ends Browserbase session when keepAlive=false", async () => {
+    const handle = await startSeaServer({ BB_ENV: "prod" });
+    const sessionId = await startKeepAliveFalseBrowserbaseSession(
+      handle.baseUrl,
+    );
+
+    try {
+      await forceKillSeaServer(handle);
+      const finalStatus = await waitForBrowserbaseNotRunning(sessionId, 30_000);
+      assert.notEqual(
+        finalStatus,
+        "RUNNING",
+        "Browserbase session should not remain RUNNING after SEA kill",
+      );
+    } finally {
+      await requestBrowserbaseReleaseBestEffort(sessionId);
+    }
+  });
+});
diff --git a/packages/server-v3/tsconfig.json b/packages/server-v3/tsconfig.json
new file mode 100644
index 000000000..dbb9efc48
--- /dev/null
+++ b/packages/server-v3/tsconfig.json
@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "verbatimModuleSyntax": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
diff --git a/packages/server-v3/tsconfig.tests.json b/packages/server-v3/tsconfig.tests.json
new file mode 100644
index 000000000..4bb0384e3
--- /dev/null
+++ b/packages/server-v3/tsconfig.tests.json
@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "test",
+    "outDir": "dist/tests",
+    "declaration": false,
+    "noEmit": false
+  },
+  "include": ["test/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}
diff --git a/packages/server-v3/vitest.config.ts b/packages/server-v3/vitest.config.ts
new file mode 100644
index 000000000..570df33ab
--- /dev/null
+++ b/packages/server-v3/vitest.config.ts
@@ -0,0 +1,9 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["test/**/*.test.ts"],
+  },
+});
diff --git a/packages/server-v4/CHANGELOG.md b/packages/server-v4/CHANGELOG.md
new file mode 100644
index 000000000..2de0c5208
--- /dev/null
+++ b/packages/server-v4/CHANGELOG.md
@@ -0,0 +1,51 @@
+# @browserbasehq/stagehand-server-v4
+
+## 3.6.0
+
+### Minor Changes
+
+- [#1611](https://github.com/browserbase/stagehand/pull/1611) [`8a3c066`](https://github.com/browserbase/stagehand/commit/8a3c06600a9ba98485db7e9ed5c3cc43ea180334) Thanks [@monadoid](https://github.com/monadoid)! - Using `mode` enum instead of old `cua` boolean in openapi spec
+
+### Patch Changes
+
+- [#1604](https://github.com/browserbase/stagehand/pull/1604) [`4753078`](https://github.com/browserbase/stagehand/commit/4753078cc9d37cbdb8d1a63dfdb53ccc4b4c2bd2) Thanks [@miguelg719](https://github.com/miguelg719)! - Enable bedrock
+
+- [#1636](https://github.com/browserbase/stagehand/pull/1636) [`ea33052`](https://github.com/browserbase/stagehand/commit/ea330520a325583b71b87d85beb740df4bdb9b2d) Thanks [@miguelg719](https://github.com/miguelg719)! - Include executionModel on the AgentConfigSchema
+
+- [#1602](https://github.com/browserbase/stagehand/pull/1602) [`22a0502`](https://github.com/browserbase/stagehand/commit/22a0502e8b042bef0cfafa32901984a8be9529d8) Thanks [@miguelg719](https://github.com/miguelg719)! - Include vertex as a supported provider
+
+- Updated dependencies [[`7584f3e`](https://github.com/browserbase/stagehand/commit/7584f3e92e60a557d2b3e0e0d2a2af04c3527523), [`1e1c9c1`](https://github.com/browserbase/stagehand/commit/1e1c9c15773e49d5c3cd36021dbc1d23495c1bce), [`6bef890`](https://github.com/browserbase/stagehand/commit/6bef89090ebd231e77d8092b2c32a0f06303d5a9), [`ffd4b33`](https://github.com/browserbase/stagehand/commit/ffd4b335a873d0f4dcd76ea22d44f47919bf8e49), [`677bff5`](https://github.com/browserbase/stagehand/commit/677bff5834c879a2d95f7dbff918b8e1510516b3), [`65ff464`](https://github.com/browserbase/stagehand/commit/65ff464bc13388eb109eba0a2cf533c1cc202854), [`101bcf2`](https://github.com/browserbase/stagehand/commit/101bcf2da8b527fd6ace6aa291ada5d0f2d90344), [`0a94301`](https://github.com/browserbase/stagehand/commit/0a94301caa991d1aa4cdade6e28a065b1aefb3e2), [`b27c04d`](https://github.com/browserbase/stagehand/commit/b27c04d278c290364347acd0c354a878ea9b7c2d), [`afbd08b`](https://github.com/browserbase/stagehand/commit/afbd08bb6367a9c9f65f67e453667987e4659918), [`e3db9aa`](https://github.com/browserbase/stagehand/commit/e3db9aa863f44270792215801fe6e3a02a1321aa), [`0e8d569`](https://github.com/browserbase/stagehand/commit/0e8d5695f662040f7384e64f46301152802e3c62), [`ff0f979`](https://github.com/browserbase/stagehand/commit/ff0f9795f3b2c1cf4f2610a80ebcb3341a24f987), [`2d89d2b`](https://github.com/browserbase/stagehand/commit/2d89d2b35ce812431956b28e0c8b52d32ddc7a27), [`aac9a19`](https://github.com/browserbase/stagehand/commit/aac9a19bdfbe62e4508631337ab0bfbcf8ae62b2), [`06de50f`](https://github.com/browserbase/stagehand/commit/06de50ff377fd31f1b0fcf79adb996d04562d2c0), [`aa4d981`](https://github.com/browserbase/stagehand/commit/aa4d981e440bdd0e3d3f42ccc310d5958aa25cc6), [`18b1e3b`](https://github.com/browserbase/stagehand/commit/18b1e3bd2b16b721845d52fcf1a45c6158e2403f), [`957d82b`](https://github.com/browserbase/stagehand/commit/957d82b9845b4413b123539e81a2e4a490e74a8a), [`b65756e`](https://github.com/browserbase/stagehand/commit/b65756e9e85643055446aa4a51956f7d6627c89f), [`22e371a`](https://github.com/browserbase/stagehand/commit/22e371ae4c25deb6350328fe02832bf2b2197b94), [`d29b91f`](https://github.com/browserbase/stagehand/commit/d29b91fa506636ca36f724fcf106320de54ec3f3), [`7b4f817`](https://github.com/browserbase/stagehand/commit/7b4f817cafb9829ac81c4b5890c318c7f9521fe4), [`176d420`](https://github.com/browserbase/stagehand/commit/176d42002cc0a2c7d13b4c0ffbbd56b70fdc49e8), [`3f9ca4d`](https://github.com/browserbase/stagehand/commit/3f9ca4d9acc109101357378d29cf969168991608), [`8a3c066`](https://github.com/browserbase/stagehand/commit/8a3c06600a9ba98485db7e9ed5c3cc43ea180334), [`49ead1e`](https://github.com/browserbase/stagehand/commit/49ead1e1e8678a8da0f87ad2042491dacc6b01d7), [`3673369`](https://github.com/browserbase/stagehand/commit/36733691f90c15386cf2a7b47d04ef429b7195ae), [`c465e87`](https://github.com/browserbase/stagehand/commit/c465e87ab41942435132c76338518fb3fa8e7896), [`ae533e4`](https://github.com/browserbase/stagehand/commit/ae533e40195181b53833f8055b1259fb360a927b), [`ea33052`](https://github.com/browserbase/stagehand/commit/ea330520a325583b71b87d85beb740df4bdb9b2d), [`5764ede`](https://github.com/browserbase/stagehand/commit/5764edee7aab00ef1aafafb68fc56eb26c0a70b2), [`f09b184`](https://github.com/browserbase/stagehand/commit/f09b184cc5e774736280ae8c94ba3f4f13adda80), [`a7d29de`](https://github.com/browserbase/stagehand/commit/a7d29decee0f7d12e2437267b9eef1795d3b4e3a), [`d334399`](https://github.com/browserbase/stagehand/commit/d3343990041bf9cd5613569840afb0c17131e33c), [`44416da`](https://github.com/browserbase/stagehand/commit/44416da7ff33301bb32d3811e6c3be8782a7d168), [`bdd8b4e`](https://github.com/browserbase/stagehand/commit/bdd8b4ee3c697a02728375510ab7fae764990576)]:
+  - @browserbasehq/stagehand@3.1.0
+
+## 3.5.0
+
+### Minor Changes
+
+- [#1578](https://github.com/browserbase/stagehand/pull/1578) [`a5074bd`](https://github.com/browserbase/stagehand/commit/a5074bdda0811140ba7847065c26ac72175cef98) Thanks [@monadoid](https://github.com/monadoid)! - /end endpoint no longer takes an empty object - instead, no request body is required.
+
+### Patch Changes
+
+- Updated dependencies [[`40ce5cc`](https://github.com/browserbase/stagehand/commit/40ce5cc83ec758f4e8c37132a7f4ac8eeea7ca34), [`5506f41`](https://github.com/browserbase/stagehand/commit/5506f416d2609d112b553263984e21d7a30e32b1), [`84c05ca`](https://github.com/browserbase/stagehand/commit/84c05ca8de4587181faf128e5c7464fd960caacc), [`692ffa0`](https://github.com/browserbase/stagehand/commit/692ffa0346ad3d121686aba503c0a22844293efa), [`1ef8901`](https://github.com/browserbase/stagehand/commit/1ef8901e1314e90f43b36be20192e652d3b5598f), [`72ac775`](https://github.com/browserbase/stagehand/commit/72ac775a831d6f0f376ceda4426525f93cc21452), [`3d5af07`](https://github.com/browserbase/stagehand/commit/3d5af07f66d6d26d1f5ac4bd9be7183c3381dd92), [`40e1d80`](https://github.com/browserbase/stagehand/commit/40e1d80776b9216422a25a81070ccb3105e56ec2), [`56c0d24`](https://github.com/browserbase/stagehand/commit/56c0d244f9b2431218bfa832ddfc0587930ae038), [`16d72fb`](https://github.com/browserbase/stagehand/commit/16d72fb4c4081dd33bf45605d75c27644ea4c00e), [`088c4cc`](https://github.com/browserbase/stagehand/commit/088c4cc31dc924bb232a9d5a09ab42cd961c2d36), [`4276f4a`](https://github.com/browserbase/stagehand/commit/4276f4abc8bbde215faac6c0321bf243484c376b), [`6005786`](https://github.com/browserbase/stagehand/commit/600578637e65f6fd18b0cdb322b9e0b857708b2f), [`6fbf5fc`](https://github.com/browserbase/stagehand/commit/6fbf5fc811e5e5d9d22f10c5309fbd336892263a), [`704cf18`](https://github.com/browserbase/stagehand/commit/704cf18cb2bdd187ba06c35f05ccb47317a7668c), [`091296e`](https://github.com/browserbase/stagehand/commit/091296e438bb2374c8bb10ef6c08283978145ebf), [`e56c6eb`](https://github.com/browserbase/stagehand/commit/e56c6eb139bf3aad37e98b16626fff13a6c671d0), [`2cb78d0`](https://github.com/browserbase/stagehand/commit/2cb78d0f5ddef9f7337a9a2fe3137f1421df700a), [`5dad639`](https://github.com/browserbase/stagehand/commit/5dad63938f08d968d434bb1ee2804f1e54fb836a), [`b7c2571`](https://github.com/browserbase/stagehand/commit/b7c2571ad4ac563f3ca0518e1f29a40da93e33bc), [`4c69117`](https://github.com/browserbase/stagehand/commit/4c6911748953199dc9aad3eabe98bcf325f871e4)]:
+  - @browserbasehq/stagehand@3.0.8
+
+## 3.2.0
+
+### Minor Changes
+
+- [#1459](https://github.com/browserbase/stagehand/pull/1459) [`abb3469`](https://github.com/browserbase/stagehand/commit/abb3469f51627b318a856fafe6047ff24e681666) Thanks [@monadoid](https://github.com/monadoid)! - Added building of binaries
+
+- [#1457](https://github.com/browserbase/stagehand/pull/1457) [`5fc1281`](https://github.com/browserbase/stagehand/commit/5fc12817a6529d4c59f2e32db92c916095a9a81e) Thanks [@monadoid](https://github.com/monadoid)! - First changeset for stagehand-server
+
+- [#1469](https://github.com/browserbase/stagehand/pull/1469) [`d634d45`](https://github.com/browserbase/stagehand/commit/d634d45a0dbc3a4c876413d94cf4aedace1f56d7) Thanks [@monadoid](https://github.com/monadoid)! - Bump to test binary builds
+
+### Patch Changes
+
+- Updated dependencies [[`0f3991e`](https://github.com/browserbase/stagehand/commit/0f3991eedc0aaff72ef718dda3ddb0839cf4a464), [`e0e22e0`](https://github.com/browserbase/stagehand/commit/e0e22e06bc752a8ffde30f3dbfa58d91e24e6c09), [`f261051`](https://github.com/browserbase/stagehand/commit/f2610517d74774374de9ee93191e663439ef55e5), [`e021674`](https://github.com/browserbase/stagehand/commit/e021674f9641c1c5f9d0c1817c3fdf599eea124d), [`6a5496f`](https://github.com/browserbase/stagehand/commit/6a5496f17dbb716be1ee1aaa4e5ba9d8c723b30b), [`fea1700`](https://github.com/browserbase/stagehand/commit/fea1700552af3319052f463685752501c8e71de3), [`5b288d9`](https://github.com/browserbase/stagehand/commit/5b288d9ac37406ff22460ac8050bea26b87a378e), [`e822f5a`](https://github.com/browserbase/stagehand/commit/e822f5a8898df9eb48ca32c321025f0c74b638f0), [`638efc7`](https://github.com/browserbase/stagehand/commit/638efc7fea401bc43dd05dceedf4c13a3495a728), [`a890f16`](https://github.com/browserbase/stagehand/commit/a890f16fa3a752f308f858e5ab9c9a0faf6b3b34), [`934f492`](https://github.com/browserbase/stagehand/commit/934f492ec587bef81f0ce75b45a35b44ab545712), [`bd2db92`](https://github.com/browserbase/stagehand/commit/bd2db925f66a826d61d58be1611d55646cbdb560), [`51e0170`](https://github.com/browserbase/stagehand/commit/51e01709ce1c947c1947b4e2cb0b1f4f97b77182), [`05f5580`](https://github.com/browserbase/stagehand/commit/05f5580937c3c157550e3c25ae6671f44f562211), [`f56a9c2`](https://github.com/browserbase/stagehand/commit/f56a9c296d4ddce25a405358c66837f8ce4d679f), [`b40ae11`](https://github.com/browserbase/stagehand/commit/b40ae11391af49c3581fce27faa1b7483fc4a169), [`0d2b398`](https://github.com/browserbase/stagehand/commit/0d2b398cd40b32a9ecaf28ede70853036b7c91bd), [`cd01f29`](https://github.com/browserbase/stagehand/commit/cd01f290578eac703521f801ba3712f5332918f3), [`a734fca`](https://github.com/browserbase/stagehand/commit/a734fca0b4573753767d3ebc48ec414baf4f23e1), [`b342acf`](https://github.com/browserbase/stagehand/commit/b342acfaae058127fb57664644c5fd965db02bf2), [`2987cd1`](https://github.com/browserbase/stagehand/commit/2987cd1e5ffabefa9411936609635d4a638faed5), [`dfab1d5`](https://github.com/browserbase/stagehand/commit/dfab1d566299c8c5a63f20565a6da07dc8f61ccd), [`4d71162`](https://github.com/browserbase/stagehand/commit/4d71162beb119635b69b17637564a2bbd0e373e7)]:
+  - @browserbasehq/stagehand@3.0.7
+
+## 3.0.6
+
+### Patch Changes
+
+- Updated dependencies [[`605ed6b`](https://github.com/browserbase/stagehand/commit/605ed6b81a3ff8f25d4022f1e5fce6b42aecfc19), [`34e7e5b`](https://github.com/browserbase/stagehand/commit/34e7e5b292f5e6af6efc0da60118663310c5f718), [`943d2d7`](https://github.com/browserbase/stagehand/commit/943d2d79d0f289ac41c9164578f2f1dd876058f2), [`0e95cd2`](https://github.com/browserbase/stagehand/commit/0e95cd2f67672f64f0017024fd47d8b3aef59a95), [`d4237e4`](https://github.com/browserbase/stagehand/commit/d4237e40951ecd10abfdbe766672d498f8806484), [`86975e7`](https://github.com/browserbase/stagehand/commit/86975e795db7505804949a267b20509bd16b5256), [`d5e119b`](https://github.com/browserbase/stagehand/commit/d5e119be5eec84915a79f8d611b6ba0546f48c99), [`4e051b2`](https://github.com/browserbase/stagehand/commit/4e051b23add7ae276b0dbead38b4587838cfc1c1), [`6b5a3c9`](https://github.com/browserbase/stagehand/commit/6b5a3c9035654caaed2da375085b465edda97de4), [`bb85ad9`](https://github.com/browserbase/stagehand/commit/bb85ad912738623a7a866f0cb6e8d5807c6c2738), [`88d28cc`](https://github.com/browserbase/stagehand/commit/88d28cc6f31058d1cf6ec6dc948a4ae77a926b3c), [`45bcef0`](https://github.com/browserbase/stagehand/commit/45bcef0e5788b083f9e38dfd7c3bc63afcd4b6dd), [`6aa9d45`](https://github.com/browserbase/stagehand/commit/6aa9d455aa5836ec2ee8ab2e8b9df3fb218e5381), [`d382084`](https://github.com/browserbase/stagehand/commit/d382084745fff98c3e71413371466394a2625429), [`1df08cc`](https://github.com/browserbase/stagehand/commit/1df08ccb0a2cf73b5c37a91c129721114ff6371c), [`2b56600`](https://github.com/browserbase/stagehand/commit/2b566009606fcbba987260f21b075b318690ce99)]:
+  - @browserbasehq/stagehand@3.0.6
diff --git a/packages/server-v4/README.md b/packages/server-v4/README.md
new file mode 100644
index 000000000..c484b57df
--- /dev/null
+++ b/packages/server-v4/README.md
@@ -0,0 +1,36 @@
+# Stagehand API
+
+The Stagehand  is a powerful service that provides a RESTful interface for browser automation and session management using the Browserbase platform. It enables recording, playback, and manipulation of browser sessions with a focus on reliability and performance.
+
+## 📋 Prerequisites
+
+To run the Stagehand API locally, ensure you have the following installed:
+
+- Node.js
+- pnpm
+
+## 🛠 Installation
+
+1. Clone the repository:
+
+```bash
+git clone https://github.com/browserbase/stagehand/
+cd stagehand/packages/server-v4
+```
+
+2. Install dependencies:
+
+```bash
+pnpm install
+```
+
+3. Set up environment variables:
+
+```bash
+cp .env.example .env
+```
+
+4. Configure your `.env` file with the environment variables required by `src/lib/env.ts` (BB environment, API base URLs, etc.).
+
+5. `pnpm dev`
+
diff --git a/packages/server-v4/SDK_RELEASE_WORKFLOW.md b/packages/server-v4/SDK_RELEASE_WORKFLOW.md
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/server-v4/openapi.v4.yaml b/packages/server-v4/openapi.v4.yaml
new file mode 100644
index 000000000..b7f443f44
--- /dev/null
+++ b/packages/server-v4/openapi.v4.yaml
@@ -0,0 +1,2157 @@
+openapi: "3.1.0"
+info:
+  title: Stagehand API v4
+  version: "4.0.0"
+  description: >-
+    Stagehand SDK for AI browser automation [ALPHA]. This API allows clients to
+
+    execute browser automation tasks remotely on the Browserbase cloud.
+
+    All endpoints except /sessions/start require an active session ID.
+
+    Responses are streamed using Server-Sent Events (SSE) when the
+
+    `x-stream-response: true` header is provided.
+
+
+    This SDK is currently ALPHA software and is not production ready!
+
+    Please try it and give us your feedback, stay tuned for upcoming release
+    announcements!
+  contact:
+    name: Browserbase
+    url: https://browserbase.com
+components:
+  securitySchemes:
+    BrowserbaseApiKey:
+      type: apiKey
+      in: header
+      name: x-bb-api-key
+      description: Browserbase API key for authentication
+    BrowserbaseProjectId:
+      type: apiKey
+      in: header
+      name: x-bb-project-id
+      description: Browserbase project ID
+    ModelApiKey:
+      type: apiKey
+      in: header
+      name: x-model-api-key
+      description: API key for the AI model provider (OpenAI, Anthropic, etc.)
+  links:
+    SessionAct:
+      operationId: SessionAct
+      parameters:
+        id: $response.body#/data/sessionId
+      description: Perform an action on the session
+    SessionExtract:
+      operationId: SessionExtract
+      parameters:
+        id: $response.body#/data/sessionId
+      description: Extract data from the session
+    SessionObserve:
+      operationId: SessionObserve
+      parameters:
+        id: $response.body#/data/sessionId
+      description: Observe available actions on the session
+    SessionNavigate:
+      operationId: SessionNavigate
+      parameters:
+        id: $response.body#/data/sessionId
+      description: Navigate to a URL in the session
+    SessionAgentExecute:
+      operationId: SessionAgentExecute
+      parameters:
+        id: $response.body#/data/sessionId
+      description: Execute an agent on the session
+    SessionReplay:
+      operationId: SessionReplay
+      parameters:
+        id: $response.body#/data/sessionId
+      description: Replay session metrics
+    SessionEnd:
+      operationId: SessionEnd
+      parameters:
+        id: $response.body#/data/sessionId
+      description: End the session and release resources
+  schemas:
+    AgentCacheEntry:
+      type: object
+      properties:
+        cacheKey:
+          description: Opaque cache identifier computed from instruction, URL, options,
+            and config
+          type: string
+        entry:
+          description: Serialized cache entry that can be written to disk
+      required:
+        - cacheKey
+        - entry
+    BrowserbaseRegion:
+      type: string
+      enum:
+        - us-west-2
+        - us-east-1
+        - eu-central-1
+        - ap-southeast-1
+    LocalBrowserLaunchOptions:
+      type: object
+      properties:
+        args:
+          type: array
+          items:
+            type: string
+        executablePath:
+          type: string
+        port:
+          type: number
+        userDataDir:
+          type: string
+        preserveUserDataDir:
+          type: boolean
+        headless:
+          type: boolean
+        devtools:
+          type: boolean
+        chromiumSandbox:
+          type: boolean
+        ignoreDefaultArgs:
+          anyOf:
+            - type: boolean
+            - type: array
+              items:
+                type: string
+        proxy:
+          type: object
+          properties:
+            server:
+              type: string
+            bypass:
+              type: string
+            username:
+              type: string
+            password:
+              type: string
+          required:
+            - server
+        locale:
+          type: string
+        viewport:
+          type: object
+          properties:
+            width:
+              type: number
+            height:
+              type: number
+          required:
+            - width
+            - height
+        deviceScaleFactor:
+          type: number
+        hasTouch:
+          type: boolean
+        ignoreHTTPSErrors:
+          type: boolean
+        cdpUrl:
+          type: string
+        cdpHeaders:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties:
+            type: string
+        connectTimeoutMs:
+          type: number
+        downloadsPath:
+          type: string
+        acceptDownloads:
+          type: boolean
+      additionalProperties: false
+    ModelConfigObject:
+      type: object
+      properties:
+        provider:
+          description: AI provider for the model (or provide a baseURL endpoint instead)
+          example: openai
+          type: string
+          enum:
+            - openai
+            - anthropic
+            - google
+            - microsoft
+            - bedrock
+        modelName:
+          description: Model name string with provider prefix (e.g., 'openai/gpt-5-nano')
+          example: openai/gpt-5-nano
+          type: string
+        apiKey:
+          description: API key for the model provider
+          example: sk-some-openai-api-key
+          type: string
+        baseURL:
+          description: Base URL for the model provider
+          example: https://api.openai.com/v1
+          type: string
+          format: uri
+      required:
+        - modelName
+    ModelConfig:
+      $ref: "#/components/schemas/ModelConfigObject"
+    Action:
+      description: Action object returned by observe and used by act
+      type: object
+      properties:
+        selector:
+          description: CSS selector or XPath for the element
+          example: "[data-testid='submit-button']"
+          type: string
+        description:
+          description: Human-readable description of the action
+          example: Click the submit button
+          type: string
+        backendNodeId:
+          description: Backend node ID for the element
+          type: number
+        method:
+          description: The method to execute (click, fill, etc.)
+          example: click
+          type: string
+        arguments:
+          description: Arguments to pass to the method
+          example:
+            - Hello World
+          type: array
+          items:
+            type: string
+      required:
+        - selector
+        - description
+    BrowserConfig:
+      type: object
+      properties:
+        type:
+          description: Browser type to use
+          example: local
+          type: string
+          enum:
+            - local
+            - browserbase
+        cdpUrl:
+          description: Chrome DevTools Protocol URL for connecting to existing browser
+          example: ws://localhost:9222
+          type: string
+        launchOptions:
+          $ref: "#/components/schemas/LocalBrowserLaunchOptions"
+    BrowserbaseViewport:
+      type: object
+      properties:
+        width:
+          type: number
+        height:
+          type: number
+    BrowserbaseFingerprintScreen:
+      type: object
+      properties:
+        maxHeight:
+          type: number
+        maxWidth:
+          type: number
+        minHeight:
+          type: number
+        minWidth:
+          type: number
+    BrowserbaseFingerprint:
+      type: object
+      properties:
+        browsers:
+          type: array
+          items:
+            type: string
+            enum:
+              - chrome
+              - edge
+              - firefox
+              - safari
+        devices:
+          type: array
+          items:
+            type: string
+            enum:
+              - desktop
+              - mobile
+        httpVersion:
+          type: string
+          enum:
+            - "1"
+            - "2"
+        locales:
+          type: array
+          items:
+            type: string
+        operatingSystems:
+          type: array
+          items:
+            type: string
+            enum:
+              - android
+              - ios
+              - linux
+              - macos
+              - windows
+        screen:
+          $ref: "#/components/schemas/BrowserbaseFingerprintScreen"
+    BrowserbaseContext:
+      type: object
+      properties:
+        id:
+          type: string
+        persist:
+          type: boolean
+      required:
+        - id
+    BrowserbaseBrowserSettings:
+      type: object
+      properties:
+        advancedStealth:
+          type: boolean
+        blockAds:
+          type: boolean
+        context:
+          $ref: "#/components/schemas/BrowserbaseContext"
+        extensionId:
+          type: string
+        fingerprint:
+          $ref: "#/components/schemas/BrowserbaseFingerprint"
+        logSession:
+          type: boolean
+        recordSession:
+          type: boolean
+        solveCaptchas:
+          type: boolean
+        viewport:
+          $ref: "#/components/schemas/BrowserbaseViewport"
+    BrowserbaseProxyGeolocation:
+      type: object
+      properties:
+        country:
+          type: string
+        city:
+          type: string
+        state:
+          type: string
+      required:
+        - country
+    BrowserbaseProxyConfig:
+      type: object
+      properties:
+        type:
+          type: string
+          const: browserbase
+        domainPattern:
+          type: string
+        geolocation:
+          $ref: "#/components/schemas/BrowserbaseProxyGeolocation"
+      required:
+        - type
+    ExternalProxyConfig:
+      type: object
+      properties:
+        type:
+          type: string
+          const: external
+        server:
+          type: string
+        domainPattern:
+          type: string
+        username:
+          type: string
+        password:
+          type: string
+      required:
+        - type
+        - server
+    ProxyConfig:
+      oneOf:
+        - $ref: "#/components/schemas/BrowserbaseProxyConfig"
+        - $ref: "#/components/schemas/ExternalProxyConfig"
+      type: object
+      discriminator:
+        propertyName: type
+        mapping:
+          browserbase: "#/components/schemas/BrowserbaseProxyConfig"
+          external: "#/components/schemas/ExternalProxyConfig"
+    BrowserbaseSessionCreateParams:
+      type: object
+      properties:
+        projectId:
+          type: string
+        browserSettings:
+          $ref: "#/components/schemas/BrowserbaseBrowserSettings"
+        extensionId:
+          type: string
+        keepAlive:
+          type: boolean
+        proxies:
+          anyOf:
+            - type: boolean
+            - type: array
+              items:
+                $ref: "#/components/schemas/ProxyConfig"
+        region:
+          $ref: "#/components/schemas/BrowserbaseRegion"
+        timeout:
+          type: number
+        userMetadata:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+    SessionStartRequest:
+      type: object
+      properties:
+        modelName:
+          description: Model name to use for AI operations
+          example: openai/gpt-4o
+          type: string
+        domSettleTimeoutMs:
+          description: Timeout in ms to wait for DOM to settle
+          example: 5000
+          type: number
+        verbose:
+          description: Logging verbosity level (0=quiet, 1=normal, 2=debug)
+          example: 1
+          type: number
+          enum:
+            - 0
+            - 1
+            - 2
+        systemPrompt:
+          description: Custom system prompt for AI operations
+          type: string
+        browserbaseSessionCreateParams:
+          $ref: "#/components/schemas/BrowserbaseSessionCreateParams"
+        browser:
+          $ref: "#/components/schemas/BrowserConfig"
+        selfHeal:
+          description: Enable self-healing for failed actions
+          example: true
+          type: boolean
+        browserbaseSessionID:
+          description: Existing Browserbase session ID to resume
+          type: string
+        experimental:
+          type: boolean
+        waitForCaptchaSolves:
+          description: Wait for captcha solves
+          type: boolean
+        actTimeoutMs:
+          description: Timeout in ms for act operations
+          type: number
+      required:
+        - modelName
+    SessionStartResult:
+      type: object
+      properties:
+        sessionId:
+          description: Unique Browserbase session identifier
+          example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+          type: string
+        cdpUrl:
+          description: CDP WebSocket URL for connecting to the Browserbase cloud browser
+            (present when available)
+          example: wss://connect.browserbase.com/?signingKey=abc123
+          anyOf:
+            - type: string
+            - type: "null"
+        available:
+          type: boolean
+      required:
+        - sessionId
+        - available
+    ActOptions:
+      type: object
+      properties:
+        model:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano')
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfig"
+            - type: string
+        variables:
+          description: Variables to substitute in the action instruction
+          example:
+            username: john_doe
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties:
+            type: string
+        timeout:
+          description: Timeout in ms for the action
+          example: 30000
+          type: number
+    ActRequest:
+      type: object
+      properties:
+        input:
+          description: Natural language instruction or Action object
+          example: Click the login button
+          anyOf:
+            - type: string
+            - $ref: "#/components/schemas/Action"
+        options:
+          $ref: "#/components/schemas/ActOptions"
+        frameId:
+          description: Target frame ID for the action
+          anyOf:
+            - type: string
+            - type: "null"
+        streamResponse:
+          description: Whether to stream the response via SSE
+          example: true
+          type: boolean
+      required:
+        - input
+    ActResultData:
+      type: object
+      properties:
+        success:
+          description: Whether the action completed successfully
+          example: true
+          type: boolean
+        message:
+          description: Human-readable result message
+          example: Successfully clicked the login button
+          type: string
+        actionDescription:
+          description: Description of the action that was performed
+          example: Clicked button with text 'Login'
+          type: string
+        actions:
+          description: List of actions that were executed
+          type: array
+          items:
+            $ref: "#/components/schemas/Action"
+      required:
+        - success
+        - message
+        - actionDescription
+        - actions
+    ActResult:
+      type: object
+      properties:
+        result:
+          $ref: "#/components/schemas/ActResultData"
+        actionId:
+          description: Action ID for tracking
+          type: string
+      required:
+        - result
+    ExtractOptions:
+      type: object
+      properties:
+        model:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano')
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfig"
+            - type: string
+        timeout:
+          description: Timeout in ms for the extraction
+          example: 30000
+          type: number
+        selector:
+          description: CSS selector to scope extraction to a specific element
+          example: "#main-content"
+          type: string
+    ExtractRequest:
+      type: object
+      properties:
+        instruction:
+          description: Natural language instruction for what to extract
+          example: Extract all product names and prices from the page
+          type: string
+        schema:
+          description: JSON Schema defining the structure of data to extract
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+        options:
+          $ref: "#/components/schemas/ExtractOptions"
+        frameId:
+          description: Target frame ID for the extraction
+          anyOf:
+            - type: string
+            - type: "null"
+        streamResponse:
+          description: Whether to stream the response via SSE
+          example: true
+          type: boolean
+    ExtractResult:
+      type: object
+      properties:
+        result:
+          description: Extracted data matching the requested schema
+          x-stainless-any: true
+        actionId:
+          description: Action ID for tracking
+          type: string
+      required:
+        - result
+    ObserveOptions:
+      type: object
+      properties:
+        model:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano')
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfig"
+            - type: string
+        timeout:
+          description: Timeout in ms for the observation
+          example: 30000
+          type: number
+        selector:
+          description: CSS selector to scope observation to a specific element
+          example: nav
+          type: string
+    ObserveRequest:
+      type: object
+      properties:
+        instruction:
+          description: Natural language instruction for what actions to find
+          example: Find all clickable navigation links
+          type: string
+        options:
+          $ref: "#/components/schemas/ObserveOptions"
+        frameId:
+          description: Target frame ID for the observation
+          anyOf:
+            - type: string
+            - type: "null"
+        streamResponse:
+          description: Whether to stream the response via SSE
+          example: true
+          type: boolean
+    ObserveResult:
+      type: object
+      properties:
+        result:
+          type: array
+          items:
+            $ref: "#/components/schemas/Action"
+        actionId:
+          description: Action ID for tracking
+          type: string
+      required:
+        - result
+    AgentConfig:
+      type: object
+      properties:
+        provider:
+          description: "AI provider for the agent (legacy, use model: openai/gpt-5-nano
+            instead)"
+          example: openai
+          type: string
+          enum:
+            - openai
+            - anthropic
+            - google
+            - microsoft
+            - bedrock
+        model:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano')
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfig"
+            - type: string
+        systemPrompt:
+          description: Custom system prompt for the agent
+          type: string
+        cua:
+          description: "Deprecated. Use mode: 'cua' instead. If both are provided, mode
+            takes precedence."
+          example: true
+          type: boolean
+        mode:
+          description: Tool mode for the agent (dom, hybrid, cua). If set, overrides cua.
+          example: cua
+          type: string
+          enum:
+            - dom
+            - hybrid
+            - cua
+        executionModel:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano') for tool execution (observe/act calls within
+            agent tools). If not specified, inherits from the main model
+            configuration.
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfig"
+            - type: string
+    AgentAction:
+      type: object
+      properties:
+        type:
+          description: Type of action taken
+          example: click
+          type: string
+        reasoning:
+          description: Agent's reasoning for taking this action
+          type: string
+        taskCompleted:
+          type: boolean
+        action:
+          type: string
+        timeMs:
+          description: Time taken for this action in ms
+          type: number
+        pageText:
+          type: string
+        pageUrl:
+          type: string
+        instruction:
+          type: string
+      required:
+        - type
+      additionalProperties: {}
+    AgentUsage:
+      type: object
+      properties:
+        input_tokens:
+          example: 1500
+          type: number
+        output_tokens:
+          example: 250
+          type: number
+        reasoning_tokens:
+          type: number
+        cached_input_tokens:
+          type: number
+        inference_time_ms:
+          example: 2500
+          type: number
+      required:
+        - input_tokens
+        - output_tokens
+        - inference_time_ms
+    AgentResultData:
+      type: object
+      properties:
+        success:
+          description: Whether the agent completed successfully
+          example: true
+          type: boolean
+        message:
+          description: Summary of what the agent accomplished
+          example: Successfully logged in and navigated to dashboard
+          type: string
+        actions:
+          type: array
+          items:
+            $ref: "#/components/schemas/AgentAction"
+        completed:
+          description: Whether the agent finished its task
+          example: true
+          type: boolean
+        metadata:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+        usage:
+          $ref: "#/components/schemas/AgentUsage"
+      required:
+        - success
+        - message
+        - actions
+        - completed
+    AgentExecuteOptions:
+      type: object
+      properties:
+        instruction:
+          description: Natural language instruction for the agent
+          example: Log in with username 'demo' and password 'test123', then navigate to
+            settings
+          type: string
+        maxSteps:
+          description: Maximum number of steps the agent can take
+          example: 20
+          type: number
+        highlightCursor:
+          description: Whether to visually highlight the cursor during execution
+          example: true
+          type: boolean
+      required:
+        - instruction
+    AgentExecuteRequest:
+      type: object
+      properties:
+        agentConfig:
+          $ref: "#/components/schemas/AgentConfig"
+        executeOptions:
+          $ref: "#/components/schemas/AgentExecuteOptions"
+        frameId:
+          description: Target frame ID for the agent
+          anyOf:
+            - type: string
+            - type: "null"
+        streamResponse:
+          description: Whether to stream the response via SSE
+          example: true
+          type: boolean
+        shouldCache:
+          description: If true, the server captures a cache entry and returns it to the
+            client
+          type: boolean
+      required:
+        - agentConfig
+        - executeOptions
+    AgentExecuteResult:
+      type: object
+      properties:
+        result:
+          $ref: "#/components/schemas/AgentResultData"
+        cacheEntry:
+          $ref: "#/components/schemas/AgentCacheEntry"
+      required:
+        - result
+    NavigateOptions:
+      type: object
+      properties:
+        referer:
+          description: Referer header to send with the request
+          type: string
+        timeout:
+          description: Timeout in ms for the navigation
+          example: 30000
+          type: number
+        waitUntil:
+          description: When to consider navigation complete
+          example: networkidle
+          type: string
+          enum:
+            - load
+            - domcontentloaded
+            - networkidle
+    NavigateRequest:
+      type: object
+      properties:
+        url:
+          description: URL to navigate to
+          example: https://example.com
+          type: string
+        options:
+          $ref: "#/components/schemas/NavigateOptions"
+        frameId:
+          description: Target frame ID for the navigation
+          anyOf:
+            - type: string
+            - type: "null"
+        streamResponse:
+          description: Whether to stream the response via SSE
+          example: true
+          type: boolean
+      required:
+        - url
+    NavigateResult:
+      type: object
+      properties:
+        result:
+          description: Navigation response (Playwright Response object or null)
+          anyOf:
+            - {}
+            - type: "null"
+          x-stainless-any: true
+        actionId:
+          description: Action ID for tracking
+          type: string
+      required:
+        - result
+    TokenUsage:
+      type: object
+      properties:
+        inputTokens:
+          type: number
+        outputTokens:
+          type: number
+        timeMs:
+          type: number
+        cost:
+          type: number
+    ReplayAction:
+      type: object
+      properties:
+        method:
+          type: string
+        parameters:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+        result:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+        timestamp:
+          type: number
+        endTime:
+          type: number
+        tokenUsage:
+          $ref: "#/components/schemas/TokenUsage"
+      required:
+        - method
+        - parameters
+        - result
+        - timestamp
+    ReplayPage:
+      type: object
+      properties:
+        url:
+          type: string
+        timestamp:
+          type: number
+        duration:
+          type: number
+        actions:
+          type: array
+          items:
+            $ref: "#/components/schemas/ReplayAction"
+      required:
+        - url
+        - timestamp
+        - duration
+        - actions
+    ReplayResult:
+      type: object
+      properties:
+        pages:
+          type: array
+          items:
+            $ref: "#/components/schemas/ReplayPage"
+        clientLanguage:
+          type: string
+      required:
+        - pages
+    StreamEventStatus:
+      description: Current status of the streaming operation
+      type: string
+      enum:
+        - starting
+        - connected
+        - running
+        - finished
+        - error
+    StreamEventType:
+      description: Type of stream event - system events or log messages
+      type: string
+      enum:
+        - system
+        - log
+    StreamEventSystemData:
+      type: object
+      properties:
+        status:
+          $ref: "#/components/schemas/StreamEventStatus"
+        result:
+          description: Operation result (present when status is 'finished')
+          x-stainless-any: true
+        error:
+          description: Error message (present when status is 'error')
+          type: string
+      required:
+        - status
+    StreamEventLogData:
+      type: object
+      properties:
+        status:
+          type: string
+          const: running
+        message:
+          description: Log message from the operation
+          type: string
+      required:
+        - status
+        - message
+    SessionStartResponse:
+      type: object
+      properties:
+        success:
+          description: Indicates whether the request was successful
+          type: boolean
+        data:
+          $ref: "#/components/schemas/SessionStartResultOutput"
+      required:
+        - success
+        - data
+      additionalProperties: false
+    SessionEndResponse:
+      type: object
+      properties:
+        success:
+          description: Indicates whether the request was successful
+          type: boolean
+      required:
+        - success
+      additionalProperties: false
+    ActResponse:
+      type: object
+      properties:
+        success:
+          description: Indicates whether the request was successful
+          type: boolean
+        data:
+          $ref: "#/components/schemas/ActResultOutput"
+      required:
+        - success
+        - data
+      additionalProperties: false
+    ExtractResponse:
+      type: object
+      properties:
+        success:
+          description: Indicates whether the request was successful
+          type: boolean
+        data:
+          $ref: "#/components/schemas/ExtractResultOutput"
+      required:
+        - success
+        - data
+      additionalProperties: false
+    ObserveResponse:
+      type: object
+      properties:
+        success:
+          description: Indicates whether the request was successful
+          type: boolean
+        data:
+          $ref: "#/components/schemas/ObserveResultOutput"
+      required:
+        - success
+        - data
+      additionalProperties: false
+    AgentExecuteResponse:
+      type: object
+      properties:
+        success:
+          description: Indicates whether the request was successful
+          type: boolean
+        data:
+          $ref: "#/components/schemas/AgentExecuteResultOutput"
+      required:
+        - success
+        - data
+      additionalProperties: false
+    NavigateResponse:
+      type: object
+      properties:
+        success:
+          description: Indicates whether the request was successful
+          type: boolean
+        data:
+          $ref: "#/components/schemas/NavigateResultOutput"
+      required:
+        - success
+        - data
+      additionalProperties: false
+    ReplayResponse:
+      type: object
+      properties:
+        success:
+          description: Indicates whether the request was successful
+          type: boolean
+        data:
+          $ref: "#/components/schemas/ReplayResultOutput"
+      required:
+        - success
+        - data
+      additionalProperties: false
+    AgentCacheEntryOutput:
+      type: object
+      properties:
+        cacheKey:
+          description: Opaque cache identifier computed from instruction, URL, options,
+            and config
+          type: string
+        entry:
+          description: Serialized cache entry that can be written to disk
+      required:
+        - cacheKey
+        - entry
+      additionalProperties: false
+    LocalBrowserLaunchOptionsOutput:
+      type: object
+      properties:
+        args:
+          type: array
+          items:
+            type: string
+        executablePath:
+          type: string
+        port:
+          type: number
+        userDataDir:
+          type: string
+        preserveUserDataDir:
+          type: boolean
+        headless:
+          type: boolean
+        devtools:
+          type: boolean
+        chromiumSandbox:
+          type: boolean
+        ignoreDefaultArgs:
+          anyOf:
+            - type: boolean
+            - type: array
+              items:
+                type: string
+        proxy:
+          type: object
+          properties:
+            server:
+              type: string
+            bypass:
+              type: string
+            username:
+              type: string
+            password:
+              type: string
+          required:
+            - server
+          additionalProperties: false
+        locale:
+          type: string
+        viewport:
+          type: object
+          properties:
+            width:
+              type: number
+            height:
+              type: number
+          required:
+            - width
+            - height
+          additionalProperties: false
+        deviceScaleFactor:
+          type: number
+        hasTouch:
+          type: boolean
+        ignoreHTTPSErrors:
+          type: boolean
+        cdpUrl:
+          type: string
+        cdpHeaders:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties:
+            type: string
+        connectTimeoutMs:
+          type: number
+        downloadsPath:
+          type: string
+        acceptDownloads:
+          type: boolean
+      additionalProperties: false
+    ModelConfigObjectOutput:
+      type: object
+      properties:
+        provider:
+          description: AI provider for the model (or provide a baseURL endpoint instead)
+          example: openai
+          type: string
+          enum:
+            - openai
+            - anthropic
+            - google
+            - microsoft
+            - bedrock
+        modelName:
+          description: Model name string with provider prefix (e.g., 'openai/gpt-5-nano')
+          example: openai/gpt-5-nano
+          type: string
+        apiKey:
+          description: API key for the model provider
+          example: sk-some-openai-api-key
+          type: string
+        baseURL:
+          description: Base URL for the model provider
+          example: https://api.openai.com/v1
+          type: string
+          format: uri
+      required:
+        - modelName
+      additionalProperties: false
+    ModelConfigOutput:
+      $ref: "#/components/schemas/ModelConfigObjectOutput"
+    ActionOutput:
+      description: Action object returned by observe and used by act
+      type: object
+      properties:
+        selector:
+          description: CSS selector or XPath for the element
+          example: "[data-testid='submit-button']"
+          type: string
+        description:
+          description: Human-readable description of the action
+          example: Click the submit button
+          type: string
+        backendNodeId:
+          description: Backend node ID for the element
+          type: number
+        method:
+          description: The method to execute (click, fill, etc.)
+          example: click
+          type: string
+        arguments:
+          description: Arguments to pass to the method
+          example:
+            - Hello World
+          type: array
+          items:
+            type: string
+      required:
+        - selector
+        - description
+      additionalProperties: false
+    BrowserConfigOutput:
+      type: object
+      properties:
+        type:
+          description: Browser type to use
+          example: local
+          type: string
+          enum:
+            - local
+            - browserbase
+        cdpUrl:
+          description: Chrome DevTools Protocol URL for connecting to existing browser
+          example: ws://localhost:9222
+          type: string
+        launchOptions:
+          $ref: "#/components/schemas/LocalBrowserLaunchOptionsOutput"
+      additionalProperties: false
+    BrowserbaseViewportOutput:
+      type: object
+      properties:
+        width:
+          type: number
+        height:
+          type: number
+      additionalProperties: false
+    BrowserbaseFingerprintScreenOutput:
+      type: object
+      properties:
+        maxHeight:
+          type: number
+        maxWidth:
+          type: number
+        minHeight:
+          type: number
+        minWidth:
+          type: number
+      additionalProperties: false
+    BrowserbaseFingerprintOutput:
+      type: object
+      properties:
+        browsers:
+          type: array
+          items:
+            type: string
+            enum:
+              - chrome
+              - edge
+              - firefox
+              - safari
+        devices:
+          type: array
+          items:
+            type: string
+            enum:
+              - desktop
+              - mobile
+        httpVersion:
+          type: string
+          enum:
+            - "1"
+            - "2"
+        locales:
+          type: array
+          items:
+            type: string
+        operatingSystems:
+          type: array
+          items:
+            type: string
+            enum:
+              - android
+              - ios
+              - linux
+              - macos
+              - windows
+        screen:
+          $ref: "#/components/schemas/BrowserbaseFingerprintScreenOutput"
+      additionalProperties: false
+    BrowserbaseContextOutput:
+      type: object
+      properties:
+        id:
+          type: string
+        persist:
+          type: boolean
+      required:
+        - id
+      additionalProperties: false
+    BrowserbaseBrowserSettingsOutput:
+      type: object
+      properties:
+        advancedStealth:
+          type: boolean
+        blockAds:
+          type: boolean
+        context:
+          $ref: "#/components/schemas/BrowserbaseContextOutput"
+        extensionId:
+          type: string
+        fingerprint:
+          $ref: "#/components/schemas/BrowserbaseFingerprintOutput"
+        logSession:
+          type: boolean
+        recordSession:
+          type: boolean
+        solveCaptchas:
+          type: boolean
+        viewport:
+          $ref: "#/components/schemas/BrowserbaseViewportOutput"
+      additionalProperties: false
+    BrowserbaseProxyGeolocationOutput:
+      type: object
+      properties:
+        country:
+          type: string
+        city:
+          type: string
+        state:
+          type: string
+      required:
+        - country
+      additionalProperties: false
+    BrowserbaseProxyConfigOutput:
+      type: object
+      properties:
+        type:
+          type: string
+          const: browserbase
+        domainPattern:
+          type: string
+        geolocation:
+          $ref: "#/components/schemas/BrowserbaseProxyGeolocationOutput"
+      required:
+        - type
+      additionalProperties: false
+    ExternalProxyConfigOutput:
+      type: object
+      properties:
+        type:
+          type: string
+          const: external
+        server:
+          type: string
+        domainPattern:
+          type: string
+        username:
+          type: string
+        password:
+          type: string
+      required:
+        - type
+        - server
+      additionalProperties: false
+    ProxyConfigOutput:
+      oneOf:
+        - $ref: "#/components/schemas/BrowserbaseProxyConfigOutput"
+        - $ref: "#/components/schemas/ExternalProxyConfigOutput"
+      type: object
+      discriminator:
+        propertyName: type
+        mapping:
+          browserbase: "#/components/schemas/BrowserbaseProxyConfigOutput"
+          external: "#/components/schemas/ExternalProxyConfigOutput"
+    BrowserbaseSessionCreateParamsOutput:
+      type: object
+      properties:
+        projectId:
+          type: string
+        browserSettings:
+          $ref: "#/components/schemas/BrowserbaseBrowserSettingsOutput"
+        extensionId:
+          type: string
+        keepAlive:
+          type: boolean
+        proxies:
+          anyOf:
+            - type: boolean
+            - type: array
+              items:
+                $ref: "#/components/schemas/ProxyConfigOutput"
+        region:
+          $ref: "#/components/schemas/BrowserbaseRegion"
+        timeout:
+          type: number
+        userMetadata:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+      additionalProperties: false
+    SessionStartResultOutput:
+      type: object
+      properties:
+        sessionId:
+          description: Unique Browserbase session identifier
+          example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+          type: string
+        cdpUrl:
+          description: CDP WebSocket URL for connecting to the Browserbase cloud browser
+            (present when available)
+          example: wss://connect.browserbase.com/?signingKey=abc123
+          anyOf:
+            - type: string
+            - type: "null"
+        available:
+          type: boolean
+      required:
+        - sessionId
+        - available
+      additionalProperties: false
+    ActOptionsOutput:
+      type: object
+      properties:
+        model:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano')
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfigOutput"
+            - type: string
+        variables:
+          description: Variables to substitute in the action instruction
+          example:
+            username: john_doe
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties:
+            type: string
+        timeout:
+          description: Timeout in ms for the action
+          example: 30000
+          type: number
+      additionalProperties: false
+    ActResultDataOutput:
+      type: object
+      properties:
+        success:
+          description: Whether the action completed successfully
+          example: true
+          type: boolean
+        message:
+          description: Human-readable result message
+          example: Successfully clicked the login button
+          type: string
+        actionDescription:
+          description: Description of the action that was performed
+          example: Clicked button with text 'Login'
+          type: string
+        actions:
+          description: List of actions that were executed
+          type: array
+          items:
+            $ref: "#/components/schemas/ActionOutput"
+      required:
+        - success
+        - message
+        - actionDescription
+        - actions
+      additionalProperties: false
+    ActResultOutput:
+      type: object
+      properties:
+        result:
+          $ref: "#/components/schemas/ActResultDataOutput"
+        actionId:
+          description: Action ID for tracking
+          type: string
+      required:
+        - result
+      additionalProperties: false
+    ExtractOptionsOutput:
+      type: object
+      properties:
+        model:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano')
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfigOutput"
+            - type: string
+        timeout:
+          description: Timeout in ms for the extraction
+          example: 30000
+          type: number
+        selector:
+          description: CSS selector to scope extraction to a specific element
+          example: "#main-content"
+          type: string
+      additionalProperties: false
+    ExtractResultOutput:
+      type: object
+      properties:
+        result:
+          description: Extracted data matching the requested schema
+          x-stainless-any: true
+        actionId:
+          description: Action ID for tracking
+          type: string
+      required:
+        - result
+      additionalProperties: false
+    ObserveOptionsOutput:
+      type: object
+      properties:
+        model:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano')
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfigOutput"
+            - type: string
+        timeout:
+          description: Timeout in ms for the observation
+          example: 30000
+          type: number
+        selector:
+          description: CSS selector to scope observation to a specific element
+          example: nav
+          type: string
+      additionalProperties: false
+    ObserveResultOutput:
+      type: object
+      properties:
+        result:
+          type: array
+          items:
+            $ref: "#/components/schemas/ActionOutput"
+        actionId:
+          description: Action ID for tracking
+          type: string
+      required:
+        - result
+      additionalProperties: false
+    AgentConfigOutput:
+      type: object
+      properties:
+        provider:
+          description: "AI provider for the agent (legacy, use model: openai/gpt-5-nano
+            instead)"
+          example: openai
+          type: string
+          enum:
+            - openai
+            - anthropic
+            - google
+            - microsoft
+            - bedrock
+        model:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano')
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfigOutput"
+            - type: string
+        systemPrompt:
+          description: Custom system prompt for the agent
+          type: string
+        cua:
+          description: "Deprecated. Use mode: 'cua' instead. If both are provided, mode
+            takes precedence."
+          example: true
+          type: boolean
+        mode:
+          description: Tool mode for the agent (dom, hybrid, cua). If set, overrides cua.
+          example: cua
+          type: string
+          enum:
+            - dom
+            - hybrid
+            - cua
+        executionModel:
+          description: Model configuration object or model name string (e.g.,
+            'openai/gpt-5-nano') for tool execution (observe/act calls within
+            agent tools). If not specified, inherits from the main model
+            configuration.
+          anyOf:
+            - $ref: "#/components/schemas/ModelConfigOutput"
+            - type: string
+      additionalProperties: false
+    AgentUsageOutput:
+      type: object
+      properties:
+        input_tokens:
+          example: 1500
+          type: number
+        output_tokens:
+          example: 250
+          type: number
+        reasoning_tokens:
+          type: number
+        cached_input_tokens:
+          type: number
+        inference_time_ms:
+          example: 2500
+          type: number
+      required:
+        - input_tokens
+        - output_tokens
+        - inference_time_ms
+      additionalProperties: false
+    AgentResultDataOutput:
+      type: object
+      properties:
+        success:
+          description: Whether the agent completed successfully
+          example: true
+          type: boolean
+        message:
+          description: Summary of what the agent accomplished
+          example: Successfully logged in and navigated to dashboard
+          type: string
+        actions:
+          type: array
+          items:
+            $ref: "#/components/schemas/AgentAction"
+        completed:
+          description: Whether the agent finished its task
+          example: true
+          type: boolean
+        metadata:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+        usage:
+          $ref: "#/components/schemas/AgentUsageOutput"
+      required:
+        - success
+        - message
+        - actions
+        - completed
+      additionalProperties: false
+    AgentExecuteOptionsOutput:
+      type: object
+      properties:
+        instruction:
+          description: Natural language instruction for the agent
+          example: Log in with username 'demo' and password 'test123', then navigate to
+            settings
+          type: string
+        maxSteps:
+          description: Maximum number of steps the agent can take
+          example: 20
+          type: number
+        highlightCursor:
+          description: Whether to visually highlight the cursor during execution
+          example: true
+          type: boolean
+      required:
+        - instruction
+      additionalProperties: false
+    AgentExecuteResultOutput:
+      type: object
+      properties:
+        result:
+          $ref: "#/components/schemas/AgentResultDataOutput"
+        cacheEntry:
+          $ref: "#/components/schemas/AgentCacheEntryOutput"
+      required:
+        - result
+      additionalProperties: false
+    NavigateOptionsOutput:
+      type: object
+      properties:
+        referer:
+          description: Referer header to send with the request
+          type: string
+        timeout:
+          description: Timeout in ms for the navigation
+          example: 30000
+          type: number
+        waitUntil:
+          description: When to consider navigation complete
+          example: networkidle
+          type: string
+          enum:
+            - load
+            - domcontentloaded
+            - networkidle
+      additionalProperties: false
+    NavigateResultOutput:
+      type: object
+      properties:
+        result:
+          description: Navigation response (Playwright Response object or null)
+          anyOf:
+            - {}
+            - type: "null"
+          x-stainless-any: true
+        actionId:
+          description: Action ID for tracking
+          type: string
+      required:
+        - result
+      additionalProperties: false
+    TokenUsageOutput:
+      type: object
+      properties:
+        inputTokens:
+          type: number
+        outputTokens:
+          type: number
+        timeMs:
+          type: number
+        cost:
+          type: number
+      additionalProperties: false
+    ReplayActionOutput:
+      type: object
+      properties:
+        method:
+          type: string
+        parameters:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+        result:
+          type: object
+          propertyNames:
+            type: string
+          additionalProperties: {}
+        timestamp:
+          type: number
+        endTime:
+          type: number
+        tokenUsage:
+          $ref: "#/components/schemas/TokenUsageOutput"
+      required:
+        - method
+        - parameters
+        - result
+        - timestamp
+      additionalProperties: false
+    ReplayPageOutput:
+      type: object
+      properties:
+        url:
+          type: string
+        timestamp:
+          type: number
+        duration:
+          type: number
+        actions:
+          type: array
+          items:
+            $ref: "#/components/schemas/ReplayActionOutput"
+      required:
+        - url
+        - timestamp
+        - duration
+        - actions
+      additionalProperties: false
+    ReplayResultOutput:
+      type: object
+      properties:
+        pages:
+          type: array
+          items:
+            $ref: "#/components/schemas/ReplayPageOutput"
+        clientLanguage:
+          type: string
+      required:
+        - pages
+      additionalProperties: false
+    StreamEventSystemDataOutput:
+      type: object
+      properties:
+        status:
+          $ref: "#/components/schemas/StreamEventStatus"
+        result:
+          description: Operation result (present when status is 'finished')
+          x-stainless-any: true
+        error:
+          description: Error message (present when status is 'error')
+          type: string
+      required:
+        - status
+      additionalProperties: false
+    StreamEventLogDataOutput:
+      type: object
+      properties:
+        status:
+          type: string
+          const: running
+        message:
+          description: Log message from the operation
+          type: string
+      required:
+        - status
+        - message
+      additionalProperties: false
+    SessionIdParams:
+      type: object
+      properties:
+        id:
+          description: Unique session identifier
+          example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+          type: string
+      required:
+        - id
+      additionalProperties: false
+    SessionHeaders:
+      type: object
+      properties:
+        x-stream-response:
+          description: Whether to stream the response via SSE
+          example: "true"
+          type: string
+          enum:
+            - "true"
+            - "false"
+      additionalProperties: false
+    ErrorResponse:
+      type: object
+      properties:
+        success:
+          type: boolean
+          const: false
+        error:
+          type: string
+        code:
+          type: string
+      required:
+        - success
+        - error
+      additionalProperties: false
+    SessionEndResult:
+      type: object
+      properties: {}
+      additionalProperties: false
+    StreamEvent:
+      description: "Server-Sent Event emitted during streaming responses. Events are
+        sent as `data: <JSON>\\n\\n`. Key order: data (with status first), type,
+        id."
+      type: object
+      properties:
+        data:
+          anyOf:
+            - $ref: "#/components/schemas/StreamEventSystemDataOutput"
+            - $ref: "#/components/schemas/StreamEventLogDataOutput"
+        type:
+          $ref: "#/components/schemas/StreamEventType"
+        id:
+          description: Unique identifier for this event
+          example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+          type: string
+          format: uuid
+          pattern: ^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$
+      required:
+        - data
+        - type
+        - id
+      additionalProperties: false
+paths:
+  /v4/sessions/{id}/act:
+    post:
+      operationId: SessionAct
+      summary: Perform an action
+      description: Executes a browser action using natural language instructions or a
+        predefined Action object.
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/ActRequest"
+        required: true
+      parameters:
+        - schema:
+            description: Unique session identifier
+            example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+            type: string
+          in: path
+          name: id
+          required: true
+          description: Unique session identifier
+        - schema:
+            description: Whether to stream the response via SSE
+            example: "true"
+            type: string
+            enum:
+              - "true"
+              - "false"
+          in: header
+          name: x-stream-response
+          description: Whether to stream the response via SSE
+      responses:
+        "200":
+          description: Default Response
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ActResponse"
+  /v4/sessions/{id}/end:
+    post:
+      operationId: SessionEnd
+      summary: End a browser session
+      description: Terminates the browser session and releases all associated resources.
+      parameters:
+        - schema:
+            description: Unique session identifier
+            example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+            type: string
+          in: path
+          name: id
+          required: true
+          description: Unique session identifier
+        - schema:
+            description: Whether to stream the response via SSE
+            example: "true"
+            type: string
+            enum:
+              - "true"
+              - "false"
+          in: header
+          name: x-stream-response
+          description: Whether to stream the response via SSE
+      responses:
+        "200":
+          description: Default Response
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/SessionEndResponse"
+  /v4/sessions/{id}/extract:
+    post:
+      operationId: SessionExtract
+      summary: Extract data from the page
+      description: Extracts structured data from the current page using AI-powered analysis.
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/ExtractRequest"
+        required: true
+      parameters:
+        - schema:
+            description: Unique session identifier
+            example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+            type: string
+          in: path
+          name: id
+          required: true
+          description: Unique session identifier
+        - schema:
+            description: Whether to stream the response via SSE
+            example: "true"
+            type: string
+            enum:
+              - "true"
+              - "false"
+          in: header
+          name: x-stream-response
+          description: Whether to stream the response via SSE
+      responses:
+        "200":
+          description: Default Response
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ExtractResponse"
+  /v4/sessions/{id}/navigate:
+    post:
+      operationId: SessionNavigate
+      summary: Navigate to a URL
+      description: Navigates the browser to the specified URL.
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/NavigateRequest"
+        required: true
+      parameters:
+        - schema:
+            description: Unique session identifier
+            example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+            type: string
+          in: path
+          name: id
+          required: true
+          description: Unique session identifier
+        - schema:
+            description: Whether to stream the response via SSE
+            example: "true"
+            type: string
+            enum:
+              - "true"
+              - "false"
+          in: header
+          name: x-stream-response
+          description: Whether to stream the response via SSE
+      responses:
+        "200":
+          description: Default Response
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/NavigateResponse"
+  /v4/sessions/{id}/observe:
+    post:
+      operationId: SessionObserve
+      summary: Observe available actions
+      description: Identifies and returns available actions on the current page that
+        match the given instruction.
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/ObserveRequest"
+        required: true
+      parameters:
+        - schema:
+            description: Unique session identifier
+            example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+            type: string
+          in: path
+          name: id
+          required: true
+          description: Unique session identifier
+        - schema:
+            description: Whether to stream the response via SSE
+            example: "true"
+            type: string
+            enum:
+              - "true"
+              - "false"
+          in: header
+          name: x-stream-response
+          description: Whether to stream the response via SSE
+      responses:
+        "200":
+          description: Default Response
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ObserveResponse"
+  /v4/sessions/{id}/replay:
+    get:
+      operationId: SessionReplay
+      summary: Replay session metrics
+      description: Retrieves replay metrics for a session.
+      parameters:
+        - schema:
+            description: Unique session identifier
+            example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+            type: string
+          in: path
+          name: id
+          required: true
+          description: Unique session identifier
+        - schema:
+            description: Whether to stream the response via SSE
+            example: "true"
+            type: string
+            enum:
+              - "true"
+              - "false"
+          in: header
+          name: x-stream-response
+          description: Whether to stream the response via SSE
+      responses:
+        "200":
+          description: Default Response
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ReplayResponse"
+  /v4/sessions/start:
+    post:
+      operationId: SessionStart
+      summary: Start a new browser session
+      description: Creates a new browser session with the specified configuration.
+        Returns a session ID used for all subsequent operations.
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/SessionStartRequest"
+        required: true
+      parameters:
+        - schema:
+            description: Whether to stream the response via SSE
+            example: "true"
+            type: string
+            enum:
+              - "true"
+              - "false"
+          in: header
+          name: x-stream-response
+          description: Whether to stream the response via SSE
+      responses:
+        "200":
+          description: Default Response
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/SessionStartResponse"
+  /v4/sessions/{id}/agentExecute:
+    post:
+      operationId: SessionAgentExecute
+      summary: Execute an AI agent
+      description: Runs an autonomous AI agent that can perform complex multi-step
+        browser tasks.
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/AgentExecuteRequest"
+        required: true
+      parameters:
+        - schema:
+            description: Unique session identifier
+            example: c4dbf3a9-9a58-4b22-8a1c-9f20f9f9e123
+            type: string
+          in: path
+          name: id
+          required: true
+          description: Unique session identifier
+        - schema:
+            description: Whether to stream the response via SSE
+            example: "true"
+            type: string
+            enum:
+              - "true"
+              - "false"
+          in: header
+          name: x-stream-response
+          description: Whether to stream the response via SSE
+      responses:
+        "200":
+          description: Default Response
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/AgentExecuteResponse"
+servers:
+  - url: https://api.stagehand.browserbase.com
+security:
+  - BrowserbaseApiKey: []
+    BrowserbaseProjectId: []
+    ModelApiKey: []
diff --git a/packages/server-v4/package.json b/packages/server-v4/package.json
new file mode 100644
index 000000000..0da2c9033
--- /dev/null
+++ b/packages/server-v4/package.json
@@ -0,0 +1,62 @@
+{
+  "name": "@browserbasehq/stagehand-server-v4",
+  "version": "3.6.0",
+  "description": "Stagehand API server v4",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "build": "pnpm --filter @browserbasehq/stagehand-server-v4 run --parallel \"/^(build:esm-tests|build:server:dist|gen:openapi|build:sea:esm)$/\"",
+    "dev": "tsx watch src/server.ts",
+    "build:esm-tests": "pnpm -w --dir ../.. exec tsc -p packages/server-v4/tsconfig.tests.json",
+    "build:server:dist": "pnpm -w --dir ../.. exec tsc -p packages/server-v4/tsconfig.json && pnpm -w --dir ../.. exec tsc-alias -p packages/server-v4/tsconfig.json",
+    "build:sea:esm": "tsx scripts/build-sea.ts --mode=esm",
+    "build:sea:cjs": "tsx scripts/build-sea.ts --mode=cjs",
+    "lint": "cd ../.. && prettier --check packages/server-v4 && cd packages/server-v4 && eslint . && pnpm run typecheck",
+    "typecheck": "pnpm -w --dir ../.. exec tsc -p packages/server-v4/tsconfig.json --noEmit",
+    "test": "pnpm -w --dir ../.. exec turbo run test:server --filter=@browserbasehq/stagehand-server-v4 --",
+    "test:server": "tsx scripts/test-server.ts",
+    "test:integration": "pnpm run test:server -- packages/server-v4/dist/tests/integration",
+    "test:integration:local": "STAGEHAND_SERVER_TARGET=local pnpm run test:server -- packages/server-v4/dist/tests/integration",
+    "test:integration:sea": "STAGEHAND_SERVER_TARGET=sea pnpm run test:server -- packages/server-v4/dist/tests/integration",
+    "gen:openapi": "tsx scripts/gen-openapi.ts"
+  },
+  "dependencies": {
+    "@browserbasehq/sdk": "^2.7.0",
+    "@browserbasehq/stagehand": "workspace:*",
+    "@fastify/cors": "^11.0.1",
+    "@fastify/swagger": "^9.6.1",
+    "@fastify/swagger-ui": "^5.2.3",
+    "@t3-oss/env-core": "^0.13.8",
+    "fastify": "^5.3.2",
+    "fastify-metrics": "^12.1.0",
+    "fastify-plugin": "^4.5.1",
+    "fastify-zod-openapi": "^5.5.0",
+    "http-status-codes": "^2.3.0",
+    "pino": "^9.7.0",
+    "pino-pretty": "^11.3.0",
+    "playwright": "1.52.0",
+    "uuid": "^11.0.5",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "@types/node": "22.13.1",
+    "eslint": "10.0.2",
+    "eslint-plugin-security": "^3.0.1",
+    "openai": "4.87.1",
+    "postject": "1.0.0-alpha.6",
+    "prettier": "^3.2.5",
+    "source-map": "^0.7.4",
+    "tsc-alias": "^1.8.10",
+    "tsx": "*",
+    "vitest": "^4.0.8"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/browserbase/stagehand.git",
+    "directory": "packages/server-v4"
+  },
+  "bugs": {
+    "url": "https://github.com/browserbase/stagehand/issues"
+  },
+  "homepage": "https://stagehand.dev"
+}
diff --git a/packages/server-v4/scripts/build-sea.ts b/packages/server-v4/scripts/build-sea.ts
new file mode 100644
index 000000000..79c3a0b12
--- /dev/null
+++ b/packages/server-v4/scripts/build-sea.ts
@@ -0,0 +1,497 @@
+#!/usr/bin/env node
+/**
+ * Build SEA binary from ESM (test) or CJS (release) bundles.
+ *
+ * Prereqs:
+ * - CJS mode: runs core CJS build via Turbo if dist is missing.
+ * - ESM mode: core dist/esm available (pnpm run build:esm).
+ * - postject installed; tar available for non-Windows downloads.
+ *
+ * Args: --mode=esm|cjs --target-platform=<platform> --target-arch=<arch> --binary-name=<name>
+ * Env: SEA_BUILD_MODE, SEA_TARGET_PLATFORM, SEA_TARGET_ARCH, SEA_BINARY_NAME,
+ *      SEA_INCLUDE_SOURCEMAPS.
+ * Example: pnpm run build:sea:cjs -- --target-platform=linux --target-arch=arm64
+ */
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import https from "node:https";
+import { pathToFileURL } from "node:url";
+import esbuild from "esbuild";
+import { getRepoRootDir } from "./runtimePaths.js";
+
+const repoDir = getRepoRootDir();
+
+const argValue = (name: string) => {
+  const prefix = `--${name}=`;
+  for (let i = 0; i < process.argv.length; i++) {
+    const arg = process.argv[i];
+    if (arg === `--${name}` && process.argv[i + 1]) return process.argv[i + 1];
+    if (arg.startsWith(prefix)) return arg.slice(prefix.length);
+  }
+  return undefined;
+};
+
+const mode = (
+  argValue("mode") ??
+  process.env.SEA_BUILD_MODE ??
+  "esm"
+).toLowerCase();
+const parseBoolean = (
+  value: string | undefined,
+  fallback: boolean,
+): boolean => {
+  if (value === undefined) return fallback;
+
+  const normalized = value.toLowerCase();
+  if (
+    normalized === "1" ||
+    normalized === "true" ||
+    normalized === "yes" ||
+    normalized === "on"
+  ) {
+    return true;
+  }
+  if (
+    normalized === "0" ||
+    normalized === "false" ||
+    normalized === "no" ||
+    normalized === "off"
+  ) {
+    return false;
+  }
+
+  throw new Error(
+    `Invalid boolean value "${value}" for --include-sourcemaps / SEA_INCLUDE_SOURCEMAPS`,
+  );
+};
+const targetPlatform =
+  argValue("target-platform") ??
+  argValue("platform") ??
+  process.env.SEA_TARGET_PLATFORM ??
+  process.platform;
+const targetArch =
+  argValue("target-arch") ??
+  argValue("arch") ??
+  process.env.SEA_TARGET_ARCH ??
+  process.arch;
+const binaryName =
+  argValue("binary-name") ??
+  process.env.SEA_BINARY_NAME ??
+  `stagehand-server-v4-${targetPlatform}-${targetArch}${targetPlatform === "win32" ? ".exe" : ""}`;
+const includeSourcemaps = parseBoolean(
+  argValue("include-sourcemaps") ?? process.env.SEA_INCLUDE_SOURCEMAPS,
+  false,
+);
+
+const run = (cmd: string, args: string[], opts: { cwd?: string } = {}) => {
+  const result = spawnSync(cmd, args, { stdio: "inherit", ...opts });
+  if (result.error) {
+    throw new Error(
+      `Command failed to start: ${cmd} ${args.join(" ")}\n${String(result.error)}`,
+    );
+  }
+  if (result.status !== 0) {
+    throw new Error(`Command failed: ${cmd} ${args.join(" ")}`);
+  }
+};
+
+const runNodeScript = (
+  scriptPath: string,
+  args: string[],
+  opts: { cwd?: string } = {},
+) => run(process.execPath, [scriptPath, ...args], opts);
+
+const resolveFirstExisting = (paths: string[]): string => {
+  for (const candidate of paths) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  throw new Error(`Missing tool script. Tried: ${paths.join(", ")}`);
+};
+
+const runOptional = (
+  cmd: string,
+  args: string[],
+  opts: { cwd?: string } = {},
+) => {
+  spawnSync(cmd, args, { stdio: "ignore", ...opts });
+};
+
+const download = (url: string, dest: string): Promise<void> =>
+  new Promise((resolve, reject) => {
+    https
+      .get(url, (res) => {
+        if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400) {
+          const location = res.headers.location;
+          if (!location) {
+            reject(new Error(`Redirect without location: ${url}`));
+            return;
+          }
+          res.resume();
+          download(location, dest).then(resolve, reject);
+          return;
+        }
+        if (res.statusCode !== 200) {
+          reject(new Error(`Download failed (${res.statusCode}) ${url}`));
+          res.resume();
+          return;
+        }
+
+        const file = fs.createWriteStream(dest);
+        const fail = (error: Error) => {
+          file.destroy();
+          reject(error);
+        };
+
+        res.on("error", fail);
+        file.on("error", fail);
+        file.on("finish", () => {
+          file.close((closeError) => {
+            if (closeError) {
+              reject(closeError);
+              return;
+            }
+            resolve();
+          });
+        });
+        res.pipe(file);
+      })
+      .on("error", reject);
+  });
+
+const resolveNodeBinary = async (): Promise<string> => {
+  if (targetPlatform !== process.platform) {
+    throw new Error(
+      `Cross-platform builds are not supported. Host=${process.platform}, target=${targetPlatform}`,
+    );
+  }
+  if (targetArch === process.arch) {
+    return process.execPath;
+  }
+
+  const version = process.version;
+  const distPlatform = targetPlatform === "win32" ? "win" : targetPlatform;
+  const archiveBase = `node-${version}-${distPlatform}-${targetArch}`;
+  const archiveExt = distPlatform === "win" ? "zip" : "tar.xz";
+  const tmpRoot = `${os.tmpdir()}/stagehand-sea/${archiveBase}`;
+  const archivePath = `${tmpRoot}/${archiveBase}.${archiveExt}`;
+  const extractRoot = `${tmpRoot}/${archiveBase}`;
+  const binaryPath =
+    distPlatform === "win"
+      ? `${extractRoot}/node.exe`
+      : `${extractRoot}/bin/node`;
+
+  if (fs.existsSync(binaryPath)) {
+    return binaryPath;
+  }
+
+  fs.mkdirSync(tmpRoot, { recursive: true });
+  if (!fs.existsSync(archivePath)) {
+    const url = `https://nodejs.org/dist/${version}/${archiveBase}.${archiveExt}`;
+    await download(url, archivePath);
+  }
+
+  if (archiveExt === "zip") {
+    if (process.platform !== "win32") {
+      throw new Error("Windows binaries must be built on Windows runners.");
+    }
+    run("powershell", [
+      "-Command",
+      `Expand-Archive -Path '${archivePath}' -DestinationPath '${tmpRoot}' -Force`,
+    ]);
+  } else {
+    run("tar", ["-xf", archivePath, "-C", tmpRoot]);
+  }
+
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(`Missing Node binary at ${binaryPath}`);
+  }
+  return binaryPath;
+};
+
+const writeSeaConfig = (
+  mainPath: string,
+  outputPath: string,
+  execArgvExtension?: string,
+) => {
+  const configPath = `${repoDir}/packages/server-v4/dist/sea/sea-config-${mode}.json`;
+  const config = {
+    main: path
+      .relative(`${repoDir}/packages/server-v4`, mainPath)
+      .replaceAll("\\", "/"),
+    output: path
+      .relative(`${repoDir}/packages/server-v4`, outputPath)
+      .replaceAll("\\", "/"),
+    ...(execArgvExtension ? { execArgvExtension } : {}),
+  };
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  return configPath;
+};
+
+const buildCjsBundle = () => {
+  const turboBin = resolveFirstExisting([
+    `${repoDir}/node_modules/turbo/bin/turbo`,
+  ]);
+  runNodeScript(
+    turboBin,
+    ["run", "build:cjs", "--filter", "@browserbasehq/stagehand"],
+    {
+      cwd: repoDir,
+    },
+  );
+  fs.mkdirSync(`${repoDir}/packages/server-v4/dist/sea`, { recursive: true });
+  const bundlePath = `${repoDir}/packages/server-v4/dist/sea/bundle.cjs`;
+  esbuild.buildSync({
+    entryPoints: ["packages/server-v4/src/sea-entry.ts"],
+    bundle: true,
+    platform: "node",
+    format: "cjs",
+    outfile: bundlePath,
+    logLevel: "warning",
+    absWorkingDir: repoDir,
+  });
+  return bundlePath;
+};
+
+const buildEsmBundle = () => {
+  if (!fs.existsSync(`${repoDir}/packages/core/dist/esm/index.js`)) {
+    throw new Error(
+      `Missing ${repoDir}/packages/core/dist/esm/index.js. Run pnpm run build:esm first.`,
+    );
+  }
+
+  fs.mkdirSync(`${repoDir}/packages/server-v4/dist/sea`, { recursive: true });
+  const appBundlePath = `${repoDir}/packages/server-v4/dist/app.mjs`;
+  esbuild.buildSync({
+    entryPoints: ["packages/server-v4/src/sea-entry.ts"],
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    treeShaking: false,
+    outfile: appBundlePath,
+    alias: {
+      "@browserbasehq/stagehand": `${repoDir}/packages/core/dist/esm/index.js`,
+    },
+    sourcemap: includeSourcemaps ? "inline" : false,
+    sourcesContent: includeSourcemaps,
+    ...(includeSourcemaps ? { sourceRoot: repoDir } : {}),
+    banner: {
+      js: 'import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);',
+    },
+    logLevel: "warning",
+    absWorkingDir: repoDir,
+  });
+
+  const appSource = fs.readFileSync(appBundlePath, "utf8");
+  let finalAppSource = appSource;
+
+  if (includeSourcemaps) {
+    const mapMatch = appSource.match(
+      /sourceMappingURL=data:application\/json;base64,([A-Za-z0-9+/=]+)\s*$/,
+    );
+    if (!mapMatch) {
+      throw new Error("Missing inline sourcemap in dist/app.mjs");
+    }
+    const mapJson = Buffer.from(mapMatch[1], "base64").toString("utf8");
+    const map = JSON.parse(mapJson) as {
+      sourceRoot?: string;
+      sources: string[];
+      sourcesContent?: string[];
+    };
+    const toPosix = (value: string) => value.replaceAll("\\", "/");
+    const fileUrlToPathSafe = (value: string) => {
+      const parsed = new URL(value);
+      let pathname = decodeURIComponent(parsed.pathname);
+      if (/^\/[A-Za-z]:/.test(pathname)) {
+        pathname = pathname.slice(1);
+      }
+      return pathname;
+    };
+    const toRepoRelative = (source: string) => {
+      let sourcePath = source;
+      if (source.startsWith("file://")) {
+        sourcePath = fileUrlToPathSafe(source);
+      }
+
+      if (path.isAbsolute(sourcePath)) {
+        const normalizedSourcePath = toPosix(sourcePath);
+        if (normalizedSourcePath.startsWith(`${repoDir}/`)) {
+          return toPosix(path.relative(repoDir, normalizedSourcePath));
+        }
+        return normalizedSourcePath;
+      }
+
+      if (sourcePath.startsWith("../src/")) {
+        const rel = sourcePath.slice("../src/".length);
+        return `packages/server-v4/src/${rel}`;
+      }
+      if (sourcePath.startsWith("../../core/")) {
+        const rel = sourcePath.slice("../../core/".length);
+        return `packages/core/${rel}`;
+      }
+      if (sourcePath.startsWith("../../../node_modules/")) {
+        const rel = sourcePath.slice("../../../node_modules/".length);
+        return `node_modules/${rel}`;
+      }
+      if (sourcePath.startsWith("src/")) {
+        const rel = sourcePath.slice("src/".length);
+        return `packages/server-v4/src/${rel}`;
+      }
+      if (sourcePath.startsWith("../node_modules/")) {
+        const rel = sourcePath.slice("../node_modules/".length);
+        return `node_modules/${rel}`;
+      }
+      if (sourcePath.startsWith("../core/")) {
+        const rel = sourcePath.slice("../core/".length);
+        return `packages/core/${rel}`;
+      }
+      if (sourcePath.startsWith("core/")) {
+        return `packages/core/${sourcePath.slice("core/".length)}`;
+      }
+      if (
+        sourcePath.startsWith("packages/") ||
+        sourcePath.startsWith("node_modules/")
+      ) {
+        return toPosix(sourcePath);
+      }
+
+      const resolved = toPosix(
+        path.resolve(`${repoDir}/packages/server-v4`, sourcePath),
+      );
+      if (resolved.startsWith(`${repoDir}/`)) {
+        return toPosix(path.relative(repoDir, resolved));
+      }
+
+      return toPosix(sourcePath);
+    };
+
+    map.sourceRoot = pathToFileURL(`${repoDir}/`).href;
+    map.sources = map.sources.map(toRepoRelative);
+    const updatedMap = Buffer.from(JSON.stringify(map)).toString("base64");
+    finalAppSource = appSource.replace(mapMatch[1], updatedMap);
+    fs.writeFileSync(appBundlePath, finalAppSource);
+  }
+
+  const appBytes = Buffer.from(finalAppSource);
+  const bundleHash = createHash("sha256")
+    .update(appBytes)
+    .digest("hex")
+    .slice(0, 12);
+  const bootstrapPath = `${repoDir}/packages/server-v4/dist/sea/sea-bootstrap.cjs`;
+  const bootstrap = `/* eslint-disable */
+const fs = require("node:fs");
+const os = require("node:os");
+const { pathToFileURL } = require("node:url");
+
+const bundleBase64 = ${JSON.stringify(appBytes.toString("base64"))};
+const bundleLength = ${appBytes.length};
+const bundleHash = ${JSON.stringify(bundleHash)};
+
+const cacheRoot =
+  process.env.STAGEHAND_SEA_CACHE_DIR ||
+  \`\${os.tmpdir()}/stagehand-server-v4-sea\`;
+const cacheDir = \`\${cacheRoot}/\${bundleHash}\`;
+const appPath = \`\${cacheDir}/app.mjs\`;
+
+fs.mkdirSync(cacheDir, { recursive: true });
+let needsWrite = true;
+try {
+  const stat = fs.statSync(appPath);
+  needsWrite = stat.size !== bundleLength;
+} catch {}
+
+if (needsWrite) {
+  const tmpPath =
+    \`\${cacheDir}/app.mjs.tmp-\${process.pid}-\${Date.now().toString(16)}\`;
+  fs.writeFileSync(tmpPath, Buffer.from(bundleBase64, "base64"));
+  try {
+    fs.renameSync(tmpPath, appPath);
+  } catch (err) {
+    if (!fs.existsSync(appPath)) throw err;
+  }
+  try {
+    fs.chmodSync(appPath, 0o500);
+  } catch {}
+}
+
+(async () => {
+  await import(pathToFileURL(appPath).href);
+})().catch((err) => {
+  console.error(err);
+  process.exitCode = 1;
+});
+`;
+  fs.writeFileSync(bootstrapPath, bootstrap);
+  return bootstrapPath;
+};
+
+const main = async () => {
+  fs.mkdirSync(`${repoDir}/packages/server-v4/dist/sea`, { recursive: true });
+
+  let mainPath: string;
+  let execArgvExtension: string | undefined;
+
+  if (mode === "cjs") {
+    mainPath = buildCjsBundle();
+  } else if (mode === "esm") {
+    mainPath = buildEsmBundle();
+    execArgvExtension = "cli";
+  } else {
+    throw new Error(`Unknown SEA build mode: ${mode}`);
+  }
+
+  const seaConfigPath = writeSeaConfig(
+    mainPath,
+    `${repoDir}/packages/server-v4/dist/sea/sea-prep.blob`,
+    execArgvExtension,
+  );
+
+  run("node", ["--experimental-sea-config", seaConfigPath], {
+    cwd: `${repoDir}/packages/server-v4`,
+  });
+  if (!fs.existsSync(`${repoDir}/packages/server-v4/dist/sea/sea-prep.blob`)) {
+    throw new Error(
+      `Missing ${repoDir}/packages/server-v4/dist/sea/sea-prep.blob; SEA blob generation failed.`,
+    );
+  }
+
+  const nodeBinary = await resolveNodeBinary();
+  const outPath = `${repoDir}/packages/server-v4/dist/sea/${binaryName}`;
+  fs.copyFileSync(nodeBinary, outPath);
+  if (targetPlatform !== "win32") {
+    fs.chmodSync(outPath, 0o755);
+  }
+
+  if (targetPlatform === "darwin") {
+    runOptional("codesign", ["--remove-signature", outPath]);
+  }
+
+  const postjectCliPath = resolveFirstExisting([
+    `${repoDir}/packages/server-v4/node_modules/postject/dist/cli.js`,
+    `${repoDir}/node_modules/postject/dist/cli.js`,
+  ]);
+  const postjectArgs = [
+    outPath,
+    "NODE_SEA_BLOB",
+    `${repoDir}/packages/server-v4/dist/sea/sea-prep.blob`,
+    "--sentinel-fuse",
+    "NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2",
+  ];
+  if (targetPlatform === "darwin") {
+    postjectArgs.push("--macho-segment-name", "NODE_SEA");
+  }
+  runNodeScript(postjectCliPath, postjectArgs, {
+    cwd: `${repoDir}/packages/server-v4`,
+  });
+
+  if (targetPlatform === "darwin") {
+    runOptional("codesign", ["--sign", "-", outPath]);
+  }
+};
+
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});
diff --git a/packages/server-v4/scripts/gen-openapi.ts b/packages/server-v4/scripts/gen-openapi.ts
new file mode 100644
index 000000000..6380a0fd9
--- /dev/null
+++ b/packages/server-v4/scripts/gen-openapi.ts
@@ -0,0 +1,195 @@
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getCurrentDirPath } from "./runtimePaths.js";
+
+import fastify from "fastify";
+import fastifySwagger from "@fastify/swagger";
+import {
+  fastifyZodOpenApiPlugin,
+  fastifyZodOpenApiTransformers,
+  serializerCompiler,
+  validatorCompiler,
+  type FastifyZodOpenApiTypeProvider,
+} from "fastify-zod-openapi";
+import { Api } from "@browserbasehq/stagehand";
+
+// Routes
+import actRoute from "../src/routes/v4/sessions/_id/act.js";
+import agentExecuteRoute from "../src/routes/v4/sessions/_id/agentExecute.js";
+import endRoute from "../src/routes/v4/sessions/_id/end.js";
+import extractRoute from "../src/routes/v4/sessions/_id/extract.js";
+import navigateRoute from "../src/routes/v4/sessions/_id/navigate.js";
+import observeRoute from "../src/routes/v4/sessions/_id/observe.js";
+import replayRoute from "../src/routes/v4/sessions/_id/replay.js";
+import startRoute from "../src/routes/v4/sessions/start.js";
+import healthcheckRoute from "../src/routes/healthcheck.js";
+import readinessRoute from "../src/routes/readiness.js";
+
+const OUTPUT_PATH = path.resolve(getCurrentDirPath(), "../openapi.v4.yaml");
+
+async function main() {
+  const app = fastify({
+    logger: false,
+  }).withTypeProvider<FastifyZodOpenApiTypeProvider>();
+
+  app.setValidatorCompiler(validatorCompiler);
+  app.setSerializerCompiler(serializerCompiler);
+
+  // Register all API schemas as components so fastify-zod-openapi can create $ref links
+  const components = {
+    schemas: {
+      // Region support
+      BrowserbaseRegion: Api.BrowserbaseRegionSchema,
+      // Shared components
+      LocalBrowserLaunchOptions: Api.LocalBrowserLaunchOptionsSchema,
+      ModelConfigObject: Api.ModelConfigObjectSchema,
+      ModelConfig: Api.ModelConfigSchema,
+      Action: Api.ActionSchema,
+      SessionIdParams: Api.SessionIdParamsSchema,
+      BrowserConfig: Api.BrowserConfigSchema,
+      SessionHeaders: Api.SessionHeadersSchema,
+      ErrorResponse: Api.ErrorResponseSchema,
+      // Browserbase schemas
+      BrowserbaseViewport: Api.BrowserbaseViewportSchema,
+      BrowserbaseFingerprintScreen: Api.BrowserbaseFingerprintScreenSchema,
+      BrowserbaseFingerprint: Api.BrowserbaseFingerprintSchema,
+      BrowserbaseContext: Api.BrowserbaseContextSchema,
+      BrowserbaseBrowserSettings: Api.BrowserbaseBrowserSettingsSchema,
+      BrowserbaseProxyGeolocation: Api.BrowserbaseProxyGeolocationSchema,
+      BrowserbaseProxyConfig: Api.BrowserbaseProxyConfigSchema,
+      ExternalProxyConfig: Api.ExternalProxyConfigSchema,
+      ProxyConfig: Api.ProxyConfigSchema,
+      BrowserbaseSessionCreateParams: Api.BrowserbaseSessionCreateParamsSchema,
+      // Session Start
+      SessionStartRequest: Api.SessionStartRequestSchema,
+      SessionStartResult: Api.SessionStartResultSchema,
+      SessionStartResponse: Api.SessionStartResponseSchema,
+      // Session End
+      SessionEndResult: Api.SessionEndResultSchema,
+      SessionEndResponse: Api.SessionEndResponseSchema,
+      // Act
+      ActOptions: Api.ActOptionsSchema,
+      ActRequest: Api.ActRequestSchema,
+      ActResultData: Api.ActResultDataSchema,
+      ActResult: Api.ActResultSchema,
+      ActResponse: Api.ActResponseSchema,
+      // Extract
+      ExtractOptions: Api.ExtractOptionsSchema,
+      ExtractRequest: Api.ExtractRequestSchema,
+      ExtractResult: Api.ExtractResultSchema,
+      ExtractResponse: Api.ExtractResponseSchema,
+      // Observe
+      ObserveOptions: Api.ObserveOptionsSchema,
+      ObserveRequest: Api.ObserveRequestSchema,
+      ObserveResult: Api.ObserveResultSchema,
+      ObserveResponse: Api.ObserveResponseSchema,
+      // Agent Execute
+      AgentConfig: Api.AgentConfigSchema,
+      AgentAction: Api.AgentActionSchema,
+      AgentUsage: Api.AgentUsageSchema,
+      AgentResultData: Api.AgentResultDataSchema,
+      AgentExecuteOptions: Api.AgentExecuteOptionsSchema,
+      AgentExecuteRequest: Api.AgentExecuteRequestSchema,
+      AgentExecuteResult: Api.AgentExecuteResultSchema,
+      AgentExecuteResponse: Api.AgentExecuteResponseSchema,
+      // Navigate
+      NavigateOptions: Api.NavigateOptionsSchema,
+      NavigateRequest: Api.NavigateRequestSchema,
+      NavigateResult: Api.NavigateResultSchema,
+      NavigateResponse: Api.NavigateResponseSchema,
+      // Replay
+      TokenUsage: Api.TokenUsageSchema,
+      ReplayAction: Api.ReplayActionSchema,
+      ReplayPage: Api.ReplayPageSchema,
+      ReplayResult: Api.ReplayResultSchema,
+      ReplayResponse: Api.ReplayResponseSchema,
+      // SSE Stream Events
+      StreamEventStatus: Api.StreamEventStatusSchema,
+      StreamEventType: Api.StreamEventTypeSchema,
+      StreamEventSystemData: Api.StreamEventSystemDataSchema,
+      StreamEventLogData: Api.StreamEventLogDataSchema,
+      StreamEvent: Api.StreamEventSchema,
+    },
+  };
+
+  await app.register(fastifyZodOpenApiPlugin, { components });
+
+  await app.register(fastifySwagger, {
+    openapi: {
+      info: {
+        title: "Stagehand API v4",
+        version: "4.0.0",
+        description: `Stagehand SDK for AI browser automation [ALPHA]. This API allows clients to
+execute browser automation tasks remotely on the Browserbase cloud.
+All endpoints except /sessions/start require an active session ID.
+Responses are streamed using Server-Sent Events (SSE) when the
+\`x-stream-response: true\` header is provided.
+
+This SDK is currently ALPHA software and is not production ready!
+Please try it and give us your feedback, stay tuned for upcoming release announcements!`,
+        contact: {
+          name: "Browserbase",
+          url: "https://browserbase.com",
+        },
+      },
+      openapi: "3.1.0",
+      servers: [
+        {
+          url: "https://api.stagehand.browserbase.com",
+        },
+      ],
+      components: {
+        securitySchemes: Api.openApiSecuritySchemes,
+        links: Api.openApiLinks,
+      },
+      security: [
+        { BrowserbaseApiKey: [], BrowserbaseProjectId: [], ModelApiKey: [] },
+      ],
+    },
+    ...fastifyZodOpenApiTransformers,
+  });
+
+  await app.register(
+    (instance, _opts, done) => {
+      instance.route(actRoute);
+      instance.route(endRoute);
+      instance.route(extractRoute);
+      instance.route(navigateRoute);
+      instance.route(observeRoute);
+      instance.route(replayRoute);
+      instance.route(startRoute);
+      instance.route(agentExecuteRoute);
+      done();
+    },
+    { prefix: "/v4" },
+  );
+
+  app.route(healthcheckRoute);
+  app.route(readinessRoute);
+
+  await app.ready();
+
+  const yaml = app.swagger({ yaml: true });
+  // Mintlify expects OpenAPI version fields to be strings, so quote them here.
+  const fixedYaml = yaml
+    .replace(/^openapi:\s*(?!['"])([^#\s]+)\s*$/m, 'openapi: "$1"')
+    .replace(/^ {2}version:\s*(?!['"])([^#\s]+)\s*$/m, '  version: "$1"')
+    .replace(
+      "description: Wait for captcha solves (deprecated, v2 only)",
+      "description: Wait for captcha solves",
+    )
+    .replace(
+      "description: Timeout in ms for act operations (deprecated, v2 only)",
+      "description: Timeout in ms for act operations",
+    );
+
+  await writeFile(OUTPUT_PATH, fixedYaml, "utf8");
+
+  await app.close();
+  console.log(`OpenAPI spec written to ${OUTPUT_PATH}`);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
diff --git a/packages/server-v4/scripts/runtimePaths.ts b/packages/server-v4/scripts/runtimePaths.ts
new file mode 100644
index 000000000..244c8eeba
--- /dev/null
+++ b/packages/server-v4/scripts/runtimePaths.ts
@@ -0,0 +1,122 @@
+/**
+ * Keep this file in sync with:
+ * - /packages/core/lib/v3/runtimePaths.ts
+ * - /packages/server-v4/scripts/runtimePaths.ts
+ * - /packages/evals/runtimePaths.ts
+ * - /packages/docs/scripts/runtimePaths.js
+ */
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+
+const PACKAGE_SEGMENT = "/packages/server-v4/";
+const EVAL_FRAMES = new Set(["[eval]", "[eval]-wrapper"]);
+const INTERNAL_FRAME_NAMES = new Set([
+  "readCallsites",
+  "readCallsitePath",
+  "resolveCallerFilePath",
+  "getCurrentFilePath",
+  "getCurrentDirPath",
+  "getRepoRootDir",
+  "getPackageRootDir",
+  "createRequireFromCaller",
+  "isMainModule",
+]);
+
+const normalizePath = (value: string): string => {
+  const input = value.startsWith("file://") ? fileURLToPath(value) : value;
+  return path.resolve(input).replaceAll("\\", "/");
+};
+
+const readCallsites = (): NodeJS.CallSite[] => {
+  const previousPrepare = Error.prepareStackTrace;
+  try {
+    Error.prepareStackTrace = (_, stack) => stack;
+    return (
+      (new Error().stack as unknown as NodeJS.CallSite[] | undefined) ?? []
+    );
+  } finally {
+    Error.prepareStackTrace = previousPrepare;
+  }
+};
+
+type CallSiteWithScriptName = NodeJS.CallSite & {
+  getScriptNameOrSourceURL?: () => string | null;
+};
+
+const readCallsitePath = (callsite: NodeJS.CallSite): string | null => {
+  const callsiteWithScript = callsite as CallSiteWithScriptName;
+  const rawPath =
+    callsite.getFileName() ?? callsiteWithScript.getScriptNameOrSourceURL?.();
+  if (!rawPath) return null;
+  if (rawPath.startsWith("node:")) return null;
+  if (EVAL_FRAMES.has(rawPath)) return null;
+  return normalizePath(rawPath);
+};
+
+const isInternalCallsite = (callsite: NodeJS.CallSite): boolean => {
+  const functionName = callsite.getFunctionName();
+  if (functionName && INTERNAL_FRAME_NAMES.has(functionName)) return true;
+
+  const methodName = callsite.getMethodName();
+  if (methodName && INTERNAL_FRAME_NAMES.has(methodName)) return true;
+
+  const callsiteString = callsite.toString();
+  for (const frameName of INTERNAL_FRAME_NAMES) {
+    if (callsiteString.includes(`${frameName} (`)) return true;
+    if (callsiteString.includes(`.${frameName} (`)) return true;
+  }
+  return false;
+};
+
+const resolveCallerFilePath = (): string => {
+  const packageCandidates: string[] = [];
+  const fallbackCandidates: string[] = [];
+
+  for (const callsite of readCallsites()) {
+    const filePath = readCallsitePath(callsite);
+    if (!filePath) continue;
+    if (isInternalCallsite(callsite)) continue;
+    if (filePath.includes(PACKAGE_SEGMENT)) {
+      packageCandidates.push(filePath);
+      continue;
+    }
+    fallbackCandidates.push(filePath);
+  }
+
+  const packageCandidate = packageCandidates[0];
+  if (packageCandidate) return packageCandidate;
+
+  const fallbackCandidate = fallbackCandidates[0];
+  if (fallbackCandidate) return fallbackCandidate;
+
+  throw new Error("Unable to resolve caller file path.");
+};
+
+export const getCurrentFilePath = (): string => resolveCallerFilePath();
+
+export const getCurrentDirPath = (): string =>
+  path.dirname(getCurrentFilePath());
+
+export const getRepoRootDir = (): string => {
+  const currentFilePath = getCurrentFilePath();
+  const index = currentFilePath.lastIndexOf(PACKAGE_SEGMENT);
+  if (index === -1) {
+    throw new Error(
+      `Unable to determine repo root from ${currentFilePath} (missing ${PACKAGE_SEGMENT}).`,
+    );
+  }
+  return currentFilePath.slice(0, index);
+};
+
+export const getPackageRootDir = (): string =>
+  `${getRepoRootDir()}${PACKAGE_SEGMENT.slice(0, -1)}`;
+
+export const createRequireFromCaller = () =>
+  createRequire(getCurrentFilePath());
+
+export const isMainModule = (): boolean => {
+  const entryScript = process.argv.at(1);
+  if (!entryScript) return false;
+  return normalizePath(entryScript) === getCurrentFilePath();
+};
diff --git a/packages/server-v4/scripts/test-server.ts b/packages/server-v4/scripts/test-server.ts
new file mode 100644
index 000000000..7a45eabbe
--- /dev/null
+++ b/packages/server-v4/scripts/test-server.ts
@@ -0,0 +1,399 @@
+/**
+ * Server unit + integration tests on dist/esm + SEA/local server targets.
+ *
+ * Prereqs:
+ * - pnpm run build (packages/server-v4/dist/tests + packages/server-v4/dist/server.js).
+ * - SEA integration still requires build:sea when STAGEHAND_SERVER_TARGET=sea.
+ *
+ * Args: [test paths...] -- [node --test args...] | --list (prints JSON matrix)
+ * Env: STAGEHAND_SERVER_TARGET=sea|local|remote, STAGEHAND_BASE_URL, SEA_BINARY_NAME,
+ *      NODE_TEST_CONSOLE_REPORTER, NODE_TEST_REPORTER, NODE_TEST_REPORTER_DESTINATION,
+ *      NODE_V8_COVERAGE; writes CTRF to ctrf/node-test-*.xml by default.
+ * Example: STAGEHAND_SERVER_TARGET=sea pnpm run test:server -- packages/server-v4/dist/tests/integration/v4/start.test.js
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+import { getRepoRootDir } from "./runtimePaths.js";
+
+const ensureParentDir = (filePath: string) => {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+};
+
+const splitArgs = (args: string[]) => {
+  const tokens = [...args];
+  while (tokens[0] === "--") {
+    tokens.shift();
+  }
+
+  const leadingExtra: string[] = [];
+  while (tokens.length > 0 && tokens[0].startsWith("-")) {
+    const arg = tokens.shift();
+    if (!arg) break;
+    if (arg === "--") break;
+    leadingExtra.push(arg);
+    if (
+      !arg.includes("=") &&
+      tokens[0] &&
+      tokens[0] !== "--" &&
+      !tokens[0].startsWith("-")
+    ) {
+      leadingExtra.push(tokens.shift() as string);
+    }
+  }
+
+  while (tokens[0] === "--") {
+    tokens.shift();
+  }
+
+  const separatorIndex = tokens.indexOf("--");
+  return {
+    paths: separatorIndex === -1 ? tokens : tokens.slice(0, separatorIndex),
+    extra: [
+      ...leadingExtra,
+      ...(separatorIndex === -1 ? [] : tokens.slice(separatorIndex + 1)),
+    ],
+  };
+};
+
+const toSafeName = (name: string) => name.replace(/[\\/]/g, "-");
+
+const collectFiles = (dir: string, suffix: string) => {
+  const results: string[] = [];
+  const walk = (current: string) => {
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const full = `${current}/${entry.name}`;
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile() && entry.name.endsWith(suffix)) {
+        results.push(full);
+      }
+    }
+  };
+  if (fs.existsSync(dir)) walk(dir);
+  return results.sort();
+};
+
+const repoRoot = getRepoRootDir();
+
+const writeCtrfFromJunit = (junitPath: string, tool: string) => {
+  if (!fs.existsSync(junitPath)) return;
+  const stat = fs.statSync(junitPath);
+  if (stat.size === 0) return;
+  const ctrfPath = junitPath.match(/\.xml$/i)
+    ? junitPath.replace(/\.xml$/i, ".json")
+    : `${junitPath}.json`;
+  const result = spawnSync(
+    "pnpm",
+    ["exec", "junit-to-ctrf", junitPath, "-o", ctrfPath, "-t", tool],
+    { stdio: "inherit", cwd: repoRoot },
+  );
+  if (result.status !== 0) {
+    console.warn(`CTRF conversion failed for ${junitPath}.`);
+  }
+};
+
+const sourceTestsDir = `${repoRoot}/packages/server-v4/test`;
+const sourceUnitDir = `${sourceTestsDir}/unit`;
+const sourceIntegrationDir = `${sourceTestsDir}/integration`;
+const unitDir = `${repoRoot}/packages/server-v4/dist/tests/unit`;
+const integrationDir = `${repoRoot}/packages/server-v4/dist/tests/integration`;
+const allTestsDir = `${repoRoot}/packages/server-v4/dist/tests`;
+
+const resolveRepoRelative = (value: string) =>
+  path.isAbsolute(value) ? value : path.resolve(repoRoot, value);
+
+const stripNodeReporterArgs = (argsList: string[]) => {
+  const filtered: string[] = [];
+  let removed = false;
+  for (let i = 0; i < argsList.length; i++) {
+    const arg = argsList[i];
+    if (
+      arg === "--test-reporter" ||
+      arg.startsWith("--test-reporter=") ||
+      arg === "--test-reporter-destination" ||
+      arg.startsWith("--test-reporter-destination=")
+    ) {
+      removed = true;
+      if (
+        (arg === "--test-reporter" || arg === "--test-reporter-destination") &&
+        argsList[i + 1]
+      ) {
+        i += 1;
+      }
+      continue;
+    }
+    filtered.push(arg);
+  }
+  return { filtered, removed };
+};
+
+const toTestName = (testPath: string, root: string) => {
+  const abs = resolveRepoRelative(testPath);
+  const rel = path.relative(root, abs).replaceAll("\\", "/");
+  if (!rel.startsWith("..")) {
+    return rel.replace(/\.test\.js$/i, "");
+  }
+  return path.basename(abs).replace(/\.test\.js$/i, "");
+};
+
+const rawArgs = process.argv.slice(2);
+const listRequested = rawArgs.includes("--list");
+
+if (listRequested) {
+  const unitTests = collectFiles(sourceUnitDir, ".test.ts").map((file) => {
+    const relSource = path.relative(sourceTestsDir, file).replaceAll("\\", "/");
+    const distPath = `${repoRoot}/packages/server-v4/dist/tests/${relSource.replace(/\.test\.ts$/, ".test.js")}`;
+    const name = path.basename(file, ".test.ts");
+    return {
+      path: path.relative(repoRoot, distPath).replaceAll("\\", "/"),
+      name,
+      safe_name: toSafeName(name),
+    };
+  });
+  const integrationTests = collectFiles(sourceIntegrationDir, ".test.ts").map(
+    (file) => {
+      const relSource = path
+        .relative(sourceTestsDir, file)
+        .replaceAll("\\", "/");
+      const distPath = `${repoRoot}/packages/server-v4/dist/tests/${relSource.replace(/\.test\.ts$/, ".test.js")}`;
+      const rel = path
+        .relative(sourceIntegrationDir, file)
+        .replaceAll("\\", "/")
+        .replace(/\.test\.ts$/, "");
+      return {
+        path: path.relative(repoRoot, distPath).replaceAll("\\", "/"),
+        name: rel,
+        safe_name: toSafeName(rel),
+      };
+    },
+  );
+  console.log(JSON.stringify([...unitTests, ...integrationTests]));
+  process.exit(0);
+}
+
+const { paths, extra } = splitArgs(rawArgs);
+const { filtered: extraArgs, removed: removedReporterOverride } =
+  stripNodeReporterArgs(extra);
+if (removedReporterOverride) {
+  console.warn(
+    "Ignoring node --test reporter overrides to preserve console + JUnit output.",
+  );
+}
+
+if (!fs.existsSync(allTestsDir)) {
+  console.error(
+    "Missing packages/server-v4/dist/tests. Run pnpm run build first.",
+  );
+  process.exit(1);
+}
+
+const serverTarget = (
+  process.env.STAGEHAND_SERVER_TARGET ?? "sea"
+).toLowerCase();
+const explicitBaseUrl = process.env.STAGEHAND_BASE_URL;
+const baseUrl = explicitBaseUrl ?? "http://stagehand-api.localhost:3107";
+
+if (serverTarget === "remote" && !explicitBaseUrl) {
+  console.error("Missing STAGEHAND_BASE_URL for remote server target.");
+  process.exit(1);
+}
+
+if (
+  serverTarget === "local" &&
+  !fs.existsSync(`${repoRoot}/packages/server-v4/dist/server.js`)
+) {
+  console.error(
+    "Missing packages/server-v4/dist/server.js. Run pnpm run build first.",
+  );
+  process.exit(1);
+}
+
+const parsedBaseUrl = new URL(baseUrl);
+const port =
+  parsedBaseUrl.port || (parsedBaseUrl.protocol === "https:" ? "443" : "80");
+
+process.env.PORT = port;
+process.env.STAGEHAND_API_URL = baseUrl;
+process.env.BB_ENV = process.env.BB_ENV ?? "local";
+
+const baseNodeOptions = "--enable-source-maps";
+const nodeOptions = [process.env.NODE_OPTIONS, baseNodeOptions]
+  .filter(Boolean)
+  .join(" ");
+
+const allPaths =
+  paths.length > 0
+    ? paths.map(resolveRepoRelative)
+    : [
+        ...collectFiles(unitDir, ".test.js"),
+        ...collectFiles(integrationDir, ".test.js"),
+      ];
+
+const unitPaths = allPaths.filter((p) =>
+  p.replaceAll("\\", "/").includes("/packages/server-v4/dist/tests/unit/"),
+);
+const integrationPaths = allPaths.filter((p) =>
+  p
+    .replaceAll("\\", "/")
+    .includes("/packages/server-v4/dist/tests/integration/"),
+);
+
+const singlePath = allPaths.length === 1 ? allPaths[0] : null;
+const coverageSuffix =
+  singlePath &&
+  singlePath.startsWith(`${repoRoot}/packages/server-v4/dist/tests/unit/`)
+    ? `server-unit/${path.basename(singlePath).replace(/\.test\.js$/, "")}`
+    : singlePath &&
+        singlePath.startsWith(
+          `${repoRoot}/packages/server-v4/dist/tests/integration/`,
+        )
+      ? `server-integration/${path
+          .relative(integrationDir, singlePath)
+          .replace(/\.test\.js$/, "")
+          .replaceAll("\\", "/")}`
+      : "server";
+
+const coverageRoot = resolveRepoRelative(
+  process.env.NODE_V8_COVERAGE ?? `${repoRoot}/coverage/${coverageSuffix}`,
+);
+const testsCoverage = `${coverageRoot}/tests`;
+const serverCoverage = `${coverageRoot}/server`;
+fs.mkdirSync(testsCoverage, { recursive: true });
+fs.mkdirSync(serverCoverage, { recursive: true });
+
+const consoleReporter = process.env.NODE_TEST_CONSOLE_REPORTER ?? "spec";
+const defaultReporter = process.env.NODE_TEST_REPORTER ?? "junit";
+const envDestination = process.env.NODE_TEST_REPORTER_DESTINATION
+  ? resolveRepoRelative(process.env.NODE_TEST_REPORTER_DESTINATION)
+  : null;
+
+const reporterArgsFor = (kind: "unit" | "integration", testName?: string) => {
+  const destination =
+    envDestination ??
+    `${repoRoot}/ctrf/${kind === "unit" ? "server-unit" : "server-integration"}/${testName ? `${testName}.xml` : "all.xml"}`;
+  ensureParentDir(destination);
+  return {
+    args: [
+      `--test-reporter=${consoleReporter}`,
+      `--test-reporter=${defaultReporter}`,
+      "--test-reporter-destination=stdout",
+      `--test-reporter-destination=${destination}`,
+    ],
+    destination,
+  };
+};
+
+const runNodeTests = (files: string[], reporterArgs: string[]) =>
+  spawnSync(
+    process.execPath,
+    ["--test", ...extraArgs, ...reporterArgs, ...files],
+    {
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        NODE_OPTIONS: nodeOptions,
+        NODE_V8_COVERAGE: testsCoverage,
+      },
+    },
+  );
+
+const waitForServer = async (url: string, timeoutMs = 30_000) => {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 2_000);
+      const res = await fetch(url, { signal: controller.signal });
+      clearTimeout(timer);
+      if (res.ok) return true;
+    } catch {
+      // retry
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1_000));
+  }
+  return false;
+};
+
+const startServer = async () => {
+  if (serverTarget === "remote") return null;
+  if (serverTarget === "local") {
+    return spawn(
+      process.execPath,
+      [`${repoRoot}/packages/server-v4/dist/server.js`],
+      {
+        stdio: "inherit",
+        env: {
+          ...process.env,
+          NODE_ENV: "development",
+          NODE_OPTIONS: nodeOptions,
+          NODE_V8_COVERAGE: serverCoverage,
+        },
+      },
+    );
+  }
+
+  const defaultName = `stagehand-server-v4-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`;
+  const seaBinary = `${repoRoot}/packages/server-v4/dist/sea/${process.env.SEA_BINARY_NAME ?? defaultName}`;
+
+  if (!fs.existsSync(seaBinary)) {
+    console.error(`SEA binary not found at ${seaBinary}`);
+    process.exit(1);
+  }
+
+  return spawn(seaBinary, ["--node-options=--no-lazy --enable-source-maps"], {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      NODE_ENV: "production",
+      NODE_V8_COVERAGE: serverCoverage,
+      STAGEHAND_SEA_CACHE_DIR:
+        process.env.STAGEHAND_SEA_CACHE_DIR ?? `${repoRoot}/.stagehand-sea`,
+    },
+  });
+};
+
+let serverProc: ReturnType<typeof spawn> | null = null;
+let status = 0;
+
+if (unitPaths.length > 0) {
+  const unitName =
+    unitPaths.length === 1 ? toTestName(unitPaths[0], unitDir) : undefined;
+  const reporter = reporterArgsFor("unit", unitName);
+  const result = runNodeTests(unitPaths, reporter.args);
+  status = result.status ?? 1;
+  writeCtrfFromJunit(reporter.destination, "node-test");
+}
+
+if (status === 0 && integrationPaths.length > 0) {
+  serverProc = await startServer();
+  const ready = await waitForServer(`${process.env.STAGEHAND_API_URL}/healthz`);
+  if (!ready) {
+    console.error("Server failed to start within 30 seconds.");
+    status = 1;
+  } else {
+    const integrationName =
+      integrationPaths.length === 1
+        ? toTestName(integrationPaths[0], integrationDir)
+        : undefined;
+    const reporter = reporterArgsFor("integration", integrationName);
+    const result = runNodeTests(integrationPaths, reporter.args);
+    status = result.status ?? 1;
+    writeCtrfFromJunit(reporter.destination, "node-test");
+  }
+}
+
+if (serverProc) {
+  serverProc.kill("SIGTERM");
+  await new Promise<void>((resolve) => {
+    if (serverProc?.exitCode !== null) return resolve();
+    const timer = setTimeout(resolve, 10_000);
+    serverProc?.once("exit", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+  await new Promise((resolve) => setTimeout(resolve, 5_000));
+}
+
+process.exit(status);
diff --git a/packages/server-v4/src/lib/InMemorySessionStore.ts b/packages/server-v4/src/lib/InMemorySessionStore.ts
new file mode 100644
index 000000000..5c8be3e86
--- /dev/null
+++ b/packages/server-v4/src/lib/InMemorySessionStore.ts
@@ -0,0 +1,366 @@
+import { randomUUID } from "crypto";
+import type { V3Options, LogLine } from "@browserbasehq/stagehand";
+import { V3 } from "@browserbasehq/stagehand";
+import type {
+  SessionStore,
+  CreateSessionParams,
+  RequestContext,
+  SessionCacheConfig,
+  SessionStartResult,
+} from "./SessionStore.js";
+
+const DEFAULT_MAX_CAPACITY = 100;
+const DEFAULT_TTL_MS = 0; // 0 = infinite (no TTL-based eviction)
+
+/**
+ * Internal node for LRU linked list
+ */
+interface LruNode {
+  sessionId: string;
+  params: CreateSessionParams;
+  stagehand: V3 | null;
+  loggerRef: { current?: (message: LogLine) => void };
+  expiry: number;
+  prev: LruNode | null;
+  next: LruNode | null;
+}
+
+/**
+ * In-memory implementation of SessionStore with full caching support.
+ *
+ * Features:
+ * - LRU eviction when at capacity
+ * - TTL-based expiration
+ * - Lazy V3 instance creation
+ * - Dynamic logger updates for streaming
+ * - Automatic cleanup of evicted sessions
+ *
+ * This is the default implementation used when no custom store is provided.
+ * For stateless pod architectures, use a database-backed implementation.
+ */
+export class InMemorySessionStore implements SessionStore {
+  private first: LruNode | null = null;
+  private last: LruNode | null = null;
+  private items: Map<string, LruNode> = new Map();
+  private maxCapacity: number;
+  private ttlMs: number;
+  private cleanupInterval: NodeJS.Timeout | null = null;
+
+  constructor(config?: SessionCacheConfig) {
+    this.maxCapacity = config?.maxCapacity ?? DEFAULT_MAX_CAPACITY;
+    this.ttlMs = config?.ttlMs ?? DEFAULT_TTL_MS;
+    this.startCleanupInterval();
+  }
+
+  /**
+   * Start periodic cleanup of expired sessions
+   */
+  private startCleanupInterval(): void {
+    // Run cleanup every minute
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupExpired();
+    }, 60_000);
+    // Allow process to exit gracefully even if this timer is still active
+    this.cleanupInterval.unref();
+  }
+
+  /**
+   * Cleanup expired sessions
+   */
+  private async cleanupExpired(): Promise<void> {
+    const now = Date.now();
+    const expiredIds: string[] = [];
+
+    for (const [sessionId, node] of this.items.entries()) {
+      if (this.ttlMs > 0 && node.expiry <= now) {
+        expiredIds.push(sessionId);
+      }
+    }
+
+    for (const sessionId of expiredIds) {
+      await this.deleteSession(sessionId);
+    }
+  }
+
+  /**
+   * Bump a node to the end of the LRU list (most recently used)
+   */
+  private bumpNode(node: LruNode): void {
+    // Update expiry
+    node.expiry = this.ttlMs > 0 ? Date.now() + this.ttlMs : Infinity;
+
+    if (this.last === node) {
+      return; // Already most recent
+    }
+
+    const { prev, next } = node;
+
+    // Unlink from current position
+    if (prev) prev.next = next;
+    if (next) next.prev = prev;
+    if (this.first === node) this.first = next;
+
+    // Link to end
+    node.prev = this.last;
+    node.next = null;
+    if (this.last) this.last.next = node;
+    this.last = node;
+
+    if (!this.first) this.first = node;
+  }
+
+  /**
+   * Evict the least recently used session
+   */
+  private async evictLru(): Promise<void> {
+    const lruNode = this.first;
+    if (!lruNode) return;
+
+    await this.deleteSession(lruNode.sessionId);
+  }
+
+  async startSession(params: CreateSessionParams): Promise<SessionStartResult> {
+    // Generate session ID or use provided browserbase session ID
+    const sessionId = params.browserbaseSessionID ?? randomUUID();
+
+    // Store the session
+    await this.createSession(sessionId, params);
+
+    return {
+      sessionId,
+      cdpUrl: params.connectUrl ?? "",
+      available: true,
+    };
+  }
+
+  async endSession(sessionId: string): Promise<void> {
+    await this.deleteSession(sessionId);
+  }
+
+  async hasSession(sessionId: string): Promise<boolean> {
+    const node = this.items.get(sessionId);
+    if (!node) return false;
+
+    // Check if expired
+    if (this.ttlMs > 0 && node.expiry <= Date.now()) {
+      await this.deleteSession(sessionId);
+      return false;
+    }
+
+    return true;
+  }
+
+  async getOrCreateStagehand(
+    sessionId: string,
+    ctx: RequestContext,
+  ): Promise<V3> {
+    const node = this.items.get(sessionId);
+
+    if (!node) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    // Check if expired
+    if (this.ttlMs > 0 && node.expiry <= Date.now()) {
+      await this.deleteSession(sessionId);
+      throw new Error(`Session expired: ${sessionId}`);
+    }
+
+    // Bump to most recently used
+    this.bumpNode(node);
+
+    // Update logger reference for this request
+    if (ctx.logger) {
+      node.loggerRef.current = ctx.logger;
+    }
+
+    // If V3 instance exists, return it
+    if (node.stagehand) {
+      return node.stagehand;
+    }
+
+    // Create V3 instance (lazy initialization)
+    const options = this.buildV3Options(node.params, ctx, node.loggerRef);
+    const stagehand = new V3(options);
+    try {
+      await stagehand.init();
+    } catch (error) {
+      try {
+        await stagehand.close();
+      } catch {
+        // best-effort cleanup for failed init attempts
+      }
+      throw error;
+    }
+    node.stagehand = stagehand;
+    return stagehand;
+  }
+
+  /**
+   * Build V3Options from stored params and request context
+   */
+  private buildV3Options(
+    params: CreateSessionParams,
+    ctx: RequestContext,
+    loggerRef: { current?: (message: LogLine) => void },
+  ): V3Options {
+    const isBrowserbase = params.browserType === "browserbase";
+
+    const options: V3Options = {
+      env: isBrowserbase ? "BROWSERBASE" : "LOCAL",
+      model: {
+        modelName: params.modelName,
+        apiKey: ctx.modelApiKey,
+      },
+      verbose: params.verbose,
+      systemPrompt: params.systemPrompt,
+      selfHeal: params.selfHeal,
+      domSettleTimeout: params.domSettleTimeoutMs,
+      experimental: params.experimental,
+      // Wrap logger to use the ref so it can be updated per-request
+      logger: (message: LogLine) => {
+        if (loggerRef.current) {
+          loggerRef.current(message);
+        }
+      },
+    };
+
+    if (isBrowserbase) {
+      options.apiKey = params.browserbaseApiKey;
+      options.projectId = params.browserbaseProjectId;
+
+      if (params.browserbaseSessionID) {
+        options.browserbaseSessionID = params.browserbaseSessionID;
+      }
+
+      if (params.browserbaseSessionCreateParams) {
+        options.browserbaseSessionCreateParams =
+          params.browserbaseSessionCreateParams;
+      }
+    } else if (params.localBrowserLaunchOptions) {
+      options.localBrowserLaunchOptions = params.localBrowserLaunchOptions;
+    }
+
+    return options;
+  }
+
+  async createSession(
+    sessionId: string,
+    params: CreateSessionParams,
+  ): Promise<void> {
+    // Check if already exists
+    if (this.items.has(sessionId)) {
+      throw new Error(`Session already exists: ${sessionId}`);
+    }
+
+    // Evict LRU if at capacity
+    if (this.maxCapacity > 0 && this.items.size >= this.maxCapacity) {
+      await this.evictLru();
+    }
+
+    // Create new node
+    const node: LruNode = {
+      sessionId,
+      params,
+      stagehand: null, // Lazy initialization
+      loggerRef: {},
+      expiry: this.ttlMs > 0 ? Date.now() + this.ttlMs : Infinity,
+      prev: this.last,
+      next: null,
+    };
+
+    this.items.set(sessionId, node);
+
+    // Link to end of list
+    if (this.last) this.last.next = node;
+    this.last = node;
+    if (!this.first) this.first = node;
+  }
+
+  async deleteSession(sessionId: string): Promise<void> {
+    const node = this.items.get(sessionId);
+    if (!node) return;
+
+    // Close V3 instance if it exists
+    if (node.stagehand) {
+      try {
+        await node.stagehand.close();
+      } catch (error) {
+        console.error(
+          `Error closing stagehand for session ${sessionId}:`,
+          error,
+        );
+      }
+    }
+
+    // Remove from map
+    this.items.delete(sessionId);
+
+    // Unlink from list
+    const { prev, next } = node;
+    if (prev) prev.next = next;
+    if (next) next.prev = prev;
+    if (this.first === node) this.first = next;
+    if (this.last === node) this.last = prev;
+  }
+
+  async getSessionConfig(sessionId: string): Promise<CreateSessionParams> {
+    const node = this.items.get(sessionId);
+
+    if (!node) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    // Return the stored params (contains browser metadata needed downstream)
+    return node.params;
+  }
+
+  updateCacheConfig(config: SessionCacheConfig): void {
+    if (config.maxCapacity !== undefined) {
+      if (config.maxCapacity <= 0) {
+        throw new Error("Max capacity must be greater than 0");
+      }
+      const previousCapacity = this.maxCapacity;
+      this.maxCapacity = config.maxCapacity;
+
+      // Evict excess if new capacity is smaller
+      if (this.maxCapacity < previousCapacity) {
+        const excess = this.items.size - this.maxCapacity;
+        for (let i = 0; i < excess; i++) {
+          // Fire and forget - don't await to match cloud behavior
+          this.evictLru().catch(console.error);
+        }
+      }
+    }
+
+    if (config.ttlMs !== undefined) {
+      this.ttlMs = config.ttlMs;
+    }
+  }
+
+  getCacheConfig(): SessionCacheConfig {
+    return {
+      maxCapacity: this.maxCapacity,
+      ttlMs: this.ttlMs,
+    };
+  }
+
+  async destroy(): Promise<void> {
+    // Stop cleanup interval
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+
+    // Close all V3 instances
+    const sessionIds = Array.from(this.items.keys());
+    await Promise.all(sessionIds.map((id) => this.deleteSession(id)));
+  }
+
+  /**
+   * Get the number of cached sessions
+   */
+  get size(): number {
+    return this.items.size;
+  }
+}
diff --git a/packages/server-v4/src/lib/SessionStore.ts b/packages/server-v4/src/lib/SessionStore.ts
new file mode 100644
index 000000000..387cb856f
--- /dev/null
+++ b/packages/server-v4/src/lib/SessionStore.ts
@@ -0,0 +1,184 @@
+import type {
+  Api,
+  LocalBrowserLaunchOptions,
+  LogLine,
+  V3,
+} from "@browserbasehq/stagehand";
+
+/**
+ * Result from SessionStore.startSession().
+ */
+export type SessionStartResult = Api.SessionStartResult;
+
+/**
+ * Parameters for creating a new session.
+ * This is what gets persisted - a subset of StartSessionParams
+ * that excludes runtime-only values like modelApiKey.
+ *
+ * Includes cloud-specific fields that pass through to cloud implementations.
+ * The library ignores fields it doesn't need, but they're available to SessionStore.
+ */
+export interface CreateSessionParams {
+  /** Browser choice for this session */
+  browserType: "local" | "browserbase";
+  /** Model name (e.g., "openai/gpt-4o") */
+  modelName: string;
+  /** Verbosity level */
+  verbose?: 0 | 1 | 2;
+  /** Custom system prompt */
+  systemPrompt?: string;
+  /** Enable self-healing for failed actions */
+  selfHeal?: boolean;
+  /** DOM settle timeout in milliseconds */
+  domSettleTimeoutMs?: number;
+  /** Enable experimental features */
+  experimental?: boolean;
+
+  // Browserbase-specific (used by cloud implementations)
+  /** Browserbase API key */
+  browserbaseApiKey?: string;
+  /** Browserbase project ID */
+  browserbaseProjectId?: string;
+  /** Existing Browserbase session ID to connect to */
+  browserbaseSessionID?: string;
+  /** Wait for captcha solves */
+  waitForCaptchaSolves?: boolean;
+  /** Browserbase session creation params */
+  browserbaseSessionCreateParams?: Record<string, unknown>;
+  /** Local browser launch overrides when browserType is local */
+  localBrowserLaunchOptions?: LocalBrowserLaunchOptions;
+
+  /** WebSocket URL for connecting to the browser (returned to client) */
+  connectUrl?: string;
+
+  // Cloud-specific metadata fields
+  /** Act timeout in milliseconds */
+  actTimeoutMs?: number;
+  /** Client language (typescript, python, playground) */
+  clientLanguage?: string;
+  /** SDK version */
+  sdkVersion?: string;
+}
+
+/**
+ * Request-time context passed when resolving a session.
+ * Contains values that come from request headers rather than storage.
+ */
+export interface RequestContext {
+  /** Model API key (from x-model-api-key header) */
+  modelApiKey?: string;
+  /** Logger function for this request */
+  logger?: (message: LogLine) => void;
+}
+
+/**
+ * Configuration options for session cache behavior.
+ */
+export interface SessionCacheConfig {
+  /** Maximum number of sessions to cache. Default: 100 */
+  maxCapacity?: number;
+  /** TTL for cached sessions in milliseconds. Default: 300000 (5 minutes) */
+  ttlMs?: number;
+}
+
+/**
+ * SessionStore interface for managing session lifecycle and V3 instances.
+ *
+ * The library provides an InMemorySessionStore as the default implementation
+ * with full caching support (TTL, LRU eviction, etc.).
+ *
+ * Cloud environments can implement this interface to:
+ * - Persist session config to a database
+ * - Use custom caching strategies (e.g., LaunchDarkly-driven config)
+ * - Add eviction hooks for cleanup
+ * - Handle platform-specific session lifecycle (e.g., Browserbase)
+ *
+ * This enables stateless pod architectures where any pod can handle any request.
+ */
+export interface SessionStore {
+  /**
+   * Start a new session.
+   *
+   * This is the main entry point for session creation. Implementations can:
+   * - Create platform-specific resources (e.g., Browserbase session)
+   * - Persist session config to storage
+   * - Check feature flags for availability
+   *
+   * @param params - Session configuration
+   * @returns Session ID and availability status
+   */
+  startSession(params: CreateSessionParams): Promise<SessionStartResult>;
+
+  /**
+   * End a session and cleanup all resources.
+   *
+   * This is the main entry point for session cleanup. Implementations can:
+   * - Close platform-specific resources (e.g., Browserbase session)
+   * - Evict V3 instance from cache
+   * - Update session status in storage
+   *
+   * @param sessionId - The session identifier
+   */
+  endSession(sessionId: string): Promise<void>;
+
+  /**
+   * Check if a session exists.
+   * @param sessionId - The session identifier
+   * @returns true if the session exists
+   */
+  hasSession(sessionId: string): Promise<boolean>;
+
+  /**
+   * Get or create a V3 instance for a session.
+   *
+   * This method handles:
+   * - Checking the cache for an existing V3 instance
+   * - On cache miss: loading config, creating V3, caching it
+   * - Updating the logger reference for streaming
+   *
+   * @param sessionId - The session identifier
+   * @param ctx - Request-time context containing values from headers
+   * @returns The V3 instance ready for use
+   * @throws Error if session not found
+   */
+  getOrCreateStagehand(sessionId: string, ctx: RequestContext): Promise<V3>;
+
+  /**
+   * Create a new session with the given parameters.
+   * Lower-level than startSession - just stores the config.
+   * @param sessionId - The session identifier
+   * @param params - Session configuration to persist
+   */
+  createSession(sessionId: string, params: CreateSessionParams): Promise<void>;
+
+  /**
+   * Delete a session from cache and close V3 instance.
+   * Lower-level than endSession - just handles cache cleanup.
+   * @param sessionId - The session identifier
+   */
+  deleteSession(sessionId: string): Promise<void>;
+
+  /**
+   * Retrieve the stored session configuration for a given session.
+   * @param sessionId - The session identifier
+   */
+  getSessionConfig(sessionId: string): Promise<CreateSessionParams>;
+
+  /**
+   * Update cache configuration dynamically.
+   * @param config - New cache configuration values
+   */
+  updateCacheConfig?(config: SessionCacheConfig): void;
+
+  /**
+   * Get current cache configuration.
+   * @returns Current cache config
+   */
+  getCacheConfig?(): SessionCacheConfig;
+
+  /**
+   * Cleanup all resources (close all V3 instances, stop timers).
+   * Called when shutting down the server.
+   */
+  destroy(): Promise<void>;
+}
diff --git a/packages/server-v4/src/lib/auth.ts b/packages/server-v4/src/lib/auth.ts
new file mode 100644
index 000000000..9eb7428b7
--- /dev/null
+++ b/packages/server-v4/src/lib/auth.ts
@@ -0,0 +1,14 @@
+import type { FastifyRequest } from "fastify";
+
+export const authMiddleware = async (
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  request: FastifyRequest,
+): Promise<boolean> => {
+  // Authentication is currently disabled; we may re-enable when a real auth backend is wired up.
+  return await isAuthenticated();
+};
+
+// TODO: Temporarily disable auth until setup in supabase
+const isAuthenticated = async (): Promise<boolean> => {
+  return true;
+};
diff --git a/packages/server-v4/src/lib/env.ts b/packages/server-v4/src/lib/env.ts
new file mode 100644
index 000000000..919732532
--- /dev/null
+++ b/packages/server-v4/src/lib/env.ts
@@ -0,0 +1,18 @@
+import { createEnv } from "@t3-oss/env-core";
+import { z } from "zod/v4";
+
+// Temporarily defining here until browserbase zod package is updated to 3.25.0+
+const bbEnvSchema = z.enum(["local", "dev", "prod"]);
+
+export const env = createEnv({
+  server: {
+    NODE_ENV: z.enum(["development", "production", "staging", "test"]),
+    BB_ENV: bbEnvSchema,
+  },
+  client: {},
+  clientPrefix: "PUBLIC_",
+  runtimeEnv: {
+    NODE_ENV: process.env.NODE_ENV ?? "production",
+    BB_ENV: process.env.BB_ENV ?? "local",
+  },
+});
diff --git a/packages/server-v4/src/lib/errorHandler.ts b/packages/server-v4/src/lib/errorHandler.ts
new file mode 100644
index 000000000..1e533fe03
--- /dev/null
+++ b/packages/server-v4/src/lib/errorHandler.ts
@@ -0,0 +1,70 @@
+import type {
+  FastifyReply,
+  FastifyRequest,
+  RouteGenericInterface,
+} from "fastify";
+import { StatusCodes } from "http-status-codes";
+
+import { error } from "./response.js";
+
+export class AppError extends Error {
+  statusCode: number;
+  isInternal: boolean;
+
+  constructor(
+    message: string,
+    statusCode = StatusCodes.BAD_REQUEST,
+    isInternal = false,
+  ) {
+    super(message);
+    this.statusCode = statusCode;
+    this.isInternal = isInternal;
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+  }
+
+  /**
+   * Get the message safe to send to clients.
+   * For internal errors (5xx), returns generic message.
+   * For client errors (4xx), returns actual message.
+   */
+  getClientMessage(): string {
+    if (this.isInternal) {
+      return this.statusCode >= StatusCodes.INTERNAL_SERVER_ERROR
+        ? "An internal server error occurred"
+        : "An error occurred while processing your request";
+    }
+    return this.message;
+  }
+}
+
+/**
+ * Wraps a route handler with error handling
+ * @param handler The route handler to wrap
+ * @returns A wrapped route handler that catches errors
+ */
+export function withErrorHandling<
+  T extends RouteGenericInterface = RouteGenericInterface,
+  R = unknown,
+>(handler: (request: FastifyRequest<T>, reply: FastifyReply) => Promise<R>) {
+  return async (
+    request: FastifyRequest<T>,
+    reply: FastifyReply,
+  ): Promise<R | FastifyReply> => {
+    try {
+      return await handler(request, reply);
+    } catch (err) {
+      request.log.error(err);
+
+      if (err instanceof AppError) {
+        return error(reply, err.getClientMessage(), err.statusCode);
+      }
+
+      return error(
+        reply,
+        "An internal server error occurred",
+        StatusCodes.INTERNAL_SERVER_ERROR,
+      );
+    }
+  };
+}
diff --git a/packages/server-v4/src/lib/header.ts b/packages/server-v4/src/lib/header.ts
new file mode 100644
index 000000000..daf1f6b62
--- /dev/null
+++ b/packages/server-v4/src/lib/header.ts
@@ -0,0 +1,99 @@
+import type { FastifyRequest } from "fastify";
+
+import { MissingHeaderError } from "../types/error.js";
+
+export const dangerouslyGetHeader = (
+  request: FastifyRequest,
+  header: string,
+): string => {
+  const headerValue = request.headers[header];
+
+  if (!headerValue) {
+    throw new MissingHeaderError(header);
+  }
+  if (Array.isArray(headerValue)) {
+    const [value] = headerValue;
+    if (!value) {
+      throw new MissingHeaderError(header);
+    }
+    return value;
+  }
+  return headerValue;
+};
+
+export const getOptionalHeader = (
+  request: FastifyRequest,
+  header: string,
+): string | undefined => {
+  const headerValue = request.headers[header];
+  if (!headerValue) {
+    return undefined;
+  }
+  if (Array.isArray(headerValue)) {
+    const [value] = headerValue;
+    if (!value) {
+      return undefined;
+    }
+    return value;
+  }
+  return headerValue;
+};
+
+/**
+ * Extracts model name from request body, supporting V3 structure.
+ * - V3: body.options.model.modelName
+ */
+export function getModelName(request: FastifyRequest): string | undefined {
+  const body = request.body as Record<string, unknown> | undefined;
+  const options = body?.options as Record<string, unknown> | undefined;
+  const model = options?.model as Record<string, unknown> | undefined;
+
+  if (typeof model?.modelName === "string" && model.modelName) {
+    return model.modelName;
+  }
+
+  if (typeof body?.modelName === "string" && body.modelName) {
+    return body.modelName;
+  }
+
+  return undefined;
+}
+
+/**
+ * Extracts the model API key with precedence:
+ * 1. Per-request body apiKey (V3: body.options.model.apiKey)
+ * 2. Per-request header x-model-api-key
+ */
+export function getModelApiKey(request: FastifyRequest): string | undefined {
+  const body = request.body as Record<string, unknown> | undefined;
+  const options = body?.options as Record<string, unknown> | undefined;
+  const model = options?.model as Record<string, unknown> | undefined;
+
+  if (typeof model?.apiKey === "string" && model.apiKey) {
+    return model.apiKey;
+  }
+
+  return getOptionalHeader(request, "x-model-api-key");
+}
+
+/**
+ * Extracts the stream response value from either the request header or body.
+ * Body parameter takes precedence over header.
+ * Defaults to false (non-streaming) if neither is provided.
+ */
+export function shouldRespondWithSSE(request: FastifyRequest): boolean {
+  const body = request.body as Record<string, unknown> | undefined;
+  if (typeof body?.streamResponse === "boolean") {
+    return body.streamResponse;
+  }
+  if (typeof body?.streamResponse === "string") {
+    return body.streamResponse.toLowerCase() === "true";
+  }
+
+  const streamHeader = getOptionalHeader(request, "x-stream-response");
+  if (streamHeader) {
+    return streamHeader.toLowerCase() === "true";
+  }
+
+  return false;
+}
diff --git a/packages/server-v4/src/lib/logging/index.ts b/packages/server-v4/src/lib/logging/index.ts
new file mode 100644
index 000000000..c680c1bf0
--- /dev/null
+++ b/packages/server-v4/src/lib/logging/index.ts
@@ -0,0 +1,59 @@
+import { FastifyInstance } from "fastify";
+
+import { env } from "../../lib/env.js";
+
+// List of routes to ignore for request logging in local environments
+const ignoredRoutes = ["/healthz", "/readyz"];
+
+// Helper function to determine if a request should be logged
+const shouldLog = (url: string) => {
+  return env.BB_ENV !== "local" || !ignoredRoutes.includes(url);
+};
+
+const logging = (app: FastifyInstance) => {
+  // Add request logging hooks
+  app.addHook("onRequest", (req, _reply, done) => {
+    // Add request ID to response headers
+    if (shouldLog(req.url)) {
+      req.log.info(
+        {
+          req: {
+            host: req.hostname,
+            method: req.method,
+            remoteAddress: req.ip,
+            remotePort: req.socket.remotePort,
+            url: req.url,
+          },
+          reqId: req.id,
+        },
+        "incoming request",
+      );
+    }
+    done();
+  });
+
+  app.addHook("onResponse", (req, reply, done) => {
+    if (shouldLog(req.url)) {
+      req.log.info(
+        {
+          reqId: req.id,
+          req: {
+            host: req.hostname,
+            method: req.method,
+            remoteAddress: req.ip,
+            remotePort: req.socket.remotePort,
+            url: req.url,
+          },
+          res: {
+            statusCode: reply.statusCode,
+          },
+          responseTime: reply.elapsedTime,
+        },
+        "request completed",
+      );
+    }
+    done();
+  });
+};
+
+export { logging };
diff --git a/packages/server-v4/src/lib/response.ts b/packages/server-v4/src/lib/response.ts
new file mode 100644
index 000000000..94bd2aeb3
--- /dev/null
+++ b/packages/server-v4/src/lib/response.ts
@@ -0,0 +1,48 @@
+import type { FastifyReply } from "fastify";
+import { StatusCodes } from "http-status-codes";
+
+interface SuccessResponse<T> {
+  success: true;
+  data: T;
+}
+
+interface ErrorResponse {
+  success: false;
+  message: string;
+}
+
+type ApiResponse<T> = SuccessResponse<T> | ErrorResponse;
+
+export function success<T>(
+  reply: FastifyReply,
+  data: T,
+  status = StatusCodes.OK,
+): FastifyReply {
+  return reply.status(status).send({
+    success: true,
+    data,
+  });
+}
+
+export function error(
+  reply: FastifyReply,
+  message: string,
+  status = StatusCodes.BAD_REQUEST,
+): FastifyReply {
+  return reply.status(status).send({
+    success: false,
+    message,
+  });
+}
+
+export function isSuccessResponse<T>(
+  response: ApiResponse<T>,
+): response is SuccessResponse<T> {
+  return response.success;
+}
+
+export function isErrorResponse(
+  response: ApiResponse<unknown>,
+): response is ErrorResponse {
+  return !response.success;
+}
diff --git a/packages/server-v4/src/lib/sessionStoreManager.ts b/packages/server-v4/src/lib/sessionStoreManager.ts
new file mode 100644
index 000000000..1bd840e21
--- /dev/null
+++ b/packages/server-v4/src/lib/sessionStoreManager.ts
@@ -0,0 +1,27 @@
+import { InMemorySessionStore } from "./InMemorySessionStore.js";
+import type { SessionCacheConfig, SessionStore } from "./SessionStore.js";
+
+let sessionStore: SessionStore | null = null;
+
+export function initializeSessionStore(
+  config?: SessionCacheConfig,
+): SessionStore {
+  if (!sessionStore) {
+    sessionStore = new InMemorySessionStore(config);
+  }
+  return sessionStore;
+}
+
+export function getSessionStore(): SessionStore {
+  if (!sessionStore) {
+    throw new Error("Session store has not been initialized");
+  }
+  return sessionStore;
+}
+
+export async function destroySessionStore(): Promise<void> {
+  if (sessionStore) {
+    await sessionStore.destroy();
+    sessionStore = null;
+  }
+}
diff --git a/packages/server-v4/src/lib/stream.ts b/packages/server-v4/src/lib/stream.ts
new file mode 100644
index 000000000..4866e41f1
--- /dev/null
+++ b/packages/server-v4/src/lib/stream.ts
@@ -0,0 +1,195 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import type { Stagehand as V3Stagehand } from "@browserbasehq/stagehand";
+import { v4 } from "uuid";
+import { z } from "zod/v4";
+
+import { AppError } from "./errorHandler.js";
+import {
+  getModelApiKey,
+  getOptionalHeader,
+  shouldRespondWithSSE,
+} from "./header.js";
+import { error, success } from "./response.js";
+import { getSessionStore } from "./sessionStoreManager.js";
+import type { RequestContext } from "./SessionStore.js";
+
+interface StreamingResponseOptions<TV3> {
+  sessionId: string;
+  request: FastifyRequest;
+  reply: FastifyReply;
+  schema: z.ZodType<TV3>;
+  handler: (ctx: {
+    stagehand: V3Stagehand;
+    data: TV3;
+  }) => Promise<{ result: unknown; actionId?: string }>;
+  operation?: string;
+}
+
+export async function createStreamingResponse<TV3>({
+  sessionId,
+  request,
+  reply,
+  schema,
+  handler,
+  operation,
+}: StreamingResponseOptions<TV3>) {
+  const shouldStreamResponse = shouldRespondWithSSE(request);
+  const modelApiKey = getModelApiKey(request);
+
+  const sessionStore = getSessionStore();
+  const sessionConfig = await sessionStore.getSessionConfig(sessionId);
+  const browserType = sessionConfig.browserType ?? "local";
+
+  let browserbaseApiKey = sessionConfig.browserbaseApiKey;
+  let browserbaseProjectId = sessionConfig.browserbaseProjectId;
+
+  if (browserType === "browserbase") {
+    browserbaseApiKey =
+      browserbaseApiKey ?? getOptionalHeader(request, "x-bb-api-key");
+    browserbaseProjectId =
+      browserbaseProjectId ?? getOptionalHeader(request, "x-bb-project-id");
+
+    if (!browserbaseApiKey || !browserbaseProjectId) {
+      return reply.status(StatusCodes.BAD_REQUEST).send({
+        error:
+          "Browserbase API key and project ID are required for browserbase sessions",
+      });
+    }
+  }
+
+  // Parse data using V3 schema
+  let parsedData: TV3;
+
+  try {
+    const json: unknown = request.body;
+    parsedData = await schema.parseAsync(json);
+  } catch (err) {
+    const parseError = err as Error | z.ZodError;
+
+    if (parseError instanceof z.ZodError) {
+      return reply.status(StatusCodes.BAD_REQUEST).send({
+        error: parseError.issues.map((issue) => ({
+          path: issue.path[0],
+          message: issue.message,
+        })),
+      });
+    }
+
+    return reply
+      .status(StatusCodes.BAD_REQUEST)
+      .send({ error: parseError.message });
+  }
+
+  if (shouldStreamResponse) {
+    try {
+      reply.raw.writeHead(StatusCodes.OK, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+        "Transfer-Encoding": "chunked",
+        "X-Accel-Buffering": "no",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers": "*",
+      });
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (_err) {
+      return error(
+        reply,
+        "Failed to write head",
+        StatusCodes.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
+  const sendData = (type: string, data: object) => {
+    if (!shouldStreamResponse) {
+      return;
+    }
+
+    reply.raw.write(`data: ${JSON.stringify({ data, type, id: v4() })}\n\n`);
+  };
+
+  const actionId = v4();
+
+  sendData("system", { status: "starting" });
+
+  const requestContext: RequestContext = {
+    modelApiKey,
+    logger: shouldStreamResponse
+      ? (message) => {
+          sendData("log", { status: "running", message });
+        }
+      : undefined,
+  };
+
+  let stagehand: V3Stagehand;
+  try {
+    stagehand = (await sessionStore.getOrCreateStagehand(
+      sessionId,
+      requestContext,
+    )) as V3Stagehand;
+  } catch (err) {
+    const loadError = err instanceof Error ? err : new Error(String(err));
+
+    sendData("system", { status: "error", error: loadError.message });
+
+    if (shouldStreamResponse) {
+      reply.raw.end();
+      return reply;
+    }
+
+    return error(
+      reply,
+      loadError.message,
+      loadError instanceof AppError
+        ? loadError.statusCode
+        : StatusCodes.INTERNAL_SERVER_ERROR,
+    );
+  }
+
+  sendData("system", { status: "connected" });
+
+  let result: Awaited<ReturnType<typeof handler>> | null = null;
+  let handlerError: Error | null = null;
+
+  try {
+    result = await handler({ stagehand, data: parsedData });
+  } catch (err) {
+    handlerError = err instanceof Error ? err : new Error("Unknown error");
+  }
+
+  if (handlerError) {
+    const clientMessage =
+      handlerError instanceof AppError
+        ? handlerError.getClientMessage()
+        : `${operation ?? "operation"} failed`;
+
+    sendData("system", { status: "error", error: clientMessage });
+
+    if (shouldStreamResponse) {
+      reply.raw.end();
+      return reply;
+    }
+
+    const statusCode =
+      handlerError instanceof AppError
+        ? handlerError.statusCode
+        : StatusCodes.INTERNAL_SERVER_ERROR;
+    return error(reply, clientMessage, statusCode);
+  }
+
+  sendData("system", {
+    status: "finished",
+    result: result?.result,
+    actionId,
+  });
+
+  if (shouldStreamResponse) {
+    reply.raw.end();
+    return reply;
+  }
+
+  return success(reply, { result: result?.result, actionId });
+}
diff --git a/packages/server-v4/src/lib/utils.ts b/packages/server-v4/src/lib/utils.ts
new file mode 100644
index 000000000..c736adc64
--- /dev/null
+++ b/packages/server-v4/src/lib/utils.ts
@@ -0,0 +1,220 @@
+import { StatusCodes } from "http-status-codes";
+import { z } from "zod/v3";
+import type { ZodTypeAny } from "zod/v3";
+
+import { LegacyModel, LegacyProvider } from "../types/model.js";
+import { AppError } from "./errorHandler.js";
+
+interface JSONSchema {
+  type?: string | string[];
+  properties?: Record<string, JSONSchema>;
+  required?: string[];
+  description?: string;
+  items?: JSONSchema;
+  enum?: string[];
+  minimum?: number;
+  maximum?: number;
+  format?: "uri" | "url" | "email" | "uuid";
+  anyOf?: JSONSchema[];
+  oneOf?: JSONSchema[];
+  allOf?: JSONSchema[];
+}
+
+/**
+ * Converts a JSON Schema object to a Zod schema.
+ * @param schema The JSON Schema object to convert
+ * @returns A Zod schema equivalent to the input JSON Schema
+ */
+export function jsonSchemaToZod(schema: JSONSchema): ZodTypeAny {
+  if (Array.isArray(schema.type)) {
+    const subSchemas = schema.type.map((singleType) => {
+      const sub = { ...schema, type: singleType };
+      return jsonSchemaToZod(sub);
+    });
+
+    if (subSchemas.length === 0) {
+      return z.any();
+    } else if (subSchemas.length === 1) {
+      const [subSchema] = subSchemas;
+      if (!subSchema) {
+        return z.any();
+      }
+      return subSchema;
+    }
+    return z.union(subSchemas as [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]);
+  }
+
+  if (schema.anyOf && Array.isArray(schema.anyOf)) {
+    const subSchemas = schema.anyOf.map((sub) => jsonSchemaToZod(sub));
+    if (subSchemas.length === 0) {
+      return z.any();
+    } else if (subSchemas.length === 1) {
+      const [subSchema] = subSchemas;
+      if (!subSchema) {
+        return z.any();
+      }
+      return subSchema;
+    }
+    return z.union(subSchemas as [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]);
+  }
+
+  if (schema.oneOf && Array.isArray(schema.oneOf)) {
+    const subSchemas = schema.oneOf.map((sub) => jsonSchemaToZod(sub));
+    if (subSchemas.length === 0) {
+      return z.any();
+    } else if (subSchemas.length === 1) {
+      const [subSchema] = subSchemas;
+      if (!subSchema) {
+        return z.any();
+      }
+      return subSchema;
+    }
+    return z.union(subSchemas as [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]);
+  }
+
+  switch (schema.type) {
+    case "object":
+      if (schema.properties) {
+        const shape: Record<string, ZodTypeAny> = {};
+        for (const key in schema.properties) {
+          const subSchema = schema.properties[key];
+          if (!subSchema) {
+            throw new AppError(
+              `Property ${key} is not defined in the schema`,
+              StatusCodes.BAD_REQUEST,
+            );
+          }
+          shape[key] = jsonSchemaToZod(subSchema);
+        }
+        let zodObject = z.object(shape);
+
+        if (schema.required && Array.isArray(schema.required)) {
+          const requiredFields = schema.required.reduce<Record<string, true>>(
+            (acc, key) => {
+              acc[key] = true;
+              return acc;
+            },
+            {},
+          );
+          zodObject = zodObject.partial().required(requiredFields);
+        }
+
+        if (schema.description) {
+          zodObject = zodObject.describe(schema.description);
+        }
+        return zodObject;
+      }
+
+      return z.object({});
+
+    case "array":
+      if (schema.items) {
+        let zodArray = z.array(jsonSchemaToZod(schema.items));
+        if (schema.description) {
+          zodArray = zodArray.describe(schema.description);
+        }
+        return zodArray;
+      }
+      return z.array(z.any());
+
+    case "string": {
+      if (schema.enum) {
+        return z.string().refine((val) => schema.enum?.includes(val) ?? false);
+      }
+      let zodString = z.string();
+
+      switch (schema.format) {
+        case "uri":
+        case "url":
+          zodString = zodString.url();
+          break;
+        case "email":
+          zodString = zodString.email();
+          break;
+        case "uuid":
+          zodString = zodString.uuid();
+          break;
+        default:
+      }
+
+      if (schema.description) {
+        zodString = zodString.describe(schema.description);
+      }
+      return zodString;
+    }
+
+    case "integer": // integer is a subset of number
+    case "number": {
+      let zodNumber = z.number();
+      if (schema.minimum !== undefined) {
+        zodNumber = zodNumber.min(schema.minimum);
+      }
+      if (schema.maximum !== undefined) {
+        zodNumber = zodNumber.max(schema.maximum);
+      }
+      if (schema.description) {
+        zodNumber = zodNumber.describe(schema.description);
+      }
+      return zodNumber;
+    }
+
+    case "boolean": {
+      let zodBoolean = z.boolean();
+      if (schema.description) {
+        zodBoolean = zodBoolean.describe(schema.description);
+      }
+      return zodBoolean;
+    }
+
+    case "null": {
+      let zodNull = z.null();
+      if (schema.description) {
+        zodNull = zodNull.describe(schema.description);
+      }
+      return zodNull;
+    }
+
+    default:
+      // fallback if no recognized schema.type is present
+      return z.any();
+  }
+}
+
+// This function is legacy and will not be required after complete AISDK migration
+export function mapModelToProvider(model: LegacyModel): LegacyProvider {
+  switch (model) {
+    case "gpt-4o":
+    case "gpt-4o-mini":
+    case "gpt-4o-2024-08-06":
+    case "gpt-4o-2024-05-13":
+    case "o1-mini":
+    case "o1-preview":
+    case "gpt-4.5-preview":
+    case "o3-mini":
+      return "openai";
+    case "gemini-1.5-flash":
+    case "gemini-1.5-pro":
+    case "gemini-1.5-flash-8b":
+    case "gemini-2.0-flash-lite":
+    case "gemini-2.0-flash":
+    case "gemini-2.5-pro-preview-03-25":
+    case "gemini-2.5-flash-preview-04-17":
+      return "google";
+    case "cerebras-llama-3.3-70b":
+    case "cerebras-llama-3.1-8b":
+      throw new AppError(
+        "Cerebras models are not supported yet",
+        StatusCodes.BAD_REQUEST,
+      );
+    case "groq-llama-3.3-70b-specdec":
+    case "groq-llama-3.3-70b-versatile":
+      throw new AppError(
+        "Groq models are not supported yet",
+        StatusCodes.BAD_REQUEST,
+      );
+    default: {
+      const errorMessage = `Unknown model: ${String(model)}`;
+      throw new AppError(errorMessage, StatusCodes.BAD_REQUEST);
+    }
+  }
+}
diff --git a/packages/server-v4/src/routes/healthcheck.ts b/packages/server-v4/src/routes/healthcheck.ts
new file mode 100644
index 000000000..0864cfb13
--- /dev/null
+++ b/packages/server-v4/src/routes/healthcheck.ts
@@ -0,0 +1,30 @@
+import type { RouteOptions } from "fastify";
+import { z } from "zod/v4";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+
+import { withErrorHandling } from "../lib/errorHandler.js";
+
+const healthcheckRoute: RouteOptions = {
+  method: "GET",
+  url: "/healthz",
+  logLevel: "silent",
+  schema: {
+    hide: true, // Hide from OpenAPI spec - utility endpoint
+    response: {
+      200: z
+        .object({
+          status: z.string(),
+          timestamp: z.string(),
+        })
+        .strict(),
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: withErrorHandling(async () => {
+    return {
+      status: "ok",
+      timestamp: new Date().toISOString(),
+    };
+  }),
+};
+
+export default healthcheckRoute;
diff --git a/packages/server-v4/src/routes/readiness.ts b/packages/server-v4/src/routes/readiness.ts
new file mode 100644
index 000000000..d602e9a0e
--- /dev/null
+++ b/packages/server-v4/src/routes/readiness.ts
@@ -0,0 +1,55 @@
+import type { RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import { z } from "zod/v4";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+
+import { withErrorHandling } from "../lib/errorHandler.js";
+
+// Server readiness state management
+let isReady = false;
+
+/**
+ * Get the current readiness state of the server
+ * @returns {boolean} Whether the server is ready to accept requests
+ */
+export const getIsReady = (): boolean => {
+  return isReady;
+};
+
+/**
+ * Mark the server as ready to accept requests
+ */
+export const setReady = (): void => {
+  isReady = true;
+};
+
+/**
+ * Mark the server as not ready to accept requests
+ * Used during graceful shutdown to stop accepting new requests
+ */
+export const setUnready = (): void => {
+  isReady = false;
+};
+
+const readinessRoute: RouteOptions = {
+  method: "GET",
+  url: "/readyz",
+  logLevel: "silent",
+  schema: {
+    hide: true, // Hide from OpenAPI spec - utility endpoint
+    response: {
+      200: z.string(),
+      503: z.string(),
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: withErrorHandling(async (_request, reply) => {
+    if (!isReady) {
+      return reply
+        .code(StatusCodes.SERVICE_UNAVAILABLE)
+        .send("Service Unavailable");
+    }
+    return reply.code(StatusCodes.OK).send("Ready");
+  }),
+};
+
+export default readinessRoute;
diff --git a/packages/server-v4/src/routes/v4/sessions/_id/act.ts b/packages/server-v4/src/routes/v4/sessions/_id/act.ts
new file mode 100644
index 000000000..3a64c8336
--- /dev/null
+++ b/packages/server-v4/src/routes/v4/sessions/_id/act.ts
@@ -0,0 +1,97 @@
+import type { RouteHandlerMethod, RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import type { ActResult, Action } from "@browserbasehq/stagehand";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+import { Api } from "@browserbasehq/stagehand";
+
+import { authMiddleware } from "../../../../lib/auth.js";
+import { AppError, withErrorHandling } from "../../../../lib/errorHandler.js";
+import { createStreamingResponse } from "../../../../lib/stream.js";
+import { getSessionStore } from "../../../../lib/sessionStoreManager.js";
+
+const actRouteHandler: RouteHandlerMethod = withErrorHandling(
+  async (request, reply) => {
+    if (!(await authMiddleware(request))) {
+      return reply
+        .status(StatusCodes.UNAUTHORIZED)
+        .send({ error: "Unauthorized" });
+    }
+
+    const { id } = request.params as Api.SessionIdParams;
+
+    if (!id.length) {
+      return reply.status(StatusCodes.BAD_REQUEST).send({
+        message: "Missing session id",
+      });
+    }
+
+    const sessionStore = getSessionStore();
+    const hasSession = await sessionStore.hasSession(id);
+    if (!hasSession) {
+      return reply.status(StatusCodes.NOT_FOUND).send({
+        message: "Session not found",
+      });
+    }
+
+    return createStreamingResponse<Api.ActRequest>({
+      sessionId: id,
+      request,
+      reply,
+      schema: Api.ActRequestSchema,
+      handler: async ({ stagehand, data }) => {
+        const { frameId } = data;
+        const page = frameId
+          ? stagehand.context.resolvePageByMainFrameId(frameId)
+          : await stagehand.context.awaitActivePage();
+
+        if (!page) {
+          throw new AppError(
+            "Page not found",
+            StatusCodes.INTERNAL_SERVER_ERROR,
+          );
+        }
+
+        const modelOpt = data.options?.model;
+        const normalizedModel =
+          typeof modelOpt === "string"
+            ? { modelName: modelOpt }
+            : modelOpt
+              ? { ...modelOpt, modelName: modelOpt.modelName ?? "gpt-4o" }
+              : undefined;
+
+        const safeOptions = {
+          ...data.options,
+          model: normalizedModel,
+          page,
+        };
+
+        let result: ActResult;
+        if (typeof data.input === "string") {
+          result = await stagehand.act(data.input, safeOptions);
+        } else {
+          result = await stagehand.act(data.input as Action, safeOptions);
+        }
+
+        return { result };
+      },
+      operation: "act",
+    });
+  },
+);
+
+const actRoute: RouteOptions = {
+  method: "POST",
+  url: "/sessions/:id/act",
+  schema: {
+    ...Api.Operations.SessionAct,
+    headers: Api.SessionHeadersSchema,
+    params: Api.SessionIdParamsSchema,
+    body: Api.ActRequestSchema,
+    response: {
+      200: Api.ActResponseSchema,
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: actRouteHandler,
+};
+
+export default actRoute;
diff --git a/packages/server-v4/src/routes/v4/sessions/_id/agentExecute.ts b/packages/server-v4/src/routes/v4/sessions/_id/agentExecute.ts
new file mode 100644
index 000000000..8e16f71fb
--- /dev/null
+++ b/packages/server-v4/src/routes/v4/sessions/_id/agentExecute.ts
@@ -0,0 +1,103 @@
+import type { RouteHandlerMethod, RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+import { Api } from "@browserbasehq/stagehand";
+
+import { authMiddleware } from "../../../../lib/auth.js";
+import { AppError, withErrorHandling } from "../../../../lib/errorHandler.js";
+import { createStreamingResponse } from "../../../../lib/stream.js";
+import { getSessionStore } from "../../../../lib/sessionStoreManager.js";
+
+const agentExecuteRouteHandler: RouteHandlerMethod = withErrorHandling(
+  async (request, reply) => {
+    if (!(await authMiddleware(request))) {
+      return reply
+        .status(StatusCodes.UNAUTHORIZED)
+        .send({ error: "Unauthorized" });
+    }
+
+    const { id } = request.params as Api.SessionIdParams;
+
+    if (!id.length) {
+      return reply.status(StatusCodes.BAD_REQUEST).send({
+        message: "Missing session id",
+      });
+    }
+
+    const sessionStore = getSessionStore();
+    const hasSession = await sessionStore.hasSession(id);
+    if (!hasSession) {
+      return reply.status(StatusCodes.NOT_FOUND).send({
+        message: "Session not found",
+      });
+    }
+
+    return createStreamingResponse<Api.AgentExecuteRequest>({
+      sessionId: id,
+      request,
+      reply,
+      schema: Api.AgentExecuteRequestSchema,
+      handler: async ({ stagehand, data }) => {
+        const { agentConfig, executeOptions } = data;
+        const { frameId } = data;
+        const page = frameId
+          ? stagehand.context.resolvePageByMainFrameId(frameId)
+          : await stagehand.context.awaitActivePage();
+        if (!page) {
+          throw new AppError(
+            "Page not found",
+            StatusCodes.INTERNAL_SERVER_ERROR,
+          );
+        }
+        const normalizedAgentConfig = {
+          ...agentConfig,
+          model:
+            typeof agentConfig.model === "string"
+              ? { modelName: agentConfig.model }
+              : agentConfig.model
+                ? {
+                    ...agentConfig.model,
+                    modelName: agentConfig.model.modelName ?? "gpt-4o",
+                  }
+                : undefined,
+        };
+
+        const { instruction, ...restExecuteOptions } = executeOptions;
+        const fullExecuteOptions = {
+          instruction,
+          ...restExecuteOptions,
+          page,
+        };
+        let result;
+        try {
+          result = await stagehand
+            .agent(normalizedAgentConfig)
+            .execute(fullExecuteOptions);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          throw new AppError(message, StatusCodes.UNPROCESSABLE_ENTITY);
+        }
+
+        return { result };
+      },
+      operation: "agentExecute",
+    });
+  },
+);
+
+const agentExecuteRoute: RouteOptions = {
+  method: "POST",
+  url: "/sessions/:id/agentExecute",
+  schema: {
+    ...Api.Operations.SessionAgentExecute,
+    headers: Api.SessionHeadersSchema,
+    params: Api.SessionIdParamsSchema,
+    body: Api.AgentExecuteRequestSchema,
+    response: {
+      200: Api.AgentExecuteResponseSchema,
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: agentExecuteRouteHandler,
+};
+
+export default agentExecuteRoute;
diff --git a/packages/server-v4/src/routes/v4/sessions/_id/end.ts b/packages/server-v4/src/routes/v4/sessions/_id/end.ts
new file mode 100644
index 000000000..3e4c634bf
--- /dev/null
+++ b/packages/server-v4/src/routes/v4/sessions/_id/end.ts
@@ -0,0 +1,64 @@
+import type { RouteHandlerMethod, RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+import { Api } from "@browserbasehq/stagehand";
+
+import { authMiddleware } from "../../../../lib/auth.js";
+import { withErrorHandling } from "../../../../lib/errorHandler.js";
+import { error } from "../../../../lib/response.js";
+import { getSessionStore } from "../../../../lib/sessionStoreManager.js";
+
+const endRouteHandler: RouteHandlerMethod = withErrorHandling(
+  async (request, reply) => {
+    if (!(await authMiddleware(request))) {
+      return error(reply, "Unauthorized", StatusCodes.UNAUTHORIZED);
+    }
+
+    // This endpoint intentionally has no request body. Reject unexpected bodies to
+    // catch misconfigured clients, while still allowing empty JSON bodies.
+    const body = (request as { body?: unknown }).body;
+    if (body != null) {
+      if (typeof body !== "object" || Buffer.isBuffer(body)) {
+        return error(
+          reply,
+          "Request body must be empty",
+          StatusCodes.BAD_REQUEST,
+        );
+      }
+
+      if (Object.keys(body as Record<string, unknown>).length > 0) {
+        return error(
+          reply,
+          "Request body must be empty",
+          StatusCodes.BAD_REQUEST,
+        );
+      }
+    }
+
+    const { id: sessionId } = request.params as Api.SessionIdParams;
+    const sessionStore = getSessionStore();
+    const hasSession = await sessionStore.hasSession(sessionId);
+    if (!hasSession) {
+      return error(reply, "Session not found", StatusCodes.NOT_FOUND);
+    }
+    await sessionStore.endSession(sessionId);
+
+    return reply.status(StatusCodes.OK).send({ success: true });
+  },
+);
+
+const endRoute: RouteOptions = {
+  method: "POST",
+  url: "/sessions/:id/end",
+  schema: {
+    ...Api.Operations.SessionEnd,
+    headers: Api.SessionHeadersSchema,
+    params: Api.SessionIdParamsSchema,
+    response: {
+      200: Api.SessionEndResponseSchema,
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: endRouteHandler,
+};
+
+export default endRoute;
diff --git a/packages/server-v4/src/routes/v4/sessions/_id/extract.ts b/packages/server-v4/src/routes/v4/sessions/_id/extract.ts
new file mode 100644
index 000000000..47e54d77c
--- /dev/null
+++ b/packages/server-v4/src/routes/v4/sessions/_id/extract.ts
@@ -0,0 +1,106 @@
+import type { RouteHandlerMethod, RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import type { ZodTypeAny } from "zod/v3";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+import { Api } from "@browserbasehq/stagehand";
+
+import { authMiddleware } from "../../../../lib/auth.js";
+import { AppError, withErrorHandling } from "../../../../lib/errorHandler.js";
+import { createStreamingResponse } from "../../../../lib/stream.js";
+import { jsonSchemaToZod } from "../../../../lib/utils.js";
+import { getSessionStore } from "../../../../lib/sessionStoreManager.js";
+
+const extractRouteHandler: RouteHandlerMethod = withErrorHandling(
+  async (request, reply) => {
+    if (!(await authMiddleware(request))) {
+      return reply
+        .status(StatusCodes.UNAUTHORIZED)
+        .send({ error: "Unauthorized" });
+    }
+
+    const { id } = request.params as Api.SessionIdParams;
+
+    if (!id.length) {
+      return reply.status(StatusCodes.BAD_REQUEST).send({
+        message: "Missing session id",
+      });
+    }
+
+    const sessionStore = getSessionStore();
+    const hasSession = await sessionStore.hasSession(id);
+    if (!hasSession) {
+      return reply.status(StatusCodes.NOT_FOUND).send({
+        message: "Session not found",
+      });
+    }
+
+    return createStreamingResponse<Api.ExtractRequest>({
+      sessionId: id,
+      request,
+      reply,
+      schema: Api.ExtractRequestSchema,
+      handler: async ({ stagehand, data }) => {
+        const { frameId } = data;
+        const page = frameId
+          ? stagehand.context.resolvePageByMainFrameId(frameId)
+          : await stagehand.context.awaitActivePage();
+
+        if (!page) {
+          throw new AppError(
+            "Page not found",
+            StatusCodes.INTERNAL_SERVER_ERROR,
+          );
+        }
+
+        const modelOpt = data.options?.model;
+        const normalizedModel =
+          typeof modelOpt === "string"
+            ? { modelName: modelOpt }
+            : modelOpt
+              ? { ...modelOpt, modelName: modelOpt.modelName ?? "gpt-4o" }
+              : undefined;
+
+        const safeOptions = {
+          ...data.options,
+          model: normalizedModel,
+          page,
+        };
+
+        const extractFn = stagehand.extract.bind(stagehand);
+
+        let result: unknown;
+
+        if (data.instruction) {
+          if (data.schema) {
+            const zodSchema = jsonSchemaToZod(data.schema) as ZodTypeAny;
+            result = await extractFn(data.instruction, zodSchema, safeOptions);
+          } else {
+            result = await extractFn(data.instruction, safeOptions);
+          }
+        } else {
+          result = await extractFn(safeOptions);
+        }
+
+        return { result };
+      },
+      operation: "extract",
+    });
+  },
+);
+
+const extractRoute: RouteOptions = {
+  method: "POST",
+  url: "/sessions/:id/extract",
+  schema: {
+    ...Api.Operations.SessionExtract,
+    headers: Api.SessionHeadersSchema,
+    params: Api.SessionIdParamsSchema,
+    body: Api.ExtractRequestSchema,
+    response: {
+      200: Api.ExtractResponseSchema,
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: extractRouteHandler,
+};
+
+export default extractRoute;
diff --git a/packages/server-v4/src/routes/v4/sessions/_id/navigate.ts b/packages/server-v4/src/routes/v4/sessions/_id/navigate.ts
new file mode 100644
index 000000000..5b9131ff4
--- /dev/null
+++ b/packages/server-v4/src/routes/v4/sessions/_id/navigate.ts
@@ -0,0 +1,73 @@
+import type { RouteHandlerMethod, RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+import { Api } from "@browserbasehq/stagehand";
+
+import { authMiddleware } from "../../../../lib/auth.js";
+import { AppError, withErrorHandling } from "../../../../lib/errorHandler.js";
+import { createStreamingResponse } from "../../../../lib/stream.js";
+import { getSessionStore } from "../../../../lib/sessionStoreManager.js";
+
+const navigateRouteHandler: RouteHandlerMethod = withErrorHandling(
+  async (request, reply) => {
+    if (!(await authMiddleware(request))) {
+      return reply
+        .status(StatusCodes.UNAUTHORIZED)
+        .send({ error: "Unauthorized" });
+    }
+
+    const { id } = request.params as Api.SessionIdParams;
+
+    if (!id.length) {
+      return reply.status(StatusCodes.BAD_REQUEST).send({
+        message: "Missing session id",
+      });
+    }
+
+    const sessionStore = getSessionStore();
+    const hasSession = await sessionStore.hasSession(id);
+    if (!hasSession) {
+      return reply.status(StatusCodes.NOT_FOUND).send({
+        message: "Session not found",
+      });
+    }
+
+    return createStreamingResponse<Api.NavigateRequest>({
+      sessionId: id,
+      request,
+      reply,
+      schema: Api.NavigateRequestSchema,
+      handler: async ({ stagehand, data }) => {
+        const page = data.frameId
+          ? stagehand.context.resolvePageByMainFrameId(data.frameId)
+          : await stagehand.context.awaitActivePage();
+
+        if (!page) {
+          throw new AppError("Page not found", StatusCodes.NOT_FOUND);
+        }
+
+        const result = await page.goto(data.url, data.options);
+
+        return { result };
+      },
+      operation: "navigate",
+    });
+  },
+);
+
+const navigateRoute: RouteOptions = {
+  method: "POST",
+  url: "/sessions/:id/navigate",
+  schema: {
+    ...Api.Operations.SessionNavigate,
+    headers: Api.SessionHeadersSchema,
+    params: Api.SessionIdParamsSchema,
+    body: Api.NavigateRequestSchema,
+    response: {
+      200: Api.NavigateResponseSchema,
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: navigateRouteHandler,
+};
+
+export default navigateRoute;
diff --git a/packages/server-v4/src/routes/v4/sessions/_id/observe.ts b/packages/server-v4/src/routes/v4/sessions/_id/observe.ts
new file mode 100644
index 000000000..84fd0a3ec
--- /dev/null
+++ b/packages/server-v4/src/routes/v4/sessions/_id/observe.ts
@@ -0,0 +1,98 @@
+import type { RouteHandlerMethod, RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import type { Action } from "@browserbasehq/stagehand";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+import { Api } from "@browserbasehq/stagehand";
+
+import { authMiddleware } from "../../../../lib/auth.js";
+import { AppError, withErrorHandling } from "../../../../lib/errorHandler.js";
+import { createStreamingResponse } from "../../../../lib/stream.js";
+import { getSessionStore } from "../../../../lib/sessionStoreManager.js";
+
+const observeRouteHandler: RouteHandlerMethod = withErrorHandling(
+  async (request, reply) => {
+    if (!(await authMiddleware(request))) {
+      return reply
+        .status(StatusCodes.UNAUTHORIZED)
+        .send({ error: "Unauthorized" });
+    }
+
+    const { id } = request.params as Api.SessionIdParams;
+
+    if (!id.length) {
+      return reply.status(StatusCodes.BAD_REQUEST).send({
+        message: "Missing session id",
+      });
+    }
+
+    const sessionStore = getSessionStore();
+    const hasSession = await sessionStore.hasSession(id);
+    if (!hasSession) {
+      return reply.status(StatusCodes.NOT_FOUND).send({
+        message: "Session not found",
+      });
+    }
+
+    return createStreamingResponse<Api.ObserveRequest>({
+      sessionId: id,
+      request,
+      reply,
+      schema: Api.ObserveRequestSchema,
+      handler: async ({ stagehand, data }) => {
+        const { frameId } = data;
+        const page = frameId
+          ? stagehand.context.resolvePageByMainFrameId(frameId)
+          : await stagehand.context.awaitActivePage();
+
+        if (!page) {
+          throw new AppError(
+            "Page not found",
+            StatusCodes.INTERNAL_SERVER_ERROR,
+          );
+        }
+
+        const safeOptions = {
+          ...data.options,
+          model:
+            typeof data.options?.model === "string"
+              ? { modelName: data.options.model }
+              : data.options?.model
+                ? {
+                    ...data.options.model,
+                    modelName: data.options.model.modelName ?? "gpt-4o",
+                  }
+                : undefined,
+          page,
+        };
+
+        let result: Action[];
+
+        if (data.instruction) {
+          result = await stagehand.observe(data.instruction, safeOptions);
+        } else {
+          result = await stagehand.observe(safeOptions);
+        }
+
+        return { result };
+      },
+      operation: "observe",
+    });
+  },
+);
+
+const observeRoute: RouteOptions = {
+  method: "POST",
+  url: "/sessions/:id/observe",
+  schema: {
+    ...Api.Operations.SessionObserve,
+    headers: Api.SessionHeadersSchema,
+    params: Api.SessionIdParamsSchema,
+    body: Api.ObserveRequestSchema,
+    response: {
+      200: Api.ObserveResponseSchema,
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: observeRouteHandler,
+};
+
+export default observeRoute;
diff --git a/packages/server-v4/src/routes/v4/sessions/_id/replay.ts b/packages/server-v4/src/routes/v4/sessions/_id/replay.ts
new file mode 100644
index 000000000..bf5318f7e
--- /dev/null
+++ b/packages/server-v4/src/routes/v4/sessions/_id/replay.ts
@@ -0,0 +1,40 @@
+import type { RouteHandlerMethod, RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import type { FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+import { Api } from "@browserbasehq/stagehand";
+
+import { authMiddleware } from "../../../../lib/auth.js";
+import { withErrorHandling } from "../../../../lib/errorHandler.js";
+import { error, success } from "../../../../lib/response.js";
+
+const replayRouteHandler: RouteHandlerMethod = withErrorHandling(
+  async (request, reply) => {
+    if (!(await authMiddleware(request))) {
+      return error(reply, "Unauthorized", StatusCodes.UNAUTHORIZED);
+    }
+
+    reply.log.warn("Replay endpoint not implemented for local server.");
+
+    const replay: Api.ReplayResult = {
+      pages: [],
+    };
+
+    return success(reply, replay);
+  },
+);
+
+const replayRoute: RouteOptions = {
+  method: "GET",
+  url: "/sessions/:id/replay",
+  schema: {
+    ...Api.Operations.SessionReplay,
+    headers: Api.SessionHeadersSchema,
+    params: Api.SessionIdParamsSchema,
+    response: {
+      200: Api.ReplayResponseSchema,
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: replayRouteHandler,
+};
+
+export default replayRoute;
diff --git a/packages/server-v4/src/routes/v4/sessions/start.ts b/packages/server-v4/src/routes/v4/sessions/start.ts
new file mode 100644
index 000000000..2019af456
--- /dev/null
+++ b/packages/server-v4/src/routes/v4/sessions/start.ts
@@ -0,0 +1,258 @@
+import type { RouteHandler, RouteOptions } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import Browserbase from "@browserbasehq/sdk";
+import { Api } from "@browserbasehq/stagehand";
+import type { SessionRetrieveResponse } from "@browserbasehq/sdk/resources/sessions/sessions";
+import { type FastifyZodOpenApiSchema } from "fastify-zod-openapi";
+import { z } from "zod/v4";
+
+import { authMiddleware } from "../../../lib/auth.js";
+import { withErrorHandling } from "../../../lib/errorHandler.js";
+import { getModelApiKey, getOptionalHeader } from "../../../lib/header.js";
+import { error, success } from "../../../lib/response.js";
+import { getSessionStore } from "../../../lib/sessionStoreManager.js";
+import { AISDK_PROVIDERS } from "../../../types/model.js";
+
+// Extended schema with custom refinement for local browser validation
+const startBodySchema = z
+  .preprocess((value) => {
+    if (!value || typeof value !== "object") {
+      return value;
+    }
+    const record = value as Record<string, unknown>;
+    if (
+      typeof record.verbose === "string" &&
+      ["0", "1", "2"].includes(record.verbose)
+    ) {
+      return { ...record, verbose: Number(record.verbose) };
+    }
+    return value;
+  }, Api.SessionStartRequestSchema)
+  .superRefine((value, ctx) => {
+    if (value.browser?.type === "local") {
+      const hasConnect = Boolean(value.browser.cdpUrl);
+      const hasLaunch = Boolean(value.browser.launchOptions);
+      if (!hasConnect && !hasLaunch) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["browser"],
+          message:
+            "When browser.type is 'local', provide either browser.cdpUrl or browser.launchOptions.",
+        });
+      }
+    }
+  });
+
+const startRouteHandler: RouteHandler = withErrorHandling(
+  async (request, reply) => {
+    if (!(await authMiddleware(request))) {
+      return error(reply, "Unauthorized", StatusCodes.UNAUTHORIZED);
+    }
+
+    const sdkVersion = getOptionalHeader(request, "x-sdk-version");
+
+    const clientLanguage = request.headers["x-language"] as string | undefined;
+    if (
+      clientLanguage &&
+      !["typescript", "python", "playground"].includes(clientLanguage)
+    ) {
+      return error(
+        reply,
+        "Invalid client language header",
+        StatusCodes.BAD_REQUEST,
+      );
+    }
+
+    // Use the validated request body directly - fields come from Api.SessionStartRequestSchema
+    const body = request.body as Api.SessionStartRequest;
+    const {
+      modelName,
+      domSettleTimeoutMs,
+      verbose,
+      systemPrompt,
+      browserbaseSessionCreateParams,
+      selfHeal,
+      waitForCaptchaSolves,
+      browserbaseSessionID,
+      experimental,
+      browser,
+    } = body;
+    if (!modelName) {
+      return error(reply, "Missing required model name");
+    }
+
+    // TODO: Remove this after complete AISDK migration. Validation should be done stagehand-side
+    if (modelName.includes("/")) {
+      const [providerName] = modelName.split("/", 1);
+      if (!providerName) {
+        return error(
+          reply,
+          `Invalid model: ${modelName}`,
+          StatusCodes.BAD_REQUEST,
+        );
+      }
+      if (!(AISDK_PROVIDERS as readonly string[]).includes(providerName)) {
+        return error(
+          reply,
+          `Invalid provider: ${providerName}`,
+          StatusCodes.BAD_REQUEST,
+        );
+      }
+    }
+
+    const browserType = browser?.type ?? "browserbase";
+
+    let bbApiKey: string | undefined;
+    let bbProjectId: string | undefined;
+    let browserbaseSessionId: string | undefined;
+    let connectUrl: string | undefined;
+
+    if (browserType === "browserbase") {
+      bbApiKey = getOptionalHeader(request, "x-bb-api-key");
+      bbProjectId = getOptionalHeader(request, "x-bb-project-id");
+
+      if (!bbApiKey) {
+        return error(
+          reply,
+          "Missing required headers for browserbase sessions",
+        );
+      }
+
+      const bb = new Browserbase({ apiKey: bbApiKey });
+
+      if (browserbaseSessionID) {
+        const existing = await bb.sessions.retrieve(browserbaseSessionID);
+        browserbaseSessionId = existing?.id;
+        connectUrl = existing?.connectUrl;
+        if (!browserbaseSessionId) {
+          return error(reply, "Failed to retrieve browserbase session");
+        }
+        if (!connectUrl) {
+          return error(reply, "Browserbase session missing connectUrl");
+        }
+      } else {
+        const resolvedProjectId =
+          browserbaseSessionCreateParams?.projectId ?? bbProjectId;
+        const createPayload = {
+          ...(resolvedProjectId ? { projectId: resolvedProjectId } : {}),
+          ...browserbaseSessionCreateParams,
+          browserSettings: {
+            ...(browserbaseSessionCreateParams?.browserSettings ?? {}),
+            viewport: browserbaseSessionCreateParams?.browserSettings
+              ?.viewport ?? {
+              width: 1288,
+              height: 711,
+            },
+          },
+          userMetadata: {
+            ...(browserbaseSessionCreateParams?.userMetadata ?? {}),
+            stagehand: "true",
+          },
+        } satisfies Browserbase.Sessions.SessionCreateParams;
+
+        const created = (await bb.sessions.create(
+          createPayload,
+        )) as SessionRetrieveResponse;
+
+        browserbaseSessionId = created?.id;
+        connectUrl = created?.connectUrl;
+        if (!browserbaseSessionId) {
+          return error(reply, "Failed to create browserbase session");
+        }
+        if (!connectUrl) {
+          return error(reply, "Browserbase session missing connectUrl");
+        }
+      }
+    }
+
+    const sessionStore = getSessionStore();
+
+    // For local browsers without a connectUrl, get it from browser.connectUrl
+    if (browserType === "local") {
+      connectUrl = browser?.cdpUrl;
+    }
+
+    const session = await sessionStore.startSession({
+      browserType,
+      connectUrl,
+      browserbaseSessionID:
+        browserType === "browserbase"
+          ? (browserbaseSessionId ?? browserbaseSessionID)
+          : undefined,
+      browserbaseApiKey: bbApiKey,
+      browserbaseProjectId: bbProjectId,
+      modelName,
+      domSettleTimeoutMs,
+      verbose,
+      systemPrompt,
+      browserbaseSessionCreateParams,
+      selfHeal,
+      waitForCaptchaSolves,
+      clientLanguage,
+      sdkVersion,
+      experimental,
+      localBrowserLaunchOptions:
+        browserType === "local" && (browser?.launchOptions || browser?.cdpUrl)
+          ? {
+              cdpUrl: browser?.cdpUrl,
+              ...(browser?.launchOptions ?? {}),
+            }
+          : undefined,
+    });
+
+    // For local browsers with launchOptions (no explicit cdpUrl), eagerly
+    // initialize the browser so we can return the actual CDP URL
+    let finalCdpUrl = connectUrl ?? session.cdpUrl ?? "";
+    if (browserType === "local" && browser?.launchOptions && !browser?.cdpUrl) {
+      const modelApiKey = getModelApiKey(request);
+      try {
+        const stagehand = await sessionStore.getOrCreateStagehand(
+          session.sessionId,
+          { modelApiKey },
+        );
+        finalCdpUrl = stagehand.connectURL();
+      } catch (err) {
+        request.log.error(
+          {
+            err,
+            sessionId: session.sessionId,
+            browserType,
+            chromePathEnv: process.env.CHROME_PATH,
+            launchOptions: {
+              executablePath: browser.launchOptions.executablePath,
+              argsCount: browser.launchOptions.args?.length ?? 0,
+              headless: browser.launchOptions.headless,
+              hasUserDataDir: Boolean(browser.launchOptions.userDataDir),
+              port: browser.launchOptions.port,
+              connectTimeoutMs: browser.launchOptions.connectTimeoutMs,
+            },
+          },
+          "Failed to initialize local browser session in /v4/sessions/start",
+        );
+        throw err;
+      }
+    }
+
+    return success(reply, {
+      sessionId: session.sessionId,
+      available: session.available,
+      cdpUrl: finalCdpUrl,
+    });
+  },
+);
+
+const startRoute: RouteOptions = {
+  method: "POST",
+  url: "/sessions/start",
+  schema: {
+    ...Api.Operations.SessionStart,
+    headers: Api.SessionHeadersSchema,
+    body: startBodySchema,
+    response: {
+      200: Api.SessionStartResponseSchema,
+    },
+  } satisfies FastifyZodOpenApiSchema,
+  handler: startRouteHandler,
+};
+
+export default startRoute;
diff --git a/packages/server-v4/src/sea-entry.ts b/packages/server-v4/src/sea-entry.ts
new file mode 100644
index 000000000..27ccaedf8
--- /dev/null
+++ b/packages/server-v4/src/sea-entry.ts
@@ -0,0 +1,13 @@
+import { __internalMaybeRunShutdownSupervisorFromArgv } from "@browserbasehq/stagehand";
+
+// if SEA binary is launched with --supervisor, it will run the shutdown supervisor only
+const argv = process.argv.slice(1);
+const normalizedArgv = argv[0]?.startsWith("--") ? argv : argv.slice(1);
+
+// otherwise, start the stagehand/server
+if (!__internalMaybeRunShutdownSupervisorFromArgv(normalizedArgv)) {
+  void import("./server.js").catch((err) => {
+    console.error("Failed to start server:", err);
+    process.exit(1);
+  });
+}
diff --git a/packages/server-v4/src/server.ts b/packages/server-v4/src/server.ts
new file mode 100644
index 000000000..59f421804
--- /dev/null
+++ b/packages/server-v4/src/server.ts
@@ -0,0 +1,278 @@
+import { randomUUID } from "crypto";
+
+import cors from "@fastify/cors";
+import fastify from "fastify";
+import metricsPlugin from "fastify-metrics";
+import fastifySwagger from "@fastify/swagger";
+import fastifySwaggerUI from "@fastify/swagger-ui";
+import {
+  fastifyZodOpenApiPlugin,
+  fastifyZodOpenApiTransformers,
+  serializerCompiler,
+  validatorCompiler,
+  type FastifyZodOpenApiTypeProvider,
+  RequestValidationError,
+  ResponseSerializationError,
+} from "fastify-zod-openapi";
+import { StatusCodes } from "http-status-codes";
+
+import { logging } from "./lib/logging/index.js";
+import {
+  destroySessionStore,
+  initializeSessionStore,
+} from "./lib/sessionStoreManager.js";
+import healthcheckRoute from "./routes/healthcheck.js";
+import readinessRoute, { setReady, setUnready } from "./routes/readiness.js";
+import actRoute from "./routes/v4/sessions/_id/act.js";
+import agentExecuteRoute from "./routes/v4/sessions/_id/agentExecute.js";
+import endRoute from "./routes/v4/sessions/_id/end.js";
+import extractRoute from "./routes/v4/sessions/_id/extract.js";
+import navigateRoute from "./routes/v4/sessions/_id/navigate.js";
+import observeRoute from "./routes/v4/sessions/_id/observe.js";
+import replayRoute from "./routes/v4/sessions/_id/replay.js";
+import startRoute from "./routes/v4/sessions/start.js";
+
+// Constants for graceful shutdown
+const READY_WAIT_PERIOD = 10_000; // 10 seconds
+const GRACEFUL_SHUTDOWN_PERIOD = 30_000; // 30 seconds
+
+const usePrettyLogs = process.env.NODE_ENV === "development" && !process.env.CI;
+
+const app = fastify({
+  disableRequestLogging: true,
+
+  genReqId: () => {
+    return randomUUID();
+  },
+
+  logger: {
+    formatters: {
+      level(label: string) {
+        return { level: label };
+      },
+    },
+
+    level: process.env.NODE_ENV === "production" ? "info" : "trace",
+
+    ...(usePrettyLogs && {
+      transport: {
+        options: {
+          colorize: true,
+          ignore: "pid,hostname",
+        },
+        target: "pino-pretty",
+      },
+    }),
+  },
+
+  return503OnClosing: false,
+});
+
+export const logger = app.log;
+
+// Allow requests with `Content-Type: application/json` and an empty body (0 bytes).
+// Some clients always send the header even when there is no request body (e.g. /end).
+const defaultJsonParser = app.getDefaultJsonParser("error", "error");
+app.addContentTypeParser<string>(
+  "application/json",
+  { parseAs: "string" },
+  (request, body, done) => {
+    if (body === "" || (Buffer.isBuffer(body) && body.length === 0)) {
+      done(null, {});
+      return;
+    }
+
+    void defaultJsonParser(request, body, done);
+  },
+);
+
+process.on("uncaughtException", (error) => {
+  app.log.error(error, "Uncaught Exception:");
+});
+
+process.on("unhandledRejection", (reason, promise) => {
+  app.log.error(
+    reason instanceof Error ? reason : new Error(String(reason)),
+    "Unhandled Rejection at:",
+    promise,
+    "reason:",
+    reason,
+  );
+});
+
+// Graceful shutdown handler
+const gracefulShutdown = async () => {
+  app.log.info("gracefulShutdown");
+
+  setUnready();
+
+  await new Promise((resolve) => setTimeout(resolve, READY_WAIT_PERIOD));
+
+  const timeout = setTimeout(() => {
+    app.log.warn("forcefully shutting down after 30 seconds");
+    process.exit(1);
+  }, GRACEFUL_SHUTDOWN_PERIOD);
+
+  timeout.unref();
+
+  await app.close();
+  await destroySessionStore();
+  clearTimeout(timeout);
+
+  app.log.info("gracefulShutdown complete");
+  process.exit(0);
+};
+
+// Handle termination signals
+process.on("SIGTERM", () => {
+  gracefulShutdown().catch((err: unknown) => {
+    app.log.error(err, "error gracefully shutting down");
+  });
+});
+
+process.on("SIGINT", () => {
+  gracefulShutdown().catch((err: unknown) => {
+    app.log.error(err, "error gracefully shutting down");
+  });
+});
+
+const start = async () => {
+  try {
+    if (process.env.NODE_ENV === "development") {
+      await app.register(cors, {
+        origin: ["http://localhost:3000"],
+        methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+        allowedHeaders: ["*"],
+        credentials: true,
+      });
+    }
+
+    app.setValidatorCompiler(validatorCompiler);
+    app.setSerializerCompiler(serializerCompiler);
+
+    await app.register(fastifyZodOpenApiPlugin);
+
+    await app.register(fastifySwagger, {
+      openapi: {
+        info: {
+          title: "Stagehand API",
+          version: "3.0.5",
+        },
+        openapi: "3.1.0",
+      },
+      ...fastifyZodOpenApiTransformers,
+    });
+
+    // Only register Swagger UI in development - SEA binaries can't load static files
+    if (process.env.NODE_ENV === "development") {
+      await app.register(fastifySwaggerUI, {
+        routePrefix: "/documentation",
+      });
+    }
+
+    app.setSchemaErrorFormatter(function (errors, dataVar) {
+      const zodIssues = errors
+        .filter((err) => err instanceof RequestValidationError)
+        .map((err) => err.params.issue);
+      this.log.warn({ dataVar, zodIssues }, "request validation failed");
+      return new Error(`${dataVar} validation failed`);
+    });
+
+    app.setErrorHandler((error, request, reply) => {
+      if ((error as { validation?: unknown }).validation) {
+        const zodIssues = (error as { validation: unknown[] }).validation
+          .filter((err) => err instanceof RequestValidationError)
+          .map((err) => (err as RequestValidationError).params.issue);
+
+        request.log.warn({ zodIssues }, "request validation failed");
+        return reply.status(StatusCodes.BAD_REQUEST).send({
+          error: "Request validation failed",
+          issues: zodIssues,
+        });
+      }
+
+      if (error instanceof ResponseSerializationError) {
+        request.log.error({ err: error }, "response serialization failed");
+        return reply
+          .status(StatusCodes.INTERNAL_SERVER_ERROR)
+          .send({ error: "Response validation failed" });
+      }
+
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      request.log.error(`Server error: ${errorMessage}`);
+
+      const statusCode =
+        (error as { statusCode?: number }).statusCode ??
+        StatusCodes.INTERNAL_SERVER_ERROR;
+
+      reply.status(statusCode).send({
+        error:
+          statusCode === Number(StatusCodes.INTERNAL_SERVER_ERROR)
+            ? "Internal Server Error"
+            : errorMessage,
+        statusCode,
+      });
+    });
+
+    await app.register(metricsPlugin, {
+      defaultMetrics: {
+        enabled: true,
+        prefix: "stagehand_api_",
+      },
+      routeMetrics: {
+        overrides: {
+          histogram: {
+            name: "stagehand_api_http_request_duration_seconds",
+          },
+          summary: {
+            name: "stagehand_api_http_request_summary_seconds",
+          },
+        },
+      },
+    });
+
+    initializeSessionStore();
+
+    const appWithTypes = app.withTypeProvider<FastifyZodOpenApiTypeProvider>();
+
+    await appWithTypes.register(
+      (instance, _opts, done) => {
+        instance.route(actRoute);
+        instance.route(endRoute);
+        instance.route(extractRoute);
+        instance.route(navigateRoute);
+        instance.route(observeRoute);
+        instance.route(replayRoute);
+        instance.route(startRoute);
+        instance.route(agentExecuteRoute);
+        done();
+      },
+      { prefix: "/v4" },
+    );
+
+    logging(app);
+
+    // Register health and readiness routes at the root level
+    appWithTypes.route(healthcheckRoute);
+    appWithTypes.route(readinessRoute);
+    await app.ready();
+
+    await app.listen({
+      host: "0.0.0.0",
+      port: parseInt(process.env.PORT ?? "3000", 10),
+    });
+    console.log("Routes registered:", app.printRoutes());
+
+    // Mark the server as ready after it's started
+    setReady();
+  } catch (err) {
+    console.error("Failed to start server:", err);
+    process.exit(1);
+  }
+};
+
+start().catch((err: unknown) => {
+  console.error("Failed to start server:", err);
+  process.exit(1);
+});
diff --git a/packages/server-v4/src/types/error.ts b/packages/server-v4/src/types/error.ts
new file mode 100644
index 000000000..a970f9651
--- /dev/null
+++ b/packages/server-v4/src/types/error.ts
@@ -0,0 +1,101 @@
+import { StatusCodes } from "http-status-codes";
+
+import { AppError } from "../lib/errorHandler.js";
+
+export class UnknownModelError extends AppError {
+  constructor(model: string) {
+    super(`Unknown model: ${model}`, StatusCodes.BAD_REQUEST);
+  }
+}
+export class InvalidProviderError extends AppError {
+  constructor(provider: string) {
+    super(`Invalid provider: ${provider}`, StatusCodes.BAD_REQUEST);
+  }
+}
+
+export class InvalidModelError extends AppError {
+  constructor(model: string) {
+    super(`Invalid model: ${model}`, StatusCodes.BAD_REQUEST);
+  }
+}
+
+export class UnauthorizedError extends AppError {
+  constructor() {
+    super("Unauthorized", StatusCodes.UNAUTHORIZED);
+  }
+}
+
+export class MissingHeaderError extends AppError {
+  constructor(header: string) {
+    super(`Missing required header: ${header}`, StatusCodes.BAD_REQUEST);
+  }
+}
+
+export class InvalidAPIKeyError extends AppError {
+  constructor(provider: string) {
+    super(`Invalid API key for provider: ${provider}`, StatusCodes.BAD_REQUEST);
+  }
+}
+
+export class AttemptedCloseOnNonActiveSessionError extends AppError {
+  constructor() {
+    super(
+      "Attempted to close session that is not currently active",
+      StatusCodes.CONFLICT,
+    );
+  }
+}
+
+interface BrowserbaseError {
+  status?: number;
+  statusCode?: number;
+  message?: string;
+  response?: {
+    status?: number;
+    data?: {
+      message?: string;
+    };
+  };
+}
+
+export class BrowserbaseSDKError extends AppError {
+  constructor(error: unknown, defaultMessage: string) {
+    const browserbaseError = error as BrowserbaseError;
+    const {
+      message: errMessage,
+      status,
+      statusCode: errStatusCode,
+      response,
+    } = browserbaseError;
+
+    let message = defaultMessage;
+    let finalStatusCode = StatusCodes.BAD_REQUEST;
+
+    // Extract message from error
+    if (errMessage) {
+      message = errMessage;
+    } else if (response?.data?.message) {
+      ({ message } = response.data);
+    }
+
+    // Extract status code from error
+    if (status && typeof status === "number") {
+      finalStatusCode = status as StatusCodes;
+    } else if (errStatusCode && typeof errStatusCode === "number") {
+      finalStatusCode = errStatusCode as StatusCodes;
+    } else if (response?.status && typeof response.status === "number") {
+      finalStatusCode = response.status as StatusCodes;
+    }
+
+    // Check for specific session error
+    if (message.includes("is not running")) {
+      throw new AttemptedCloseOnNonActiveSessionError();
+    }
+
+    // Mark 5xx errors as internal to sanitize sensitive details
+    const isInternal =
+      Number(finalStatusCode) >= Number(StatusCodes.INTERNAL_SERVER_ERROR);
+
+    super(message, finalStatusCode, isInternal);
+  }
+}
diff --git a/packages/server-v4/src/types/fastify.d.ts b/packages/server-v4/src/types/fastify.d.ts
new file mode 100644
index 000000000..0fe0694eb
--- /dev/null
+++ b/packages/server-v4/src/types/fastify.d.ts
@@ -0,0 +1,9 @@
+import "fastify";
+
+declare module "fastify" {
+  interface FastifyRequest {
+    metrics: {
+      startTime: number;
+    };
+  }
+}
diff --git a/packages/server-v4/src/types/model.ts b/packages/server-v4/src/types/model.ts
new file mode 100644
index 000000000..491b699b6
--- /dev/null
+++ b/packages/server-v4/src/types/model.ts
@@ -0,0 +1,40 @@
+export const AISDK_PROVIDERS = [
+  "openai",
+  "anthropic",
+  "google",
+  "xai",
+  "azure",
+  "groq",
+  "cerebras",
+  "togetherai",
+  "mistral",
+  "deepseek",
+  "perplexity",
+  "ollama",
+  "vertex",
+  "bedrock",
+] as const;
+export type AISDKProvider = (typeof AISDK_PROVIDERS)[number];
+
+export type LegacyModel =
+  | "gpt-4o"
+  | "gpt-4o-mini"
+  | "gpt-4o-2024-08-06"
+  | "gpt-4o-2024-05-13"
+  | "cerebras-llama-3.3-70b"
+  | "cerebras-llama-3.1-8b"
+  | "o1-mini"
+  | "o1-preview"
+  | "o3-mini"
+  | "gpt-4.5-preview"
+  | "groq-llama-3.3-70b-specdec"
+  | "groq-llama-3.3-70b-versatile"
+  | "gemini-1.5-flash"
+  | "gemini-1.5-pro"
+  | "gemini-1.5-flash-8b"
+  | "gemini-2.0-flash-lite"
+  | "gemini-2.0-flash"
+  | "gemini-2.5-pro-preview-03-25"
+  | "gemini-2.5-flash-preview-04-17";
+
+export type LegacyProvider = "openai" | "anthropic" | "google";
diff --git a/packages/server-v4/src/types/rrweb.ts b/packages/server-v4/src/types/rrweb.ts
new file mode 100644
index 000000000..e2aaf9828
--- /dev/null
+++ b/packages/server-v4/src/types/rrweb.ts
@@ -0,0 +1,21 @@
+export interface Node {
+  type: string;
+  tagName?: string;
+  attributes?: Record<string, string>;
+  childNodes?: Node[];
+  textContent?: string;
+  id: number;
+}
+
+export interface Event {
+  type: number;
+  /*
+  The data object is different for each event type
+  but we're only accessing it when the data follows
+  this structure, so we can just type this way.
+  */
+  data: { node: Node };
+  sessionId?: string;
+  timestamp: Date;
+  actionId: string;
+}
diff --git a/packages/server-v4/test/integration/api-server-cache.test.ts b/packages/server-v4/test/integration/api-server-cache.test.ts
new file mode 100644
index 000000000..ec886a5e7
--- /dev/null
+++ b/packages/server-v4/test/integration/api-server-cache.test.ts
@@ -0,0 +1,123 @@
+import assert from "node:assert/strict";
+import { after, before, describe, it } from "node:test";
+
+import {
+  assertFetchOk,
+  assertFetchStatus,
+  createSession,
+  endSession,
+  fetchWithContext,
+  getBaseUrl,
+  getHeaders,
+  HTTP_OK,
+  navigateSession,
+} from "./utils.js";
+
+// Shared read-only session — extract is safe to re-use across tests.
+let sessionId: string;
+
+before(async () => {
+  sessionId = await createSession(getHeaders("3.0.0"));
+  const nav = await navigateSession(
+    sessionId,
+    "https://example.com",
+    getHeaders("3.0.0"),
+  );
+  assert.equal(nav.status, HTTP_OK, "Navigate should succeed");
+});
+
+after(async () => {
+  await endSession(sessionId, getHeaders("3.0.0"));
+});
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function extractUrl() {
+  return `${getBaseUrl()}/v4/sessions/${sessionId}/extract`;
+}
+
+function extractBody(instruction = "extract the page title") {
+  return JSON.stringify({ instruction });
+}
+
+// ---------------------------------------------------------------------------
+// browserbase-cache-bypass request header
+// ---------------------------------------------------------------------------
+
+describe("browserbase-cache-bypass request header", () => {
+  it("request with bypass header does not return cache HIT", async () => {
+    const ctx = await fetchWithContext(extractUrl(), {
+      method: "POST",
+      headers: {
+        ...getHeaders("3.0.0"),
+        "browserbase-cache-bypass": "true",
+      },
+      body: extractBody(),
+    });
+
+    assertFetchStatus(ctx, HTTP_OK, "Extract with bypass should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+
+    const cacheStatus = ctx.headers.get("browserbase-cache-status");
+    assert.notEqual(
+      cacheStatus,
+      "HIT",
+      "A bypassed request must not return a cache HIT",
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// browserbase-cache-status response header
+// ---------------------------------------------------------------------------
+
+describe("browserbase-cache-status response header", () => {
+  it("returns HIT or MISS when the header is present", async () => {
+    const ctx = await fetchWithContext(extractUrl(), {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: extractBody(),
+    });
+
+    assertFetchStatus(ctx, HTTP_OK, "Extract should succeed");
+
+    const cacheStatus = ctx.headers.get("browserbase-cache-status");
+    if (cacheStatus !== null) {
+      assert.ok(
+        cacheStatus === "HIT" || cacheStatus === "MISS",
+        `browserbase-cache-status must be HIT or MISS, got: ${cacheStatus}`,
+      );
+    }
+  });
+
+  it("returns HIT on a repeated identical request when caching is active", async () => {
+    const body = extractBody("count the number of links");
+
+    // First call — warms the cache.
+    const first = await fetchWithContext(extractUrl(), {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body,
+    });
+    assertFetchStatus(first, HTTP_OK, "First extract should succeed");
+
+    // Second call — should be a HIT if server-side caching is enabled.
+    const second = await fetchWithContext(extractUrl(), {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body,
+    });
+    assertFetchStatus(second, HTTP_OK, "Second extract should succeed");
+
+    const cacheStatus = second.headers.get("browserbase-cache-status");
+    if (cacheStatus !== null) {
+      assert.equal(
+        cacheStatus,
+        "HIT",
+        "Repeated identical request should be a cache HIT",
+      );
+    }
+  });
+});
diff --git a/packages/server-v4/test/integration/utils.ts b/packages/server-v4/test/integration/utils.ts
new file mode 100644
index 000000000..c3899a083
--- /dev/null
+++ b/packages/server-v4/test/integration/utils.ts
@@ -0,0 +1,690 @@
+import fs from "node:fs";
+import path from "node:path";
+import { chromium } from "playwright";
+
+// =============================================================================
+// HTTP Status Codes
+// =============================================================================
+
+export const HTTP_OK = 200;
+export const HTTP_BAD_REQUEST = 400;
+export const HTTP_NOT_FOUND = 404;
+export const HTTP_GONE = 410;
+export const HTTP_UNPROCESSABLE_ENTITY = 422;
+export const HTTP_INTERNAL_SERVER_ERROR = 500;
+
+// =============================================================================
+// Timing Constants
+// =============================================================================
+
+export const SESSION_CLOSE_WAIT_MS = 2000;
+
+// =============================================================================
+// Environment Variables
+// =============================================================================
+
+export const {
+  STAGEHAND_API_URL,
+  OPENAI_API_KEY,
+  GEMINI_API_KEY,
+  ANTHROPIC_API_KEY,
+} = process.env;
+
+// =============================================================================
+// Utility Functions
+// =============================================================================
+
+export function requireEnv(name: string, value: string | undefined): string {
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
+}
+
+export function getBaseUrl(): string {
+  return STAGEHAND_API_URL ?? "http://127.0.0.1:3107";
+}
+
+// =============================================================================
+// Header Generators
+// =============================================================================
+
+export function getHeaders(
+  sdkVersion: string,
+  language: string = "typescript",
+): Record<string, string> {
+  return {
+    "Content-Type": "application/json",
+    "x-model-api-key": requireEnv("OPENAI_API_KEY", OPENAI_API_KEY),
+    "x-language": language,
+    "x-sdk-version": sdkVersion,
+  };
+}
+
+// =============================================================================
+// Session Management
+// =============================================================================
+
+export interface StartSessionResponse {
+  success: boolean;
+  message?: string;
+  data?: {
+    sessionId: string;
+    cdpUrl: string;
+    available: boolean;
+  };
+}
+
+const SESSION_READY_DELAY_MS = 250;
+const LOCAL_CONNECT_TIMEOUT_MS = (() => {
+  const parsed = Number(process.env.STAGEHAND_TEST_LOCAL_CONNECT_TIMEOUT_MS);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 60_000;
+})();
+
+export interface SessionInfo {
+  sessionId: string;
+  cdpUrl: string;
+}
+
+function createLocalBrowserBody() {
+  const resolveChromePath = (): string => {
+    const explicit = process.env.CHROME_PATH;
+    if (explicit && fs.existsSync(explicit)) {
+      return explicit;
+    }
+    if (explicit) {
+      throw new Error(`CHROME_PATH does not exist: ${explicit}`);
+    }
+
+    const playwrightPath = chromium.executablePath();
+    if (playwrightPath && fs.existsSync(playwrightPath)) {
+      return playwrightPath;
+    }
+
+    throw new Error(
+      "Unable to locate a Chrome executable. Set CHROME_PATH in the test environment.",
+    );
+  };
+
+  return {
+    browser: {
+      type: "local",
+      launchOptions: {
+        headless: true,
+        executablePath: resolveChromePath(),
+        args: process.env.CI ? ["--no-sandbox"] : undefined,
+        connectTimeoutMs: LOCAL_CONNECT_TIMEOUT_MS,
+      },
+    },
+  };
+}
+
+export const LOCAL_BROWSER_BODY = createLocalBrowserBody();
+
+function readLaunchDiagnostics(launchOptions?: {
+  executablePath?: string;
+  args?: string[];
+  headless?: boolean;
+  userDataDir?: string;
+  port?: number;
+  connectTimeoutMs?: number;
+}): string {
+  const diagnostics: string[] = [];
+  const userDataDir = launchOptions?.userDataDir;
+  diagnostics.push("--- launch diagnostics ---");
+  diagnostics.push(`CHROME_PATH env: ${process.env.CHROME_PATH ?? "<unset>"}`);
+  diagnostics.push(`CI env: ${process.env.CI ?? "<unset>"}`);
+  diagnostics.push(`userDataDir: ${userDataDir ?? "<auto>"}`);
+  if (!userDataDir) {
+    diagnostics.push(
+      "chrome stdout/stderr logs unavailable (profile dir auto-managed by server launch)",
+    );
+  } else {
+    diagnostics.push(`userDataDir exists: ${fs.existsSync(userDataDir)}`);
+    if (fs.existsSync(userDataDir)) {
+      const outPath = path.join(userDataDir, "chrome-out.log");
+      const errPath = path.join(userDataDir, "chrome-err.log");
+      if (fs.existsSync(outPath)) {
+        diagnostics.push(
+          `--- chrome stdout ---\n${fs.readFileSync(outPath, "utf8")}`,
+        );
+      }
+      if (fs.existsSync(errPath)) {
+        diagnostics.push(
+          `--- chrome stderr ---\n${fs.readFileSync(errPath, "utf8")}`,
+        );
+      }
+    }
+  }
+  if (launchOptions) {
+    diagnostics.push(
+      `launch.executablePath: ${launchOptions.executablePath ?? "<unset>"}`,
+    );
+    diagnostics.push(
+      `launch.executablePath exists: ${
+        launchOptions.executablePath
+          ? fs.existsSync(launchOptions.executablePath)
+          : false
+      }`,
+    );
+    diagnostics.push(`launch.headless: ${String(launchOptions.headless)}`);
+    diagnostics.push(
+      `launch.args: ${JSON.stringify(launchOptions.args ?? [])}`,
+    );
+    diagnostics.push(`launch.port: ${launchOptions.port ?? "<auto>"}`);
+    diagnostics.push(
+      `launch.connectTimeoutMs: ${launchOptions.connectTimeoutMs ?? "<default>"}`,
+    );
+  }
+  return diagnostics.join("\n");
+}
+
+export async function createSession(
+  headers: Record<string, string>,
+): Promise<string> {
+  const info = await createSessionWithCdp(headers);
+  return info.sessionId;
+}
+
+export async function createSessionWithCdp(
+  headers: Record<string, string>,
+): Promise<SessionInfo> {
+  const url = getBaseUrl();
+  const startPayload = {
+    modelName: "gpt-4.1-nano",
+    ...createLocalBrowserBody(),
+  };
+
+  const response = await fetch(`${url}/v4/sessions/start`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(startPayload),
+  });
+
+  const responseText = await response.text();
+  let parsedBody: unknown;
+  try {
+    parsedBody = responseText ? JSON.parse(responseText) : null;
+  } catch {
+    parsedBody = responseText;
+  }
+  const body = parsedBody as StartSessionResponse;
+
+  if (!response.ok || !body?.success) {
+    const launchDiagnostics = readLaunchDiagnostics(
+      startPayload.browser?.launchOptions,
+    );
+    throw new Error(
+      `Failed to create session (status=${response.status}): ${JSON.stringify(
+        parsedBody,
+      )}\n${launchDiagnostics}`,
+    );
+  }
+  if (!body.data?.available) {
+    throw new Error(`Session not available`);
+  }
+  if (!body.data.sessionId) {
+    throw new Error("No sessionId returned");
+  }
+  if (!body.data.cdpUrl) {
+    throw new Error("No cdpUrl returned");
+  }
+
+  // Wait for session to be fully ready before returning
+  await new Promise((resolve) => setTimeout(resolve, SESSION_READY_DELAY_MS));
+
+  return {
+    sessionId: body.data.sessionId,
+    cdpUrl: body.data.cdpUrl,
+  };
+}
+
+export async function endSession(
+  sessionId: string,
+  headers: Record<string, string>,
+): Promise<void> {
+  const url = getBaseUrl();
+
+  await fetch(`${url}/v4/sessions/${sessionId}/end`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({}),
+  });
+}
+
+// =============================================================================
+// Navigation Helper
+// =============================================================================
+
+export async function navigateSession(
+  sessionId: string,
+  targetUrl: string,
+  headers: Record<string, string>,
+): Promise<Response> {
+  const url = getBaseUrl();
+
+  return fetch(`${url}/v4/sessions/${sessionId}/navigate`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ url: targetUrl, frameId: "" }),
+  });
+}
+
+/**
+ * Gets the main frame ID from a CDP session
+ */
+export async function getMainFrameId(cdpUrl: string): Promise<string> {
+  const browser = await chromium.connectOverCDP(cdpUrl);
+  try {
+    const contexts = browser.contexts();
+    if (contexts.length === 0) {
+      throw new Error("No browser contexts found");
+    }
+    const pages = contexts[0]!.pages();
+    if (pages.length === 0) {
+      throw new Error("No pages found");
+    }
+    const page = pages[0]!;
+
+    // Use CDP to get the frame tree and extract the main frame ID
+    const cdpSession = await page.context().newCDPSession(page);
+    const { frameTree } = await cdpSession.send("Page.getFrameTree");
+    await cdpSession.detach();
+
+    return frameTree.frame.id;
+  } finally {
+    await browser.close();
+  }
+}
+
+// =============================================================================
+// SSE Stream Reader
+// =============================================================================
+
+// Legacy SSE event interface (generic)
+export interface SSEEvent {
+  event?: string;
+  data?: string;
+  parsed?: unknown;
+}
+
+export async function readSSEStream(response: Response): Promise<SSEEvent[]> {
+  const reader = response.body?.getReader() as
+    | ReadableStreamDefaultReader<Uint8Array>
+    | undefined;
+  if (!reader) {
+    throw new Error("No response body reader available");
+  }
+
+  const decoder = new TextDecoder();
+  let fullResponse = "";
+
+  for (;;) {
+    const result = await reader.read();
+    if (result.done) break;
+    fullResponse += decoder.decode(result.value, { stream: true });
+  }
+
+  // Parse SSE events
+  const events: SSEEvent[] = [];
+  const rawEvents = fullResponse.split("\n\n").filter((e) => e.trim());
+
+  for (const rawEvent of rawEvents) {
+    const event: SSEEvent = {};
+    const lines = rawEvent.split("\n");
+
+    for (const line of lines) {
+      if (line.startsWith("event:")) {
+        event.event = line.slice(6).trim();
+      } else if (line.startsWith("data:")) {
+        event.data = line.slice(5).trim();
+        try {
+          event.parsed = JSON.parse(event.data);
+        } catch {
+          // Keep as string if not valid JSON
+        }
+      }
+    }
+
+    if (event.data || event.event) {
+      events.push(event);
+    }
+  }
+
+  return events;
+}
+
+// =============================================================================
+// Typed SSE Event Helpers (for stagehand-api backend format)
+// =============================================================================
+
+// Actual SSE event format from backend (see stream.ts):
+// { data: { status: "starting" | "connected" | "finished", result?: ... }, type: "system" | "log", id: "<uuid>" }
+export interface TypedSSEEvent<TResult = unknown> {
+  data: {
+    status: string;
+    result?: TResult;
+    message?: string;
+    error?: string;
+  };
+  type: string;
+  id: string;
+}
+
+/**
+ * Read SSE stream from response and return raw string
+ */
+export async function readSSEStreamRaw(response: Response): Promise<string> {
+  const reader = response.body?.getReader() as
+    | ReadableStreamDefaultReader<Uint8Array>
+    | undefined;
+  if (!reader) throw new Error("No response body reader");
+
+  const decoder = new TextDecoder();
+  let fullResponse = "";
+
+  for (;;) {
+    const result = await reader.read();
+    if (result.done) break;
+    fullResponse += decoder.decode(result.value, { stream: true });
+  }
+
+  return fullResponse;
+}
+
+/**
+ * Parse raw SSE response string into typed events
+ */
+export function parseTypedSSEEvents<TResult = unknown>(
+  rawResponse: string,
+): TypedSSEEvent<TResult>[] {
+  const events = rawResponse.split("\n\n").filter((e) => e.trim());
+  return events
+    .map((event) => {
+      const dataMatch = event.match(/data: (.+)/);
+      if (dataMatch?.[1]) {
+        return JSON.parse(dataMatch[1]) as TypedSSEEvent<TResult>;
+      }
+      return null;
+    })
+    .filter((e): e is TypedSSEEvent<TResult> => e !== null);
+}
+
+/**
+ * Result of reading an SSE stream with full context for debugging
+ */
+export interface SSEStreamResult<TResult = unknown> {
+  /** HTTP status code */
+  status: number;
+  /** HTTP status text */
+  statusText: string;
+  /** Raw response body */
+  raw: string;
+  /** Parsed SSE events */
+  events: TypedSSEEvent<TResult>[];
+  /** Get debug summary for error messages */
+  debugSummary(): string;
+}
+
+/**
+ * Read SSE stream and parse into typed events (legacy - no debug context)
+ */
+export async function readTypedSSEStream<TResult = unknown>(
+  response: Response,
+): Promise<TypedSSEEvent<TResult>[]> {
+  const raw = await readSSEStreamRaw(response);
+  return parseTypedSSEEvents<TResult>(raw);
+}
+
+/**
+ * Read SSE stream with full context for debugging test failures.
+ * Use this instead of readTypedSSEStream when you need better error messages.
+ */
+export async function readTypedSSEStreamWithContext<TResult = unknown>(
+  response: Response,
+): Promise<SSEStreamResult<TResult>> {
+  const status = response.status;
+  const statusText = response.statusText;
+  const raw = await readSSEStreamRaw(response);
+  const events = parseTypedSSEEvents<TResult>(raw);
+
+  return {
+    status,
+    statusText,
+    raw,
+    events,
+    debugSummary() {
+      const eventStatuses = events.map((e) => e.data.status).join(" → ");
+      const errorEvents = events.filter((e) => e.data.status === "error");
+      const errorMessages = errorEvents
+        .map((e) => e.data.error ?? "unknown error")
+        .join(", ");
+
+      let summary = `HTTP ${status} ${statusText}`;
+      if (events.length === 0) {
+        summary += `\n  No SSE events received`;
+        summary += `\n  Raw response: ${raw.slice(0, 500)}${raw.length > 500 ? "..." : ""}`;
+      } else {
+        summary += `\n  Events (${events.length}): ${eventStatuses}`;
+        if (errorMessages) {
+          summary += `\n  Errors: ${errorMessages}`;
+        }
+      }
+      return summary;
+    },
+  };
+}
+
+/**
+ * Assert with debug context - includes SSE stream info on failure
+ */
+export function assertWithContext(
+  condition: boolean,
+  message: string,
+  context: SSEStreamResult<unknown>,
+): asserts condition {
+  if (!condition) {
+    throw new Error(`${message}\n\nDebug context:\n${context.debugSummary()}`);
+  }
+}
+
+/**
+ * Assert SSE event exists with debug context on failure, returns the found event
+ */
+export function assertEventExists<TResult>(
+  events: TypedSSEEvent<TResult>[],
+  status: string,
+  context: SSEStreamResult<TResult>,
+): TypedSSEEvent<TResult> {
+  const found = events.find((e) => e.data.status === status);
+  assertWithContext(
+    found !== undefined,
+    `Should have a "${status}" event`,
+    context,
+  );
+  return found;
+}
+
+/**
+ * Assert HTTP status with debug context on failure
+ */
+export function assertHttpStatus(
+  context: SSEStreamResult<unknown>,
+  expectedStatus: number,
+  message?: string,
+): void {
+  assertWithContext(
+    context.status === expectedStatus,
+    message ?? `Expected HTTP ${expectedStatus}, got ${context.status}`,
+    context,
+  );
+}
+
+// =============================================================================
+// JSON Response Debug Utilities (for non-SSE tests)
+// =============================================================================
+
+/**
+ * Result of a fetch request with full context for debugging
+ */
+export interface FetchResult<T = unknown> {
+  /** HTTP status code */
+  status: number;
+  /** HTTP status text */
+  statusText: string;
+  /** Parsed JSON body (if parseable) */
+  body: T | null;
+  /** Raw response text */
+  raw: string;
+  /** Request duration in ms */
+  durationMs: number;
+  /** Response headers */
+  headers: Headers;
+  /** Get debug summary for error messages */
+  debugSummary(): string;
+}
+
+/**
+ * Fetch with full context for debugging test failures.
+ * Captures timing, status, and response body.
+ */
+export async function fetchWithContext<T = unknown>(
+  url: string,
+  options: RequestInit,
+): Promise<FetchResult<T>> {
+  const startTime = Date.now();
+  let response: Response;
+
+  try {
+    response = await fetch(url, options);
+  } catch (err) {
+    const durationMs = Date.now() - startTime;
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    return {
+      status: 0,
+      statusText: "FETCH_ERROR",
+      body: null,
+      raw: errorMsg,
+      durationMs,
+      headers: new Headers(),
+      debugSummary() {
+        return `Fetch failed after ${durationMs}ms: ${errorMsg}`;
+      },
+    };
+  }
+
+  const durationMs = Date.now() - startTime;
+  const status = response.status;
+  const statusText = response.statusText;
+  const headers = response.headers;
+  const raw = await response.text();
+
+  let body: T | null = null;
+  try {
+    body = JSON.parse(raw) as T;
+  } catch {
+    // Keep body as null if not valid JSON
+  }
+
+  return {
+    status,
+    statusText,
+    body,
+    raw,
+    durationMs,
+    headers,
+    debugSummary() {
+      const seconds = (durationMs / 1000).toFixed(1);
+      let summary = `HTTP ${status} ${statusText} (${seconds}s)`;
+
+      if (body && typeof body === "object") {
+        const b = body as Record<string, unknown>;
+        if (b.success === false && typeof b.message === "string") {
+          summary += `\n  Error: ${b.message}`;
+        }
+        if (typeof b.error === "string") {
+          summary += `\n  Error: ${b.error}`;
+        }
+      }
+
+      // Show raw response if it's an error or unexpected
+      if (status >= 400 || !body) {
+        const truncated = raw.slice(0, 500);
+        summary += `\n  Response: ${truncated}${raw.length > 500 ? "..." : ""}`;
+      }
+
+      return summary;
+    },
+  };
+}
+
+/**
+ * Assert with fetch context - includes response info on failure
+ */
+export function assertFetchOk<T>(
+  condition: boolean,
+  message: string,
+  context: FetchResult<T>,
+): asserts condition {
+  if (!condition) {
+    throw new Error(`${message}\n\nDebug context:\n${context.debugSummary()}`);
+  }
+}
+
+/**
+ * Assert fetch succeeded with expected status
+ */
+export function assertFetchStatus<T>(
+  context: FetchResult<T>,
+  expectedStatus: number,
+  message?: string,
+): void {
+  assertFetchOk(
+    context.status === expectedStatus,
+    message ?? `Expected HTTP ${expectedStatus}, got ${context.status}`,
+    context,
+  );
+}
+
+// =============================================================================
+// Test Context Manager
+// =============================================================================
+
+export class TestSession {
+  public sessionId: string | null = null;
+  private headers: Record<string, string>;
+
+  constructor(headers: Record<string, string>) {
+    this.headers = headers;
+  }
+
+  async start(): Promise<string> {
+    this.sessionId = await createSession(this.headers);
+    return this.sessionId;
+  }
+
+  async navigate(targetUrl: string): Promise<Response> {
+    if (!this.sessionId) {
+      throw new Error("Session not started");
+    }
+    return navigateSession(this.sessionId, targetUrl, this.headers);
+  }
+
+  async end(): Promise<void> {
+    if (this.sessionId) {
+      try {
+        await endSession(this.sessionId, this.headers);
+      } catch {
+        // Ignore errors when ending session
+      }
+      this.sessionId = null;
+    }
+  }
+
+  getSessionId(): string {
+    if (!this.sessionId) {
+      throw new Error("Session not started");
+    }
+    return this.sessionId;
+  }
+}
diff --git a/packages/server-v4/test/integration/v4/act.test.ts b/packages/server-v4/test/integration/v4/act.test.ts
new file mode 100644
index 000000000..ccccc2db0
--- /dev/null
+++ b/packages/server-v4/test/integration/v4/act.test.ts
@@ -0,0 +1,461 @@
+import assert from "node:assert/strict";
+import { after, before, beforeEach, describe, it } from "node:test";
+
+import { chromium } from "playwright";
+
+import {
+  assertEventExists,
+  assertFetchOk,
+  assertFetchStatus,
+  assertWithContext,
+  createSessionWithCdp,
+  endSession,
+  fetchWithContext,
+  GEMINI_API_KEY,
+  getBaseUrl,
+  getHeaders,
+  getMainFrameId,
+  HTTP_OK,
+  navigateSession,
+  OPENAI_API_KEY,
+  readTypedSSEStreamWithContext,
+  requireEnv,
+} from "../utils.js";
+
+interface ActResponse {
+  success: boolean;
+  data?: {
+    result: { success: boolean; message?: string };
+    actionId?: string;
+  };
+}
+
+/** Result type for act SSE events */
+interface ActResult {
+  success: boolean;
+  message?: string;
+  action?: string;
+}
+
+// Module-level session variable shared across all describe blocks
+let sessionId: string;
+let cdpUrl: string;
+
+// Single session creation for all tests
+before(async () => {
+  ({ sessionId, cdpUrl } = await createSessionWithCdp(getHeaders("3.0.0")));
+});
+
+// Navigate back to example.com before each test since act() may navigate away
+beforeEach(async () => {
+  const navResponse = await navigateSession(
+    sessionId,
+    "https://example.com",
+    getHeaders("3.0.0"),
+  );
+  assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+});
+
+// Single session cleanup after all tests
+after(async () => {
+  await endSession(sessionId, getHeaders("3.0.0"));
+});
+
+// =============================================================================
+// POST /v4/sessions/:id/act (V3 Format)
+// =============================================================================
+
+describe("POST /v4/sessions/:id/act (V3)", () => {
+  // ===========================================================================
+  // V3 Format Tests
+  // ===========================================================================
+
+  it("should perform an action using string input format", async () => {
+    const url = getBaseUrl();
+    const frameId = await getMainFrameId(cdpUrl);
+
+    const ctx = await fetchWithContext<ActResponse>(
+      `${url}/v4/sessions/${sessionId}/act`,
+      {
+        method: "POST",
+        headers: {
+          ...getHeaders("3.0.0"),
+        },
+        body: JSON.stringify({
+          input: "click the Learn more link",
+          frameId,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "act should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result.success,
+      "boolean",
+      "Result should have success boolean",
+    );
+
+    // Verify navigation via CDP
+    const browser = await chromium.connectOverCDP(cdpUrl);
+    const contexts = browser.contexts();
+    assert.ok(contexts.length > 0, "Should have at least one browser context");
+    const pages = contexts[0]!.pages();
+    assert.ok(pages.length > 0, "Should have at least one page");
+    const pageUrl = pages[0]!.url();
+    assert.ok(
+      pageUrl.includes("iana.org/help/example-domains"),
+      `Page URL should be iana.org/help/example-domains, got: ${pageUrl}`,
+    );
+    await browser.close();
+  });
+
+  it("should perform an action using object input format", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<ActResponse>(
+      `${url}/v4/sessions/${sessionId}/act`,
+      {
+        method: "POST",
+        headers: {
+          ...getHeaders("3.0.0"),
+        },
+        body: JSON.stringify({
+          input: {
+            selector: "a",
+            description: "Click a link on the page",
+            method: "click",
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "act with object input should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result.success,
+      "boolean",
+      "Result should have success boolean",
+    );
+  });
+
+  it("should accept options with string input", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<ActResponse>(
+      `${url}/v4/sessions/${sessionId}/act`,
+      {
+        method: "POST",
+        headers: {
+          ...getHeaders("3.0.0"),
+        },
+        body: JSON.stringify({
+          input: "click the Learn more link",
+          options: {
+            timeout: 30000,
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "act with options should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result.success,
+      "boolean",
+      "Result should have success boolean",
+    );
+  });
+
+  // ===========================================================================
+  // V3 Inline Model Configuration Tests
+  // ===========================================================================
+
+  it("should perform action with inline model config (modelName + apiKey)", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const ctx = await fetchWithContext<ActResponse>(
+      `${url}/v4/sessions/${sessionId}/act`,
+      {
+        method: "POST",
+        headers: {
+          ...getHeaders("3.0.0"),
+          "x-model-api-key": "", // Clear the header to ensure body config is used
+        },
+        body: JSON.stringify({
+          input: "click the Learn more link",
+          options: {
+            model: {
+              modelName: "openai/gpt-4.1-nano",
+              apiKey: openaiApiKey,
+            },
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "act with inline model config should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result.success,
+      "boolean",
+      "Result should have success boolean",
+    );
+  });
+
+  it("should perform action with inline model config and options", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const ctx = await fetchWithContext<ActResponse>(
+      `${url}/v4/sessions/${sessionId}/act`,
+      {
+        method: "POST",
+        headers: {
+          ...getHeaders("3.0.0"),
+          "x-model-api-key": "", // Clear the header to ensure body config is used
+        },
+        body: JSON.stringify({
+          input: "click the Learn more link",
+          options: {
+            model: {
+              modelName: "openai/gpt-4.1-nano",
+              apiKey: openaiApiKey,
+            },
+            timeout: 30000,
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "act with inline model config and options should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result.success,
+      "boolean",
+      "Result should have success boolean",
+    );
+  });
+
+  it("should perform action with object input and inline model config", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const ctx = await fetchWithContext<ActResponse>(
+      `${url}/v4/sessions/${sessionId}/act`,
+      {
+        method: "POST",
+        headers: {
+          ...getHeaders("3.0.0"),
+          "x-model-api-key": "", // Clear the header to ensure body config is used
+        },
+        body: JSON.stringify({
+          input: {
+            selector: "a",
+            description: "Click a link on the page",
+            method: "click",
+          },
+          options: {
+            model: {
+              modelName: "openai/gpt-4.1-nano",
+              apiKey: openaiApiKey,
+            },
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "act with object input and inline model config should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result.success,
+      "boolean",
+      "Result should have success boolean",
+    );
+  });
+
+  it("should perform action with google/gemini-2.5-flash-lite model", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    const ctx = await fetchWithContext<ActResponse>(
+      `${url}/v4/sessions/${sessionId}/act`,
+      {
+        method: "POST",
+        headers: {
+          ...getHeaders("3.0.0"),
+          "x-model-api-key": "", // Clear the header to ensure body config is used
+        },
+        body: JSON.stringify({
+          input: "click the Learn more link",
+          options: {
+            model: {
+              modelName: "google/gemini-2.5-flash-lite",
+              apiKey: geminiApiKey,
+            },
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "act with google/gemini-2.5-flash-lite model should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result.success,
+      "boolean",
+      "Result should have success boolean",
+    );
+  });
+});
+
+// =============================================================================
+// SSE Streaming Tests (V3)
+// =============================================================================
+
+describe("POST /v4/sessions/:id/act with SSE streaming (V3)", () => {
+  it("should stream valid SSE events with correct structure", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v4/sessions/${sessionId}/act`, {
+      method: "POST",
+      headers: {
+        ...getHeaders("3.0.0"),
+      },
+      body: JSON.stringify({
+        input: "click the Learn more link",
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ActResult>(response);
+    const { events } = ctx;
+
+    assertWithContext(
+      events.length >= 2,
+      "Should have at least starting and finished events",
+      ctx,
+    );
+
+    // Verify starting event
+    const startingEvent = assertEventExists(events, "starting", ctx);
+    assert.equal(
+      startingEvent.type,
+      "system",
+      "Starting event should be system type",
+    );
+
+    // Verify finished event with result
+    const finishedEvent = assertEventExists(events, "finished", ctx);
+    assert.equal(
+      finishedEvent.type,
+      "system",
+      "Finished event should be system type",
+    );
+    assertWithContext(
+      !!finishedEvent.data.result,
+      "Finished event must have result",
+      ctx,
+    );
+    assert.equal(
+      typeof finishedEvent.data.result.success,
+      "boolean",
+      "Result.success must be a boolean",
+    );
+  });
+
+  it("should stream SSE events with inline model config", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const response = await fetch(`${url}/v4/sessions/${sessionId}/act`, {
+      method: "POST",
+      headers: {
+        ...getHeaders("3.0.0"),
+        "x-model-api-key": "", // Clear the header to ensure body config is used
+      },
+      body: JSON.stringify({
+        input: "click the Learn more link",
+        options: {
+          model: {
+            modelName: "openai/gpt-4.1-nano",
+            apiKey: openaiApiKey,
+          },
+        },
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ActResult>(response);
+    const { events } = ctx;
+
+    assertWithContext(
+      events.length >= 2,
+      "Should have at least starting and finished events",
+      ctx,
+    );
+
+    // Verify starting event
+    const startingEvent = assertEventExists(events, "starting", ctx);
+    assert.equal(
+      startingEvent.type,
+      "system",
+      "Starting event should be system type",
+    );
+
+    // Verify finished event with result
+    const finishedEvent = assertEventExists(events, "finished", ctx);
+    assert.equal(
+      finishedEvent.type,
+      "system",
+      "Finished event should be system type",
+    );
+    assertWithContext(
+      !!finishedEvent.data.result,
+      "Finished event must have result",
+      ctx,
+    );
+    assert.equal(
+      typeof finishedEvent.data.result.success,
+      "boolean",
+      "Result.success must be a boolean",
+    );
+  });
+});
diff --git a/packages/server-v4/test/integration/v4/agentExecute.test.ts b/packages/server-v4/test/integration/v4/agentExecute.test.ts
new file mode 100644
index 000000000..36ca4a637
--- /dev/null
+++ b/packages/server-v4/test/integration/v4/agentExecute.test.ts
@@ -0,0 +1,1220 @@
+import assert from "node:assert/strict";
+import { after, before, beforeEach, describe, it } from "node:test";
+
+import {
+  assertFetchOk,
+  assertFetchStatus,
+  assertWithContext,
+  createSession,
+  createSessionWithCdp,
+  endSession,
+  fetchWithContext,
+  GEMINI_API_KEY,
+  getBaseUrl,
+  getHeaders,
+  getMainFrameId,
+  HTTP_BAD_REQUEST,
+  HTTP_OK,
+  HTTP_UNPROCESSABLE_ENTITY,
+  navigateSession,
+  OPENAI_API_KEY,
+  readTypedSSEStreamWithContext,
+  requireEnv,
+} from "../utils.js";
+
+// =============================================================================
+// POST /v4/sessions/:id/agentExecute (V3 Format)
+// =============================================================================
+
+describe("POST /v4/sessions/:id/agentExecute (V3) - Basic Config", () => {
+  let sessionId: string;
+  let cdpUrl: string;
+  const headers = getHeaders("3.0.0");
+
+  before(async () => {
+    ({ sessionId, cdpUrl } = await createSessionWithCdp(headers));
+  });
+
+  beforeEach(async () => {
+    // Navigate to example.com before each test (including first)
+    const navResponse = await navigateSession(
+      sessionId,
+      "https://example.com",
+      headers,
+    );
+    assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+  });
+
+  after(async () => {
+    if (sessionId) {
+      await endSession(sessionId, headers);
+      sessionId = "";
+    }
+  });
+
+  it("should execute agent with basic config (empty agentConfig)", async () => {
+    const url = getBaseUrl();
+    const frameId = await getMainFrameId(cdpUrl);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {},
+        executeOptions: {
+          instruction: "Describe the main heading on this page",
+          frameId,
+        },
+      }),
+    });
+
+    assertFetchStatus(ctx, HTTP_OK, "V3 agent execute should succeed");
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with string agentConfig.model", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          model: "gpt-4.1-nano",
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with string model should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with object model config (provider + modelName)", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          model: {
+            provider: "openai",
+            modelName: "gpt-4.1-nano",
+          },
+        },
+        executeOptions: {
+          instruction: "Describe the page content",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with object model should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with systemPrompt and maxSteps", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          systemPrompt: "You are a helpful web browsing assistant.",
+        },
+        executeOptions: {
+          instruction: "Find and describe the main content",
+          maxSteps: 3,
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with systemPrompt and maxSteps should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+});
+
+// ===========================================================================
+// V3 Format Tests with model: {modelName, apiKey} format - Google Gemini
+// ===========================================================================
+
+describe("POST /v4/sessions/:id/agentExecute (V3) - Google Gemini with API key", () => {
+  let sessionId: string;
+  const headers = getHeaders("3.0.0");
+
+  before(async () => {
+    sessionId = await createSession(headers);
+  });
+
+  beforeEach(async () => {
+    // Navigate to example.com before each test (including first)
+    const navResponse = await navigateSession(
+      sessionId,
+      "https://example.com",
+      headers,
+    );
+    assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+  });
+
+  after(async () => {
+    if (sessionId) {
+      await endSession(sessionId, headers);
+      sessionId = "";
+    }
+  });
+
+  it("should execute agent with Google model object containing modelName and apiKey", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          model: {
+            modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+            apiKey: geminiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with Google model object should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with Google model object, systemPrompt, and maxSteps", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          model: {
+            modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+            apiKey: geminiApiKey,
+          },
+          systemPrompt: "You are a helpful web browsing assistant.",
+        },
+        executeOptions: {
+          instruction: "Find and read the main heading",
+          maxSteps: 3,
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with Google model, systemPrompt and maxSteps should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+});
+
+// ===========================================================================
+// V3 Format Tests with OpenAI model: {modelName, apiKey} format
+// ===========================================================================
+
+describe("POST /v4/sessions/:id/agentExecute (V3) - OpenAI with API key", () => {
+  let sessionId: string;
+  const headers = getHeaders("3.0.0");
+
+  before(async () => {
+    sessionId = await createSession(headers);
+  });
+
+  beforeEach(async () => {
+    // Navigate to example.com before each test (including first)
+    const navResponse = await navigateSession(
+      sessionId,
+      "https://example.com",
+      headers,
+    );
+    assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+  });
+
+  after(async () => {
+    if (sessionId) {
+      await endSession(sessionId, headers);
+      sessionId = "";
+    }
+  });
+
+  it("should execute agent with OpenAI model object containing modelName and apiKey", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          model: {
+            modelName: "openai/gpt-4.1-nano",
+            apiKey: openaiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with OpenAI model object should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+});
+
+// ===========================================================================
+// V3 CUA Mode Tests - Testing explicit cua flag with model compatibility
+// ===========================================================================
+
+describe("POST /v4/sessions/:id/agentExecute (V3) - CUA flag compatibility", () => {
+  let sessionId: string;
+  const headers = getHeaders("3.0.0");
+
+  before(async () => {
+    sessionId = await createSession(headers);
+  });
+
+  beforeEach(async () => {
+    // Navigate to example.com before each test (including first)
+    const navResponse = await navigateSession(
+      sessionId,
+      "https://example.com",
+      headers,
+    );
+    assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+  });
+
+  after(async () => {
+    if (sessionId) {
+      await endSession(sessionId, headers);
+      sessionId = "";
+    }
+  });
+
+  it("should execute agent with cua: true and CUA model (valid combination)", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          cua: true,
+          model: {
+            modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+            apiKey: geminiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with cua: true and CUA model should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with cua: false and non-CUA model (valid combination)", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          cua: false,
+          model: {
+            modelName: "openai/gpt-4.1-nano",
+            apiKey: openaiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with cua: false and non-CUA model should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with cua: false and CUA model (works in non-CUA mode)", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      message?: string;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          cua: false,
+          model: {
+            modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+            apiKey: geminiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with cua: false and Google CUA model should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should fail with cua: true and non-CUA model (invalid combination)", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      message?: string;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          cua: true,
+          model: {
+            modelName: "google/gemini-2.5-flash-lite",
+            apiKey: geminiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_UNPROCESSABLE_ENTITY,
+      "V3 agent execute with cua: true and non-CUA model should fail",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(!ctx.body.success, "Response should indicate failure", ctx);
+  });
+
+  it("should prefer mode over cua when both are provided", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          cua: true,
+          mode: "dom",
+          model: {
+            modelName: "openai/gpt-4.1-nano",
+            apiKey: openaiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with mode: dom and cua: true should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+});
+
+// =============================================================================
+// V3 executionModel Tests - Testing agentConfig.executionModel serialization
+// =============================================================================
+
+describe("POST /v4/sessions/:id/agentExecute (V3) - executionModel serialization", () => {
+  let sessionId: string;
+  const headers = getHeaders("3.0.0");
+
+  before(async () => {
+    sessionId = await createSession(headers);
+  });
+
+  beforeEach(async () => {
+    // Navigate to example.com before each test (including first)
+    const navResponse = await navigateSession(
+      sessionId,
+      "https://example.com",
+      headers,
+    );
+    assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+  });
+
+  after(async () => {
+    if (sessionId) {
+      await endSession(sessionId, headers);
+      sessionId = "";
+    }
+  });
+
+  it("should execute agent with string executionModel", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          executionModel: "gpt-4.1-nano",
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with string executionModel should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with object executionModel (modelName and apiKey)", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          executionModel: {
+            modelName: "openai/gpt-4.1-nano",
+            apiKey: openaiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "Describe the main content of this page",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with object executionModel should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with both model and executionModel", async () => {
+    const url = getBaseUrl();
+    const openaiApiKey = requireEnv("OPENAI_API_KEY", OPENAI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          model: {
+            modelName: "openai/gpt-4.1-nano",
+            apiKey: openaiApiKey,
+          },
+          executionModel: {
+            modelName: "openai/gpt-4.1-nano",
+            apiKey: openaiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with both model and executionModel should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+});
+
+// =============================================================================
+// V3 Mode Tests - Testing agentConfig.mode field (dom, hybrid, cua)
+// =============================================================================
+
+describe("POST /v4/sessions/:id/agentExecute - agentConfig.mode (V3)", () => {
+  let sessionId: string;
+  const headers = getHeaders("3.0.0");
+
+  before(async () => {
+    sessionId = await createSession(headers);
+  });
+
+  beforeEach(async () => {
+    // Navigate to example.com before each test (including first)
+    const navResponse = await navigateSession(
+      sessionId,
+      "https://example.com",
+      headers,
+    );
+    assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+  });
+
+  after(async () => {
+    if (sessionId) {
+      await endSession(sessionId, headers);
+      sessionId = "";
+    }
+  });
+
+  it("should execute agent with mode: dom", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          mode: "dom",
+        },
+        executeOptions: {
+          instruction: "What is the title of this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with mode: dom should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with mode: hybrid", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          mode: "hybrid",
+          model: {
+            provider: "google", // bonus: test split provider/modelName format
+            modelName: "gemini-2.5-flash-preview-04-17",
+            apiKey: geminiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "Describe the main heading on this page",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with mode: hybrid should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+
+  it("should execute agent with mode: cua and CUA model", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          mode: "cua",
+          model: {
+            modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+            apiKey: geminiApiKey,
+          },
+        },
+        executeOptions: {
+          instruction: "What is visible on this page?",
+        },
+      }),
+    });
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "V3 agent execute with mode: cua and CUA model should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.result !== undefined,
+      "Response should have result",
+      ctx,
+    );
+  });
+});
+
+// =============================================================================
+// SSE Streaming Tests (V3)
+// =============================================================================
+
+describe("POST /v4/sessions/:id/agentExecute with SSE streaming (V3)", () => {
+  let sessionId: string;
+  const headers = getHeaders("3.0.0");
+
+  before(async () => {
+    sessionId = await createSession(headers);
+  });
+
+  beforeEach(async () => {
+    // Navigate to example.com before each test (including first)
+    const navResponse = await navigateSession(
+      sessionId,
+      "https://example.com",
+      headers,
+    );
+    assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+  });
+
+  after(async () => {
+    if (sessionId) {
+      await endSession(sessionId, headers);
+      sessionId = "";
+    }
+  });
+
+  it("should stream SSE events with valid structure, sequence, and UUIDs", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(
+      `${url}/v4/sessions/${sessionId}/agentExecute`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          agentConfig: {},
+          executeOptions: {
+            instruction: "Describe the main content on the page",
+          },
+          streamResponse: true,
+        }),
+      },
+    );
+
+    const ctx = await readTypedSSEStreamWithContext(response);
+
+    // Verify event count
+    assertWithContext(
+      ctx.events.length >= 2,
+      "Should have at least starting and finished events",
+      ctx,
+    );
+
+    // Verify event sequence
+    const startingIndex = ctx.events.findIndex(
+      (e) => e.data.status === "starting",
+    );
+    const connectedIndex = ctx.events.findIndex(
+      (e) => e.data.status === "connected",
+    );
+    const finishedIndex = ctx.events.findIndex(
+      (e) => e.data.status === "finished",
+    );
+
+    assertWithContext(
+      startingIndex !== -1,
+      "Should have a starting event",
+      ctx,
+    );
+    assertWithContext(
+      connectedIndex !== -1,
+      "Should have a connected event",
+      ctx,
+    );
+    assertWithContext(
+      finishedIndex !== -1,
+      "Should have a finished event",
+      ctx,
+    );
+    assertWithContext(
+      startingIndex < connectedIndex,
+      "Starting event must come before connected event",
+      ctx,
+    );
+    assertWithContext(
+      connectedIndex < finishedIndex,
+      "Connected event must come before finished event",
+      ctx,
+    );
+
+    // Verify event types
+    const startingEvent = ctx.events[startingIndex];
+    const finishedEvent = ctx.events[finishedIndex];
+
+    assertWithContext(
+      startingEvent !== undefined,
+      "Starting event should exist",
+      ctx,
+    );
+    assertWithContext(
+      finishedEvent !== undefined,
+      "Finished event should exist",
+      ctx,
+    );
+    assertWithContext(
+      startingEvent.type === "system",
+      "Starting event should be system type",
+      ctx,
+    );
+    assertWithContext(
+      finishedEvent.type === "system",
+      "Finished event should be system type",
+      ctx,
+    );
+    assertWithContext(
+      finishedEvent.data.result !== undefined,
+      "Finished event must have result",
+      ctx,
+    );
+
+    // Verify UUID format
+    const uuidRegex =
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+    for (const event of ctx.events) {
+      assertWithContext(
+        uuidRegex.test(event.id),
+        `Event id should be a valid UUID format, got: ${event.id}`,
+        ctx,
+      );
+    }
+  });
+});
+
+// =============================================================================
+// Validation Error Tests (V3)
+// =============================================================================
+
+describe("POST /v4/sessions/:id/agentExecute - validation errors (V3)", () => {
+  let sessionId: string;
+  const headers = getHeaders("3.0.0");
+
+  before(async () => {
+    sessionId = await createSession(headers);
+  });
+
+  beforeEach(async () => {
+    // Navigate to example.com before each test (including first)
+    const navResponse = await navigateSession(
+      sessionId,
+      "https://example.com",
+      headers,
+    );
+    assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+  });
+
+  after(async () => {
+    if (sessionId) {
+      await endSession(sessionId, headers);
+      sessionId = "";
+    }
+  });
+
+  it("should return 400 when agentConfig is missing", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success?: boolean;
+      error?: string;
+      message?: string;
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        executeOptions: {
+          instruction: "Do something",
+        },
+      }),
+    });
+
+    assertFetchStatus(ctx, HTTP_BAD_REQUEST);
+    assertFetchOk(
+      !ctx.body?.success || ctx.body.error !== undefined,
+      "Response should indicate failure",
+      ctx,
+    );
+  });
+
+  it("should return 400 when executeOptions is missing", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success?: boolean;
+      error?: string;
+      message?: string;
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          model: {
+            modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+          },
+        },
+      }),
+    });
+
+    assertFetchStatus(ctx, HTTP_BAD_REQUEST);
+    assertFetchOk(
+      !ctx.body?.success || ctx.body.error !== undefined,
+      "Response should indicate failure",
+      ctx,
+    );
+  });
+
+  it("should return 400 when instruction is missing", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success?: boolean;
+      error?: string;
+      message?: string;
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          model: {
+            modelName: "google/gemini-2.5-computer-use-preview-10-2025",
+          },
+        },
+        executeOptions: {
+          maxSteps: 5,
+        },
+      }),
+    });
+
+    assertFetchStatus(ctx, HTTP_BAD_REQUEST);
+    assertFetchOk(
+      !ctx.body?.success || ctx.body.error !== undefined,
+      "Response should indicate failure",
+      ctx,
+    );
+  });
+
+  it("should return 400 for invalid agentConfig.mode", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success?: boolean;
+      error?: string;
+      message?: string;
+    }>(`${url}/v4/sessions/${sessionId}/agentExecute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentConfig: {
+          mode: "invalid-mode",
+        },
+        executeOptions: {
+          instruction: "Do something",
+        },
+      }),
+    });
+
+    assertFetchStatus(ctx, HTTP_BAD_REQUEST);
+    assertFetchOk(
+      !ctx.body?.success || ctx.body.error !== undefined,
+      "Response should indicate failure",
+      ctx,
+    );
+  });
+});
diff --git a/packages/server-v4/test/integration/v4/end.test.ts b/packages/server-v4/test/integration/v4/end.test.ts
new file mode 100644
index 000000000..380d8e334
--- /dev/null
+++ b/packages/server-v4/test/integration/v4/end.test.ts
@@ -0,0 +1,182 @@
+import { after, before, describe, it } from "node:test";
+
+import assert from "node:assert/strict";
+
+import {
+  assertFetchOk,
+  assertFetchStatus,
+  createSession,
+  endSession,
+  fetchWithContext,
+  getBaseUrl,
+  getHeaders,
+  HTTP_BAD_REQUEST,
+  HTTP_NOT_FOUND,
+  HTTP_INTERNAL_SERVER_ERROR,
+  HTTP_OK,
+} from "../utils.js";
+
+// =============================================================================
+// POST /v4/sessions/:id/end (V3 Format)
+// =============================================================================
+
+describe("POST /v4/sessions/:id/end (V3)", () => {
+  const headers = getHeaders("3.0.0");
+  let sessionId: string;
+
+  before(async () => {
+    sessionId = await createSession(headers);
+  });
+
+  after(async () => {
+    // Try to clean up in case test didn't end the session
+    try {
+      await endSession(sessionId, headers);
+    } catch {
+      // Ignore - session may already be ended
+    }
+  });
+
+  it("should return 200 if JSON content-type has an empty body", async () => {
+    const url = getBaseUrl();
+    // Create a fresh session for this test since we need to test error cases
+    const testSessionId = await createSession(headers);
+
+    const response = await fetch(`${url}/v4/sessions/${testSessionId}/end`, {
+      method: "POST",
+      headers: {
+        ...headers,
+        "Content-Type": "application/json",
+      },
+      body: "",
+    });
+
+    // Empty body should be accepted
+    assertFetchStatus(
+      {
+        status: response.status,
+        statusText: response.statusText,
+        body: null,
+        raw: "",
+        durationMs: 0,
+        headers: response.headers,
+        debugSummary: () => `HTTP ${response.status}`,
+      },
+      HTTP_OK,
+      "Should return 200 for empty body with JSON content-type",
+    );
+
+    // Clean up
+    await endSession(testSessionId, headers);
+  });
+
+  it("should return 400 if body contains extra keys", async () => {
+    const url = getBaseUrl();
+    const testSessionId = await createSession(headers);
+
+    const ctx = await fetchWithContext<{ success?: boolean; message?: string }>(
+      `${url}/v4/sessions/${testSessionId}/end`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ unexpected: true }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_BAD_REQUEST,
+      "Should return 400 for extra keys",
+    );
+
+    // Clean up
+    await endSession(testSessionId, headers);
+  });
+
+  it("should return 200 when body is {}", async () => {
+    const url = getBaseUrl();
+    const testSessionId = await createSession(headers);
+
+    const ctx = await fetchWithContext<{ success: boolean }>(
+      `${url}/v4/sessions/${testSessionId}/end`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({}),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Should return 200 for empty object body");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(ctx.body.success === true, "Should indicate success", ctx);
+  });
+
+  it("should return 200 when body is 0 bytes (no body)", async () => {
+    const url = getBaseUrl();
+    const testSessionId = await createSession(headers);
+
+    // Send request with no body at all
+    const response = await fetch(`${url}/v4/sessions/${testSessionId}/end`, {
+      method: "POST",
+      headers: {
+        ...headers,
+        // Don't set Content-Type to application/json when there's no body
+      },
+    });
+
+    // Should succeed with 200 for no body
+    assert.equal(
+      response.status,
+      HTTP_OK,
+      `Should return 200 for 0-byte body, got ${response.status}`,
+    );
+
+    const body = await response.json();
+    assert.equal(body.success, true, "Should indicate success");
+  });
+
+  it("should end session successfully", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{ success: boolean }>(
+      `${url}/v4/sessions/${sessionId}/end`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({}),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "End session should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(ctx.body.success === true, "Should indicate success", ctx);
+  });
+
+  it("should return error for non-existent session", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{ success?: boolean; message?: string }>(
+      `${url}/v4/sessions/non-existent-session-id/end`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({}),
+      },
+    );
+
+    // Server returns 404 or 500 for non-existent sessions
+    assert.ok(
+      [HTTP_NOT_FOUND, HTTP_INTERNAL_SERVER_ERROR].includes(ctx.status),
+      `Expected 404 or 500, got ${ctx.status}`,
+    );
+
+    if (ctx.status === HTTP_INTERNAL_SERVER_ERROR) {
+      assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+      assertFetchOk(
+        ctx.body.message === "An internal server error occurred",
+        "500 responses should return a generic internal error message",
+        ctx,
+      );
+    }
+  });
+});
diff --git a/packages/server-v4/test/integration/v4/extract.test.ts b/packages/server-v4/test/integration/v4/extract.test.ts
new file mode 100644
index 000000000..31c55c872
--- /dev/null
+++ b/packages/server-v4/test/integration/v4/extract.test.ts
@@ -0,0 +1,511 @@
+import assert from "node:assert/strict";
+import { after, before, describe, it } from "node:test";
+
+import {
+  assertEventExists,
+  assertFetchOk,
+  assertFetchStatus,
+  assertWithContext,
+  createSessionWithCdp,
+  endSession,
+  fetchWithContext,
+  GEMINI_API_KEY,
+  getBaseUrl,
+  getHeaders,
+  getMainFrameId,
+  HTTP_OK,
+  navigateSession,
+  readTypedSSEStreamWithContext,
+  requireEnv,
+} from "../utils.js";
+
+/** Result type for extract SSE events */
+type ExtractResult = Record<string, unknown>;
+
+// Shared session for all extract tests (extract is read-only, safe to share)
+let sessionId: string;
+let cdpUrl: string;
+
+before(async () => {
+  ({ sessionId, cdpUrl } = await createSessionWithCdp(getHeaders("3.0.0")));
+  const navResponse = await navigateSession(
+    sessionId,
+    "https://example.com",
+    getHeaders("3.0.0"),
+  );
+  assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+});
+
+after(async () => {
+  await endSession(sessionId, getHeaders("3.0.0"));
+});
+
+// =============================================================================
+// POST /v4/sessions/:id/extract - V3 Format Tests
+// =============================================================================
+
+describe("POST /v4/sessions/:id/extract (V3)", () => {
+  it("should extract data with instruction and schema", async () => {
+    const url = getBaseUrl();
+    const frameId = await getMainFrameId(cdpUrl);
+
+    interface ExtractResponse {
+      success: boolean;
+      data?: { result: Record<string, unknown>; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ExtractResponse>(
+      `${url}/v4/sessions/${sessionId}/extract`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "extract the page title",
+          schema: {
+            type: "object",
+            properties: {
+              title: { type: "string" },
+            },
+            required: ["title"],
+          },
+          frameId,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Extract should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result,
+      "object",
+      "Result should be an object",
+    );
+    assertFetchOk(
+      "title" in ctx.body.data.result,
+      "Result should have title property",
+      ctx,
+    );
+  });
+
+  it("should extract with instruction and options", async () => {
+    const url = getBaseUrl();
+
+    interface ExtractResponse {
+      success: boolean;
+      data?: { result: Record<string, unknown>; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ExtractResponse>(
+      `${url}/v4/sessions/${sessionId}/extract`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "extract the page title",
+          schema: {
+            type: "object",
+            properties: {
+              title: { type: "string" },
+            },
+          },
+          options: {
+            timeout: 30000,
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Extract with options should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result,
+      "object",
+      "Result should be an object",
+    );
+  });
+
+  it("should extract with CSS selector in options", async () => {
+    const url = getBaseUrl();
+
+    interface ExtractResponse {
+      success: boolean;
+      data?: { result: Record<string, unknown>; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ExtractResponse>(
+      `${url}/v4/sessions/${sessionId}/extract`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "extract the link information",
+          schema: {
+            type: "object",
+            properties: {
+              href: { type: "string" },
+              text: { type: "string" },
+            },
+          },
+          options: {
+            selector: "a", // CSS selector
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Extract with CSS selector should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result,
+      "object",
+      "Result should be an object",
+    );
+  });
+
+  it("should extract with XPath selector in options", async () => {
+    const url = getBaseUrl();
+
+    interface ExtractResponse {
+      success: boolean;
+      data?: { result: Record<string, unknown>; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ExtractResponse>(
+      `${url}/v4/sessions/${sessionId}/extract`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "extract the link information",
+          schema: {
+            type: "object",
+            properties: {
+              href: { type: "string" },
+              text: { type: "string" },
+            },
+          },
+          options: {
+            selector: "//a", // XPath selector
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "Extract with XPath selector should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result,
+      "object",
+      "Result should be an object",
+    );
+  });
+
+  it("should extract with instruction only (no schema)", async () => {
+    const url = getBaseUrl();
+
+    interface ExtractResponse {
+      success: boolean;
+      data?: { result: Record<string, unknown>; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ExtractResponse>(
+      `${url}/v4/sessions/${sessionId}/extract`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "extract the main content from the page",
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Extract without schema should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result,
+      "object",
+      "Result should be an object",
+    );
+  });
+
+  it("should extract without instruction (extract all)", async () => {
+    const url = getBaseUrl();
+
+    interface ExtractResponse {
+      success: boolean;
+      data?: { result: Record<string, unknown>; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ExtractResponse>(
+      `${url}/v4/sessions/${sessionId}/extract`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          options: {
+            timeout: 30000,
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "Extract without instruction should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result,
+      "object",
+      "Result should be an object",
+    );
+  });
+
+  it("should extract with google/gemini-2.5-flash-lite model", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    interface ExtractResponse {
+      success: boolean;
+      data?: { result: Record<string, unknown>; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ExtractResponse>(
+      `${url}/v4/sessions/${sessionId}/extract`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "extract the page title",
+          schema: {
+            type: "object",
+            properties: {
+              title: { type: "string" },
+            },
+            required: ["title"],
+          },
+          options: {
+            model: {
+              modelName: "google/gemini-2.5-flash-lite",
+              apiKey: geminiApiKey,
+            },
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Extract with Gemini model should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(!!ctx.body.data, "Response should have data", ctx);
+    assertFetchOk(!!ctx.body.data.result, "Response should have result", ctx);
+    assert.equal(
+      typeof ctx.body.data.result,
+      "object",
+      "Result should be an object",
+    );
+    assertFetchOk(
+      "title" in ctx.body.data.result,
+      "Result should have title property",
+      ctx,
+    );
+  });
+});
+
+// =============================================================================
+// SSE Streaming Tests - V3
+// =============================================================================
+
+describe("POST /v4/sessions/:id/extract with SSE streaming (V3)", () => {
+  it("should stream valid SSE events with correct structure", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v4/sessions/${sessionId}/extract`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        instruction: "extract the page title",
+        schema: {
+          type: "object",
+          properties: {
+            title: { type: "string" },
+          },
+          required: ["title"],
+        },
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ExtractResult>(response);
+    const { events } = ctx;
+
+    assertWithContext(
+      events.length >= 2,
+      "Should have at least starting and finished events",
+      ctx,
+    );
+
+    // Verify starting event
+    const startingEvent = assertEventExists(events, "starting", ctx);
+    assert.equal(
+      startingEvent.type,
+      "system",
+      "Starting event should be system type",
+    );
+
+    // Verify finished event with result
+    const finishedEvent = assertEventExists(events, "finished", ctx);
+    assert.equal(
+      finishedEvent.type,
+      "system",
+      "Finished event should be system type",
+    );
+    assertWithContext(
+      !!finishedEvent.data.result,
+      "Finished event must have result",
+      ctx,
+    );
+    assert.equal(
+      typeof finishedEvent.data.result,
+      "object",
+      "Result must be an object",
+    );
+    assertWithContext(
+      "title" in finishedEvent.data.result,
+      "Result should have title property",
+      ctx,
+    );
+  });
+
+  it("should have correct event sequence: starting -> connected -> finished", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v4/sessions/${sessionId}/extract`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        instruction: "extract the page title",
+        schema: {
+          type: "object",
+          properties: {
+            title: { type: "string" },
+          },
+        },
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ExtractResult>(response);
+    const { events } = ctx;
+
+    assertEventExists(events, "starting", ctx);
+    assertEventExists(events, "connected", ctx);
+    assertEventExists(events, "finished", ctx);
+
+    const startingIndex = events.findIndex((e) => e.data.status === "starting");
+    const connectedIndex = events.findIndex(
+      (e) => e.data.status === "connected",
+    );
+    const finishedIndex = events.findIndex((e) => e.data.status === "finished");
+
+    assertWithContext(
+      startingIndex < connectedIndex,
+      "Starting event must come before connected event",
+      ctx,
+    );
+    assertWithContext(
+      connectedIndex < finishedIndex,
+      "Connected event must come before finished event",
+      ctx,
+    );
+  });
+
+  it("should have valid UUID for each event id", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v4/sessions/${sessionId}/extract`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        instruction: "extract the page title",
+        schema: {
+          type: "object",
+          properties: {
+            title: { type: "string" },
+          },
+        },
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ExtractResult>(response);
+    const { events } = ctx;
+
+    const uuidRegex =
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+    for (const event of events) {
+      assertWithContext(
+        uuidRegex.test(event.id),
+        `Event id should be a valid UUID format, got: ${event.id}`,
+        ctx,
+      );
+    }
+  });
+
+  it("should extract data matching the provided schema", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v4/sessions/${sessionId}/extract`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        instruction: "extract the page title",
+        schema: {
+          type: "object",
+          properties: {
+            title: { type: "string" },
+          },
+          required: ["title"],
+        },
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ExtractResult>(response);
+    const { events } = ctx;
+
+    const finishedEvent = assertEventExists(events, "finished", ctx);
+    assertWithContext(!!finishedEvent.data.result, "Should have result", ctx);
+
+    // Verify the extracted data has the expected shape
+    assert.equal(
+      typeof finishedEvent.data.result.title,
+      "string",
+      "Extracted title should be a string",
+    );
+  });
+});
diff --git a/packages/server-v4/test/integration/v4/multiRegion.test.ts b/packages/server-v4/test/integration/v4/multiRegion.test.ts
new file mode 100644
index 000000000..076b3ef80
--- /dev/null
+++ b/packages/server-v4/test/integration/v4/multiRegion.test.ts
@@ -0,0 +1,277 @@
+import { describe, it } from "node:test";
+
+import {
+  assertFetchOk,
+  assertFetchStatus,
+  endSession,
+  fetchWithContext,
+  getBaseUrl,
+  getHeaders,
+  HTTP_OK,
+  LOCAL_BROWSER_BODY,
+} from "../utils.js";
+
+// =============================================================================
+// Response Type Definitions
+// =============================================================================
+
+interface StartSuccessResponse {
+  success: true;
+  data: {
+    sessionId: string;
+    cdpUrl: string;
+    available: boolean;
+  };
+}
+
+interface StartErrorResponse {
+  success: false;
+  message: string;
+}
+
+type StartResponse = StartSuccessResponse | StartErrorResponse;
+
+function isSuccessResponse(
+  response: StartResponse,
+): response is StartSuccessResponse {
+  return response.success && response.data.sessionId !== null;
+}
+
+// =============================================================================
+// Multi-Region Integration Tests
+// =============================================================================
+// These tests verify that the API client correctly handles multi-region
+// configuration. Prior to the multi-region feature, non-us-west-2 regions
+// would be rejected with { available: false }. Now all supported regions
+// are accepted.
+// =============================================================================
+
+describe("POST /v4/sessions/start - Multi-region support", () => {
+  const headers = getHeaders("3.0.0");
+  const localBrowser = LOCAL_BROWSER_BODY;
+
+  it("should start session with us-west-2 region (default)", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v4/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browserbaseSessionCreateParams: {
+            region: "us-west-2",
+          },
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+
+    try {
+      assertFetchOk(
+        ctx.body.data.available,
+        "Session should be available",
+        ctx,
+      );
+      assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+    } finally {
+      await endSession(ctx.body.data.sessionId, headers);
+    }
+  });
+
+  it("should start session with us-east-1 region", async () => {
+    const url = getBaseUrl();
+
+    // This test verifies that non-us-west-2 regions are now accepted.
+    // Previously, this would have returned { available: false }.
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v4/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browserbaseSessionCreateParams: {
+            region: "us-east-1",
+          },
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+
+    try {
+      assertFetchOk(
+        ctx.body.data.available,
+        "Session should be available",
+        ctx,
+      );
+      assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+    } finally {
+      await endSession(ctx.body.data.sessionId, headers);
+    }
+  });
+
+  it("should start session with eu-central-1 region", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v4/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browserbaseSessionCreateParams: {
+            region: "eu-central-1",
+          },
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+
+    try {
+      assertFetchOk(
+        ctx.body.data.available,
+        "Session should be available",
+        ctx,
+      );
+      assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+    } finally {
+      await endSession(ctx.body.data.sessionId, headers);
+    }
+  });
+
+  it("should start session with ap-southeast-1 region", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v4/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browserbaseSessionCreateParams: {
+            region: "ap-southeast-1",
+          },
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+
+    try {
+      assertFetchOk(
+        ctx.body.data.available,
+        "Session should be available",
+        ctx,
+      );
+      assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+    } finally {
+      await endSession(ctx.body.data.sessionId, headers);
+    }
+  });
+
+  it("should start session without region (defaults to us-west-2)", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v4/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browserbaseSessionCreateParams: {},
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+
+    try {
+      assertFetchOk(
+        ctx.body.data.available,
+        "Session should be available",
+        ctx,
+      );
+      assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+    } finally {
+      await endSession(ctx.body.data.sessionId, headers);
+    }
+  });
+
+  it("should start session without browserbaseSessionCreateParams", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v4/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+
+    try {
+      assertFetchOk(
+        ctx.body.data.available,
+        "Session should be available",
+        ctx,
+      );
+      assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+    } finally {
+      await endSession(ctx.body.data.sessionId, headers);
+    }
+  });
+});
diff --git a/packages/server-v4/test/integration/v4/navigate.test.ts b/packages/server-v4/test/integration/v4/navigate.test.ts
new file mode 100644
index 000000000..2371369d8
--- /dev/null
+++ b/packages/server-v4/test/integration/v4/navigate.test.ts
@@ -0,0 +1,143 @@
+import assert from "node:assert/strict";
+import { after, before, describe, it } from "node:test";
+
+import { chromium } from "playwright";
+
+import {
+  assertFetchOk,
+  assertFetchStatus,
+  createSessionWithCdp,
+  endSession,
+  fetchWithContext,
+  getBaseUrl,
+  getHeaders,
+  HTTP_BAD_REQUEST,
+  HTTP_OK,
+} from "../utils.js";
+
+// =============================================================================
+// POST /v4/sessions/:id/navigate (V3 Format)
+// =============================================================================
+
+describe("POST /v4/sessions/:id/navigate (V3)", () => {
+  let sessionId: string;
+  let cdpUrl: string;
+
+  before(async () => {
+    ({ sessionId, cdpUrl } = await createSessionWithCdp(getHeaders("3.0.0")));
+  });
+
+  after(async () => {
+    await endSession(sessionId, getHeaders("3.0.0"));
+  });
+
+  it("should navigate to a URL successfully and verify via CDP", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/navigate`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({ url: "https://example.com", frameId: "" }),
+    });
+
+    assertFetchStatus(ctx, HTTP_OK, "Navigate should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      typeof ctx.body.data.actionId === "string",
+      "Response should have actionId",
+      ctx,
+    );
+
+    // Verify navigation via CDP
+    const browser = await chromium.connectOverCDP(cdpUrl);
+    const contexts = browser.contexts();
+    assert.ok(contexts.length > 0, "Should have at least one browser context");
+    const pages = contexts[0]!.pages();
+    assert.ok(pages.length > 0, "Should have at least one page");
+    const page = pages[0]!;
+    await page
+      .waitForLoadState("domcontentloaded", { timeout: 15_000 })
+      .catch(() => {});
+    await page
+      .waitForURL("**example.com**", { timeout: 15_000 })
+      .catch(() => {});
+    const pageUrl = page.url();
+    assert.ok(
+      pageUrl.includes("example.com"),
+      `Page URL should be example.com, got: ${pageUrl}`,
+    );
+    await browser.close();
+  });
+
+  it("should navigate with options", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success: boolean;
+      data?: { result: unknown; actionId?: string };
+    }>(`${url}/v4/sessions/${sessionId}/navigate`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        url: "https://example.com",
+        frameId: "",
+        options: {
+          waitUntil: "networkidle",
+          timeout: 30000,
+        },
+      }),
+    });
+
+    assertFetchStatus(ctx, HTTP_OK, "Navigate with options should succeed");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      typeof ctx.body.data.actionId === "string",
+      "Response should have actionId",
+      ctx,
+    );
+  });
+
+  // ===========================================================================
+  // Validation Tests
+  // ===========================================================================
+
+  it("should return 400 when url is missing", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<{
+      success?: boolean;
+      message?: string;
+      error?: string;
+    }>(`${url}/v4/sessions/${sessionId}/navigate`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({ frameId: "" }), // Missing url
+    });
+
+    assertFetchStatus(ctx, HTTP_BAD_REQUEST);
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    // Fastify validation errors may have different format than our custom errors
+    assertFetchOk(
+      !ctx.body.success ||
+        ctx.body.error !== undefined ||
+        ctx.body.message !== undefined,
+      "Response should indicate failure",
+      ctx,
+    );
+  });
+});
diff --git a/packages/server-v4/test/integration/v4/observe.test.ts b/packages/server-v4/test/integration/v4/observe.test.ts
new file mode 100644
index 000000000..d7fcc584c
--- /dev/null
+++ b/packages/server-v4/test/integration/v4/observe.test.ts
@@ -0,0 +1,407 @@
+import assert from "node:assert/strict";
+import { after, before, describe, it } from "node:test";
+
+import {
+  assertEventExists,
+  assertFetchOk,
+  assertFetchStatus,
+  assertWithContext,
+  createSessionWithCdp,
+  endSession,
+  fetchWithContext,
+  GEMINI_API_KEY,
+  getBaseUrl,
+  getHeaders,
+  getMainFrameId,
+  HTTP_OK,
+  navigateSession,
+  readTypedSSEStreamWithContext,
+  requireEnv,
+} from "../utils.js";
+
+/** Result type for observe SSE events */
+type ObserveResult = unknown[];
+
+// Shared session for all observe tests (observe is read-only, safe to share)
+let sessionId: string;
+let cdpUrl: string;
+
+before(async () => {
+  ({ sessionId, cdpUrl } = await createSessionWithCdp(getHeaders("3.0.0")));
+  // Navigate to a page first
+  const navResponse = await navigateSession(
+    sessionId,
+    "https://example.com",
+    getHeaders("3.0.0"),
+  );
+  assert.equal(navResponse.status, HTTP_OK, "Navigate should succeed");
+});
+
+after(async () => {
+  await endSession(sessionId, getHeaders("3.0.0"));
+});
+
+// =============================================================================
+// POST /v4/sessions/:id/observe - V3 Format Tests
+// =============================================================================
+
+describe("POST /v4/sessions/:id/observe (V3)", () => {
+  it("should observe elements with instruction", async () => {
+    const url = getBaseUrl();
+    const frameId = await getMainFrameId(cdpUrl);
+
+    interface ObserveResponse {
+      success: boolean;
+      data?: { result: unknown[]; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ObserveResponse>(
+      `${url}/v4/sessions/${sessionId}/observe`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "Find any link on the page",
+          frameId,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Observe should succeed");
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      Array.isArray(ctx.body.data.result),
+      "Result should be an array of observed elements",
+      ctx,
+    );
+  });
+
+  it("should observe with instruction and options", async () => {
+    const url = getBaseUrl();
+
+    interface ObserveResponse {
+      success: boolean;
+      data?: { result: unknown[]; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ObserveResponse>(
+      `${url}/v4/sessions/${sessionId}/observe`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "Find any link on the page",
+          options: {
+            timeout: 30000,
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Observe with options should succeed");
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      Array.isArray(ctx.body.data.result),
+      "Result should be an array of observed elements",
+      ctx,
+    );
+  });
+
+  it("should observe with selector option", async () => {
+    const url = getBaseUrl();
+
+    interface ObserveResponse {
+      success: boolean;
+      data?: { result: unknown[]; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ObserveResponse>(
+      `${url}/v4/sessions/${sessionId}/observe`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          instruction: "Find any link on the page",
+          options: {
+            selector: "a",
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Observe with selector should succeed");
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      Array.isArray(ctx.body.data.result),
+      "Result should be an array of observed elements",
+      ctx,
+    );
+  });
+
+  it("should observe without instruction (observe all)", async () => {
+    const url = getBaseUrl();
+
+    interface ObserveResponse {
+      success: boolean;
+      data?: { result: unknown[]; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ObserveResponse>(
+      `${url}/v4/sessions/${sessionId}/observe`,
+      {
+        method: "POST",
+        headers: getHeaders("3.0.0"),
+        body: JSON.stringify({
+          options: {
+            timeout: 30000,
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "Observe without instruction should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      Array.isArray(ctx.body.data.result),
+      "Result should be an array of observed elements",
+      ctx,
+    );
+  });
+
+  it("should observe with google/gemini-2.5-flash-lite model", async () => {
+    const url = getBaseUrl();
+    const geminiApiKey = requireEnv("GEMINI_API_KEY", GEMINI_API_KEY);
+
+    interface ObserveResponse {
+      success: boolean;
+      data?: { result: unknown[]; actionId?: string };
+    }
+
+    const ctx = await fetchWithContext<ObserveResponse>(
+      `${url}/v4/sessions/${sessionId}/observe`,
+      {
+        method: "POST",
+        headers: {
+          ...getHeaders("3.0.0"),
+          "x-model-api-key": "", // Clear the header to ensure body config is used
+        },
+        body: JSON.stringify({
+          instruction: "Find any link on the page",
+          options: {
+            model: {
+              modelName: "google/gemini-2.5-flash-lite",
+              apiKey: geminiApiKey,
+            },
+          },
+        }),
+      },
+    );
+
+    assertFetchStatus(
+      ctx,
+      HTTP_OK,
+      "Observe with google/gemini-2.5-flash-lite model should succeed",
+    );
+    assertFetchOk(ctx.body !== null, "Response body should be parseable", ctx);
+    assertFetchOk(ctx.body.success, "Response should indicate success", ctx);
+    assertFetchOk(
+      ctx.body.data !== undefined,
+      "Response should have data",
+      ctx,
+    );
+    assertFetchOk(
+      Array.isArray(ctx.body.data.result),
+      "Result should be an array of observed elements",
+      ctx,
+    );
+  });
+});
+
+// =============================================================================
+// SSE Streaming Tests - V3
+// =============================================================================
+
+describe("POST /v4/sessions/:id/observe with SSE streaming (V3)", () => {
+  it("should stream valid SSE events with correct structure", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v4/sessions/${sessionId}/observe`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        instruction: "Find any link on the page",
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ObserveResult>(response);
+    const { events } = ctx;
+
+    assertWithContext(
+      events.length >= 2,
+      "Should have at least starting and finished events",
+      ctx,
+    );
+
+    // Verify starting event
+    const startingEvent = assertEventExists(events, "starting", ctx);
+    assertWithContext(
+      startingEvent.type === "system",
+      "Starting event should be system type",
+      ctx,
+    );
+
+    // Verify finished event with result
+    const finishedEvent = assertEventExists(events, "finished", ctx);
+    assertWithContext(
+      finishedEvent.type === "system",
+      "Finished event should be system type",
+      ctx,
+    );
+    assertWithContext(
+      !!finishedEvent.data.result,
+      "Finished event must have result",
+      ctx,
+    );
+    assertWithContext(
+      Array.isArray(finishedEvent.data.result),
+      "Result must be an array of observed elements",
+      ctx,
+    );
+  });
+
+  it("should have correct event sequence: starting -> connected -> finished", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v4/sessions/${sessionId}/observe`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        instruction: "Find any link on the page",
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ObserveResult>(response);
+    const { events } = ctx;
+
+    assertEventExists(events, "starting", ctx);
+    assertEventExists(events, "connected", ctx);
+    assertEventExists(events, "finished", ctx);
+
+    const startingIndex = events.findIndex((e) => e.data.status === "starting");
+    const connectedIndex = events.findIndex(
+      (e) => e.data.status === "connected",
+    );
+    const finishedIndex = events.findIndex((e) => e.data.status === "finished");
+
+    assertWithContext(
+      startingIndex < connectedIndex,
+      "Starting event must come before connected event",
+      ctx,
+    );
+    assertWithContext(
+      connectedIndex < finishedIndex,
+      "Connected event must come before finished event",
+      ctx,
+    );
+  });
+
+  it("should have valid UUID for each event id", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v4/sessions/${sessionId}/observe`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        instruction: "Find any link on the page",
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ObserveResult>(response);
+    const { events } = ctx;
+
+    const uuidRegex =
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+    for (const event of events) {
+      assertWithContext(
+        uuidRegex.test(event.id),
+        `Event id should be a valid UUID format, got: ${event.id}`,
+        ctx,
+      );
+    }
+  });
+
+  it("should return observed elements with expected properties", async () => {
+    const url = getBaseUrl();
+
+    const response = await fetch(`${url}/v4/sessions/${sessionId}/observe`, {
+      method: "POST",
+      headers: getHeaders("3.0.0"),
+      body: JSON.stringify({
+        instruction: "Find any link on the page",
+        streamResponse: true,
+      }),
+    });
+
+    const ctx = await readTypedSSEStreamWithContext<ObserveResult>(response);
+    const { events } = ctx;
+
+    const finishedEvent = assertEventExists(events, "finished", ctx);
+    assertWithContext(!!finishedEvent.data.result, "Should have result", ctx);
+    assertWithContext(
+      Array.isArray(finishedEvent.data.result),
+      "Result should be an array",
+      ctx,
+    );
+
+    // If there are observed elements, verify they have expected structure
+    if (finishedEvent.data.result.length > 0) {
+      const firstElement = finishedEvent.data.result[0] as Record<
+        string,
+        unknown
+      >;
+      assertWithContext(
+        typeof firstElement === "object",
+        "Each observed element should be an object",
+        ctx,
+      );
+      // Observed elements typically have selector and description
+      assertWithContext(
+        "selector" in firstElement || "description" in firstElement,
+        "Observed element should have selector or description",
+        ctx,
+      );
+    }
+  });
+});
diff --git a/packages/server-v4/test/integration/v4/replay.test.ts b/packages/server-v4/test/integration/v4/replay.test.ts
new file mode 100644
index 000000000..b923c4541
--- /dev/null
+++ b/packages/server-v4/test/integration/v4/replay.test.ts
@@ -0,0 +1,59 @@
+import { describe, it } from "node:test";
+import { Api } from "@browserbasehq/stagehand";
+
+import {
+  assertFetchOk,
+  assertFetchStatus,
+  fetchWithContext,
+  getBaseUrl,
+  getHeaders,
+  HTTP_OK,
+} from "../utils.js";
+
+describe("GET /v4/sessions/:id/replay (V3)", () => {
+  it("should return an empty replay result for local server", async () => {
+    const url = getBaseUrl();
+    const headers = getHeaders("3.0.0");
+
+    const ctx = await fetchWithContext<unknown>(
+      `${url}/v4/sessions/test-session-id/replay`,
+      {
+        method: "GET",
+        headers,
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Replay should return 200");
+    assertFetchOk(ctx.body !== null, "Response should have body", ctx);
+    const parsedBody = Api.ReplayResponseSchema.safeParse(ctx.body);
+    assertFetchOk(
+      parsedBody.success,
+      "Replay response should match schema",
+      ctx,
+    );
+    if (!parsedBody.success) {
+      return;
+    }
+
+    assertFetchOk(
+      parsedBody.data.success,
+      "Response should indicate success",
+      ctx,
+    );
+    assertFetchOk(
+      parsedBody.data.data !== undefined,
+      "Response should include data",
+      ctx,
+    );
+    assertFetchOk(
+      Array.isArray(parsedBody.data.data.pages),
+      "Replay pages should be an array",
+      ctx,
+    );
+    assertFetchOk(
+      parsedBody.data.data.pages.length === 0,
+      "Replay pages should be empty on local server",
+      ctx,
+    );
+  });
+});
diff --git a/packages/server-v4/test/integration/v4/start.test.ts b/packages/server-v4/test/integration/v4/start.test.ts
new file mode 100644
index 000000000..f8ab7e672
--- /dev/null
+++ b/packages/server-v4/test/integration/v4/start.test.ts
@@ -0,0 +1,894 @@
+import { spawn } from "node:child_process";
+import { execFileSync } from "node:child_process";
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
+import net from "node:net";
+import { fileURLToPath } from "node:url";
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import Browserbase from "@browserbasehq/sdk";
+import { chromium } from "playwright";
+
+import {
+  assertFetchOk,
+  assertFetchStatus,
+  endSession,
+  fetchWithContext,
+  getBaseUrl,
+  getHeaders,
+  LOCAL_BROWSER_BODY,
+  HTTP_BAD_REQUEST,
+  HTTP_OK,
+} from "../utils.js";
+import type { BrowserbaseRegion } from "@browserbasehq/stagehand";
+
+// =============================================================================
+// Response Type Definitions
+// =============================================================================
+
+interface StartSuccessResponse {
+  success: true;
+  data: {
+    sessionId: string;
+    cdpUrl: string;
+    available: boolean;
+  };
+}
+
+interface StartUnavailableResponse {
+  success: true;
+  data: {
+    sessionId: null;
+    available: false;
+  };
+}
+
+interface StartErrorResponse {
+  success: false;
+  message: string;
+}
+
+type StartResponse =
+  | StartSuccessResponse
+  | StartUnavailableResponse
+  | StartErrorResponse;
+
+function isSuccessResponse(
+  response: StartResponse,
+): response is StartSuccessResponse {
+  return response.success && response.data.sessionId !== null;
+}
+
+type SeaHandle = {
+  proc: ChildProcessWithoutNullStreams;
+  baseUrl: string;
+  logs: string[];
+};
+
+type SupervisorInfo = {
+  pid: number;
+  args: string;
+  chromePid?: number;
+};
+
+const repoRoot = (() => {
+  const value = fileURLToPath(import.meta.url).replaceAll("\\", "/");
+  const root = value.split("/packages/server-v4/")[0];
+  if (root === value) {
+    throw new Error(`Unable to determine repo root from ${value}`);
+  }
+  return root;
+})();
+
+const defaultSeaBinaryName = `stagehand-server-v4-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`;
+const seaBinaryPath = `${repoRoot}/packages/server-v4/dist/sea/${process.env.SEA_BINARY_NAME ?? defaultSeaBinaryName}`;
+const bbApiKey = process.env.BROWSERBASE_API_KEY;
+const bbProjectId = process.env.BROWSERBASE_PROJECT_ID;
+const activeSea = new Set<SeaHandle>();
+
+afterEach(async () => {
+  await Promise.all(
+    [...activeSea].map(async (handle) => {
+      await stopSeaServer(handle);
+      activeSea.delete(handle);
+    }),
+  );
+});
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function getFreePort(): Promise<number> {
+  return await new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("Failed to allocate an ephemeral port"));
+        return;
+      }
+      const { port } = addr;
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(port);
+      });
+    });
+    server.on("error", reject);
+  });
+}
+
+function listProcesses(): Array<{ pid: number; args: string }> {
+  const output = execFileSync("ps", ["-axo", "pid=,args="], {
+    encoding: "utf8",
+  });
+  return output
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const firstSpace = line.indexOf(" ");
+      if (firstSpace === -1) {
+        return { pid: Number(line), args: "" };
+      }
+      return {
+        pid: Number(line.slice(0, firstSpace)),
+        args: line.slice(firstSpace + 1),
+      };
+    })
+    .filter((entry) => Number.isFinite(entry.pid) && entry.pid > 0);
+}
+
+function parseSupervisorConfigArg(args: string): {
+  kind?: string;
+  pid?: number;
+  parentPid?: number;
+} | null {
+  const prefix = "--supervisor-config=";
+  const index = args.indexOf(prefix);
+  if (index === -1) return null;
+  const raw = args.slice(index + prefix.length).trim();
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw) as {
+      kind?: string;
+      pid?: number;
+      parentPid?: number;
+    };
+  } catch {
+    return null;
+  }
+}
+
+function findLocalSupervisorByParentPid(
+  parentPid: number,
+): SupervisorInfo | null {
+  const candidates = listProcesses()
+    .map((entry) => ({
+      ...entry,
+      config: parseSupervisorConfigArg(entry.args),
+    }))
+    .filter(
+      (entry) =>
+        entry.config?.kind === "LOCAL" && entry.config.parentPid === parentPid,
+    )
+    .sort((a, b) => b.pid - a.pid);
+
+  const entry = candidates[0];
+  if (!entry) return null;
+
+  return {
+    pid: entry.pid,
+    args: entry.args,
+    chromePid:
+      typeof entry.config?.pid === "number" && Number.isFinite(entry.config.pid)
+        ? entry.config.pid
+        : undefined,
+  };
+}
+
+function isPidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const err = error as NodeJS.ErrnoException;
+    if (err.code === "ESRCH") return false;
+    return true;
+  }
+}
+
+async function waitForValue<T>(
+  read: () => T | null,
+  timeoutMs: number,
+  intervalMs = 200,
+): Promise<T> {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const value = read();
+    if (value !== null) return value;
+    await sleep(intervalMs);
+  }
+  throw new Error(`Timed out after ${timeoutMs}ms`);
+}
+
+async function waitForPidState(
+  pid: number,
+  shouldBeAlive: boolean,
+  timeoutMs: number,
+): Promise<void> {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (isPidAlive(pid) === shouldBeAlive) return;
+    await sleep(200);
+  }
+  const entry = listProcesses().find((candidate) => candidate.pid === pid);
+  const details = entry ? ` args=${entry.args}` : "";
+  throw new Error(
+    `PID ${pid} did not become ${shouldBeAlive ? "alive" : "dead"} within ${timeoutMs}ms${details}`,
+  );
+}
+
+async function waitForServerReady(baseUrl: string, timeoutMs = 30_000) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    try {
+      const response = await fetch(`${baseUrl}/healthz`);
+      if (response.ok) return;
+    } catch {
+      // retry
+    }
+    await sleep(500);
+  }
+  throw new Error(
+    `Server did not become ready at ${baseUrl} within ${timeoutMs}ms`,
+  );
+}
+
+async function waitForProcessExit(
+  proc: ChildProcessWithoutNullStreams,
+  timeoutMs: number,
+): Promise<boolean> {
+  if (proc.exitCode !== null) {
+    return true;
+  }
+  return await new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(false), timeoutMs);
+    proc.once("exit", () => {
+      clearTimeout(timer);
+      resolve(true);
+    });
+  });
+}
+
+async function startSeaServer(
+  envOverrides: Record<string, string> = {},
+): Promise<SeaHandle> {
+  const port = await getFreePort();
+  const baseUrl = `http://127.0.0.1:${port}`;
+  const logs: string[] = [];
+  const proc = spawn(
+    seaBinaryPath,
+    ["--node-options=--no-lazy --enable-source-maps"],
+    {
+      env: {
+        ...process.env,
+        ...envOverrides,
+        NODE_ENV: "production",
+        PORT: String(port),
+        STAGEHAND_SEA_CACHE_DIR:
+          process.env.STAGEHAND_SEA_CACHE_DIR ?? `${repoRoot}/.stagehand-sea`,
+      },
+      stdio: ["ignore", "pipe", "pipe"],
+    },
+  );
+
+  proc.stdout.on("data", (chunk: Buffer) => {
+    const value = chunk.toString().trim();
+    if (value) logs.push(value);
+  });
+  proc.stderr.on("data", (chunk: Buffer) => {
+    const value = chunk.toString().trim();
+    if (value) logs.push(value);
+  });
+
+  if (!proc.pid) {
+    throw new Error("SEA process did not provide a PID");
+  }
+
+  const handle: SeaHandle = { proc, baseUrl, logs };
+  activeSea.add(handle);
+
+  try {
+    await waitForServerReady(baseUrl);
+    return handle;
+  } catch (error) {
+    await stopSeaServer(handle);
+    const tail = logs.slice(-30).join("\n");
+    throw new Error(
+      `Failed to start SEA server at ${baseUrl}: ${(error as Error).message}\n${tail}`,
+      {
+        cause: error,
+      },
+    );
+  }
+}
+
+async function stopSeaServer(handle: SeaHandle): Promise<void> {
+  const { proc } = handle;
+  if (proc.exitCode !== null) return;
+  try {
+    proc.kill("SIGTERM");
+  } catch {
+    // ignore
+  }
+  const exited = await waitForProcessExit(proc, 5_000);
+  if (!exited) {
+    try {
+      proc.kill("SIGKILL");
+    } catch {
+      // ignore
+    }
+    await waitForProcessExit(proc, 5_000);
+  }
+}
+
+async function forceKillSeaServer(handle: SeaHandle): Promise<void> {
+  const { proc } = handle;
+  if (proc.exitCode !== null) return;
+  try {
+    proc.kill("SIGKILL");
+  } catch {
+    // ignore
+  }
+  await waitForProcessExit(proc, 5_000);
+}
+
+async function startKeepAliveFalseLocalSession(baseUrl: string): Promise<{
+  sessionId: string;
+  cdpUrl: string;
+}> {
+  const headers = getHeaders("3.0.0");
+  const ctx = await fetchWithContext<StartResponse>(
+    `${baseUrl}/v4/sessions/start`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        modelName: "gpt-4.1-nano",
+        keepAlive: false,
+        ...LOCAL_BROWSER_BODY,
+      }),
+    },
+  );
+
+  assert.equal(
+    ctx.status,
+    HTTP_OK,
+    `Expected local /start to succeed, got ${ctx.status}\n${ctx.debugSummary()}`,
+  );
+  assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+  assertFetchOk(
+    isSuccessResponse(ctx.body),
+    "Should return a successful start response",
+    ctx,
+  );
+  return {
+    sessionId: ctx.body.data.sessionId,
+    cdpUrl: ctx.body.data.cdpUrl,
+  };
+}
+
+async function startKeepAliveFalseBrowserbaseSession(
+  baseUrl: string,
+): Promise<string> {
+  assert.ok(bbApiKey, "BROWSERBASE_API_KEY must be set");
+  assert.ok(bbProjectId, "BROWSERBASE_PROJECT_ID must be set");
+  const headers = {
+    ...getHeaders("3.0.0"),
+    "x-bb-api-key": bbApiKey,
+    "x-bb-project-id": bbProjectId,
+  };
+  const ctx = await fetchWithContext<StartResponse>(
+    `${baseUrl}/v4/sessions/start`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        modelName: "gpt-4.1-nano",
+        keepAlive: false,
+        experimental: true,
+        browser: { type: "browserbase" },
+      }),
+    },
+  );
+
+  assert.equal(
+    ctx.status,
+    HTTP_OK,
+    `Expected browserbase /start to succeed, got ${ctx.status}\n${ctx.debugSummary()}`,
+  );
+  assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+  assertFetchOk(
+    isSuccessResponse(ctx.body),
+    "Should return a successful start response",
+    ctx,
+  );
+  const sessionId = ctx.body.data.sessionId;
+
+  // Browserbase Stagehand init is lazy; navigate once to ensure supervisor is running.
+  const navigateCtx = await fetchWithContext<{ success?: boolean }>(
+    `${baseUrl}/v4/sessions/${sessionId}/navigate`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ url: "https://example.com", frameId: "" }),
+    },
+  );
+  assert.equal(
+    navigateCtx.status,
+    HTTP_OK,
+    `Expected browserbase /navigate to succeed, got ${navigateCtx.status}\n${navigateCtx.debugSummary()}`,
+  );
+
+  return sessionId;
+}
+
+async function closeLocalBrowserViaCdp(cdpUrl: string): Promise<void> {
+  const browser = await chromium.connectOverCDP(cdpUrl);
+  try {
+    const context = browser.contexts()[0];
+    if (!context) return;
+    const page = context.pages()[0] ?? (await context.newPage());
+    const cdp = await context.newCDPSession(page);
+    await cdp.send("Browser.close");
+  } finally {
+    await browser.close().catch(() => {
+      // best-effort close of Playwright transport
+    });
+  }
+}
+
+async function waitForBrowserbaseNotRunning(
+  sessionId: string,
+  timeoutMs: number,
+): Promise<string> {
+  assert.ok(bbApiKey, "BROWSERBASE_API_KEY must be set");
+  const bb = new Browserbase({ apiKey: bbApiKey });
+
+  let lastStatus = "UNKNOWN";
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    try {
+      const snapshot = (await bb.sessions.retrieve(sessionId)) as {
+        status?: string;
+      };
+      lastStatus = snapshot.status ?? "UNKNOWN";
+      if (lastStatus !== "RUNNING") {
+        return lastStatus;
+      }
+    } catch {
+      return "RETRIEVE_FAILED";
+    }
+    await sleep(1000);
+  }
+  throw new Error(
+    `Browserbase session ${sessionId} stayed RUNNING for ${timeoutMs}ms (last status=${lastStatus})`,
+  );
+}
+
+async function requestBrowserbaseReleaseBestEffort(sessionId: string) {
+  if (!bbApiKey || !bbProjectId) return;
+  const bb = new Browserbase({ apiKey: bbApiKey });
+  try {
+    await bb.sessions.update(sessionId, {
+      status: "REQUEST_RELEASE",
+      projectId: bbProjectId,
+    });
+  } catch {
+    // best-effort cleanup
+  }
+}
+
+// =============================================================================
+// V3 Format Tests (x-sdk-version: 3.x.x header)
+// =============================================================================
+
+describe("POST /v4/sessions/start - V3 format", () => {
+  const headers = getHeaders("3.0.0");
+  const localBrowser = LOCAL_BROWSER_BODY;
+
+  it("should start session with modelName string and V3 header", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v4/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ modelName: "gpt-4.1-nano", ...localBrowser }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+    assertFetchOk(ctx.body.data.available, "Session should be available", ctx);
+    assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+    assertFetchOk(!!ctx.body.data.cdpUrl, "Should have cdpUrl", ctx);
+
+    await endSession(ctx.body.data.sessionId, headers);
+  });
+
+  it("should start session with experimental flag", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v4/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          experimental: true,
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+
+    await endSession(ctx.body.data.sessionId, headers);
+  });
+
+  it("should accept x-language header for python V3", async () => {
+    const url = getBaseUrl();
+    const pythonHeaders = getHeaders("1.0.0", "python");
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v4/sessions/start`,
+      {
+        method: "POST",
+        headers: pythonHeaders,
+        body: JSON.stringify({ modelName: "gpt-4.1-nano", ...localBrowser }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+
+    await endSession(ctx.body.data.sessionId, pythonHeaders);
+  });
+
+  it("should start session with extended options (timeouts, verbose)", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v4/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          actTimeoutMs: 30000,
+          domSettleTimeoutMs: 5000,
+          verbose: "2",
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+    assertFetchOk(ctx.body.data.available, "Session should be available", ctx);
+    assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+
+    await endSession(ctx.body.data.sessionId, headers);
+  });
+
+  it("should return cdpUrl as a valid WebSocket URL for local browser", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v4/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ modelName: "gpt-4.1-nano", ...localBrowser }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+    // cdpUrl should not be empty since we eagerly launch the browser
+    assertFetchOk(
+      ctx.body.data.cdpUrl !== "",
+      "cdpUrl should not be empty",
+      ctx,
+    );
+    // cdpUrl should be a valid WebSocket URL
+    assertFetchOk(
+      ctx.body.data.cdpUrl.startsWith("ws://"),
+      "cdpUrl should be a WebSocket URL",
+      ctx,
+    );
+
+    await endSession(ctx.body.data.sessionId, headers);
+  });
+
+  it("should return provided cdpUrl when explicit cdpUrl is passed", async () => {
+    const url = getBaseUrl();
+    const providedCdpUrl = "ws://localhost:9222/devtools/browser/test";
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v4/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browser: { type: "local", cdpUrl: providedCdpUrl },
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.cdpUrl === providedCdpUrl,
+      "cdpUrl should match provided value",
+      ctx,
+    );
+
+    await endSession(ctx.body.data.sessionId, headers);
+  });
+
+  it("should return error for browserbase requests without API key", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v4/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browser: { type: "browserbase" },
+        }),
+      },
+    );
+
+    // Should fail because browserbase requires x-bb-api-key and x-bb-project-id headers
+    assertFetchStatus(ctx, HTTP_BAD_REQUEST, "Request should fail with 400");
+  });
+
+  // =============================================================================
+  // Multi-Region Support Tests
+  // =============================================================================
+
+  it("should accept non-default region in browserbaseSessionCreateParams", async () => {
+    const url = getBaseUrl();
+
+    // Test with us-east-1 region - server should accept this request
+    // Note: Local browser sessions don't actually use the region, but the server
+    // should still accept the parameter without returning { available: false }
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v4/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browserbaseSessionCreateParams: {
+            region: "us-east-1" as BrowserbaseRegion,
+          },
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+    // The key assertion: non-default regions should NOT return available: false
+    assertFetchOk(
+      ctx.body.data.available === true,
+      "Session should be available for non-default regions",
+      ctx,
+    );
+    assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+
+    await endSession(ctx.body.data.sessionId, headers);
+  });
+
+  it("should accept eu-central-1 region in browserbaseSessionCreateParams", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v4/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browserbaseSessionCreateParams: {
+            region: "eu-central-1" as BrowserbaseRegion,
+          },
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.available === true,
+      "Session should be available for eu-central-1 region",
+      ctx,
+    );
+    assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+
+    await endSession(ctx.body.data.sessionId, headers);
+  });
+
+  it("should accept ap-southeast-1 region in browserbaseSessionCreateParams", async () => {
+    const url = getBaseUrl();
+
+    const ctx = await fetchWithContext<StartResponse>(
+      `${url}/v4/sessions/start`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelName: "gpt-4.1-nano",
+          browserbaseSessionCreateParams: {
+            region: "ap-southeast-1" as BrowserbaseRegion,
+          },
+          ...localBrowser,
+        }),
+      },
+    );
+
+    assertFetchStatus(ctx, HTTP_OK, "Request should succeed");
+    assertFetchOk(ctx.body !== null, "Should have response body", ctx);
+    assertFetchOk(
+      isSuccessResponse(ctx.body),
+      "Should be a success response",
+      ctx,
+    );
+    assertFetchOk(
+      ctx.body.data.available === true,
+      "Session should be available for ap-southeast-1 region",
+      ctx,
+    );
+    assertFetchOk(!!ctx.body.data.sessionId, "Should have sessionId", ctx);
+
+    await endSession(ctx.body.data.sessionId, headers);
+  });
+});
+
+describe("POST /v4/sessions/start - keepAlive=false supervision in SEA", () => {
+  it("spawns a supervisor and exits it when chrome dies", async () => {
+    const handle = await startSeaServer();
+    const seaPid = handle.proc.pid;
+    assert.ok(seaPid, "SEA server must have a PID");
+
+    const { cdpUrl } = await startKeepAliveFalseLocalSession(handle.baseUrl);
+    const supervisor = await waitForValue(
+      () => findLocalSupervisorByParentPid(seaPid),
+      10_000,
+    );
+
+    assert.ok(
+      supervisor.chromePid,
+      `Expected local supervisor to include --chrome-pid. args=${supervisor.args}`,
+    );
+    assert.ok(
+      isPidAlive(supervisor.pid),
+      `Supervisor PID ${supervisor.pid} should be alive`,
+    );
+    assert.ok(
+      isPidAlive(supervisor.chromePid),
+      `Chrome PID ${supervisor.chromePid} should be alive`,
+    );
+
+    await closeLocalBrowserViaCdp(cdpUrl);
+
+    await waitForPidState(supervisor.chromePid, false, 10_000);
+    await waitForPidState(supervisor.pid, false, 10_000);
+    assert.ok(
+      isPidAlive(seaPid),
+      "SEA process should stay alive after chrome dies",
+    );
+  });
+
+  it("force-killing SEA kills local chrome and exits supervisor within 10s", async () => {
+    const handle = await startSeaServer();
+    const seaPid = handle.proc.pid;
+    assert.ok(seaPid, "SEA server must have a PID");
+
+    await startKeepAliveFalseLocalSession(handle.baseUrl);
+    const supervisor = await waitForValue(
+      () => findLocalSupervisorByParentPid(seaPid),
+      10_000,
+    );
+
+    assert.ok(
+      supervisor.chromePid,
+      `Expected local supervisor to include --chrome-pid. args=${supervisor.args}`,
+    );
+    assert.ok(
+      isPidAlive(supervisor.pid),
+      `Supervisor PID ${supervisor.pid} should be alive`,
+    );
+    assert.ok(
+      isPidAlive(supervisor.chromePid),
+      `Chrome PID ${supervisor.chromePid} should be alive`,
+    );
+
+    await forceKillSeaServer(handle);
+
+    await waitForPidState(supervisor.pid, false, 10_000);
+    await waitForPidState(supervisor.chromePid, false, 10_000);
+  });
+
+  it("force-killing SEA ends Browserbase session when keepAlive=false", async () => {
+    const handle = await startSeaServer({ BB_ENV: "prod" });
+    const sessionId = await startKeepAliveFalseBrowserbaseSession(
+      handle.baseUrl,
+    );
+
+    try {
+      await forceKillSeaServer(handle);
+      const finalStatus = await waitForBrowserbaseNotRunning(sessionId, 30_000);
+      assert.notEqual(
+        finalStatus,
+        "RUNNING",
+        "Browserbase session should not remain RUNNING after SEA kill",
+      );
+    } finally {
+      await requestBrowserbaseReleaseBestEffort(sessionId);
+    }
+  });
+});
diff --git a/packages/server-v4/tsconfig.json b/packages/server-v4/tsconfig.json
new file mode 100644
index 000000000..dbb9efc48
--- /dev/null
+++ b/packages/server-v4/tsconfig.json
@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "verbatimModuleSyntax": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
diff --git a/packages/server-v4/tsconfig.tests.json b/packages/server-v4/tsconfig.tests.json
new file mode 100644
index 000000000..4bb0384e3
--- /dev/null
+++ b/packages/server-v4/tsconfig.tests.json
@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "test",
+    "outDir": "dist/tests",
+    "declaration": false,
+    "noEmit": false
+  },
+  "include": ["test/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}
diff --git a/packages/server-v4/vitest.config.ts b/packages/server-v4/vitest.config.ts
new file mode 100644
index 000000000..570df33ab
--- /dev/null
+++ b/packages/server-v4/vitest.config.ts
@@ -0,0 +1,9 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["test/**/*.test.ts"],
+  },
+});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
new file mode 100644
index 000000000..1f0e160d9
--- /dev/null
+++ b/pnpm-lock.yaml
@@ -0,0 +1,14431 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    devDependencies:
+      '@changesets/changelog-github':
+        specifier: ^0.5.0
+        version: 0.5.1
+      '@changesets/cli':
+        specifier: ^2.27.9
+        version: 2.29.2
+      '@eslint/js':
+        specifier: ^10.0.1
+        version: 10.0.1(eslint@10.0.2(jiti@1.21.7))
+      c8:
+        specifier: ^10.1.3
+        version: 10.1.3
+      dotenv:
+        specifier: ^17.3.1
+        version: 17.3.1
+      esbuild:
+        specifier: 0.27.2
+        version: 0.27.2
+      eslint:
+        specifier: ^10.0.2
+        version: 10.0.2(jiti@1.21.7)
+      eslint-plugin-security:
+        specifier: ^3.0.1
+        version: 3.0.1
+      globals:
+        specifier: ^15.13.0
+        version: 15.15.0
+      junit-to-ctrf:
+        specifier: ^0.0.14
+        version: 0.0.14
+      prettier:
+        specifier: ^3.2.5
+        version: 3.5.3
+      source-map:
+        specifier: ^0.7.4
+        version: 0.7.4
+      tsx:
+        specifier: ^4.19.4
+        version: 4.19.4
+      turbo:
+        specifier: ^2.8.10
+        version: 2.8.10
+      typescript:
+        specifier: 5.8.3
+        version: 5.8.3
+      typescript-eslint:
+        specifier: ^8.56.1
+        version: 8.56.1(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3)
+
+  packages/cli:
+    dependencies:
+      '@browserbasehq/stagehand':
+        specifier: workspace:*
+        version: link:../core
+      commander:
+        specifier: ^12.0.0
+        version: 12.1.0
+      dotenv:
+        specifier: ^16.4.5
+        version: 16.4.5
+      pino:
+        specifier: ^9.6.0
+        version: 9.14.0
+      pino-pretty:
+        specifier: ^13.0.0
+        version: 13.0.0
+      playwright:
+        specifier: ^1.50.0
+        version: 1.52.0
+      ws:
+        specifier: ^8.18.0
+        version: 8.18.3(bufferutil@4.0.9)
+    devDependencies:
+      '@eslint/js':
+        specifier: ^9.16.0
+        version: 9.39.4
+      '@types/node':
+        specifier: ^20.11.30
+        version: 20.17.32
+      eslint:
+        specifier: ^9.16.0
+        version: 9.39.4(jiti@1.21.7)
+      globals:
+        specifier: ^15.13.0
+        version: 15.15.0
+      prettier:
+        specifier: ^3.2.5
+        version: 3.5.3
+      tsup:
+        specifier: ^8.2.1
+        version: 8.5.1(jiti@1.21.7)(postcss@8.5.6)(tsx@4.19.4)(typescript@5.8.3)(yaml@2.7.1)
+      tsx:
+        specifier: ^4.10.5
+        version: 4.19.4
+      typescript:
+        specifier: ^5.2.2
+        version: 5.8.3
+      typescript-eslint:
+        specifier: ^8.17.0
+        version: 8.56.1(eslint@9.39.4(jiti@1.21.7))(typescript@5.8.3)
+      vitest:
+        specifier: ^1.6.0
+        version: 1.6.1(@types/node@20.17.32)(jsdom@24.1.3(bufferutil@4.0.9))
+
+  packages/core:
+    dependencies:
+      '@ai-sdk/provider':
+        specifier: ^2.0.0
+        version: 2.0.1
+      '@anthropic-ai/sdk':
+        specifier: 0.39.0
+        version: 0.39.0
+      '@browserbasehq/sdk':
+        specifier: ^2.7.0
+        version: 2.7.0
+      '@google/genai':
+        specifier: ^1.22.0
+        version: 1.24.0(@modelcontextprotocol/sdk@1.17.2)(bufferutil@4.0.9)
+      '@langchain/openai':
+        specifier: ^0.4.4
+        version: 0.4.9(@langchain/core@0.3.50(openai@4.87.1(ws@8.18.3(bufferutil@4.0.9))(zod@4.2.1)))(ws@8.18.3(bufferutil@4.0.9))
+      '@modelcontextprotocol/sdk':
+        specifier: ^1.17.2
+        version: 1.17.2
+      ai:
+        specifier: ^5.0.133
+        version: 5.0.133(zod@4.2.1)
+      deepmerge:
+        specifier: ^4.3.1
+        version: 4.3.1
+      devtools-protocol:
+        specifier: ^0.0.1464554
+        version: 0.0.1464554
+      fetch-cookie:
+        specifier: ^3.1.0
+        version: 3.1.0
+      openai:
+        specifier: ^4.87.1
+        version: 4.87.1(ws@8.18.3(bufferutil@4.0.9))(zod@4.2.1)
+      pino:
+        specifier: ^9.6.0
+        version: 9.14.0
+      pino-pretty:
+        specifier: ^13.0.0
+        version: 13.0.0
+      uuid:
+        specifier: ^11.1.0
+        version: 11.1.0
+      ws:
+        specifier: ^8.18.0
+        version: 8.18.3(bufferutil@4.0.9)
+      zod-to-json-schema:
+        specifier: ^3.25.0
+        version: 3.25.0(zod@4.2.1)
+    optionalDependencies:
+      '@ai-sdk/amazon-bedrock':
+        specifier: ^3.0.73
+        version: 3.0.73(zod@4.2.1)
+      '@ai-sdk/anthropic':
+        specifier: ^2.0.34
+        version: 2.0.57(zod@4.2.1)
+      '@ai-sdk/azure':
+        specifier: ^2.0.54
+        version: 2.0.54(zod@4.2.1)
+      '@ai-sdk/cerebras':
+        specifier: ^1.0.25
+        version: 1.0.25(zod@4.2.1)
+      '@ai-sdk/deepseek':
+        specifier: ^1.0.23
+        version: 1.0.23(zod@4.2.1)
+      '@ai-sdk/google':
+        specifier: ^2.0.53
+        version: 2.0.53(zod@4.2.1)
+      '@ai-sdk/google-vertex':
+        specifier: ^3.0.70
+        version: 3.0.85(zod@4.2.1)
+      '@ai-sdk/groq':
+        specifier: ^2.0.24
+        version: 2.0.24(zod@4.2.1)
+      '@ai-sdk/mistral':
+        specifier: ^2.0.19
+        version: 2.0.19(zod@4.2.1)
+      '@ai-sdk/openai':
+        specifier: ^2.0.53
+        version: 2.0.53(zod@4.2.1)
+      '@ai-sdk/perplexity':
+        specifier: ^2.0.13
+        version: 2.0.13(zod@4.2.1)
+      '@ai-sdk/togetherai':
+        specifier: ^1.0.23
+        version: 1.0.23(zod@4.2.1)
+      '@ai-sdk/xai':
+        specifier: ^2.0.26
+        version: 2.0.26(zod@4.2.1)
+      '@langchain/core':
+        specifier: ^0.3.40
+        version: 0.3.50(openai@4.87.1(ws@8.18.3(bufferutil@4.0.9))(zod@4.2.1))
+      bufferutil:
+        specifier: ^4.0.9
+        version: 4.0.9
+      chrome-launcher:
+        specifier: ^1.2.0
+        version: 1.2.0
+      ollama-ai-provider-v2:
+        specifier: ^1.5.0
+        version: 1.5.0(zod@4.2.1)
+      patchright-core:
+        specifier: ^1.55.2
+        version: 1.55.2
+      playwright:
+        specifier: ^1.52.0
+        version: 1.52.0
+      playwright-core:
+        specifier: ^1.54.1
+        version: 1.54.2
+      puppeteer-core:
+        specifier: ^22.8.0
+        version: 22.15.0(bufferutil@4.0.9)
+    devDependencies:
+      '@playwright/test':
+        specifier: ^1.42.1
+        version: 1.54.2
+      '@types/adm-zip':
+        specifier: ^0.5.7
+        version: 0.5.7
+      '@types/jsdom':
+        specifier: ^27.0.0
+        version: 27.0.0
+      '@types/node':
+        specifier: ^20.11.30
+        version: 20.17.32
+      '@types/ws':
+        specifier: ^8.5.13
+        version: 8.18.1
+      '@vitest/coverage-v8':
+        specifier: ^4.0.8
+        version: 4.0.18(vitest@4.0.8(@types/debug@4.1.12)(@types/node@20.17.32)(jiti@1.21.7)(jsdom@24.1.3(bufferutil@4.0.9))(tsx@4.19.4)(yaml@2.7.1))
+      adm-zip:
+        specifier: ^0.5.16
+        version: 0.5.16
+      chalk:
+        specifier: ^5.4.1
+        version: 5.4.1
+      eslint:
+        specifier: 10.0.2
+        version: 10.0.2(jiti@1.21.7)
+      jsdom:
+        specifier: ^24.0.0
+        version: 24.1.3(bufferutil@4.0.9)
+      prettier:
+        specifier: ^3.2.5
+        version: 3.5.3
+      tsx:
+        specifier: '*'
+        version: 4.19.4
+      vitest:
+        specifier: ^4.0.8
+        version: 4.0.8(@types/debug@4.1.12)(@types/node@20.17.32)(jiti@1.21.7)(jsdom@24.1.3(bufferutil@4.0.9))(tsx@4.19.4)(yaml@2.7.1)
+      zod:
+        specifier: ^3.25.76 || ^4.2.0
+        version: 4.2.1
+
+  packages/docs:
+    dependencies:
+      mintlify:
+        specifier: ^4.2.47
+        version: 4.2.78(@types/node@22.13.1)(@types/react@19.1.3)(bufferutil@4.0.9)(react-dom@18.3.1(react@18.3.1))(typescript@5.9.3)
+      zod:
+        specifier: ^4.2.1
+        version: 4.2.1
+
+  packages/evals:
+    dependencies:
+      '@ai-sdk/provider':
+        specifier: ^2.0.0
+        version: 2.0.1
+      '@browserbasehq/stagehand':
+        specifier: workspace:*
+        version: link:../core
+      ai:
+        specifier: ^5.0.133
+        version: 5.0.133(zod@4.2.1)
+      dotenv:
+        specifier: ^17.3.1
+        version: 17.3.1
+      openai:
+        specifier: ^4.87.1
+        version: 4.87.1(ws@8.18.3(bufferutil@4.0.9))(zod@4.2.1)
+      sharp:
+        specifier: ^0.34.5
+        version: 0.34.5
+      zod:
+        specifier: ^4.2.1
+        version: 4.2.1
+    devDependencies:
+      braintrust:
+        specifier: ^0.4.7
+        version: 0.4.7(zod@4.2.1)
+      chalk:
+        specifier: ^5.4.1
+        version: 5.4.1
+      string-comparison:
+        specifier: ^1.3.0
+        version: 1.3.0
+      tsx:
+        specifier: '*'
+        version: 4.19.4
+
+  packages/server-v3:
+    dependencies:
+      '@browserbasehq/sdk':
+        specifier: ^2.7.0
+        version: 2.7.0
+      '@browserbasehq/stagehand':
+        specifier: workspace:*
+        version: link:../core
+      '@fastify/cors':
+        specifier: ^11.0.1
+        version: 11.1.0
+      '@fastify/swagger':
+        specifier: ^9.6.1
+        version: 9.6.1
+      '@fastify/swagger-ui':
+        specifier: ^5.2.3
+        version: 5.2.3
+      '@t3-oss/env-core':
+        specifier: ^0.13.8
+        version: 0.13.8(arktype@2.1.20)(typescript@5.9.3)(zod@4.2.1)
+      fastify:
+        specifier: ^5.3.2
+        version: 5.6.2
+      fastify-metrics:
+        specifier: ^12.1.0
+        version: 12.1.0(fastify@5.6.2)
+      fastify-plugin:
+        specifier: ^4.5.1
+        version: 4.5.1
+      fastify-zod-openapi:
+        specifier: ^5.5.0
+        version: 5.5.0(@fastify/swagger-ui@5.2.3)(@fastify/swagger@9.6.1)(fastify@5.6.2)(zod@4.2.1)
+      http-status-codes:
+        specifier: ^2.3.0
+        version: 2.3.0
+      pino:
+        specifier: ^9.7.0
+        version: 9.14.0
+      pino-pretty:
+        specifier: ^11.3.0
+        version: 11.3.0
+      playwright:
+        specifier: 1.52.0
+        version: 1.52.0
+      uuid:
+        specifier: ^11.0.5
+        version: 11.1.0
+      zod:
+        specifier: ^4.2.1
+        version: 4.2.1
+    devDependencies:
+      '@types/node':
+        specifier: 22.13.1
+        version: 22.13.1
+      eslint:
+        specifier: 10.0.2
+        version: 10.0.2(jiti@1.21.7)
+      eslint-plugin-security:
+        specifier: ^3.0.1
+        version: 3.0.1
+      openai:
+        specifier: 4.87.1
+        version: 4.87.1(ws@8.18.3(bufferutil@4.0.9))(zod@4.2.1)
+      postject:
+        specifier: 1.0.0-alpha.6
+        version: 1.0.0-alpha.6
+      prettier:
+        specifier: ^3.2.5
+        version: 3.5.3
+      source-map:
+        specifier: ^0.7.4
+        version: 0.7.4
+      tsc-alias:
+        specifier: ^1.8.10
+        version: 1.8.16
+      tsx:
+        specifier: '*'
+        version: 4.19.4
+      vitest:
+        specifier: ^4.0.8
+        version: 4.0.8(@types/debug@4.1.12)(@types/node@22.13.1)(jiti@1.21.7)(jsdom@24.1.3(bufferutil@4.0.9))(tsx@4.19.4)(yaml@2.7.1)
+
+  packages/server-v4:
+    dependencies:
+      '@browserbasehq/sdk':
+        specifier: ^2.7.0
+        version: 2.7.0
+      '@browserbasehq/stagehand':
+        specifier: workspace:*
+        version: link:../core
+      '@fastify/cors':
+        specifier: ^11.0.1
+        version: 11.1.0
+      '@fastify/swagger':
+        specifier: ^9.6.1
+        version: 9.6.1
+      '@fastify/swagger-ui':
+        specifier: ^5.2.3
+        version: 5.2.3
+      '@t3-oss/env-core':
+        specifier: ^0.13.8
+        version: 0.13.8(arktype@2.1.20)(typescript@5.9.3)(zod@4.2.1)
+      fastify:
+        specifier: ^5.3.2
+        version: 5.6.2
+      fastify-metrics:
+        specifier: ^12.1.0
+        version: 12.1.0(fastify@5.6.2)
+      fastify-plugin:
+        specifier: ^4.5.1
+        version: 4.5.1
+      fastify-zod-openapi:
+        specifier: ^5.5.0
+        version: 5.5.0(@fastify/swagger-ui@5.2.3)(@fastify/swagger@9.6.1)(fastify@5.6.2)(zod@4.2.1)
+      http-status-codes:
+        specifier: ^2.3.0
+        version: 2.3.0
+      pino:
+        specifier: ^9.7.0
+        version: 9.14.0
+      pino-pretty:
+        specifier: ^11.3.0
+        version: 11.3.0
+      playwright:
+        specifier: 1.52.0
+        version: 1.52.0
+      uuid:
+        specifier: ^11.0.5
+        version: 11.1.0
+      zod:
+        specifier: ^4.2.1
+        version: 4.2.1
+    devDependencies:
+      '@types/node':
+        specifier: 22.13.1
+        version: 22.13.1
+      eslint:
+        specifier: 10.0.2
+        version: 10.0.2(jiti@1.21.7)
+      eslint-plugin-security:
+        specifier: ^3.0.1
+        version: 3.0.1
+      openai:
+        specifier: 4.87.1
+        version: 4.87.1(ws@8.18.3(bufferutil@4.0.9))(zod@4.2.1)
+      postject:
+        specifier: 1.0.0-alpha.6
+        version: 1.0.0-alpha.6
+      prettier:
+        specifier: ^3.2.5
+        version: 3.5.3
+      source-map:
+        specifier: ^0.7.4
+        version: 0.7.4
+      tsc-alias:
+        specifier: ^1.8.10
+        version: 1.8.16
+      tsx:
+        specifier: '*'
+        version: 4.19.4
+      vitest:
+        specifier: ^4.0.8
+        version: 4.0.8(@types/debug@4.1.12)(@types/node@22.13.1)(jiti@1.21.7)(jsdom@24.1.3(bufferutil@4.0.9))(tsx@4.19.4)(yaml@2.7.1)
+
+packages:
+
+  '@ai-sdk/amazon-bedrock@3.0.73':
+    resolution: {integrity: sha512-EAAGJ/dfbAZaqIhK3w52hq6cftSLZwXdC6uHKh8Cls1T0N4MxS6ykDf54UyFO3bZWkQxR+Mdw1B3qireGOxtJQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/anthropic@2.0.53':
+    resolution: {integrity: sha512-ih7NV+OFSNWZCF+tYYD7ovvvM+gv7TRKQblpVohg2ipIwC9Y0TirzocJVREzZa/v9luxUwFbsPji++DUDWWxsg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/anthropic@2.0.57':
+    resolution: {integrity: sha512-DREpYqW2pylgaj69gZ+K8u92bo9DaMgFdictYnY+IwYeY3bawQ4zI7l/o1VkDsBDljAx8iYz5lPURwVZNu+Xpg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/azure@2.0.54':
+    resolution: {integrity: sha512-nJtKcv2+4WmwfRpzc6GcVy3OlKjs7MiHhuNeibxDcDIST3h+qEX1UZYw9FDwjRFhWKbRyjSFwWxnoEP+Zwd6kQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/cerebras@1.0.25':
+    resolution: {integrity: sha512-O5MLAGWvVTe/gELhJqfnDqGcQd9D/ErXDR2oA4EI+y+fXIaKR/fZIB5CTWYOWNgQHkU+UFWfWz3RXTpq72FR2w==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/deepseek@1.0.23':
+    resolution: {integrity: sha512-9knOQmgIwlSkIYXWra550mC33HAX0PlVW8rMUAcJGzt8nka4IJEqa1aKDtLRUb6RXUWBsturZL+LwrC1ApQmbQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/gateway@2.0.39':
+    resolution: {integrity: sha512-ULnefGmRHG0/tRrf+dtDwgQYAttGi/TR0FmASAzTs1dtpeZp4Xoh1VyWrX3Z1bM3WDs9RM3ZeSE77kQT/jbfjw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/google-vertex@3.0.85':
+    resolution: {integrity: sha512-FOoPNdkXp3QE9F93HKD11YdS+ONNijacOH80bNKZSAFNIcxSQ+0UOW46b9OxCV576SP2DAuU1FSD4z6hhhMkrg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/google@2.0.44':
+    resolution: {integrity: sha512-c5dck36FjqiVoeeMJQLTEmUheoURcGTU/nBT6iJu8/nZiKFT/y8pD85KMDRB7RerRYaaQOtslR2d6/5PditiRw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/google@2.0.53':
+    resolution: {integrity: sha512-ccCxr5mrd3AC2CjLq4e1ST7+UiN5T2Pdmgi0XdWM3QohmNBwUQ/RBG7BvL+cB/ex/j6y64tkMmpYz9zBw/SEFQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/groq@2.0.24':
+    resolution: {integrity: sha512-PCtNwFsakxR6B/o+l3gtxlPIwN8lawK3vvOjRdC759Y8WtNxCv5RUs0JsxIKyAZxO+RBEy0AoL8xTQUy8fn3gw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/mistral@2.0.19':
+    resolution: {integrity: sha512-EdIZoEmGQifVjm/IoL/yQwrr59sg+tLlkQ8tccLaYaIBykrf+p5TReCg/Vx8YAJ5aSqcCsPXlBx9JZTtkolAyg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/openai-compatible@1.0.22':
+    resolution: {integrity: sha512-Q+lwBIeMprc/iM+vg1yGjvzRrp74l316wDpqWdbmd4VXXlllblzGsUgBLTeKvcEapFTgqk0FRETvSb58Y6dsfA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/openai@2.0.53':
+    resolution: {integrity: sha512-GIkR3+Fyif516ftXv+YPSPstnAHhcZxNoR2s8uSHhQ1yBT7I7aQYTVwpjAuYoT3GR+TeP50q7onj2/nDRbT2FQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/perplexity@2.0.13':
+    resolution: {integrity: sha512-t5YjnUYgDWGasUDiWx4L25WOUVSV1/kLNbrclJUv0NlK4R0ed/15ucz5Jum9nORyUfrFEej7vwS0DHA9rPWLPA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/provider-utils@3.0.12':
+    resolution: {integrity: sha512-ZtbdvYxdMoria+2SlNarEk6Hlgyf+zzcznlD55EAl+7VZvJaSg2sqPvwArY7L6TfDEDJsnCq0fdhBSkYo0Xqdg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/provider-utils@3.0.18':
+    resolution: {integrity: sha512-ypv1xXMsgGcNKUP+hglKqtdDuMg68nWHucPPAhIENrbFAI+xCHiqPVN8Zllxyv1TNZwGWUghPxJXU+Mqps0YRQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/provider-utils@3.0.20':
+    resolution: {integrity: sha512-iXHVe0apM2zUEzauqJwqmpC37A5rihrStAih5Ks+JE32iTe4LZ58y17UGBjpQQTCRw9YxMeo2UFLxLpBluyvLQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/provider-utils@3.0.21':
+    resolution: {integrity: sha512-veuMwTLxsgh31Jjn0SnBABnM1f7ebHhRWcV2ZuY3hP3iJDCZ8VXBaYqcHXoOQDqUXTCas08sKQcHyWK+zl882Q==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/provider@1.1.3':
+    resolution: {integrity: sha512-qZMxYJ0qqX/RfnuIaab+zp8UAeJn/ygXXAffR5I4N0n1IrvA6qBsjc8hXLmBiMV2zoXlifkacF7sEFnYnjBcqg==}
+    engines: {node: '>=18'}
+
+  '@ai-sdk/provider@2.0.0':
+    resolution: {integrity: sha512-6o7Y2SeO9vFKB8lArHXehNuusnpddKPk7xqL7T2/b+OvXMRIXUO1rR4wcv1hAFUAT9avGZshty3Wlua/XA7TvA==}
+    engines: {node: '>=18'}
+
+  '@ai-sdk/provider@2.0.1':
+    resolution: {integrity: sha512-KCUwswvsC5VsW2PWFqF8eJgSCu5Ysj7m1TxiHTVA6g7k360bk0RNQENT8KTMAYEs+8fWPD3Uu4dEmzGHc+jGng==}
+    engines: {node: '>=18'}
+
+  '@ai-sdk/togetherai@1.0.23':
+    resolution: {integrity: sha512-yhf/rnUVmHeGBvceDX9uB+qlnk4UVLHsTq9eTioCbqEvpjWWdRU2LUNsI7X+tc/5qmOT2mB82o1TK/4F0MkM0Q==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/xai@2.0.26':
+    resolution: {integrity: sha512-+VtaLZSxmoKnNeJGM9bbtbZ3QMkPFlBB4N8prngbrSnvU/hG8cNdvvSBW/rIk6/DHrc2R8nFntNIBQoIRuBdQw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@alcalzone/ansi-tokenize@0.1.3':
+    resolution: {integrity: sha512-3yWxPTq3UQ/FY9p1ErPxIyfT64elWaMvM9lIHnaqpyft63tkxodF5aUElYHrdisWve5cETkh1+KBw1yJuW0aRw==}
+    engines: {node: '>=14.13.1'}
+
+  '@alloc/quick-lru@5.2.0':
+    resolution: {integrity: sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==}
+    engines: {node: '>=10'}
+
+  '@anthropic-ai/sdk@0.39.0':
+    resolution: {integrity: sha512-eMyDIPRZbt1CCLErRCi3exlAvNkBtRe+kW5vvJyef93PmNr/clstYgHhtvmkxN82nlKgzyGPCyGxrm0JQ1ZIdg==}
+
+  '@ark/schema@0.46.0':
+    resolution: {integrity: sha512-c2UQdKgP2eqqDArfBqQIJppxJHvNNXuQPeuSPlDML4rjw+f1cu0qAlzOG4b8ujgm9ctIDWwhpyw6gjG5ledIVQ==}
+
+  '@ark/util@0.46.0':
+    resolution: {integrity: sha512-JPy/NGWn/lvf1WmGCPw2VGpBg5utZraE84I7wli18EDF3p3zc/e9WolT35tINeZO3l7C77SjqRJeAUoT0CvMRg==}
+
+  '@asamuzakjp/css-color@3.2.0':
+    resolution: {integrity: sha512-K1A6z8tS3XsmCMM86xoWdn7Fkdn9m6RSVtocUrJYIwZnFVkng/PvkEoWtOWmP+Scc6saYWHWZYbndEEXxl24jw==}
+
+  '@asyncapi/parser@3.4.0':
+    resolution: {integrity: sha512-Sxn74oHiZSU6+cVeZy62iPZMFMvKp4jupMFHelSICCMw1qELmUHPvuZSr+ZHDmNGgHcEpzJM5HN02kR7T4g+PQ==}
+
+  '@asyncapi/specs@6.8.1':
+    resolution: {integrity: sha512-czHoAk3PeXTLR+X8IUaD+IpT+g+zUvkcgMDJVothBsan+oHN3jfcFcFUNdOPAAFoUCQN1hXF1dWuphWy05THlA==}
+
+  '@aws-crypto/crc32@5.2.0':
+    resolution: {integrity: sha512-nLbCWqQNgUiwwtFsen1AdzAtvuLRsQS8rYgMuxCrdKf9kOssamGLuPwyTY9wyYblNr9+1XM8v6zoDTPPSIeANg==}
+    engines: {node: '>=16.0.0'}
+
+  '@aws-crypto/util@5.2.0':
+    resolution: {integrity: sha512-4RkU9EsI6ZpBve5fseQlGNUWKMa1RLPQ1dnjnQoe07ldfIzcsGb5hC5W0Dm7u423KWzawlrpbjXBrXCEv9zazQ==}
+
+  '@aws-sdk/types@3.973.1':
+    resolution: {integrity: sha512-DwHBiMNOB468JiX6+i34c+THsKHErYUdNQ3HexeXZvVn4zouLjgaS4FejiGSi2HyBuzuyHg7SuOPmjSvoU9NRg==}
+    engines: {node: '>=20.0.0'}
+
+  '@babel/code-frame@7.27.1':
+    resolution: {integrity: sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-string-parser@7.27.1':
+    resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-validator-identifier@7.28.5':
+    resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/parser@7.29.0':
+    resolution: {integrity: sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+
+  '@babel/runtime@7.27.1':
+    resolution: {integrity: sha512-1x3D2xEk2fRo3PAhwQwu5UubzgiVWSXTBfWpVd2Mx2AzRqJuDJCsgaDVZ7HB5iGzDW1Hl1sWN2mFyKjmR9uAog==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/types@7.29.0':
+    resolution: {integrity: sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==}
+    engines: {node: '>=6.9.0'}
+
+  '@bcoe/v8-coverage@1.0.2':
+    resolution: {integrity: sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==}
+    engines: {node: '>=18'}
+
+  '@browserbasehq/sdk@2.7.0':
+    resolution: {integrity: sha512-1iwuj3fChplMq+S66M9tGb9ZXA4e7Vi8MjqQQ6/T6rzoAWLGfDnEAPbgTOU479o+Mi3of5/6YXk1oIHKTw0NBw==}
+
+  '@cfworker/json-schema@4.1.1':
+    resolution: {integrity: sha512-gAmrUZSGtKc3AiBL71iNWxDsyUC5uMaKKGdvzYsBoTW/xi42JQHl7eKV2OYzCUqvc+D2RCcf7EXY2iCyFIk6og==}
+
+  '@changesets/apply-release-plan@7.0.12':
+    resolution: {integrity: sha512-EaET7As5CeuhTzvXTQCRZeBUcisoYPDDcXvgTE/2jmmypKp0RC7LxKj/yzqeh/1qFTZI7oDGFcL1PHRuQuketQ==}
+
+  '@changesets/assemble-release-plan@6.0.6':
+    resolution: {integrity: sha512-Frkj8hWJ1FRZiY3kzVCKzS0N5mMwWKwmv9vpam7vt8rZjLL1JMthdh6pSDVSPumHPshTTkKZ0VtNbE0cJHZZUg==}
+
+  '@changesets/changelog-git@0.2.1':
+    resolution: {integrity: sha512-x/xEleCFLH28c3bQeQIyeZf8lFXyDFVn1SgcBiR2Tw/r4IAWlk1fzxCEZ6NxQAjF2Nwtczoen3OA2qR+UawQ8Q==}
+
+  '@changesets/changelog-github@0.5.1':
+    resolution: {integrity: sha512-BVuHtF+hrhUScSoHnJwTELB4/INQxVFc+P/Qdt20BLiBFIHFJDDUaGsZw+8fQeJTRP5hJZrzpt3oZWh0G19rAQ==}
+
+  '@changesets/cli@2.29.2':
+    resolution: {integrity: sha512-vwDemKjGYMOc0l6WUUTGqyAWH3AmueeyoJa1KmFRtCYiCoY5K3B68ErYpDB6H48T4lLI4czum4IEjh6ildxUeg==}
+    hasBin: true
+
+  '@changesets/config@3.1.1':
+    resolution: {integrity: sha512-bd+3Ap2TKXxljCggI0mKPfzCQKeV/TU4yO2h2C6vAihIo8tzseAn2e7klSuiyYYXvgu53zMN1OeYMIQkaQoWnA==}
+
+  '@changesets/errors@0.2.0':
+    resolution: {integrity: sha512-6BLOQUscTpZeGljvyQXlWOItQyU71kCdGz7Pi8H8zdw6BI0g3m43iL4xKUVPWtG+qrrL9DTjpdn8eYuCQSRpow==}
+
+  '@changesets/get-dependents-graph@2.1.3':
+    resolution: {integrity: sha512-gphr+v0mv2I3Oxt19VdWRRUxq3sseyUpX9DaHpTUmLj92Y10AGy+XOtV+kbM6L/fDcpx7/ISDFK6T8A/P3lOdQ==}
+
+  '@changesets/get-github-info@0.6.0':
+    resolution: {integrity: sha512-v/TSnFVXI8vzX9/w3DU2Ol+UlTZcu3m0kXTjTT4KlAdwSvwutcByYwyYn9hwerPWfPkT2JfpoX0KgvCEi8Q/SA==}
+
+  '@changesets/get-release-plan@4.0.10':
+    resolution: {integrity: sha512-CCJ/f3edYaA3MqoEnWvGGuZm0uMEMzNJ97z9hdUR34AOvajSwySwsIzC/bBu3+kuGDsB+cny4FljG8UBWAa7jg==}
+
+  '@changesets/get-version-range-type@0.4.0':
+    resolution: {integrity: sha512-hwawtob9DryoGTpixy1D3ZXbGgJu1Rhr+ySH2PvTLHvkZuQ7sRT4oQwMh0hbqZH1weAooedEjRsbrWcGLCeyVQ==}
+
+  '@changesets/git@3.0.4':
+    resolution: {integrity: sha512-BXANzRFkX+XcC1q/d27NKvlJ1yf7PSAgi8JG6dt8EfbHFHi4neau7mufcSca5zRhwOL8j9s6EqsxmT+s+/E6Sw==}
+
+  '@changesets/logger@0.1.1':
+    resolution: {integrity: sha512-OQtR36ZlnuTxKqoW4Sv6x5YIhOmClRd5pWsjZsddYxpWs517R0HkyiefQPIytCVh4ZcC5x9XaG8KTdd5iRQUfg==}
+
+  '@changesets/parse@0.4.1':
+    resolution: {integrity: sha512-iwksMs5Bf/wUItfcg+OXrEpravm5rEd9Bf4oyIPL4kVTmJQ7PNDSd6MDYkpSJR1pn7tz/k8Zf2DhTCqX08Ou+Q==}
+
+  '@changesets/pre@2.0.2':
+    resolution: {integrity: sha512-HaL/gEyFVvkf9KFg6484wR9s0qjAXlZ8qWPDkTyKF6+zqjBe/I2mygg3MbpZ++hdi0ToqNUF8cjj7fBy0dg8Ug==}
+
+  '@changesets/read@0.6.5':
+    resolution: {integrity: sha512-UPzNGhsSjHD3Veb0xO/MwvasGe8eMyNrR/sT9gR8Q3DhOQZirgKhhXv/8hVsI0QpPjR004Z9iFxoJU6in3uGMg==}
+
+  '@changesets/should-skip-package@0.1.2':
+    resolution: {integrity: sha512-qAK/WrqWLNCP22UDdBTMPH5f41elVDlsNyat180A33dWxuUDyNpg6fPi/FyTZwRriVjg0L8gnjJn2F9XAoF0qw==}
+
+  '@changesets/types@4.1.0':
+    resolution: {integrity: sha512-LDQvVDv5Kb50ny2s25Fhm3d9QSZimsoUGBsUioj6MC3qbMUCuC8GPIvk/M6IvXx3lYhAs0lwWUQLb+VIEUCECw==}
+
+  '@changesets/types@6.1.0':
+    resolution: {integrity: sha512-rKQcJ+o1nKNgeoYRHKOS07tAMNd3YSN0uHaJOZYjBAgxfV7TUE7JE+z4BzZdQwb5hKaYbayKN5KrYV7ODb2rAA==}
+
+  '@changesets/write@0.4.0':
+    resolution: {integrity: sha512-CdTLvIOPiCNuH71pyDu3rA+Q0n65cmAbXnwWH84rKGiFumFzkmHNT8KHTMEchcxN+Kl8I54xGUhJ7l3E7X396Q==}
+
+  '@csstools/color-helpers@5.1.0':
+    resolution: {integrity: sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==}
+    engines: {node: '>=18'}
+
+  '@csstools/css-calc@2.1.4':
+    resolution: {integrity: sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@csstools/css-parser-algorithms': ^3.0.5
+      '@csstools/css-tokenizer': ^3.0.4
+
+  '@csstools/css-color-parser@3.1.0':
+    resolution: {integrity: sha512-nbtKwh3a6xNVIp/VRuXV64yTKnb1IjTAEEh3irzS+HkKjAOYLTGNb9pmVNntZ8iVBHcWDA2Dof0QtPgFI1BaTA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@csstools/css-parser-algorithms': ^3.0.5
+      '@csstools/css-tokenizer': ^3.0.4
+
+  '@csstools/css-parser-algorithms@3.0.5':
+    resolution: {integrity: sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@csstools/css-tokenizer': ^3.0.4
+
+  '@csstools/css-tokenizer@3.0.4':
+    resolution: {integrity: sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==}
+    engines: {node: '>=18'}
+
+  '@emnapi/runtime@1.7.1':
+    resolution: {integrity: sha512-PVtJr5CmLwYAU9PZDMITZoR5iAOShYREoR45EyyLrbntV50mdePTgUn4AmOw90Ifcj+x2kRjdzr1HP3RrNiHGA==}
+
+  '@esbuild/aix-ppc64@0.21.5':
+    resolution: {integrity: sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==}
+    engines: {node: '>=12'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/aix-ppc64@0.25.11':
+    resolution: {integrity: sha512-Xt1dOL13m8u0WE8iplx9Ibbm+hFAO0GsU2P34UNoDGvZYkY8ifSiy6Zuc1lYxfG7svWE2fzqCUmFp5HCn51gJg==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/aix-ppc64@0.27.2':
+    resolution: {integrity: sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/android-arm64@0.21.5':
+    resolution: {integrity: sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/android-arm64@0.25.11':
+    resolution: {integrity: sha512-9slpyFBc4FPPz48+f6jyiXOx/Y4v34TUeDDXJpZqAWQn/08lKGeD8aDp9TMn9jDz2CiEuHwfhRmGBvpnd/PWIQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/android-arm64@0.27.2':
+    resolution: {integrity: sha512-pvz8ZZ7ot/RBphf8fv60ljmaoydPU12VuXHImtAs0XhLLw+EXBi2BLe3OYSBslR4rryHvweW5gmkKFwTiFy6KA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/android-arm@0.21.5':
+    resolution: {integrity: sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==}
+    engines: {node: '>=12'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/android-arm@0.25.11':
+    resolution: {integrity: sha512-uoa7dU+Dt3HYsethkJ1k6Z9YdcHjTrSb5NUy66ZfZaSV8hEYGD5ZHbEMXnqLFlbBflLsl89Zke7CAdDJ4JI+Gg==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/android-arm@0.27.2':
+    resolution: {integrity: sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/android-x64@0.21.5':
+    resolution: {integrity: sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/android-x64@0.25.11':
+    resolution: {integrity: sha512-Sgiab4xBjPU1QoPEIqS3Xx+R2lezu0LKIEcYe6pftr56PqPygbB7+szVnzoShbx64MUupqoE0KyRlN7gezbl8g==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/android-x64@0.27.2':
+    resolution: {integrity: sha512-z8Ank4Byh4TJJOh4wpz8g2vDy75zFL0TlZlkUkEwYXuPSgX8yzep596n6mT7905kA9uHZsf/o2OJZubl2l3M7A==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/darwin-arm64@0.21.5':
+    resolution: {integrity: sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/darwin-arm64@0.25.11':
+    resolution: {integrity: sha512-VekY0PBCukppoQrycFxUqkCojnTQhdec0vevUL/EDOCnXd9LKWqD/bHwMPzigIJXPhC59Vd1WFIL57SKs2mg4w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/darwin-arm64@0.27.2':
+    resolution: {integrity: sha512-davCD2Zc80nzDVRwXTcQP/28fiJbcOwvdolL0sOiOsbwBa72kegmVU0Wrh1MYrbuCL98Omp5dVhQFWRKR2ZAlg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/darwin-x64@0.21.5':
+    resolution: {integrity: sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/darwin-x64@0.25.11':
+    resolution: {integrity: sha512-+hfp3yfBalNEpTGp9loYgbknjR695HkqtY3d3/JjSRUyPg/xd6q+mQqIb5qdywnDxRZykIHs3axEqU6l1+oWEQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/darwin-x64@0.27.2':
+    resolution: {integrity: sha512-ZxtijOmlQCBWGwbVmwOF/UCzuGIbUkqB1faQRf5akQmxRJ1ujusWsb3CVfk/9iZKr2L5SMU5wPBi1UWbvL+VQA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/freebsd-arm64@0.21.5':
+    resolution: {integrity: sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-arm64@0.25.11':
+    resolution: {integrity: sha512-CmKjrnayyTJF2eVuO//uSjl/K3KsMIeYeyN7FyDBjsR3lnSJHaXlVoAK8DZa7lXWChbuOk7NjAc7ygAwrnPBhA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-arm64@0.27.2':
+    resolution: {integrity: sha512-lS/9CN+rgqQ9czogxlMcBMGd+l8Q3Nj1MFQwBZJyoEKI50XGxwuzznYdwcav6lpOGv5BqaZXqvBSiB/kJ5op+g==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-x64@0.21.5':
+    resolution: {integrity: sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-x64@0.25.11':
+    resolution: {integrity: sha512-Dyq+5oscTJvMaYPvW3x3FLpi2+gSZTCE/1ffdwuM6G1ARang/mb3jvjxs0mw6n3Lsw84ocfo9CrNMqc5lTfGOw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-x64@0.27.2':
+    resolution: {integrity: sha512-tAfqtNYb4YgPnJlEFu4c212HYjQWSO/w/h/lQaBK7RbwGIkBOuNKQI9tqWzx7Wtp7bTPaGC6MJvWI608P3wXYA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/linux-arm64@0.21.5':
+    resolution: {integrity: sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/linux-arm64@0.25.11':
+    resolution: {integrity: sha512-Qr8AzcplUhGvdyUF08A1kHU3Vr2O88xxP0Tm8GcdVOUm25XYcMPp2YqSVHbLuXzYQMf9Bh/iKx7YPqECs6ffLA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/linux-arm64@0.27.2':
+    resolution: {integrity: sha512-hYxN8pr66NsCCiRFkHUAsxylNOcAQaxSSkHMMjcpx0si13t1LHFphxJZUiGwojB1a/Hd5OiPIqDdXONia6bhTw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/linux-arm@0.21.5':
+    resolution: {integrity: sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==}
+    engines: {node: '>=12'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/linux-arm@0.25.11':
+    resolution: {integrity: sha512-TBMv6B4kCfrGJ8cUPo7vd6NECZH/8hPpBHHlYI3qzoYFvWu2AdTvZNuU/7hsbKWqu/COU7NIK12dHAAqBLLXgw==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/linux-arm@0.27.2':
+    resolution: {integrity: sha512-vWfq4GaIMP9AIe4yj1ZUW18RDhx6EPQKjwe7n8BbIecFtCQG4CfHGaHuh7fdfq+y3LIA2vGS/o9ZBGVxIDi9hw==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/linux-ia32@0.21.5':
+    resolution: {integrity: sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==}
+    engines: {node: '>=12'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/linux-ia32@0.25.11':
+    resolution: {integrity: sha512-TmnJg8BMGPehs5JKrCLqyWTVAvielc615jbkOirATQvWWB1NMXY77oLMzsUjRLa0+ngecEmDGqt5jiDC6bfvOw==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/linux-ia32@0.27.2':
+    resolution: {integrity: sha512-MJt5BRRSScPDwG2hLelYhAAKh9imjHK5+NE/tvnRLbIqUWa+0E9N4WNMjmp/kXXPHZGqPLxggwVhz7QP8CTR8w==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/linux-loong64@0.21.5':
+    resolution: {integrity: sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==}
+    engines: {node: '>=12'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/linux-loong64@0.25.11':
+    resolution: {integrity: sha512-DIGXL2+gvDaXlaq8xruNXUJdT5tF+SBbJQKbWy/0J7OhU8gOHOzKmGIlfTTl6nHaCOoipxQbuJi7O++ldrxgMw==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/linux-loong64@0.27.2':
+    resolution: {integrity: sha512-lugyF1atnAT463aO6KPshVCJK5NgRnU4yb3FUumyVz+cGvZbontBgzeGFO1nF+dPueHD367a2ZXe1NtUkAjOtg==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/linux-mips64el@0.21.5':
+    resolution: {integrity: sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==}
+    engines: {node: '>=12'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/linux-mips64el@0.25.11':
+    resolution: {integrity: sha512-Osx1nALUJu4pU43o9OyjSCXokFkFbyzjXb6VhGIJZQ5JZi8ylCQ9/LFagolPsHtgw6himDSyb5ETSfmp4rpiKQ==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/linux-mips64el@0.27.2':
+    resolution: {integrity: sha512-nlP2I6ArEBewvJ2gjrrkESEZkB5mIoaTswuqNFRv/WYd+ATtUpe9Y09RnJvgvdag7he0OWgEZWhviS1OTOKixw==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/linux-ppc64@0.21.5':
+    resolution: {integrity: sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==}
+    engines: {node: '>=12'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/linux-ppc64@0.25.11':
+    resolution: {integrity: sha512-nbLFgsQQEsBa8XSgSTSlrnBSrpoWh7ioFDUmwo158gIm5NNP+17IYmNWzaIzWmgCxq56vfr34xGkOcZ7jX6CPw==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/linux-ppc64@0.27.2':
+    resolution: {integrity: sha512-C92gnpey7tUQONqg1n6dKVbx3vphKtTHJaNG2Ok9lGwbZil6DrfyecMsp9CrmXGQJmZ7iiVXvvZH6Ml5hL6XdQ==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/linux-riscv64@0.21.5':
+    resolution: {integrity: sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==}
+    engines: {node: '>=12'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/linux-riscv64@0.25.11':
+    resolution: {integrity: sha512-HfyAmqZi9uBAbgKYP1yGuI7tSREXwIb438q0nqvlpxAOs3XnZ8RsisRfmVsgV486NdjD7Mw2UrFSw51lzUk1ww==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/linux-riscv64@0.27.2':
+    resolution: {integrity: sha512-B5BOmojNtUyN8AXlK0QJyvjEZkWwy/FKvakkTDCziX95AowLZKR6aCDhG7LeF7uMCXEJqwa8Bejz5LTPYm8AvA==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/linux-s390x@0.21.5':
+    resolution: {integrity: sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==}
+    engines: {node: '>=12'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/linux-s390x@0.25.11':
+    resolution: {integrity: sha512-HjLqVgSSYnVXRisyfmzsH6mXqyvj0SA7pG5g+9W7ESgwA70AXYNpfKBqh1KbTxmQVaYxpzA/SvlB9oclGPbApw==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/linux-s390x@0.27.2':
+    resolution: {integrity: sha512-p4bm9+wsPwup5Z8f4EpfN63qNagQ47Ua2znaqGH6bqLlmJ4bx97Y9JdqxgGZ6Y8xVTixUnEkoKSHcpRlDnNr5w==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/linux-x64@0.21.5':
+    resolution: {integrity: sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/linux-x64@0.25.11':
+    resolution: {integrity: sha512-HSFAT4+WYjIhrHxKBwGmOOSpphjYkcswF449j6EjsjbinTZbp8PJtjsVK1XFJStdzXdy/jaddAep2FGY+wyFAQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/linux-x64@0.27.2':
+    resolution: {integrity: sha512-uwp2Tip5aPmH+NRUwTcfLb+W32WXjpFejTIOWZFw/v7/KnpCDKG66u4DLcurQpiYTiYwQ9B7KOeMJvLCu/OvbA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/netbsd-arm64@0.25.11':
+    resolution: {integrity: sha512-hr9Oxj1Fa4r04dNpWr3P8QKVVsjQhqrMSUzZzf+LZcYjZNqhA3IAfPQdEh1FLVUJSiu6sgAwp3OmwBfbFgG2Xg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-arm64@0.27.2':
+    resolution: {integrity: sha512-Kj6DiBlwXrPsCRDeRvGAUb/LNrBASrfqAIok+xB0LxK8CHqxZ037viF13ugfsIpePH93mX7xfJp97cyDuTZ3cw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-x64@0.21.5':
+    resolution: {integrity: sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-x64@0.25.11':
+    resolution: {integrity: sha512-u7tKA+qbzBydyj0vgpu+5h5AeudxOAGncb8N6C9Kh1N4n7wU1Xw1JDApsRjpShRpXRQlJLb9wY28ELpwdPcZ7A==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-x64@0.27.2':
+    resolution: {integrity: sha512-HwGDZ0VLVBY3Y+Nw0JexZy9o/nUAWq9MlV7cahpaXKW6TOzfVno3y3/M8Ga8u8Yr7GldLOov27xiCnqRZf0tCA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/openbsd-arm64@0.25.11':
+    resolution: {integrity: sha512-Qq6YHhayieor3DxFOoYM1q0q1uMFYb7cSpLD2qzDSvK1NAvqFi8Xgivv0cFC6J+hWVw2teCYltyy9/m/14ryHg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-arm64@0.27.2':
+    resolution: {integrity: sha512-DNIHH2BPQ5551A7oSHD0CKbwIA/Ox7+78/AWkbS5QoRzaqlev2uFayfSxq68EkonB+IKjiuxBFoV8ESJy8bOHA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-x64@0.21.5':
+    resolution: {integrity: sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-x64@0.25.11':
+    resolution: {integrity: sha512-CN+7c++kkbrckTOz5hrehxWN7uIhFFlmS/hqziSFVWpAzpWrQoAG4chH+nN3Be+Kzv/uuo7zhX716x3Sn2Jduw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-x64@0.27.2':
+    resolution: {integrity: sha512-/it7w9Nb7+0KFIzjalNJVR5bOzA9Vay+yIPLVHfIQYG/j+j9VTH84aNB8ExGKPU4AzfaEvN9/V4HV+F+vo8OEg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/openharmony-arm64@0.25.11':
+    resolution: {integrity: sha512-rOREuNIQgaiR+9QuNkbkxubbp8MSO9rONmwP5nKncnWJ9v5jQ4JxFnLu4zDSRPf3x4u+2VN4pM4RdyIzDty/wQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@esbuild/openharmony-arm64@0.27.2':
+    resolution: {integrity: sha512-LRBbCmiU51IXfeXk59csuX/aSaToeG7w48nMwA6049Y4J4+VbWALAuXcs+qcD04rHDuSCSRKdmY63sruDS5qag==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@esbuild/sunos-x64@0.21.5':
+    resolution: {integrity: sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/sunos-x64@0.25.11':
+    resolution: {integrity: sha512-nq2xdYaWxyg9DcIyXkZhcYulC6pQ2FuCgem3LI92IwMgIZ69KHeY8T4Y88pcwoLIjbed8n36CyKoYRDygNSGhA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/sunos-x64@0.27.2':
+    resolution: {integrity: sha512-kMtx1yqJHTmqaqHPAzKCAkDaKsffmXkPHThSfRwZGyuqyIeBvf08KSsYXl+abf5HDAPMJIPnbBfXvP2ZC2TfHg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/win32-arm64@0.21.5':
+    resolution: {integrity: sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/win32-arm64@0.25.11':
+    resolution: {integrity: sha512-3XxECOWJq1qMZ3MN8srCJ/QfoLpL+VaxD/WfNRm1O3B4+AZ/BnLVgFbUV3eiRYDMXetciH16dwPbbHqwe1uU0Q==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/win32-arm64@0.27.2':
+    resolution: {integrity: sha512-Yaf78O/B3Kkh+nKABUF++bvJv5Ijoy9AN1ww904rOXZFLWVc5OLOfL56W+C8F9xn5JQZa3UX6m+IktJnIb1Jjg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/win32-ia32@0.21.5':
+    resolution: {integrity: sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==}
+    engines: {node: '>=12'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/win32-ia32@0.25.11':
+    resolution: {integrity: sha512-3ukss6gb9XZ8TlRyJlgLn17ecsK4NSQTmdIXRASVsiS2sQ6zPPZklNJT5GR5tE/MUarymmy8kCEf5xPCNCqVOA==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/win32-ia32@0.27.2':
+    resolution: {integrity: sha512-Iuws0kxo4yusk7sw70Xa2E2imZU5HoixzxfGCdxwBdhiDgt9vX9VUCBhqcwY7/uh//78A1hMkkROMJq9l27oLQ==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/win32-x64@0.21.5':
+    resolution: {integrity: sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [win32]
+
+  '@esbuild/win32-x64@0.25.11':
+    resolution: {integrity: sha512-D7Hpz6A2L4hzsRpPaCYkQnGOotdUpDzSGRIv9I+1ITdHROSFUWW95ZPZWQmGka1Fg7W3zFJowyn9WGwMJ0+KPA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
+  '@esbuild/win32-x64@0.27.2':
+    resolution: {integrity: sha512-sRdU18mcKf7F+YgheI/zGf5alZatMUTKj/jNS6l744f9u3WFu4v7twcUI9vu4mknF4Y9aDlblIie0IM+5xxaqQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
+  '@eslint-community/eslint-utils@4.9.1':
+    resolution: {integrity: sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    peerDependencies:
+      eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
+
+  '@eslint-community/regexpp@4.12.2':
+    resolution: {integrity: sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==}
+    engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
+
+  '@eslint/config-array@0.21.2':
+    resolution: {integrity: sha512-nJl2KGTlrf9GjLimgIru+V/mzgSK0ABCDQRvxw5BjURL7WfH5uoWmizbH7QB6MmnMBd8cIC9uceWnezL1VZWWw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/config-array@0.23.2':
+    resolution: {integrity: sha512-YF+fE6LV4v5MGWRGj7G404/OZzGNepVF8fxk7jqmqo3lrza7a0uUcDnROGRBG1WFC1omYUS/Wp1f42i0M+3Q3A==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  '@eslint/config-helpers@0.4.2':
+    resolution: {integrity: sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/config-helpers@0.5.2':
+    resolution: {integrity: sha512-a5MxrdDXEvqnIq+LisyCX6tQMPF/dSJpCfBgBauY+pNZ28yCtSsTvyTYrMhaI+LK26bVyCJfJkT0u8KIj2i1dQ==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  '@eslint/core@0.17.0':
+    resolution: {integrity: sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/core@1.1.0':
+    resolution: {integrity: sha512-/nr9K9wkr3P1EzFTdFdMoLuo1PmIxjmwvPozwoSodjNBdefGujXQUF93u1DDZpEaTuDvMsIQddsd35BwtrW9Xw==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  '@eslint/eslintrc@3.3.5':
+    resolution: {integrity: sha512-4IlJx0X0qftVsN5E+/vGujTRIFtwuLbNsVUe7TO6zYPDR1O6nFwvwhIKEKSrl6dZchmYBITazxKoUYOjdtjlRg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/js@10.0.1':
+    resolution: {integrity: sha512-zeR9k5pd4gxjZ0abRoIaxdc7I3nDktoXZk2qOv9gCNWx3mVwEn32VRhyLaRsDiJjTs0xq/T8mfPtyuXu7GWBcA==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+    peerDependencies:
+      eslint: ^10.0.0
+    peerDependenciesMeta:
+      eslint:
+        optional: true
+
+  '@eslint/js@9.39.4':
+    resolution: {integrity: sha512-nE7DEIchvtiFTwBw4Lfbu59PG+kCofhjsKaCWzxTpt4lfRjRMqG6uMBzKXuEcyXhOHoUp9riAm7/aWYGhXZ9cw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/object-schema@2.1.7':
+    resolution: {integrity: sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/object-schema@3.0.2':
+    resolution: {integrity: sha512-HOy56KJt48Bx8KmJ+XGQNSUMT/6dZee/M54XyUyuvTvPXJmsERRvBchsUVx1UMe1WwIH49XLAczNC7V2INsuUw==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  '@eslint/plugin-kit@0.4.1':
+    resolution: {integrity: sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/plugin-kit@0.6.0':
+    resolution: {integrity: sha512-bIZEUzOI1jkhviX2cp5vNyXQc6olzb2ohewQubuYlMXZ2Q/XjBO0x0XhGPvc9fjSIiUN0vw+0hq53BJ4eQSJKQ==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  '@fastify/accept-negotiator@2.0.1':
+    resolution: {integrity: sha512-/c/TW2bO/v9JeEgoD/g1G5GxGeCF1Hafdf79WPmUlgYiBXummY0oX3VVq4yFkKKVBKDNlaDUYoab7g38RpPqCQ==}
+
+  '@fastify/ajv-compiler@4.0.5':
+    resolution: {integrity: sha512-KoWKW+MhvfTRWL4qrhUwAAZoaChluo0m0vbiJlGMt2GXvL4LVPQEjt8kSpHI3IBq5Rez8fg+XeH3cneztq+C7A==}
+
+  '@fastify/cors@11.1.0':
+    resolution: {integrity: sha512-sUw8ed8wP2SouWZTIbA7V2OQtMNpLj2W6qJOYhNdcmINTu6gsxVYXjQiM9mdi8UUDlcoDDJ/W2syPo1WB2QjYA==}
+
+  '@fastify/error@4.2.0':
+    resolution: {integrity: sha512-RSo3sVDXfHskiBZKBPRgnQTtIqpi/7zhJOEmAxCiBcM7d0uwdGdxLlsCaLzGs8v8NnxIRlfG0N51p5yFaOentQ==}
+
+  '@fastify/fast-json-stringify-compiler@5.0.3':
+    resolution: {integrity: sha512-uik7yYHkLr6fxd8hJSZ8c+xF4WafPK+XzneQDPU+D10r5X19GW8lJcom2YijX2+qtFF1ENJlHXKFM9ouXNJYgQ==}
+
+  '@fastify/forwarded@3.0.1':
+    resolution: {integrity: sha512-JqDochHFqXs3C3Ml3gOY58zM7OqO9ENqPo0UqAjAjH8L01fRZqwX9iLeX34//kiJubF7r2ZQHtBRU36vONbLlw==}
+
+  '@fastify/merge-json-schemas@0.2.1':
+    resolution: {integrity: sha512-OA3KGBCy6KtIvLf8DINC5880o5iBlDX4SxzLQS8HorJAbqluzLRn80UXU0bxZn7UOFhFgpRJDasfwn9nG4FG4A==}
+
+  '@fastify/proxy-addr@5.1.0':
+    resolution: {integrity: sha512-INS+6gh91cLUjB+PVHfu1UqcB76Sqtpyp7bnL+FYojhjygvOPA9ctiD/JDKsyD9Xgu4hUhCSJBPig/w7duNajw==}
+
+  '@fastify/send@4.1.0':
+    resolution: {integrity: sha512-TMYeQLCBSy2TOFmV95hQWkiTYgC/SEx7vMdV+wnZVX4tt8VBLKzmH8vV9OzJehV0+XBfg+WxPMt5wp+JBUKsVw==}
+
+  '@fastify/static@8.3.0':
+    resolution: {integrity: sha512-yKxviR5PH1OKNnisIzZKmgZSus0r2OZb8qCSbqmw34aolT4g3UlzYfeBRym+HJ1J471CR8e2ldNub4PubD1coA==}
+
+  '@fastify/swagger-ui@5.2.3':
+    resolution: {integrity: sha512-e7ivEJi9EpFcxTONqICx4llbpB2jmlI+LI1NQ/mR7QGQnyDOqZybPK572zJtcdHZW4YyYTBHcP3a03f1pOh0SA==}
+
+  '@fastify/swagger@9.6.1':
+    resolution: {integrity: sha512-fKlpJqFMWoi4H3EdUkDaMteEYRCfQMEkK0HJJ0eaf4aRlKd8cbq0pVkOfXDXmtvMTXYcnx3E+l023eFDBsA1HA==}
+
+  '@google/genai@1.24.0':
+    resolution: {integrity: sha512-e3jZF9Dx3dDaDCzygdMuYByHI2xJZ0PaD3r2fRgHZe2IOwBnmJ/Tu5Lt/nefTCxqr1ZnbcbQK9T13d8U/9UMWg==}
+    engines: {node: '>=20.0.0'}
+    peerDependencies:
+      '@modelcontextprotocol/sdk': ^1.11.4
+    peerDependenciesMeta:
+      '@modelcontextprotocol/sdk':
+        optional: true
+
+  '@humanfs/core@0.19.1':
+    resolution: {integrity: sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==}
+    engines: {node: '>=18.18.0'}
+
+  '@humanfs/node@0.16.6':
+    resolution: {integrity: sha512-YuI2ZHQL78Q5HbhDiBA1X4LmYdXCKCMQIfw0pw7piHJwyREFebJUvrQN4cMssyES6x+vfUbx1CIpaQUKYdQZOw==}
+    engines: {node: '>=18.18.0'}
+
+  '@humanwhocodes/module-importer@1.0.1':
+    resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==}
+    engines: {node: '>=12.22'}
+
+  '@humanwhocodes/retry@0.3.1':
+    resolution: {integrity: sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA==}
+    engines: {node: '>=18.18'}
+
+  '@humanwhocodes/retry@0.4.2':
+    resolution: {integrity: sha512-xeO57FpIu4p1Ri3Jq/EXq4ClRm86dVF2z/+kvFnyqVYRavTZmaFaUBbWCOuuTh0o/g7DSsk6kc2vrS4Vl5oPOQ==}
+    engines: {node: '>=18.18'}
+
+  '@img/colour@1.0.0':
+    resolution: {integrity: sha512-A5P/LfWGFSl6nsckYtjw9da+19jB8hkJ6ACTGcDfEJ0aE+l2n2El7dsVM7UVHZQ9s2lmYMWlrS21YLy2IR1LUw==}
+    engines: {node: '>=18'}
+
+  '@img/sharp-darwin-arm64@0.33.5':
+    resolution: {integrity: sha512-UT4p+iz/2H4twwAoLCqfA9UH5pI6DggwKEGuaPy7nCVQ8ZsiY5PIcrRvD1DzuY3qYL07NtIQcWnBSY/heikIFQ==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-darwin-arm64@0.34.5':
+    resolution: {integrity: sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-darwin-x64@0.33.5':
+    resolution: {integrity: sha512-fyHac4jIc1ANYGRDxtiqelIbdWkIuQaI84Mv45KvGRRxSAa7o7d1ZKAOBaYbnepLC1WqxfpimdeWfvqqSGwR2Q==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-darwin-x64@0.34.5':
+    resolution: {integrity: sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-libvips-darwin-arm64@1.0.4':
+    resolution: {integrity: sha512-XblONe153h0O2zuFfTAbQYAX2JhYmDHeWikp1LM9Hul9gVPjFY427k6dFEcOL72O01QxQsWi761svJ/ev9xEDg==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-libvips-darwin-arm64@1.2.4':
+    resolution: {integrity: sha512-zqjjo7RatFfFoP0MkQ51jfuFZBnVE2pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-libvips-darwin-x64@1.0.4':
+    resolution: {integrity: sha512-xnGR8YuZYfJGmWPvmlunFaWJsb9T/AO2ykoP3Fz/0X5XV2aoYBPkX6xqCQvUTKKiLddarLaxpzNe+b1hjeWHAQ==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-libvips-darwin-x64@1.2.4':
+    resolution: {integrity: sha512-1IOd5xfVhlGwX+zXv2N93k0yMONvUlANylbJw1eTah8K/Jtpi15KC+WSiaX/nBmbm2HxRM1gZ0nSdjSsrZbGKg==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-libvips-linux-arm64@1.0.4':
+    resolution: {integrity: sha512-9B+taZ8DlyyqzZQnoeIvDVR/2F4EbMepXMc/NdVbkzsJbzkUjhXv/70GQJ7tdLA4YJgNP25zukcxpX2/SueNrA==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-arm64@1.2.4':
+    resolution: {integrity: sha512-excjX8DfsIcJ10x1Kzr4RcWe1edC9PquDRRPx3YVCvQv+U5p7Yin2s32ftzikXojb1PIFc/9Mt28/y+iRklkrw==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-arm@1.0.5':
+    resolution: {integrity: sha512-gvcC4ACAOPRNATg/ov8/MnbxFDJqf/pDePbBnuBDcjsI8PssmjoKMAz4LtLaVi+OnSb5FK/yIOamqDwGmXW32g==}
+    cpu: [arm]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-arm@1.2.4':
+    resolution: {integrity: sha512-bFI7xcKFELdiNCVov8e44Ia4u2byA+l3XtsAj+Q8tfCwO6BQ8iDojYdvoPMqsKDkuoOo+X6HZA0s0q11ANMQ8A==}
+    cpu: [arm]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-ppc64@1.2.4':
+    resolution: {integrity: sha512-FMuvGijLDYG6lW+b/UvyilUWu5Ayu+3r2d1S8notiGCIyYU/76eig1UfMmkZ7vwgOrzKzlQbFSuQfgm7GYUPpA==}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-riscv64@1.2.4':
+    resolution: {integrity: sha512-oVDbcR4zUC0ce82teubSm+x6ETixtKZBh/qbREIOcI3cULzDyb18Sr/Wcyx7NRQeQzOiHTNbZFF1UwPS2scyGA==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-s390x@1.0.4':
+    resolution: {integrity: sha512-u7Wz6ntiSSgGSGcjZ55im6uvTrOxSIS8/dgoVMoiGE9I6JAfU50yH5BoDlYA1tcuGS7g/QNtetJnxA6QEsCVTA==}
+    cpu: [s390x]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-s390x@1.2.4':
+    resolution: {integrity: sha512-qmp9VrzgPgMoGZyPvrQHqk02uyjA0/QrTO26Tqk6l4ZV0MPWIW6LTkqOIov+J1yEu7MbFQaDpwdwJKhbJvuRxQ==}
+    cpu: [s390x]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-x64@1.0.4':
+    resolution: {integrity: sha512-MmWmQ3iPFZr0Iev+BAgVMb3ZyC4KeFc3jFxnNbEPas60e1cIfevbtuyf9nDGIzOaW9PdnDciJm+wFFaTlj5xYw==}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-x64@1.2.4':
+    resolution: {integrity: sha512-tJxiiLsmHc9Ax1bz3oaOYBURTXGIRDODBqhveVHonrHJ9/+k89qbLl0bcJns+e4t4rvaNBxaEZsFtSfAdquPrw==}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-libvips-linuxmusl-arm64@1.0.4':
+    resolution: {integrity: sha512-9Ti+BbTYDcsbp4wfYib8Ctm1ilkugkA/uscUn6UXK1ldpC1JjiXbLfFZtRlBhjPZ5o1NCLiDbg8fhUPKStHoTA==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-libvips-linuxmusl-arm64@1.2.4':
+    resolution: {integrity: sha512-FVQHuwx1IIuNow9QAbYUzJ+En8KcVm9Lk5+uGUQJHaZmMECZmOlix9HnH7n1TRkXMS0pGxIJokIVB9SuqZGGXw==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-libvips-linuxmusl-x64@1.0.4':
+    resolution: {integrity: sha512-viYN1KX9m+/hGkJtvYYp+CCLgnJXwiQB39damAO7WMdKWlIhmYTfHjwSbQeUK/20vY154mwezd9HflVFM1wVSw==}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-libvips-linuxmusl-x64@1.2.4':
+    resolution: {integrity: sha512-+LpyBk7L44ZIXwz/VYfglaX/okxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg==}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-linux-arm64@0.33.5':
+    resolution: {integrity: sha512-JMVv+AMRyGOHtO1RFBiJy/MBsgz0x4AWrT6QoEVVTyh1E39TrCUpTRI7mx9VksGX4awWASxqCYLCV4wBZHAYxA==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-linux-arm64@0.34.5':
+    resolution: {integrity: sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-linux-arm@0.33.5':
+    resolution: {integrity: sha512-JTS1eldqZbJxjvKaAkxhZmBqPRGmxgu+qFKSInv8moZ2AmT5Yib3EQ1c6gp493HvrvV8QgdOXdyaIBrhvFhBMQ==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@img/sharp-linux-arm@0.34.5':
+    resolution: {integrity: sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@img/sharp-linux-ppc64@0.34.5':
+    resolution: {integrity: sha512-7zznwNaqW6YtsfrGGDA6BRkISKAAE1Jo0QdpNYXNMHu2+0dTrPflTLNkpc8l7MUP5M16ZJcUvysVWWrMefZquA==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@img/sharp-linux-riscv64@0.34.5':
+    resolution: {integrity: sha512-51gJuLPTKa7piYPaVs8GmByo7/U7/7TZOq+cnXJIHZKavIRHAP77e3N2HEl3dgiqdD/w0yUfiJnII77PuDDFdw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@img/sharp-linux-s390x@0.33.5':
+    resolution: {integrity: sha512-y/5PCd+mP4CA/sPDKl2961b+C9d+vPAveS33s6Z3zfASk2j5upL6fXVPZi7ztePZ5CuH+1kW8JtvxgbuXHRa4Q==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [s390x]
+    os: [linux]
+
+  '@img/sharp-linux-s390x@0.34.5':
+    resolution: {integrity: sha512-nQtCk0PdKfho3eC5MrbQoigJ2gd1CgddUMkabUj+rBevs8tZ2cULOx46E7oyX+04WGfABgIwmMC0VqieTiR4jg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [s390x]
+    os: [linux]
+
+  '@img/sharp-linux-x64@0.33.5':
+    resolution: {integrity: sha512-opC+Ok5pRNAzuvq1AG0ar+1owsu842/Ab+4qvU879ippJBHvyY5n2mxF1izXqkPYlGuP/M556uh53jRLJmzTWA==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-linux-x64@0.34.5':
+    resolution: {integrity: sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-linuxmusl-arm64@0.33.5':
+    resolution: {integrity: sha512-XrHMZwGQGvJg2V/oRSUfSAfjfPxO+4DkiRh6p2AFjLQztWUuY/o8Mq0eMQVIY7HJ1CDQUJlxGGZRw1a5bqmd1g==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-linuxmusl-arm64@0.34.5':
+    resolution: {integrity: sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-linuxmusl-x64@0.33.5':
+    resolution: {integrity: sha512-WT+d/cgqKkkKySYmqoZ8y3pxx7lx9vVejxW/W4DOFMYVSkErR+w7mf2u8m/y4+xHe7yY9DAXQMWQhpnMuFfScw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-linuxmusl-x64@0.34.5':
+    resolution: {integrity: sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-wasm32@0.33.5':
+    resolution: {integrity: sha512-ykUW4LVGaMcU9lu9thv85CbRMAwfeadCJHRsg2GmeRa/cJxsVY9Rbd57JcMxBkKHag5U/x7TSBpScF4U8ElVzg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [wasm32]
+
+  '@img/sharp-wasm32@0.34.5':
+    resolution: {integrity: sha512-OdWTEiVkY2PHwqkbBI8frFxQQFekHaSSkUIJkwzclWZe64O1X4UlUjqqqLaPbUpMOQk6FBu/HtlGXNblIs0huw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [wasm32]
+
+  '@img/sharp-win32-arm64@0.34.5':
+    resolution: {integrity: sha512-WQ3AgWCWYSb2yt+IG8mnC6Jdk9Whs7O0gxphblsLvdhSpSTtmu69ZG1Gkb6NuvxsNACwiPV6cNSZNzt0KPsw7g==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [win32]
+
+  '@img/sharp-win32-ia32@0.33.5':
+    resolution: {integrity: sha512-T36PblLaTwuVJ/zw/LaH0PdZkRz5rd3SmMHX8GSmR7vtNSP5Z6bQkExdSK7xGWyxLw4sUknBuugTelgw2faBbQ==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [ia32]
+    os: [win32]
+
+  '@img/sharp-win32-ia32@0.34.5':
+    resolution: {integrity: sha512-FV9m/7NmeCmSHDD5j4+4pNI8Cp3aW+JvLoXcTUo0IqyjSfAZJ8dIUmijx1qaJsIiU+Hosw6xM5KijAWRJCSgNg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [ia32]
+    os: [win32]
+
+  '@img/sharp-win32-x64@0.33.5':
+    resolution: {integrity: sha512-MpY/o8/8kj+EcnxwvrP4aTJSWw/aZ7JIGR4aBeZkZw5B7/Jn+tY9/VNwtcoGmdT7GfggGIU4kygOMSbYnOrAbg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [win32]
+
+  '@img/sharp-win32-x64@0.34.5':
+    resolution: {integrity: sha512-+29YMsqY2/9eFEiW93eqWnuLcWcufowXewwSNIT6UwZdUUCrM3oFjMWH/Z6/TMmb4hlFenmfAVbpWeup2jryCw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [win32]
+
+  '@inquirer/checkbox@4.1.5':
+    resolution: {integrity: sha512-swPczVU+at65xa5uPfNP9u3qx/alNwiaykiI/ExpsmMSQW55trmZcwhYWzw/7fj+n6Q8z1eENvR7vFfq9oPSAQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/confirm@5.1.9':
+    resolution: {integrity: sha512-NgQCnHqFTjF7Ys2fsqK2WtnA8X1kHyInyG+nMIuHowVTIgIuS10T4AznI/PvbqSpJqjCUqNBlKGh1v3bwLFL4w==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/core@10.1.10':
+    resolution: {integrity: sha512-roDaKeY1PYY0aCqhRmXihrHjoSW2A00pV3Ke5fTpMCkzcGF64R8e0lw3dK+eLEHwS4vB5RnW1wuQmvzoRul8Mw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/editor@4.2.10':
+    resolution: {integrity: sha512-5GVWJ+qeI6BzR6TIInLP9SXhWCEcvgFQYmcRG6d6RIlhFjM5TyG18paTGBgRYyEouvCmzeco47x9zX9tQEofkw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/expand@4.0.12':
+    resolution: {integrity: sha512-jV8QoZE1fC0vPe6TnsOfig+qwu7Iza1pkXoUJ3SroRagrt2hxiL+RbM432YAihNR7m7XnU0HWl/WQ35RIGmXHw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/figures@1.0.11':
+    resolution: {integrity: sha512-eOg92lvrn/aRUqbxRyvpEWnrvRuTYRifixHkYVpJiygTgVSBIHDqLh0SrMQXkafvULg3ck11V7xvR+zcgvpHFw==}
+    engines: {node: '>=18'}
+
+  '@inquirer/input@4.1.9':
+    resolution: {integrity: sha512-mshNG24Ij5KqsQtOZMgj5TwEjIf+F2HOESk6bjMwGWgcH5UBe8UoljwzNFHqdMbGYbgAf6v2wU/X9CAdKJzgOA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/number@3.0.12':
+    resolution: {integrity: sha512-7HRFHxbPCA4e4jMxTQglHJwP+v/kpFsCf2szzfBHy98Wlc3L08HL76UDiA87TOdX5fwj2HMOLWqRWv9Pnn+Z5Q==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/password@4.0.12':
+    resolution: {integrity: sha512-FlOB0zvuELPEbnBYiPaOdJIaDzb2PmJ7ghi/SVwIHDDSQ2K4opGBkF+5kXOg6ucrtSUQdLhVVY5tycH0j0l+0g==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/prompts@7.5.0':
+    resolution: {integrity: sha512-tk8Bx7l5AX/CR0sVfGj3Xg6v7cYlFBkEahH+EgBB+cZib6Fc83dwerTbzj7f2+qKckjIUGsviWRI1d7lx6nqQA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/rawlist@4.1.0':
+    resolution: {integrity: sha512-6ob45Oh9pXmfprKqUiEeMz/tjtVTFQTgDDz1xAMKMrIvyrYjAmRbQZjMJfsictlL4phgjLhdLu27IkHNnNjB7g==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/search@3.0.12':
+    resolution: {integrity: sha512-H/kDJA3kNlnNIjB8YsaXoQI0Qccgf0Na14K1h8ExWhNmUg2E941dyFPrZeugihEa9AZNW5NdsD/NcvUME83OPQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/select@4.2.0':
+    resolution: {integrity: sha512-KkXQ4aSySWimpV4V/TUJWdB3tdfENZUU765GjOIZ0uPwdbGIG6jrxD4dDf1w68uP+DVtfNhr1A92B+0mbTZ8FA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/type@3.0.6':
+    resolution: {integrity: sha512-/mKVCtVpyBu3IDarv0G+59KC4stsD5mDsGpYh+GKs1NZT88Jh52+cuoA1AtLk2Q0r/quNl+1cSUyLRHBFeD0XA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@isaacs/balanced-match@4.0.1':
+    resolution: {integrity: sha512-yzMTt9lEb8Gv7zRioUilSglI0c0smZ9k5D65677DLWLtWJaXIS3CqcGyUFByYKlnUj6TkjLVs54fBl6+TiGQDQ==}
+    engines: {node: 20 || >=22}
+
+  '@isaacs/brace-expansion@5.0.0':
+    resolution: {integrity: sha512-ZT55BDLV0yv0RBm2czMiZ+SqCGO7AvmOM3G/w2xhVPH+te0aKgFjmBvGlL1dH+ql2tgGO3MVrbb3jCKyvpgnxA==}
+    engines: {node: 20 || >=22}
+
+  '@isaacs/cliui@8.0.2':
+    resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==}
+    engines: {node: '>=12'}
+
+  '@istanbuljs/schema@0.1.3':
+    resolution: {integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==}
+    engines: {node: '>=8'}
+
+  '@jest/schemas@29.6.3':
+    resolution: {integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
+  '@jridgewell/gen-mapping@0.3.8':
+    resolution: {integrity: sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==}
+    engines: {node: '>=6.0.0'}
+
+  '@jridgewell/resolve-uri@3.1.2':
+    resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
+    engines: {node: '>=6.0.0'}
+
+  '@jridgewell/set-array@1.2.1':
+    resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==}
+    engines: {node: '>=6.0.0'}
+
+  '@jridgewell/sourcemap-codec@1.5.5':
+    resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
+
+  '@jridgewell/trace-mapping@0.3.31':
+    resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
+
+  '@jsep-plugin/assignment@1.3.0':
+    resolution: {integrity: sha512-VVgV+CXrhbMI3aSusQyclHkenWSAm95WaiKrMxRFam3JSUiIaQjoMIw2sEs/OX4XifnqeQUN4DYbJjlA8EfktQ==}
+    engines: {node: '>= 10.16.0'}
+    peerDependencies:
+      jsep: ^0.4.0||^1.0.0
+
+  '@jsep-plugin/regex@1.0.4':
+    resolution: {integrity: sha512-q7qL4Mgjs1vByCaTnDFcBnV9HS7GVPJX5vyVoCgZHNSC9rjwIlmbXG5sUuorR5ndfHAIlJ8pVStxvjXHbNvtUg==}
+    engines: {node: '>= 10.16.0'}
+    peerDependencies:
+      jsep: ^0.4.0||^1.0.0
+
+  '@jsep-plugin/ternary@1.1.4':
+    resolution: {integrity: sha512-ck5wiqIbqdMX6WRQztBL7ASDty9YLgJ3sSAK5ZpBzXeySvFGCzIvM6UiAI4hTZ22fEcYQVV/zhUbNscggW+Ukg==}
+    engines: {node: '>= 10.16.0'}
+    peerDependencies:
+      jsep: ^0.4.0||^1.0.0
+
+  '@kwsites/file-exists@1.1.1':
+    resolution: {integrity: sha512-m9/5YGR18lIwxSFDwfE3oA7bWuq9kdau6ugN4H2rJeyhFQZcG9AgSHkQtSD15a8WvTgfz9aikZMrKPHvbpqFiw==}
+
+  '@kwsites/promise-deferred@1.1.1':
+    resolution: {integrity: sha512-GaHYm+c0O9MjZRu0ongGBRbinu8gVAMd2UZjji6jVmqKtZluZnptXGWhz1E8j8D2HJ3f/yMxKAUC0b+57wncIw==}
+
+  '@langchain/core@0.3.50':
+    resolution: {integrity: sha512-0MBVe7dZ4h3a3MJAg/YesWBvwkDg8t2rDIGg2Q11DxRBnxB7OqmvBlbZ1ftaDvoBZzxMY+8E58OsCLuay3Bk9w==}
+    engines: {node: '>=18'}
+
+  '@langchain/openai@0.4.9':
+    resolution: {integrity: sha512-NAsaionRHNdqaMjVLPkFCyjUDze+OqRHghA1Cn4fPoAafz+FXcl9c7LlEl9Xo0FH6/8yiCl7Rw2t780C/SBVxQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@langchain/core': '>=0.3.39 <0.4.0'
+
+  '@leichtgewicht/ip-codec@2.0.5':
+    resolution: {integrity: sha512-Vo+PSpZG2/fmgmiNzYK9qWRh8h/CHrwD0mo1h1DzL4yzHNSfWYujGTYsWGreD000gcgmZ7K4Ys6Tx9TxtsKdDw==}
+
+  '@lukeed/ms@2.0.2':
+    resolution: {integrity: sha512-9I2Zn6+NJLfaGoz9jN3lpwDgAYvfGeNYdbAIjJOqzs4Tpc+VU3Jqq4IofSUBKajiDS8k9fZIg18/z13mpk1bsA==}
+    engines: {node: '>=8'}
+
+  '@manypkg/find-root@1.1.0':
+    resolution: {integrity: sha512-mki5uBvhHzO8kYYix/WRy2WX8S3B5wdVSc9D6KcU5lQNglP2yt58/VfLuAK49glRXChosY8ap2oJ1qgma3GUVA==}
+
+  '@manypkg/get-packages@1.1.3':
+    resolution: {integrity: sha512-fo+QhuU3qE/2TQMQmbVMqaQ6EWbMhi4ABWP+O4AM1NqPBuy0OrApV5LO6BrrgnhtAHS2NH6RrVk9OL181tTi8A==}
+
+  '@mdx-js/mdx@3.1.0':
+    resolution: {integrity: sha512-/QxEhPAvGwbQmy1Px8F899L5Uc2KZ6JtXwlCgJmjSTBedwOZkByYcBG4GceIGPXRDsmfxhHazuS+hlOShRLeDw==}
+
+  '@mdx-js/react@3.1.0':
+    resolution: {integrity: sha512-QjHtSaoameoalGnKDT3FoIl4+9RwyTmo9ZJGBdLOks/YOiWHoRDI3PUwEzOE7kEmGcV3AFcp9K6dYu9rEuKLAQ==}
+    peerDependencies:
+      '@types/react': '>=16'
+      react: '>=16'
+
+  '@mintlify/cli@4.0.682':
+    resolution: {integrity: sha512-91XL+qCw9hm2KpMgKsNASIfUHYLhYwSmeoMRkE6p5Iy7P5dPAxJd+PUFPXdh4EGhMNALGRLHzm9rUoNvthM89w==}
+    engines: {node: '>=18.0.0'}
+    deprecated: This version is deprecated. Please upgrade to version 4.0.423 or later.
+    hasBin: true
+
+  '@mintlify/common@1.0.496':
+    resolution: {integrity: sha512-OSYwjfiyfuDAoj03hOD2MNCGU9mz/hxCb/r/VC38xDwiukZe0i7UB4p6ytyyNKW3UrMkNPc33bMvCS0UNu6S8Q==}
+
+  '@mintlify/link-rot@3.0.629':
+    resolution: {integrity: sha512-fFRY1CeJJ5SzcNTWHKSefcilhmUTMDLT0k4ocq6V6668piLhsHcV0lkQl1xZs9VaVpAxUJs76HLC/i2XimfBGQ==}
+    engines: {node: '>=18.0.0'}
+
+  '@mintlify/mdx@2.0.3':
+    resolution: {integrity: sha512-UGlwavma8QooWAlhtXpTAG5MAUZTTUKI8Qu25Wqfp1HMOPrYGvo5YQPmlqqogbMsqDMcFPLP/ZYnaZsGUYBspQ==}
+    peerDependencies:
+      react: ^18.3.1
+      react-dom: ^18.3.1
+
+  '@mintlify/models@0.0.219':
+    resolution: {integrity: sha512-/uR4hAwpcJW9+zbmZL48kKFnWLkOxhIqoGWvZzjg0CniVhR4emtQJAps80WqLAhz0iJgCQxg/axtA7leaznDzQ==}
+    engines: {node: '>=18.0.0'}
+
+  '@mintlify/openapi-parser@0.0.7':
+    resolution: {integrity: sha512-3ecbkzPbsnkKVZJypVL0H5pCTR7a4iLv4cP7zbffzAwy+vpH70JmPxNVpPPP62yLrdZlfNcMxu5xKeT7fllgMg==}
+    engines: {node: '>=18'}
+
+  '@mintlify/prebuild@1.0.618':
+    resolution: {integrity: sha512-onCrK/PnBK2CK+JrbhJHQMh9kAzQrfo/XcnmfNz2ENFQtx4HM1Igkky/Ul6qrAn91wEpojPOtCbBuYTjyl/umw==}
+
+  '@mintlify/previewing@4.0.665':
+    resolution: {integrity: sha512-dP5t3O1liyimSg8WeGU9ZmKcMpsVT3ic4AiaACcfk4YcrvTCz1HI0Vxf58/uxd5u6lYRKLJzOEsa8jqBFKoaiQ==}
+    engines: {node: '>=18.0.0'}
+
+  '@mintlify/scraping@4.0.354':
+    resolution: {integrity: sha512-K9QhhEYvObRncobsqWQFBdon3l/0dUCNWdFC9qL5uH3GK2mH2veVXSE4iEi0tlZAixh2jwdN1Ucj8f+DbhXivA==}
+    engines: {node: '>=18.0.0'}
+    hasBin: true
+
+  '@mintlify/validation@0.1.442':
+    resolution: {integrity: sha512-s99u9Kv92nGjUvkdMpi7Mks+B8sG3t30p/8NppS04GngqlE16VDXp8z3qHhWUTJnjJFJZCyraz8zzWaonhWykA==}
+
+  '@modelcontextprotocol/sdk@1.17.2':
+    resolution: {integrity: sha512-EFLRNXR/ixpXQWu6/3Cu30ndDFIFNaqUXcTqsGebujeMan9FzhAaFFswLRiFj61rgygDRr8WO1N+UijjgRxX9g==}
+    engines: {node: '>=18'}
+
+  '@next/env@14.2.28':
+    resolution: {integrity: sha512-PAmWhJfJQlP+kxZwCjrVd9QnR5x0R3u0mTXTiZDgSd4h5LdXmjxCCWbN9kq6hkZBOax8Rm3xDW5HagWyJuT37g==}
+
+  '@nodelib/fs.scandir@2.1.5':
+    resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
+    engines: {node: '>= 8'}
+
+  '@nodelib/fs.stat@2.0.5':
+    resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==}
+    engines: {node: '>= 8'}
+
+  '@nodelib/fs.walk@1.2.8':
+    resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==}
+    engines: {node: '>= 8'}
+
+  '@openapi-contrib/openapi-schema-to-json-schema@3.2.0':
+    resolution: {integrity: sha512-Gj6C0JwCr8arj0sYuslWXUBSP/KnUlEGnPW4qxlXvAl543oaNQgMgIgkQUA6vs5BCCvwTEiL8m/wdWzfl4UvSw==}
+
+  '@opentelemetry/api@1.9.0':
+    resolution: {integrity: sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==}
+    engines: {node: '>=8.0.0'}
+
+  '@pinojs/redact@0.4.0':
+    resolution: {integrity: sha512-k2ENnmBugE/rzQfEcdWHcCY+/FM3VLzH9cYEsbdsoqrvzAKRhUZeRNhAZvB8OitQJ1TBed3yqWtdjzS6wJKBwg==}
+
+  '@pkgjs/parseargs@0.11.0':
+    resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==}
+    engines: {node: '>=14'}
+
+  '@playwright/test@1.54.2':
+    resolution: {integrity: sha512-A+znathYxPf+72riFd1r1ovOLqsIIB0jKIoPjyK2kqEIe30/6jF6BC7QNluHuwUmsD2tv1XZVugN8GqfTMOxsA==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  '@puppeteer/browsers@2.3.0':
+    resolution: {integrity: sha512-ioXoq9gPxkss4MYhD+SFaU9p1IHFUX0ILAWFPyjGaBdjLsYAlZw6j1iLA0N/m12uVHLFDfSYNF7EQccjinIMDA==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  '@rollup/rollup-android-arm-eabi@4.53.2':
+    resolution: {integrity: sha512-yDPzwsgiFO26RJA4nZo8I+xqzh7sJTZIWQOxn+/XOdPE31lAvLIYCKqjV+lNH/vxE2L2iH3plKxDCRK6i+CwhA==}
+    cpu: [arm]
+    os: [android]
+
+  '@rollup/rollup-android-arm64@4.53.2':
+    resolution: {integrity: sha512-k8FontTxIE7b0/OGKeSN5B6j25EuppBcWM33Z19JoVT7UTXFSo3D9CdU39wGTeb29NO3XxpMNauh09B+Ibw+9g==}
+    cpu: [arm64]
+    os: [android]
+
+  '@rollup/rollup-darwin-arm64@4.53.2':
+    resolution: {integrity: sha512-A6s4gJpomNBtJ2yioj8bflM2oogDwzUiMl2yNJ2v9E7++sHrSrsQ29fOfn5DM/iCzpWcebNYEdXpaK4tr2RhfQ==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@rollup/rollup-darwin-x64@4.53.2':
+    resolution: {integrity: sha512-e6XqVmXlHrBlG56obu9gDRPW3O3hLxpwHpLsBJvuI8qqnsrtSZ9ERoWUXtPOkY8c78WghyPHZdmPhHLWNdAGEw==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@rollup/rollup-freebsd-arm64@4.53.2':
+    resolution: {integrity: sha512-v0E9lJW8VsrwPux5Qe5CwmH/CF/2mQs6xU1MF3nmUxmZUCHazCjLgYvToOk+YuuUqLQBio1qkkREhxhc656ViA==}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@rollup/rollup-freebsd-x64@4.53.2':
+    resolution: {integrity: sha512-ClAmAPx3ZCHtp6ysl4XEhWU69GUB1D+s7G9YjHGhIGCSrsg00nEGRRZHmINYxkdoJehde8VIsDC5t9C0gb6yqA==}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@rollup/rollup-linux-arm-gnueabihf@4.53.2':
+    resolution: {integrity: sha512-EPlb95nUsz6Dd9Qy13fI5kUPXNSljaG9FiJ4YUGU1O/Q77i5DYFW5KR8g1OzTcdZUqQQ1KdDqsTohdFVwCwjqg==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm-musleabihf@4.53.2':
+    resolution: {integrity: sha512-BOmnVW+khAUX+YZvNfa0tGTEMVVEerOxN0pDk2E6N6DsEIa2Ctj48FOMfNDdrwinocKaC7YXUZ1pHlKpnkja/Q==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm64-gnu@4.53.2':
+    resolution: {integrity: sha512-Xt2byDZ+6OVNuREgBXr4+CZDJtrVso5woFtpKdGPhpTPHcNG7D8YXeQzpNbFRxzTVqJf7kvPMCub/pcGUWgBjA==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm64-musl@4.53.2':
+    resolution: {integrity: sha512-+LdZSldy/I9N8+klim/Y1HsKbJ3BbInHav5qE9Iy77dtHC/pibw1SR/fXlWyAk0ThnpRKoODwnAuSjqxFRDHUQ==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/rollup-linux-loong64-gnu@4.53.2':
+    resolution: {integrity: sha512-8ms8sjmyc1jWJS6WdNSA23rEfdjWB30LH8Wqj0Cqvv7qSHnvw6kgMMXRdop6hkmGPlyYBdRPkjJnj3KCUHV/uQ==}
+    cpu: [loong64]
+    os: [linux]
+
+  '@rollup/rollup-linux-ppc64-gnu@4.53.2':
+    resolution: {integrity: sha512-3HRQLUQbpBDMmzoxPJYd3W6vrVHOo2cVW8RUo87Xz0JPJcBLBr5kZ1pGcQAhdZgX9VV7NbGNipah1omKKe23/g==}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@rollup/rollup-linux-riscv64-gnu@4.53.2':
+    resolution: {integrity: sha512-fMjKi+ojnmIvhk34gZP94vjogXNNUKMEYs+EDaB/5TG/wUkoeua7p7VCHnE6T2Tx+iaghAqQX8teQzcvrYpaQA==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@rollup/rollup-linux-riscv64-musl@4.53.2':
+    resolution: {integrity: sha512-XuGFGU+VwUUV5kLvoAdi0Wz5Xbh2SrjIxCtZj6Wq8MDp4bflb/+ThZsVxokM7n0pcbkEr2h5/pzqzDYI7cCgLQ==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@rollup/rollup-linux-s390x-gnu@4.53.2':
+    resolution: {integrity: sha512-w6yjZF0P+NGzWR3AXWX9zc0DNEGdtvykB03uhonSHMRa+oWA6novflo2WaJr6JZakG2ucsyb+rvhrKac6NIy+w==}
+    cpu: [s390x]
+    os: [linux]
+
+  '@rollup/rollup-linux-x64-gnu@4.53.2':
+    resolution: {integrity: sha512-yo8d6tdfdeBArzC7T/PnHd7OypfI9cbuZzPnzLJIyKYFhAQ8SvlkKtKBMbXDxe1h03Rcr7u++nFS7tqXz87Gtw==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/rollup-linux-x64-musl@4.53.2':
+    resolution: {integrity: sha512-ah59c1YkCxKExPP8O9PwOvs+XRLKwh/mV+3YdKqQ5AMQ0r4M4ZDuOrpWkUaqO7fzAHdINzV9tEVu8vNw48z0lA==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/rollup-openharmony-arm64@4.53.2':
+    resolution: {integrity: sha512-4VEd19Wmhr+Zy7hbUsFZ6YXEiP48hE//KPLCSVNY5RMGX2/7HZ+QkN55a3atM1C/BZCGIgqN+xrVgtdak2S9+A==}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@rollup/rollup-win32-arm64-msvc@4.53.2':
+    resolution: {integrity: sha512-IlbHFYc/pQCgew/d5fslcy1KEaYVCJ44G8pajugd8VoOEI8ODhtb/j8XMhLpwHCMB3yk2J07ctup10gpw2nyMA==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@rollup/rollup-win32-ia32-msvc@4.53.2':
+    resolution: {integrity: sha512-lNlPEGgdUfSzdCWU176ku/dQRnA7W+Gp8d+cWv73jYrb8uT7HTVVxq62DUYxjbaByuf1Yk0RIIAbDzp+CnOTFg==}
+    cpu: [ia32]
+    os: [win32]
+
+  '@rollup/rollup-win32-x64-gnu@4.53.2':
+    resolution: {integrity: sha512-S6YojNVrHybQis2lYov1sd+uj7K0Q05NxHcGktuMMdIQ2VixGwAfbJ23NnlvvVV1bdpR2m5MsNBViHJKcA4ADw==}
+    cpu: [x64]
+    os: [win32]
+
+  '@rollup/rollup-win32-x64-msvc@4.53.2':
+    resolution: {integrity: sha512-k+/Rkcyx//P6fetPoLMb8pBeqJBNGx81uuf7iljX9++yNBVRDQgD04L+SVXmXmh5ZP4/WOp4mWF0kmi06PW2tA==}
+    cpu: [x64]
+    os: [win32]
+
+  '@shikijs/core@3.11.0':
+    resolution: {integrity: sha512-oJwU+DxGqp6lUZpvtQgVOXNZcVsirN76tihOLBmwILkKuRuwHteApP8oTXmL4tF5vS5FbOY0+8seXmiCoslk4g==}
+
+  '@shikijs/engine-javascript@3.11.0':
+    resolution: {integrity: sha512-6/ov6pxrSvew13k9ztIOnSBOytXeKs5kfIR7vbhdtVRg+KPzvp2HctYGeWkqv7V6YIoLicnig/QF3iajqyElZA==}
+
+  '@shikijs/engine-oniguruma@3.11.0':
+    resolution: {integrity: sha512-4DwIjIgETK04VneKbfOE4WNm4Q7WC1wo95wv82PoHKdqX4/9qLRUwrfKlmhf0gAuvT6GHy0uc7t9cailk6Tbhw==}
+
+  '@shikijs/langs@3.11.0':
+    resolution: {integrity: sha512-Njg/nFL4HDcf/ObxcK2VeyidIq61EeLmocrwTHGGpOQx0BzrPWM1j55XtKQ1LvvDWH15cjQy7rg96aJ1/l63uw==}
+
+  '@shikijs/themes@3.11.0':
+    resolution: {integrity: sha512-BhhWRzCTEk2CtWt4S4bgsOqPJRkapvxdsifAwqP+6mk5uxboAQchc0etiJ0iIasxnMsb764qGD24DK9albcU9Q==}
+
+  '@shikijs/transformers@3.11.0':
+    resolution: {integrity: sha512-fhSpVoq0FoCtKbBpzE3mXcIbr0b7ozFDSSWiVjWrQy+wrOfaFfwxgJqh8kY3Pbv/i+4pcuMIVismLD2MfO62eQ==}
+
+  '@shikijs/types@3.11.0':
+    resolution: {integrity: sha512-RB7IMo2E7NZHyfkqAuaf4CofyY8bPzjWPjJRzn6SEak3b46fIQyG6Vx5fG/obqkfppQ+g8vEsiD7Uc6lqQt32Q==}
+
+  '@shikijs/vscode-textmate@10.0.2':
+    resolution: {integrity: sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg==}
+
+  '@sinclair/typebox@0.27.10':
+    resolution: {integrity: sha512-MTBk/3jGLNB2tVxv6uLlFh1iu64iYOQ2PbdOSK3NW8JZsmlaOh2q6sdtKowBhfw8QFLmYNzTW4/oK4uATIi6ZA==}
+
+  '@sindresorhus/is@5.6.0':
+    resolution: {integrity: sha512-TV7t8GKYaJWsn00tFDqBw8+Uqmr8A0fRU1tvTQhyZzGv0sJCGRQL3JGMI3ucuKo3XIZdUP+Lx7/gh2t3lewy7g==}
+    engines: {node: '>=14.16'}
+
+  '@sindresorhus/slugify@2.2.1':
+    resolution: {integrity: sha512-MkngSCRZ8JdSOCHRaYd+D01XhvU3Hjy6MGl06zhOk614hp9EOAp5gIkBeQg7wtmxpitU6eAL4kdiRMcJa2dlrw==}
+    engines: {node: '>=12'}
+
+  '@sindresorhus/transliterate@1.6.0':
+    resolution: {integrity: sha512-doH1gimEu3A46VX6aVxpHTeHrytJAG6HgdxntYnCFiIFHEM/ZGpG8KiZGBChchjQmG0XFIBL552kBTjVcMZXwQ==}
+    engines: {node: '>=12'}
+
+  '@smithy/eventstream-codec@4.2.8':
+    resolution: {integrity: sha512-jS/O5Q14UsufqoGhov7dHLOPCzkYJl9QDzusI2Psh4wyYx/izhzvX9P4D69aTxcdfVhEPhjK+wYyn/PzLjKbbw==}
+    engines: {node: '>=18.0.0'}
+
+  '@smithy/is-array-buffer@2.2.0':
+    resolution: {integrity: sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA==}
+    engines: {node: '>=14.0.0'}
+
+  '@smithy/is-array-buffer@4.2.0':
+    resolution: {integrity: sha512-DZZZBvC7sjcYh4MazJSGiWMI2L7E0oCiRHREDzIxi/M2LY79/21iXt6aPLHge82wi5LsuRF5A06Ds3+0mlh6CQ==}
+    engines: {node: '>=18.0.0'}
+
+  '@smithy/types@4.12.0':
+    resolution: {integrity: sha512-9YcuJVTOBDjg9LWo23Qp0lTQ3D7fQsQtwle0jVfpbUHy9qBwCEgKuVH4FqFB3VYu0nwdHKiEMA+oXz7oV8X1kw==}
+    engines: {node: '>=18.0.0'}
+
+  '@smithy/util-buffer-from@2.2.0':
+    resolution: {integrity: sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA==}
+    engines: {node: '>=14.0.0'}
+
+  '@smithy/util-buffer-from@4.2.0':
+    resolution: {integrity: sha512-kAY9hTKulTNevM2nlRtxAG2FQ3B2OR6QIrPY3zE5LqJy1oxzmgBGsHLWTcNhWXKchgA0WHW+mZkQrng/pgcCew==}
+    engines: {node: '>=18.0.0'}
+
+  '@smithy/util-hex-encoding@4.2.0':
+    resolution: {integrity: sha512-CCQBwJIvXMLKxVbO88IukazJD9a4kQ9ZN7/UMGBjBcJYvatpWk+9g870El4cB8/EJxfe+k+y0GmR9CAzkF+Nbw==}
+    engines: {node: '>=18.0.0'}
+
+  '@smithy/util-utf8@2.3.0':
+    resolution: {integrity: sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A==}
+    engines: {node: '>=14.0.0'}
+
+  '@smithy/util-utf8@4.2.0':
+    resolution: {integrity: sha512-zBPfuzoI8xyBtR2P6WQj63Rz8i3AmfAaJLuNG8dWsfvPe8lO4aCPYLn879mEgHndZH1zQ2oXmG8O1GGzzaoZiw==}
+    engines: {node: '>=18.0.0'}
+
+  '@socket.io/component-emitter@3.1.2':
+    resolution: {integrity: sha512-9BCxFwvbGg/RsZK9tjXd8s4UcwR0MWeFQ1XEKIQVVvAGJyINdrqKMcTRyLoK8Rse1GjzLV9cwjWV1olXRWEXVA==}
+
+  '@standard-schema/spec@1.1.0':
+    resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
+
+  '@stoplight/better-ajv-errors@1.0.3':
+    resolution: {integrity: sha512-0p9uXkuB22qGdNfy3VeEhxkU5uwvp/KrBTAbrLBURv6ilxIVwanKwjMc41lQfIVgPGcOkmLbTolfFrSsueu7zA==}
+    engines: {node: ^12.20 || >= 14.13}
+    peerDependencies:
+      ajv: '>=8'
+
+  '@stoplight/json-ref-readers@1.2.2':
+    resolution: {integrity: sha512-nty0tHUq2f1IKuFYsLM4CXLZGHdMn+X/IwEUIpeSOXt0QjMUbL0Em57iJUDzz+2MkWG83smIigNZ3fauGjqgdQ==}
+    engines: {node: '>=8.3.0'}
+
+  '@stoplight/json-ref-resolver@3.1.6':
+    resolution: {integrity: sha512-YNcWv3R3n3U6iQYBsFOiWSuRGE5su1tJSiX6pAPRVk7dP0L7lqCteXGzuVRQ0gMZqUl8v1P0+fAKxF6PLo9B5A==}
+    engines: {node: '>=8.3.0'}
+
+  '@stoplight/json@3.21.0':
+    resolution: {integrity: sha512-5O0apqJ/t4sIevXCO3SBN9AHCEKKR/Zb4gaj7wYe5863jme9g02Q0n/GhM7ZCALkL+vGPTe4ZzTETP8TFtsw3g==}
+    engines: {node: '>=8.3.0'}
+
+  '@stoplight/ordered-object-literal@1.0.5':
+    resolution: {integrity: sha512-COTiuCU5bgMUtbIFBuyyh2/yVVzlr5Om0v5utQDgBCuQUOPgU1DwoffkTfg4UBQOvByi5foF4w4T+H9CoRe5wg==}
+    engines: {node: '>=8'}
+
+  '@stoplight/path@1.3.2':
+    resolution: {integrity: sha512-lyIc6JUlUA8Ve5ELywPC8I2Sdnh1zc1zmbYgVarhXIp9YeAB0ReeqmGEOWNtlHkbP2DAA1AL65Wfn2ncjK/jtQ==}
+    engines: {node: '>=8'}
+
+  '@stoplight/spectral-core@1.20.0':
+    resolution: {integrity: sha512-5hBP81nCC1zn1hJXL/uxPNRKNcB+/pEIHgCjPRpl/w/qy9yC9ver04tw1W0l/PMiv0UeB5dYgozXVQ4j5a6QQQ==}
+    engines: {node: ^16.20 || ^18.18 || >= 20.17}
+
+  '@stoplight/spectral-formats@1.8.2':
+    resolution: {integrity: sha512-c06HB+rOKfe7tuxg0IdKDEA5XnjL2vrn/m/OVIIxtINtBzphZrOgtRn7epQ5bQF5SWp84Ue7UJWaGgDwVngMFw==}
+    engines: {node: ^16.20 || ^18.18 || >= 20.17}
+
+  '@stoplight/spectral-functions@1.10.1':
+    resolution: {integrity: sha512-obu8ZfoHxELOapfGsCJixKZXZcffjg+lSoNuttpmUFuDzVLT3VmH8QkPXfOGOL5Pz80BR35ClNAToDkdnYIURg==}
+    engines: {node: ^16.20 || ^18.18 || >= 20.17}
+
+  '@stoplight/spectral-parsers@1.0.5':
+    resolution: {integrity: sha512-ANDTp2IHWGvsQDAY85/jQi9ZrF4mRrA5bciNHX+PUxPr4DwS6iv4h+FVWJMVwcEYdpyoIdyL+SRmHdJfQEPmwQ==}
+    engines: {node: ^16.20 || ^18.18 || >= 20.17}
+
+  '@stoplight/spectral-ref-resolver@1.0.5':
+    resolution: {integrity: sha512-gj3TieX5a9zMW29z3mBlAtDOCgN3GEc1VgZnCVlr5irmR4Qi5LuECuFItAq4pTn5Zu+sW5bqutsCH7D4PkpyAA==}
+    engines: {node: ^16.20 || ^18.18 || >= 20.17}
+
+  '@stoplight/spectral-runtime@1.1.4':
+    resolution: {integrity: sha512-YHbhX3dqW0do6DhiPSgSGQzr6yQLlWybhKwWx0cqxjMwxej3TqLv3BXMfIUYFKKUqIwH4Q2mV8rrMM8qD2N0rQ==}
+    engines: {node: ^16.20 || ^18.18 || >= 20.17}
+
+  '@stoplight/types@13.20.0':
+    resolution: {integrity: sha512-2FNTv05If7ib79VPDA/r9eUet76jewXFH2y2K5vuge6SXbRHtWBhcaRmu+6QpF4/WRNoJj5XYRSwLGXDxysBGA==}
+    engines: {node: ^12.20 || >=14.13}
+
+  '@stoplight/types@13.6.0':
+    resolution: {integrity: sha512-dzyuzvUjv3m1wmhPfq82lCVYGcXG0xUYgqnWfCq3PCVR4BKFhjdkHrnJ+jIDoMKvXb05AZP/ObQF6+NpDo29IQ==}
+    engines: {node: ^12.20 || >=14.13}
+
+  '@stoplight/types@14.1.1':
+    resolution: {integrity: sha512-/kjtr+0t0tjKr+heVfviO9FrU/uGLc+QNX3fHJc19xsCNYqU7lVhaXxDmEID9BZTjG+/r9pK9xP/xU02XGg65g==}
+    engines: {node: ^12.20 || >=14.13}
+
+  '@stoplight/yaml-ast-parser@0.0.50':
+    resolution: {integrity: sha512-Pb6M8TDO9DtSVla9yXSTAxmo9GVEouq5P40DWXdOie69bXogZTkgvopCq+yEvTMA0F6PEvdJmbtTV3ccIp11VQ==}
+
+  '@stoplight/yaml@4.3.0':
+    resolution: {integrity: sha512-JZlVFE6/dYpP9tQmV0/ADfn32L9uFarHWxfcRhReKUnljz1ZiUM5zpX+PH8h5CJs6lao3TuFqnPm9IJJCEkE2w==}
+    engines: {node: '>=10.8'}
+
+  '@szmarczak/http-timer@5.0.1':
+    resolution: {integrity: sha512-+PmQX0PiAYPMeVYe237LJAYvOMYW1j2rH5YROyS3b4CTVJum34HfRvKvAzozHAQG0TnHNdUfY9nCeUyRAs//cw==}
+    engines: {node: '>=14.16'}
+
+  '@t3-oss/env-core@0.13.8':
+    resolution: {integrity: sha512-L1inmpzLQyYu4+Q1DyrXsGJYCXbtXjC4cICw1uAKv0ppYPQv656lhZPU91Qd1VS6SO/bou1/q5ufVzBGbNsUpw==}
+    peerDependencies:
+      arktype: ^2.1.0
+      typescript: '>=5.0.0'
+      valibot: ^1.0.0-beta.7 || ^1.0.0
+      zod: ^3.24.0 || ^4.0.0-beta.0
+    peerDependenciesMeta:
+      arktype:
+        optional: true
+      typescript:
+        optional: true
+      valibot:
+        optional: true
+      zod:
+        optional: true
+
+  '@tootallnate/quickjs-emscripten@0.23.0':
+    resolution: {integrity: sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==}
+
+  '@types/adm-zip@0.5.7':
+    resolution: {integrity: sha512-DNEs/QvmyRLurdQPChqq0Md4zGvPwHerAJYWk9l2jCbD1VPpnzRJorOdiq4zsw09NFbYnhfsoEhWtxIzXpn2yw==}
+
+  '@types/chai@5.2.3':
+    resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==}
+
+  '@types/cors@2.8.17':
+    resolution: {integrity: sha512-8CGDvrBj1zgo2qE+oS3pOCyYNqCPryMWY2bGfwA0dcfopWGgxs+78df0Rs3rc9THP4JkOhLsAa+15VdpAqkcUA==}
+
+  '@types/debug@4.1.12':
+    resolution: {integrity: sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==}
+
+  '@types/deep-eql@4.0.2':
+    resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
+
+  '@types/es-aggregate-error@1.0.6':
+    resolution: {integrity: sha512-qJ7LIFp06h1QE1aVxbVd+zJP2wdaugYXYfd6JxsyRMrYHaxb6itXPogW2tz+ylUJ1n1b+JF1PHyYCfYHm0dvUg==}
+
+  '@types/esrecurse@4.3.1':
+    resolution: {integrity: sha512-xJBAbDifo5hpffDBuHl0Y8ywswbiAp/Wi7Y/GtAgSlZyIABppyurxVueOPE8LUQOxdlgi6Zqce7uoEpqNTeiUw==}
+
+  '@types/estree-jsx@1.0.5':
+    resolution: {integrity: sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==}
+
+  '@types/estree@1.0.8':
+    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
+
+  '@types/hast@3.0.4':
+    resolution: {integrity: sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==}
+
+  '@types/http-cache-semantics@4.0.4':
+    resolution: {integrity: sha512-1m0bIFVc7eJWyve9S0RnuRgcQqF/Xd5QsUZAZeQFr1Q3/p9JWoQQEqmVy+DPTNpGXwhgIetAoYF8JSc33q29QA==}
+
+  '@types/istanbul-lib-coverage@2.0.6':
+    resolution: {integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==}
+
+  '@types/jsdom@27.0.0':
+    resolution: {integrity: sha512-NZyFl/PViwKzdEkQg96gtnB8wm+1ljhdDay9ahn4hgb+SfVtPCbm3TlmDUFXTA+MGN3CijicnMhG18SI5H3rFw==}
+
+  '@types/json-schema@7.0.15':
+    resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==}
+
+  '@types/katex@0.16.7':
+    resolution: {integrity: sha512-HMwFiRujE5PjrgwHQ25+bsLJgowjGjm5Z8FVSf0N6PwgJrwxH0QxzHYDcKsTfV3wva0vzrpqMTJS2jXPr5BMEQ==}
+
+  '@types/mdast@4.0.4':
+    resolution: {integrity: sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==}
+
+  '@types/mdx@2.0.13':
+    resolution: {integrity: sha512-+OWZQfAYyio6YkJb3HLxDrvnx6SWWDbC0zVPfBRzUk0/nqoDyf6dNxQi3eArPe8rJ473nobTMQ/8Zk+LxJ+Yuw==}
+
+  '@types/ms@2.1.0':
+    resolution: {integrity: sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==}
+
+  '@types/nlcst@2.0.3':
+    resolution: {integrity: sha512-vSYNSDe6Ix3q+6Z7ri9lyWqgGhJTmzRjZRqyq15N0Z/1/UnVsno9G/N40NBijoYx2seFDIl0+B2mgAb9mezUCA==}
+
+  '@types/node-fetch@2.6.12':
+    resolution: {integrity: sha512-8nneRWKCg3rMtF69nLQJnOYUcbafYeFSjqkw3jCRLsqkWFlHaoQrr5mXmofFGOx3DKn7UfmBMyov8ySvLRVldA==}
+
+  '@types/node@12.20.55':
+    resolution: {integrity: sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==}
+
+  '@types/node@18.19.87':
+    resolution: {integrity: sha512-OIAAu6ypnVZHmsHCeJ+7CCSub38QNBS9uceMQeg7K5Ur0Jr+wG9wEOEvvMbhp09pxD5czIUy/jND7s7Tb6Nw7A==}
+
+  '@types/node@20.17.32':
+    resolution: {integrity: sha512-zeMXFn8zQ+UkjK4ws0RiOC9EWByyW1CcVmLe+2rQocXRsGEDxUCwPEIVgpsGcLHS/P8JkT0oa3839BRABS0oPw==}
+
+  '@types/node@22.13.1':
+    resolution: {integrity: sha512-jK8uzQlrvXqEU91UxiK5J7pKHyzgnI1Qnl0QDHIgVGuolJhRb9EEl28Cj9b3rGR8B2lhFCtvIm5os8lFnO/1Ew==}
+
+  '@types/react@19.1.3':
+    resolution: {integrity: sha512-dLWQ+Z0CkIvK1J8+wrDPwGxEYFA4RAyHoZPxHVGspYmFVnwGSNT24cGIhFJrtfRnWVuW8X7NO52gCXmhkVUWGQ==}
+
+  '@types/retry@0.12.0':
+    resolution: {integrity: sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==}
+
+  '@types/tough-cookie@4.0.5':
+    resolution: {integrity: sha512-/Ad8+nIOV7Rl++6f1BdKxFSMgmoqEoYbHRpPcx3JEfv8VRsQe9Z4mCXeJBzxs7mbHY/XOZZuXlRNfhpVPbs6ZA==}
+
+  '@types/unist@2.0.11':
+    resolution: {integrity: sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==}
+
+  '@types/unist@3.0.3':
+    resolution: {integrity: sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==}
+
+  '@types/urijs@1.19.25':
+    resolution: {integrity: sha512-XOfUup9r3Y06nFAZh3WvO0rBU4OtlfPB/vgxpjg+NRdGU6CN6djdc6OEiH+PcqHCY6eFLo9Ista73uarf4gnBg==}
+
+  '@types/uuid@10.0.0':
+    resolution: {integrity: sha512-7gqG38EyHgyP1S+7+xomFtL+ZNHcKv6DwNaCZmJmo1vgMugyF3TCnXVg4t1uk89mLNwnLtnY3TpOpCOyp1/xHQ==}
+
+  '@types/ws@8.18.1':
+    resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==}
+
+  '@types/yauzl@2.10.3':
+    resolution: {integrity: sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==}
+
+  '@typescript-eslint/eslint-plugin@8.56.1':
+    resolution: {integrity: sha512-Jz9ZztpB37dNC+HU2HI28Bs9QXpzCz+y/twHOwhyrIRdbuVDxSytJNDl6z/aAKlaRIwC7y8wJdkBv7FxYGgi0A==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      '@typescript-eslint/parser': ^8.56.1
+      eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+      typescript: '>=4.8.4 <6.0.0'
+
+  '@typescript-eslint/parser@8.56.1':
+    resolution: {integrity: sha512-klQbnPAAiGYFyI02+znpBRLyjL4/BrBd0nyWkdC0s/6xFLkXYQ8OoRrSkqacS1ddVxf/LDyODIKbQ5TgKAf/Fg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+      typescript: '>=4.8.4 <6.0.0'
+
+  '@typescript-eslint/project-service@8.56.1':
+    resolution: {integrity: sha512-TAdqQTzHNNvlVFfR+hu2PDJrURiwKsUvxFn1M0h95BB8ah5jejas08jUWG4dBA68jDMI988IvtfdAI53JzEHOQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      typescript: '>=4.8.4 <6.0.0'
+
+  '@typescript-eslint/scope-manager@8.56.1':
+    resolution: {integrity: sha512-YAi4VDKcIZp0O4tz/haYKhmIDZFEUPOreKbfdAN3SzUDMcPhJ8QI99xQXqX+HoUVq8cs85eRKnD+rne2UAnj2w==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@typescript-eslint/tsconfig-utils@8.56.1':
+    resolution: {integrity: sha512-qOtCYzKEeyr3aR9f28mPJqBty7+DBqsdd63eO0yyDwc6vgThj2UjWfJIcsFeSucYydqcuudMOprZ+x1SpF3ZuQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      typescript: '>=4.8.4 <6.0.0'
+
+  '@typescript-eslint/type-utils@8.56.1':
+    resolution: {integrity: sha512-yB/7dxi7MgTtGhZdaHCemf7PuwrHMenHjmzgUW1aJpO+bBU43OycnM3Wn+DdvDO/8zzA9HlhaJ0AUGuvri4oGg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+      typescript: '>=4.8.4 <6.0.0'
+
+  '@typescript-eslint/types@8.56.1':
+    resolution: {integrity: sha512-dbMkdIUkIkchgGDIv7KLUpa0Mda4IYjo4IAMJUZ+3xNoUXxMsk9YtKpTHSChRS85o+H9ftm51gsK1dZReY9CVw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@typescript-eslint/typescript-estree@8.56.1':
+    resolution: {integrity: sha512-qzUL1qgalIvKWAf9C1HpvBjif+Vm6rcT5wZd4VoMb9+Km3iS3Cv9DY6dMRMDtPnwRAFyAi7YXJpTIEXLvdfPxg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      typescript: '>=4.8.4 <6.0.0'
+
+  '@typescript-eslint/utils@8.56.1':
+    resolution: {integrity: sha512-HPAVNIME3tABJ61siYlHzSWCGtOoeP2RTIaHXFMPqjrQKCGB9OgUVdiNgH7TJS2JNIQ5qQ4RsAUDuGaGme/KOA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+      typescript: '>=4.8.4 <6.0.0'
+
+  '@typescript-eslint/visitor-keys@8.56.1':
+    resolution: {integrity: sha512-KiROIzYdEV85YygXw6BI/Dx4fnBlFQu6Mq4QE4MOH9fFnhohw6wX/OAvDY2/C+ut0I3RSPKenvZJIVYqJNkhEw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@ungap/structured-clone@1.3.0':
+    resolution: {integrity: sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==}
+
+  '@vercel/functions@1.6.0':
+    resolution: {integrity: sha512-R6FKQrYT5MZs5IE1SqeCJWxMuBdHawFcCZboKKw8p7s+6/mcd55Gx6tWmyKnQTyrSEA04NH73Tc9CbqpEle8RA==}
+    engines: {node: '>= 16'}
+    peerDependencies:
+      '@aws-sdk/credential-provider-web-identity': '*'
+    peerDependenciesMeta:
+      '@aws-sdk/credential-provider-web-identity':
+        optional: true
+
+  '@vercel/oidc@3.1.0':
+    resolution: {integrity: sha512-Fw28YZpRnA3cAHHDlkt7xQHiJ0fcL+NRcIqsocZQUSmbzeIKRpwttJjik5ZGanXP+vlA4SbTg+AbA3bP363l+w==}
+    engines: {node: '>= 20'}
+
+  '@vitest/coverage-v8@4.0.18':
+    resolution: {integrity: sha512-7i+N2i0+ME+2JFZhfuz7Tg/FqKtilHjGyGvoHYQ6iLV0zahbsJ9sljC9OcFcPDbhYKCet+sG8SsVqlyGvPflZg==}
+    peerDependencies:
+      '@vitest/browser': 4.0.18
+      vitest: 4.0.18
+    peerDependenciesMeta:
+      '@vitest/browser':
+        optional: true
+
+  '@vitest/expect@1.6.1':
+    resolution: {integrity: sha512-jXL+9+ZNIJKruofqXuuTClf44eSpcHlgj3CiuNihUF3Ioujtmc0zIa3UJOW5RjDK1YLBJZnWBlPuqhYycLioog==}
+
+  '@vitest/expect@4.0.8':
+    resolution: {integrity: sha512-Rv0eabdP/xjAHQGr8cjBm+NnLHNoL268lMDK85w2aAGLFoVKLd8QGnVon5lLtkXQCoYaNL0wg04EGnyKkkKhPA==}
+
+  '@vitest/mocker@4.0.8':
+    resolution: {integrity: sha512-9FRM3MZCedXH3+pIh+ME5Up2NBBHDq0wqwhOKkN4VnvCiKbVxddqH9mSGPZeawjd12pCOGnl+lo/ZGHt0/dQSg==}
+    peerDependencies:
+      msw: ^2.4.9
+      vite: ^6.0.0 || ^7.0.0-0
+    peerDependenciesMeta:
+      msw:
+        optional: true
+      vite:
+        optional: true
+
+  '@vitest/pretty-format@4.0.18':
+    resolution: {integrity: sha512-P24GK3GulZWC5tz87ux0m8OADrQIUVDPIjjj65vBXYG17ZeU3qD7r+MNZ1RNv4l8CGU2vtTRqixrOi9fYk/yKw==}
+
+  '@vitest/pretty-format@4.0.8':
+    resolution: {integrity: sha512-qRrjdRkINi9DaZHAimV+8ia9Gq6LeGz2CgIEmMLz3sBDYV53EsnLZbJMR1q84z1HZCMsf7s0orDgZn7ScXsZKg==}
+
+  '@vitest/runner@1.6.1':
+    resolution: {integrity: sha512-3nSnYXkVkf3mXFfE7vVyPmi3Sazhb/2cfZGGs0JRzFsPFvAMBEcrweV1V1GsrstdXeKCTXlJbvnQwGWgEIHmOA==}
+
+  '@vitest/runner@4.0.8':
+    resolution: {integrity: sha512-mdY8Sf1gsM8hKJUQfiPT3pn1n8RF4QBcJYFslgWh41JTfrK1cbqY8whpGCFzBl45LN028g0njLCYm0d7XxSaQQ==}
+
+  '@vitest/snapshot@1.6.1':
+    resolution: {integrity: sha512-WvidQuWAzU2p95u8GAKlRMqMyN1yOJkGHnx3M1PL9Raf7AQ1kwLKg04ADlCa3+OXUZE7BceOhVZiuWAbzCKcUQ==}
+
+  '@vitest/snapshot@4.0.8':
+    resolution: {integrity: sha512-Nar9OTU03KGiubrIOFhcfHg8FYaRaNT+bh5VUlNz8stFhCZPNrJvmZkhsr1jtaYvuefYFwK2Hwrq026u4uPWCw==}
+
+  '@vitest/spy@1.6.1':
+    resolution: {integrity: sha512-MGcMmpGkZebsMZhbQKkAf9CX5zGvjkBTqf8Zx3ApYWXr3wG+QvEu2eXWfnIIWYSJExIp4V9FCKDEeygzkYrXMw==}
+
+  '@vitest/spy@4.0.8':
+    resolution: {integrity: sha512-nvGVqUunyCgZH7kmo+Ord4WgZ7lN0sOULYXUOYuHr55dvg9YvMz3izfB189Pgp28w0vWFbEEfNc/c3VTrqrXeA==}
+
+  '@vitest/utils@1.6.1':
+    resolution: {integrity: sha512-jOrrUvXM4Av9ZWiG1EajNto0u96kWAhJ1LmPmJhXXQx/32MecEKd10pOLYgS2BQx1TgkGhloPU1ArDW2vvaY6g==}
+
+  '@vitest/utils@4.0.18':
+    resolution: {integrity: sha512-msMRKLMVLWygpK3u2Hybgi4MNjcYJvwTb0Ru09+fOyCXIgT5raYP041DRRdiJiI3k/2U6SEbAETB3YtBrUkCFA==}
+
+  '@vitest/utils@4.0.8':
+    resolution: {integrity: sha512-pdk2phO5NDvEFfUTxcTP8RFYjVj/kfLSPIN5ebP2Mu9kcIMeAQTbknqcFEyBcC4z2pJlJI9aS5UQjcYfhmKAow==}
+
+  abort-controller@3.0.0:
+    resolution: {integrity: sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==}
+    engines: {node: '>=6.5'}
+
+  abstract-logging@2.0.1:
+    resolution: {integrity: sha512-2BjRTZxTPvheOvGbBslFSYOUkr+SjPtOnrLP33f+VIWLzezQpZcqVg7ja3L4dBXmzzgwT+a029jRx5PCi3JuiA==}
+
+  accepts@1.3.8:
+    resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==}
+    engines: {node: '>= 0.6'}
+
+  accepts@2.0.0:
+    resolution: {integrity: sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==}
+    engines: {node: '>= 0.6'}
+
+  acorn-jsx@5.3.2:
+    resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
+    peerDependencies:
+      acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
+
+  acorn-walk@8.3.5:
+    resolution: {integrity: sha512-HEHNfbars9v4pgpW6SO1KSPkfoS0xVOM/9UzkJltjlsHZmJasxg8aXkuZa7SMf8vKGIBhpUsPluQSqhJFCqebw==}
+    engines: {node: '>=0.4.0'}
+
+  acorn@8.15.0:
+    resolution: {integrity: sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==}
+    engines: {node: '>=0.4.0'}
+    hasBin: true
+
+  acorn@8.16.0:
+    resolution: {integrity: sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==}
+    engines: {node: '>=0.4.0'}
+    hasBin: true
+
+  address@1.2.2:
+    resolution: {integrity: sha512-4B/qKCfeE/ODUaAUpSwfzazo5x29WD4r3vXiWsB7I2mSDAihwEqKO+g8GELZUQSSAo5e1XTYh3ZVfLyxBc12nA==}
+    engines: {node: '>= 10.0.0'}
+
+  adm-zip@0.5.16:
+    resolution: {integrity: sha512-TGw5yVi4saajsSEgz25grObGHEUaDrniwvA2qwSC060KfqGPdglhvPMA2lPIoxs3PQIItj2iag35fONcQqgUaQ==}
+    engines: {node: '>=12.0'}
+
+  agent-base@7.1.3:
+    resolution: {integrity: sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==}
+    engines: {node: '>= 14'}
+
+  agentkeepalive@4.6.0:
+    resolution: {integrity: sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ==}
+    engines: {node: '>= 8.0.0'}
+
+  aggregate-error@4.0.1:
+    resolution: {integrity: sha512-0poP0T7el6Vq3rstR8Mn4V/IQrpBLO6POkUSrN7RhyY+GF/InCFShQzsQ39T25gkHhLgSLByyAz+Kjb+c2L98w==}
+    engines: {node: '>=12'}
+
+  ai@5.0.133:
+    resolution: {integrity: sha512-N6KnwSWKcXEWPnAri3anRuzRvcrvtDz1W1JG9CvMrQ0Xdp8Vu8ZToNW/eHt63CmrbmzTwVw/HaCtJuO+MYtS7A==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  ajv-draft-04@1.0.0:
+    resolution: {integrity: sha512-mv00Te6nmYbRp5DCwclxtt7yV/joXJPGS7nM+97GdxvuttCOfgI3K4U25zboyeX0O+myI8ERluxQe5wljMmVIw==}
+    peerDependencies:
+      ajv: ^8.5.0
+    peerDependenciesMeta:
+      ajv:
+        optional: true
+
+  ajv-errors@3.0.0:
+    resolution: {integrity: sha512-V3wD15YHfHz6y0KdhYFjyy9vWtEVALT9UrxfN3zqlI6dMioHnJrqOYfyPKol3oqrnCM9uwkcdCwkJ0WUcbLMTQ==}
+    peerDependencies:
+      ajv: ^8.0.1
+
+  ajv-formats@2.1.1:
+    resolution: {integrity: sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==}
+    peerDependencies:
+      ajv: ^8.0.0
+    peerDependenciesMeta:
+      ajv:
+        optional: true
+
+  ajv-formats@3.0.1:
+    resolution: {integrity: sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==}
+    peerDependencies:
+      ajv: ^8.0.0
+    peerDependenciesMeta:
+      ajv:
+        optional: true
+
+  ajv@6.12.6:
+    resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
+
+  ajv@6.14.0:
+    resolution: {integrity: sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==}
+
+  ajv@8.17.1:
+    resolution: {integrity: sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==}
+
+  ansi-colors@4.1.3:
+    resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==}
+    engines: {node: '>=6'}
+
+  ansi-escapes@4.3.2:
+    resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==}
+    engines: {node: '>=8'}
+
+  ansi-escapes@7.0.0:
+    resolution: {integrity: sha512-GdYO7a61mR0fOlAsvC9/rIHf7L96sBc6dEWzeOu+KAea5bZyQRPIpojrVoI4AXGJS/ycu/fBTdLrUkA4ODrvjw==}
+    engines: {node: '>=18'}
+
+  ansi-regex@5.0.1:
+    resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
+    engines: {node: '>=8'}
+
+  ansi-regex@6.1.0:
+    resolution: {integrity: sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==}
+    engines: {node: '>=12'}
+
+  ansi-styles@4.3.0:
+    resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
+    engines: {node: '>=8'}
+
+  ansi-styles@5.2.0:
+    resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==}
+    engines: {node: '>=10'}
+
+  ansi-styles@6.2.1:
+    resolution: {integrity: sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==}
+    engines: {node: '>=12'}
+
+  any-promise@1.3.0:
+    resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==}
+
+  anymatch@3.1.3:
+    resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==}
+    engines: {node: '>= 8'}
+
+  arg@5.0.2:
+    resolution: {integrity: sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==}
+
+  argparse@1.0.10:
+    resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==}
+
+  argparse@2.0.1:
+    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
+
+  arktype@2.1.20:
+    resolution: {integrity: sha512-IZCEEXaJ8g+Ijd59WtSYwtjnqXiwM8sWQ5EjGamcto7+HVN9eK0C4p0zDlCuAwWhpqr6fIBkxPuYDl4/Mcj/+Q==}
+
+  array-buffer-byte-length@1.0.2:
+    resolution: {integrity: sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==}
+    engines: {node: '>= 0.4'}
+
+  array-flatten@1.1.1:
+    resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==}
+
+  array-iterate@2.0.1:
+    resolution: {integrity: sha512-I1jXZMjAgCMmxT4qxXfPXa6SthSoE8h6gkSI9BGGNv8mP8G/v0blc+qFnZu6K42vTOiuME596QaLO0TP3Lk0xg==}
+
+  array-union@2.1.0:
+    resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==}
+    engines: {node: '>=8'}
+
+  arraybuffer.prototype.slice@1.0.4:
+    resolution: {integrity: sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==}
+    engines: {node: '>= 0.4'}
+
+  assertion-error@1.1.0:
+    resolution: {integrity: sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==}
+
+  assertion-error@2.0.1:
+    resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
+    engines: {node: '>=12'}
+
+  ast-types@0.13.4:
+    resolution: {integrity: sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==}
+    engines: {node: '>=4'}
+
+  ast-v8-to-istanbul@0.3.11:
+    resolution: {integrity: sha512-Qya9fkoofMjCBNVdWINMjB5KZvkYfaO9/anwkWnjxibpWUxo5iHl2sOdP7/uAqaRuUYuoo8rDwnbaaKVFxoUvw==}
+
+  astring@1.9.0:
+    resolution: {integrity: sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg==}
+    hasBin: true
+
+  async-function@1.0.0:
+    resolution: {integrity: sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==}
+    engines: {node: '>= 0.4'}
+
+  asynckit@0.4.0:
+    resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
+
+  atomic-sleep@1.0.0:
+    resolution: {integrity: sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==}
+    engines: {node: '>=8.0.0'}
+
+  auto-bind@5.0.1:
+    resolution: {integrity: sha512-ooviqdwwgfIfNmDwo94wlshcdzfO64XV0Cg6oDsDYBJfITDz1EngD2z7DkbvCWn+XIMsIqW27sEVF6qcpJrRcg==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  available-typed-arrays@1.0.7:
+    resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==}
+    engines: {node: '>= 0.4'}
+
+  avsc@5.7.7:
+    resolution: {integrity: sha512-9cYNccliXZDByFsFliVwk5GvTq058Fj513CiR4E60ndDwmuXzTJEp/Bp8FyuRmGyYupLjHLs+JA9/CBoVS4/NQ==}
+    engines: {node: '>=0.11'}
+
+  avvio@9.1.0:
+    resolution: {integrity: sha512-fYASnYi600CsH/j9EQov7lECAniYiBFiiAtBNuZYLA2leLe9qOvZzqYHFjtIj6gD2VMoMLP14834LFWvr4IfDw==}
+
+  aws4fetch@1.0.20:
+    resolution: {integrity: sha512-/djoAN709iY65ETD6LKCtyyEI04XIBP5xVvfmNxsEP0uJB5tyaGBztSryRr4HqMStr9R06PisQE7m9zDTXKu6g==}
+
+  axios@1.9.0:
+    resolution: {integrity: sha512-re4CqKTJaURpzbLHtIi6XpDv20/CnpXOtjRY5/CU32L8gU8ek9UIivcfvSWvmKEngmVbrUtPpdDwWDWL7DNHvg==}
+
+  b4a@1.6.7:
+    resolution: {integrity: sha512-OnAYlL5b7LEkALw87fUVafQw5rVR9RjwGd4KUwNQ6DrrNmaVaUCgLipfVlzrPQ4tWOR9P0IXGNOx50jYCCdSJg==}
+
+  bail@2.0.2:
+    resolution: {integrity: sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==}
+
+  balanced-match@1.0.2:
+    resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
+
+  balanced-match@4.0.4:
+    resolution: {integrity: sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==}
+    engines: {node: 18 || 20 || >=22}
+
+  bare-events@2.5.4:
+    resolution: {integrity: sha512-+gFfDkR8pj4/TrWCGUGWmJIkBwuxPS5F+a5yWjOHQt2hHvNZd5YLzadjmDUtFmMM4y429bnKLa8bYBMHcYdnQA==}
+
+  bare-fs@4.1.4:
+    resolution: {integrity: sha512-r8+26Voz8dGX3AYpJdFb1ZPaUSM8XOLCZvy+YGpRTmwPHIxA7Z3Jov/oMPtV7hfRQbOnH8qGlLTzQAbgtdNN0Q==}
+    engines: {bare: '>=1.16.0'}
+    peerDependencies:
+      bare-buffer: '*'
+    peerDependenciesMeta:
+      bare-buffer:
+        optional: true
+
+  bare-os@3.6.1:
+    resolution: {integrity: sha512-uaIjxokhFidJP+bmmvKSgiMzj2sV5GPHaZVAIktcxcpCyBFFWO+YlikVAdhmUo2vYFvFhOXIAlldqV29L8126g==}
+    engines: {bare: '>=1.14.0'}
+
+  bare-path@3.0.0:
+    resolution: {integrity: sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==}
+
+  bare-stream@2.6.5:
+    resolution: {integrity: sha512-jSmxKJNJmHySi6hC42zlZnq00rga4jjxcgNZjY9N5WlOe/iOoGRtdwGsHzQv2RlH2KOYMwGUXhf2zXd32BA9RA==}
+    peerDependencies:
+      bare-buffer: '*'
+      bare-events: '*'
+    peerDependenciesMeta:
+      bare-buffer:
+        optional: true
+      bare-events:
+        optional: true
+
+  base64-js@1.5.1:
+    resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
+
+  base64id@2.0.0:
+    resolution: {integrity: sha512-lGe34o6EHj9y3Kts9R4ZYs/Gr+6N7MCaMlIFA3F1R2O5/m7K06AxfSeO5530PEERE6/WyEg3lsuyw4GHlPZHog==}
+    engines: {node: ^4.5.0 || >= 5.9}
+
+  basic-ftp@5.0.5:
+    resolution: {integrity: sha512-4Bcg1P8xhUuqcii/S0Z9wiHIrQVPMermM1any+MX5GeGD7faD3/msQUDGLol9wOcz4/jbg/WJnGqoJF6LiBdtg==}
+    engines: {node: '>=10.0.0'}
+    deprecated: Security vulnerability fixed in 5.2.0, please upgrade
+
+  better-opn@3.0.2:
+    resolution: {integrity: sha512-aVNobHnJqLiUelTaHat9DZ1qM2w0C0Eym4LPI/3JxOnSokGVdsl1T1kN7TFvsEAD8G47A6VKQ0TVHqbBnYMJlQ==}
+    engines: {node: '>=12.0.0'}
+
+  better-path-resolve@1.0.0:
+    resolution: {integrity: sha512-pbnl5XzGBdrFU/wT4jqmJVPn2B6UHPBOhzMQkY/SPUPB6QtUXtmBHBIwCbXJol93mOpGMnQyP/+BB19q04xj7g==}
+    engines: {node: '>=4'}
+
+  bignumber.js@9.3.0:
+    resolution: {integrity: sha512-EM7aMFTXbptt/wZdMlBv2t8IViwQL+h6SLHosp8Yf0dqJMTnY6iL32opnAB6kAdL0SZPuvcAzFr31o0c/R3/RA==}
+
+  binary-extensions@2.3.0:
+    resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==}
+    engines: {node: '>=8'}
+
+  bintrees@1.0.2:
+    resolution: {integrity: sha512-VOMgTMwjAaUG580SXn3LacVgjurrbMme7ZZNYGSSV7mmtY6QQRh0Eg3pwIcntQ77DErK1L0NxkbetjcoXzVwKw==}
+
+  body-parser@1.20.3:
+    resolution: {integrity: sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==}
+    engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}
+
+  body-parser@2.2.0:
+    resolution: {integrity: sha512-02qvAaxv8tp7fBa/mw1ga98OGm+eCbqzJOKoRt70sLmfEEi+jyBYVTDGfCL/k06/4EMk/z01gCe7HoCH/f2LTg==}
+    engines: {node: '>=18'}
+
+  brace-expansion@1.1.11:
+    resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==}
+
+  brace-expansion@2.0.1:
+    resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==}
+
+  brace-expansion@5.0.3:
+    resolution: {integrity: sha512-fy6KJm2RawA5RcHkLa1z/ScpBeA762UF9KmZQxwIbDtRJrgLzM10depAiEQ+CXYcoiqW1/m96OAAoke2nE9EeA==}
+    engines: {node: 18 || 20 || >=22}
+
+  braces@3.0.3:
+    resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
+    engines: {node: '>=8'}
+
+  braintrust@0.4.7:
+    resolution: {integrity: sha512-Yzfb5sD2PiG4Gz9Xsvt1+SFsldDARyfPIgxF/cC1S7LrF8ox6hUAEuY4xHoQs+07kx3r95FdwkeCZuBfp85Baw==}
+    hasBin: true
+    peerDependencies:
+      zod: ^3.25.34
+
+  buffer-crc32@0.2.13:
+    resolution: {integrity: sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==}
+
+  buffer-equal-constant-time@1.0.1:
+    resolution: {integrity: sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==}
+
+  buffer@5.7.1:
+    resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==}
+
+  buffer@6.0.3:
+    resolution: {integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==}
+
+  bufferutil@4.0.9:
+    resolution: {integrity: sha512-WDtdLmJvAuNNPzByAYpRo2rF1Mmradw6gvWsQKf63476DDXmomT9zUiGypLcG4ibIM67vhAj8jJRdbmEws2Aqw==}
+    engines: {node: '>=6.14.2'}
+
+  bundle-require@5.1.0:
+    resolution: {integrity: sha512-3WrrOuZiyaaZPWiEt4G3+IffISVC9HYlWueJEBWED4ZH4aIAC2PnkdnuRrR94M+w6yGWn4AglWtJtBI8YqvgoA==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+    peerDependencies:
+      esbuild: '>=0.18'
+
+  bytes@3.1.2:
+    resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==}
+    engines: {node: '>= 0.8'}
+
+  c8@10.1.3:
+    resolution: {integrity: sha512-LvcyrOAaOnrrlMpW22n690PUvxiq4Uf9WMhQwNJ9vgagkL/ph1+D4uvjvDA5XCbykrc0sx+ay6pVi9YZ1GnhyA==}
+    engines: {node: '>=18'}
+    hasBin: true
+    peerDependencies:
+      monocart-coverage-reports: ^2
+    peerDependenciesMeta:
+      monocart-coverage-reports:
+        optional: true
+
+  cac@6.7.14:
+    resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==}
+    engines: {node: '>=8'}
+
+  cacheable-lookup@7.0.0:
+    resolution: {integrity: sha512-+qJyx4xiKra8mZrcwhjMRMUhD5NR1R8esPkzIYxX96JiecFoxAXFuz/GpR3+ev4PE1WamHip78wV0vcmPQtp8w==}
+    engines: {node: '>=14.16'}
+
+  cacheable-request@10.2.14:
+    resolution: {integrity: sha512-zkDT5WAF4hSSoUgyfg5tFIxz8XQK+25W/TLVojJTMKBaxevLBBtLxgqguAuVQB8PVW79FVjHcU+GJ9tVbDZ9mQ==}
+    engines: {node: '>=14.16'}
+
+  call-bind-apply-helpers@1.0.2:
+    resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==}
+    engines: {node: '>= 0.4'}
+
+  call-bind@1.0.8:
+    resolution: {integrity: sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==}
+    engines: {node: '>= 0.4'}
+
+  call-bound@1.0.4:
+    resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==}
+    engines: {node: '>= 0.4'}
+
+  callsites@3.1.0:
+    resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
+    engines: {node: '>=6'}
+
+  camelcase-css@2.0.1:
+    resolution: {integrity: sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==}
+    engines: {node: '>= 6'}
+
+  camelcase@6.3.0:
+    resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==}
+    engines: {node: '>=10'}
+
+  ccount@2.0.1:
+    resolution: {integrity: sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==}
+
+  chai@4.5.0:
+    resolution: {integrity: sha512-RITGBfijLkBddZvnn8jdqoTypxvqbOLYQkGGxXzeFjVHvudaPw0HNFD9x928/eUwYWd2dPCugVqspGALTZZQKw==}
+    engines: {node: '>=4'}
+
+  chai@6.2.1:
+    resolution: {integrity: sha512-p4Z49OGG5W/WBCPSS/dH3jQ73kD6tiMmUM+bckNK6Jr5JHMG3k9bg/BvKR8lKmtVBKmOiuVaV2ws8s9oSbwysg==}
+    engines: {node: '>=18'}
+
+  chalk@4.1.2:
+    resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
+    engines: {node: '>=10'}
+
+  chalk@5.4.1:
+    resolution: {integrity: sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==}
+    engines: {node: ^12.17.0 || ^14.13 || >=16.0.0}
+
+  character-entities-html4@2.1.0:
+    resolution: {integrity: sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==}
+
+  character-entities-legacy@3.0.0:
+    resolution: {integrity: sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==}
+
+  character-entities@2.0.2:
+    resolution: {integrity: sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==}
+
+  character-reference-invalid@2.0.1:
+    resolution: {integrity: sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==}
+
+  chardet@0.7.0:
+    resolution: {integrity: sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==}
+
+  check-error@1.0.3:
+    resolution: {integrity: sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==}
+
+  chokidar@3.6.0:
+    resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==}
+    engines: {node: '>= 8.10.0'}
+
+  chokidar@4.0.3:
+    resolution: {integrity: sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==}
+    engines: {node: '>= 14.16.0'}
+
+  chownr@2.0.0:
+    resolution: {integrity: sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==}
+    engines: {node: '>=10'}
+
+  chrome-launcher@1.2.0:
+    resolution: {integrity: sha512-JbuGuBNss258bvGil7FT4HKdC3SC2K7UAEUqiPy3ACS3Yxo3hAW6bvFpCu2HsIJLgTqxgEX6BkujvzZfLpUD0Q==}
+    engines: {node: '>=12.13.0'}
+    hasBin: true
+
+  chromium-bidi@0.6.3:
+    resolution: {integrity: sha512-qXlsCmpCZJAnoTYI83Iu6EdYQpMYdVkCfq08KDh2pmlVqK5t5IA9mGs4/LwCwp4fqisSOMXZxP3HIh8w8aRn0A==}
+    peerDependencies:
+      devtools-protocol: '*'
+
+  ci-info@3.9.0:
+    resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==}
+    engines: {node: '>=8'}
+
+  clean-stack@4.2.0:
+    resolution: {integrity: sha512-LYv6XPxoyODi36Dp976riBtSY27VmFo+MKqEU9QCCWyTrdEPDog+RWA7xQWHi6Vbp61j5c4cdzzX1NidnwtUWg==}
+    engines: {node: '>=12'}
+
+  cli-boxes@3.0.0:
+    resolution: {integrity: sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g==}
+    engines: {node: '>=10'}
+
+  cli-cursor@4.0.0:
+    resolution: {integrity: sha512-VGtlMu3x/4DOtIUwEkRezxUZ2lBacNJCHash0N0WeZDBS+7Ux1dm3XWAgWYxLJFMMdOeXMHXorshEFhbMSGelg==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  cli-progress@3.12.0:
+    resolution: {integrity: sha512-tRkV3HJ1ASwm19THiiLIXLO7Im7wlTuKnvkYaTkyoAPefqjNg7W7DHKUlGRxy9vxDvbyCYQkQozvptuMkGCg8A==}
+    engines: {node: '>=4'}
+
+  cli-spinners@2.9.2:
+    resolution: {integrity: sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==}
+    engines: {node: '>=6'}
+
+  cli-truncate@4.0.0:
+    resolution: {integrity: sha512-nPdaFdQ0h/GEigbPClz11D0v/ZJEwxmeVZGeMo3Z5StPtUTkA9o1lD6QwoirYiSDzbcwn2XcjwmCp68W1IS4TA==}
+    engines: {node: '>=18'}
+
+  cli-width@4.1.0:
+    resolution: {integrity: sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==}
+    engines: {node: '>= 12'}
+
+  cliui@8.0.1:
+    resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==}
+    engines: {node: '>=12'}
+
+  cliui@9.0.1:
+    resolution: {integrity: sha512-k7ndgKhwoQveBL+/1tqGJYNz097I7WOvwbmmU2AR5+magtbjPWQTS1C5vzGkBC8Ym8UWRzfKUzUUqFLypY4Q+w==}
+    engines: {node: '>=20'}
+
+  code-excerpt@4.0.0:
+    resolution: {integrity: sha512-xxodCmBen3iy2i0WtAK8FlFNrRzjUqjRsMfho58xT/wvZU1YTM3fCnRjcy1gJPMepaRlgm/0e6w8SpWHpn3/cA==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  collapse-white-space@2.1.0:
+    resolution: {integrity: sha512-loKTxY1zCOuG4j9f6EPnuyyYkf58RnhhWTvRoZEokgB+WbdXehfjFviyOVYkqzEWz1Q5kRiZdBYS5SwxbQYwzw==}
+
+  color-convert@2.0.1:
+    resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
+    engines: {node: '>=7.0.0'}
+
+  color-name@1.1.4:
+    resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
+
+  color-string@1.9.1:
+    resolution: {integrity: sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==}
+
+  color@4.2.3:
+    resolution: {integrity: sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==}
+    engines: {node: '>=12.5.0'}
+
+  colorette@2.0.20:
+    resolution: {integrity: sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==}
+
+  combined-stream@1.0.8:
+    resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==}
+    engines: {node: '>= 0.8'}
+
+  comma-separated-tokens@2.0.3:
+    resolution: {integrity: sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==}
+
+  commander@12.1.0:
+    resolution: {integrity: sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA==}
+    engines: {node: '>=18'}
+
+  commander@4.1.1:
+    resolution: {integrity: sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==}
+    engines: {node: '>= 6'}
+
+  commander@8.3.0:
+    resolution: {integrity: sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==}
+    engines: {node: '>= 12'}
+
+  commander@9.5.0:
+    resolution: {integrity: sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==}
+    engines: {node: ^12.20.0 || >=14}
+
+  concat-map@0.0.1:
+    resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
+
+  confbox@0.1.8:
+    resolution: {integrity: sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==}
+
+  consola@3.4.2:
+    resolution: {integrity: sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==}
+    engines: {node: ^14.18.0 || >=16.10.0}
+
+  console-table-printer@2.12.1:
+    resolution: {integrity: sha512-wKGOQRRvdnd89pCeH96e2Fn4wkbenSP6LMHfjfyNLMbGuHEFbMqQNuxXqd0oXG9caIOQ1FTvc5Uijp9/4jujnQ==}
+
+  content-disposition@0.5.4:
+    resolution: {integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==}
+    engines: {node: '>= 0.6'}
+
+  content-disposition@1.0.0:
+    resolution: {integrity: sha512-Au9nRL8VNUut/XSzbQA38+M78dzP4D+eqg3gfJHMIHHYa3bg067xj1KxMUWj+VULbiZMowKngFFbKczUrNJ1mg==}
+    engines: {node: '>= 0.6'}
+
+  content-type@1.0.5:
+    resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==}
+    engines: {node: '>= 0.6'}
+
+  convert-source-map@2.0.0:
+    resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}
+
+  convert-to-spaces@2.0.1:
+    resolution: {integrity: sha512-rcQ1bsQO9799wq24uE5AM2tAILy4gXGIK/njFWcVQkGNZ96edlpY+A7bjwvzjYvLDyzmG1MmMLZhpcsb+klNMQ==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  cookie-signature@1.0.6:
+    resolution: {integrity: sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==}
+
+  cookie-signature@1.2.2:
+    resolution: {integrity: sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==}
+    engines: {node: '>=6.6.0'}
+
+  cookie@0.7.1:
+    resolution: {integrity: sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==}
+    engines: {node: '>= 0.6'}
+
+  cookie@0.7.2:
+    resolution: {integrity: sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==}
+    engines: {node: '>= 0.6'}
+
+  cookie@1.1.1:
+    resolution: {integrity: sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ==}
+    engines: {node: '>=18'}
+
+  cors@2.8.5:
+    resolution: {integrity: sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==}
+    engines: {node: '>= 0.10'}
+
+  cosmiconfig@9.0.0:
+    resolution: {integrity: sha512-itvL5h8RETACmOTFc4UfIyB2RfEHi71Ax6E/PivVxq9NseKbOWpeyHEOIbmAw1rs8Ak0VursQNww7lf7YtUwzg==}
+    engines: {node: '>=14'}
+    peerDependencies:
+      typescript: '>=4.9.5'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+
+  cross-spawn@7.0.6:
+    resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==}
+    engines: {node: '>= 8'}
+
+  cssesc@3.0.0:
+    resolution: {integrity: sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==}
+    engines: {node: '>=4'}
+    hasBin: true
+
+  cssstyle@4.6.0:
+    resolution: {integrity: sha512-2z+rWdzbbSZv6/rhtvzvqeZQHrBaqgogqt85sqFNbabZOuFbCVFb8kPeEtZjiKkbrm395irpNKiYeFeLiQnFPg==}
+    engines: {node: '>=18'}
+
+  csstype@3.2.3:
+    resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==}
+
+  ctrf@0.0.17:
+    resolution: {integrity: sha512-PPk9b+AuA+UoBcbzSQWXMIuh5601zDHgXlmHIG8ESxTUnnb0eM2sz8H3jQLYQZTpyIaZVCLFZFslIDB1EMVZ1g==}
+    engines: {node: '>=20.19.0'}
+    hasBin: true
+
+  data-uri-to-buffer@4.0.1:
+    resolution: {integrity: sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==}
+    engines: {node: '>= 12'}
+
+  data-uri-to-buffer@6.0.2:
+    resolution: {integrity: sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw==}
+    engines: {node: '>= 14'}
+
+  data-urls@5.0.0:
+    resolution: {integrity: sha512-ZYP5VBHshaDAiVZxjbRVcFJpc+4xGgT0bK3vzy1HLN8jTO975HEbuYzZJcHoQEY5K1a0z8YayJkyVETa08eNTg==}
+    engines: {node: '>=18'}
+
+  data-view-buffer@1.0.2:
+    resolution: {integrity: sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==}
+    engines: {node: '>= 0.4'}
+
+  data-view-byte-length@1.0.2:
+    resolution: {integrity: sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==}
+    engines: {node: '>= 0.4'}
+
+  data-view-byte-offset@1.0.1:
+    resolution: {integrity: sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==}
+    engines: {node: '>= 0.4'}
+
+  dataloader@1.4.0:
+    resolution: {integrity: sha512-68s5jYdlvasItOJnCuI2Q9s4q98g0pCyL3HrcKJu8KNugUl8ahgmZYg38ysLTgQjjXX3H8CJLkAvWrclWfcalw==}
+
+  dateformat@4.6.3:
+    resolution: {integrity: sha512-2P0p0pFGzHS5EMnhdxQi7aJN+iMheud0UhG4dlE1DLAlvL8JHjJJTX/CSm4JXwV0Ka5nGk3zC5mcb5bUQUxxMA==}
+
+  debug@2.6.9:
+    resolution: {integrity: sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  debug@4.3.7:
+    resolution: {integrity: sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  debug@4.4.3:
+    resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  decamelize@1.2.0:
+    resolution: {integrity: sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==}
+    engines: {node: '>=0.10.0'}
+
+  decimal.js@10.6.0:
+    resolution: {integrity: sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==}
+
+  decode-named-character-reference@1.1.0:
+    resolution: {integrity: sha512-Wy+JTSbFThEOXQIR2L6mxJvEs+veIzpmqD7ynWxMXGpnk3smkHQOp6forLdHsKpAMW9iJpaBBIxz285t1n1C3w==}
+
+  decompress-response@6.0.0:
+    resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==}
+    engines: {node: '>=10'}
+
+  deep-eql@4.1.4:
+    resolution: {integrity: sha512-SUwdGfqdKOwxCPeVYjwSyRpJ7Z+fhpwIAtmCUdZIWZ/YP5R9WAsyuSgpLVDi9bjWoN2LXHNss/dk3urXtdQxGg==}
+    engines: {node: '>=6'}
+
+  deep-is@0.1.4:
+    resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
+
+  deepmerge@4.3.1:
+    resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==}
+    engines: {node: '>=0.10.0'}
+
+  defer-to-connect@2.0.1:
+    resolution: {integrity: sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==}
+    engines: {node: '>=10'}
+
+  define-data-property@1.1.4:
+    resolution: {integrity: sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==}
+    engines: {node: '>= 0.4'}
+
+  define-lazy-prop@2.0.0:
+    resolution: {integrity: sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==}
+    engines: {node: '>=8'}
+
+  define-properties@1.2.1:
+    resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==}
+    engines: {node: '>= 0.4'}
+
+  degenerator@5.0.1:
+    resolution: {integrity: sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ==}
+    engines: {node: '>= 14'}
+
+  delayed-stream@1.0.0:
+    resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==}
+    engines: {node: '>=0.4.0'}
+
+  depd@2.0.0:
+    resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==}
+    engines: {node: '>= 0.8'}
+
+  dependency-graph@0.11.0:
+    resolution: {integrity: sha512-JeMq7fEshyepOWDfcfHK06N3MhyPhz++vtqWhMT5O9A3K42rdsEDpfdVqjaqaAhsw6a+ZqeDvQVtD0hFHQWrzg==}
+    engines: {node: '>= 0.6.0'}
+
+  dequal@2.0.3:
+    resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==}
+    engines: {node: '>=6'}
+
+  destroy@1.2.0:
+    resolution: {integrity: sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==}
+    engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}
+
+  detect-indent@6.1.0:
+    resolution: {integrity: sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==}
+    engines: {node: '>=8'}
+
+  detect-libc@2.1.2:
+    resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==}
+    engines: {node: '>=8'}
+
+  detect-port@1.6.1:
+    resolution: {integrity: sha512-CmnVc+Hek2egPx1PeTFVta2W78xy2K/9Rkf6cC4T59S50tVnzKj+tnx5mmx5lwvCkujZ4uRrpRSuV+IVs3f90Q==}
+    engines: {node: '>= 4.0.0'}
+    hasBin: true
+
+  devlop@1.1.0:
+    resolution: {integrity: sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==}
+
+  devtools-protocol@0.0.1312386:
+    resolution: {integrity: sha512-DPnhUXvmvKT2dFA/j7B+riVLUt9Q6RKJlcppojL5CoRywJJKLDYnRlw0gTFKfgDPHP5E04UoB71SxoJlVZy8FA==}
+
+  devtools-protocol@0.0.1464554:
+    resolution: {integrity: sha512-CAoP3lYfwAGQTaAXYvA6JZR0fjGUb7qec1qf4mToyoH2TZgUFeIqYcjh6f9jNuhHfuZiEdH+PONHYrLhRQX6aw==}
+
+  didyoumean@1.2.2:
+    resolution: {integrity: sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==}
+
+  diff-sequences@29.6.3:
+    resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
+  dir-glob@3.0.1:
+    resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==}
+    engines: {node: '>=8'}
+
+  dlv@1.1.3:
+    resolution: {integrity: sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==}
+
+  dns-packet@5.6.1:
+    resolution: {integrity: sha512-l4gcSouhcgIKRvyy99RNVOgxXiicE+2jZoNmaNmZ6JXiGajBOJAesk1OBlJuM5k2c+eudGdLxDqXuPCKIj6kpw==}
+    engines: {node: '>=6'}
+
+  dns-socket@4.2.2:
+    resolution: {integrity: sha512-BDeBd8najI4/lS00HSKpdFia+OvUMytaVjfzR9n5Lq8MlZRSvtbI+uLtx1+XmQFls5wFU9dssccTmQQ6nfpjdg==}
+    engines: {node: '>=6'}
+
+  dotenv@16.4.5:
+    resolution: {integrity: sha512-ZmdL2rui+eB2YwhsWzjInR8LldtZHGDoQ1ugH85ppHKwpUHL7j7rN0Ti9NCnGiQbhaZ11FpR+7ao1dNsmduNUg==}
+    engines: {node: '>=12'}
+
+  dotenv@17.3.1:
+    resolution: {integrity: sha512-IO8C/dzEb6O3F9/twg6ZLXz164a2fhTnEWb95H23Dm4OuN+92NmEAlTrupP9VW6Jm3sO26tQlqyvyi4CsnY9GA==}
+    engines: {node: '>=12'}
+
+  dotenv@8.6.0:
+    resolution: {integrity: sha512-IrPdXQsk2BbzvCBGBOTmmSH5SodmqZNt4ERAZDmW4CT+tL8VtvinqywuANaFu4bOMWki16nqf0e4oC0QIaDr/g==}
+    engines: {node: '>=10'}
+
+  dunder-proto@1.0.1:
+    resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==}
+    engines: {node: '>= 0.4'}
+
+  eastasianwidth@0.2.0:
+    resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==}
+
+  ecdsa-sig-formatter@1.0.11:
+    resolution: {integrity: sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==}
+
+  ee-first@1.1.1:
+    resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==}
+
+  emoji-regex@10.4.0:
+    resolution: {integrity: sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw==}
+
+  emoji-regex@8.0.0:
+    resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
+
+  emoji-regex@9.2.2:
+    resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==}
+
+  encodeurl@1.0.2:
+    resolution: {integrity: sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==}
+    engines: {node: '>= 0.8'}
+
+  encodeurl@2.0.0:
+    resolution: {integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==}
+    engines: {node: '>= 0.8'}
+
+  end-of-stream@1.4.4:
+    resolution: {integrity: sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==}
+
+  engine.io-parser@5.2.3:
+    resolution: {integrity: sha512-HqD3yTBfnBxIrbnM1DoD6Pcq8NECnh8d4As1Qgh0z5Gg3jRRIqijury0CL3ghu/edArpUYiYqQiDUQBIs4np3Q==}
+    engines: {node: '>=10.0.0'}
+
+  engine.io@6.6.4:
+    resolution: {integrity: sha512-ZCkIjSYNDyGn0R6ewHDtXgns/Zre/NT6Agvq1/WobF7JXgFff4SeDroKiCO3fNJreU9YG429Sc81o4w5ok/W5g==}
+    engines: {node: '>=10.2.0'}
+
+  enquirer@2.4.1:
+    resolution: {integrity: sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ==}
+    engines: {node: '>=8.6'}
+
+  entities@6.0.0:
+    resolution: {integrity: sha512-aKstq2TDOndCn4diEyp9Uq/Flu2i1GlLkc6XIDQSDMuaFE3OPW5OphLCyQ5SpSJZTb4reN+kTcYru5yIfXoRPw==}
+    engines: {node: '>=0.12'}
+
+  env-paths@2.2.1:
+    resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==}
+    engines: {node: '>=6'}
+
+  environment@1.1.0:
+    resolution: {integrity: sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==}
+    engines: {node: '>=18'}
+
+  error-ex@1.3.2:
+    resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==}
+
+  es-abstract@1.23.9:
+    resolution: {integrity: sha512-py07lI0wjxAC/DcfK1S6G7iANonniZwTISvdPzk9hzeH0IZIshbuuFxLIU96OyF89Yb9hiqWn8M/bY83KY5vzA==}
+    engines: {node: '>= 0.4'}
+
+  es-aggregate-error@1.0.13:
+    resolution: {integrity: sha512-KkzhUUuD2CUMqEc8JEqsXEMDHzDPE8RCjZeUBitsnB1eNcAJWQPiciKsMXe3Yytj4Flw1XLl46Qcf9OxvZha7A==}
+    engines: {node: '>= 0.4'}
+
+  es-define-property@1.0.1:
+    resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==}
+    engines: {node: '>= 0.4'}
+
+  es-errors@1.3.0:
+    resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==}
+    engines: {node: '>= 0.4'}
+
+  es-module-lexer@1.7.0:
+    resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==}
+
+  es-object-atoms@1.1.1:
+    resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==}
+    engines: {node: '>= 0.4'}
+
+  es-set-tostringtag@2.1.0:
+    resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==}
+    engines: {node: '>= 0.4'}
+
+  es-to-primitive@1.3.0:
+    resolution: {integrity: sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==}
+    engines: {node: '>= 0.4'}
+
+  es-toolkit@1.39.10:
+    resolution: {integrity: sha512-E0iGnTtbDhkeczB0T+mxmoVlT4YNweEKBLq7oaU4p11mecdsZpNWOglI4895Vh4usbQ+LsJiuLuI2L0Vdmfm2w==}
+
+  esast-util-from-estree@2.0.0:
+    resolution: {integrity: sha512-4CyanoAudUSBAn5K13H4JhsMH6L9ZP7XbLVe/dKybkxMO7eDyLsT8UHl9TRNrU2Gr9nz+FovfSIjuXWJ81uVwQ==}
+
+  esast-util-from-js@2.0.1:
+    resolution: {integrity: sha512-8Ja+rNJ0Lt56Pcf3TAmpBZjmx8ZcK5Ts4cAzIOjsjevg9oSXJnl6SUQ2EevU8tv3h6ZLWmoKL5H4fgWvdvfETw==}
+
+  esbuild@0.21.5:
+    resolution: {integrity: sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==}
+    engines: {node: '>=12'}
+    hasBin: true
+
+  esbuild@0.25.11:
+    resolution: {integrity: sha512-KohQwyzrKTQmhXDW1PjCv3Tyspn9n5GcY2RTDqeORIdIJY8yKIF7sTSopFmn/wpMPW4rdPXI0UE5LJLuq3bx0Q==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  esbuild@0.27.2:
+    resolution: {integrity: sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  escalade@3.2.0:
+    resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
+    engines: {node: '>=6'}
+
+  escape-html@1.0.3:
+    resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==}
+
+  escape-string-regexp@2.0.0:
+    resolution: {integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==}
+    engines: {node: '>=8'}
+
+  escape-string-regexp@4.0.0:
+    resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==}
+    engines: {node: '>=10'}
+
+  escape-string-regexp@5.0.0:
+    resolution: {integrity: sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==}
+    engines: {node: '>=12'}
+
+  escodegen@2.1.0:
+    resolution: {integrity: sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==}
+    engines: {node: '>=6.0'}
+    hasBin: true
+
+  eslint-plugin-security@3.0.1:
+    resolution: {integrity: sha512-XjVGBhtDZJfyuhIxnQ/WMm385RbX3DBu7H1J7HNNhmB2tnGxMeqVSnYv79oAj992ayvIBZghsymwkYFS6cGH4Q==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  eslint-scope@8.4.0:
+    resolution: {integrity: sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  eslint-scope@9.1.1:
+    resolution: {integrity: sha512-GaUN0sWim5qc8KVErfPBWmc31LEsOkrUJbvJZV+xuL3u2phMUK4HIvXlWAakfC8W4nzlK+chPEAkYOYb5ZScIw==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  eslint-visitor-keys@3.4.3:
+    resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+
+  eslint-visitor-keys@4.2.1:
+    resolution: {integrity: sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  eslint-visitor-keys@5.0.1:
+    resolution: {integrity: sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  eslint@10.0.2:
+    resolution: {integrity: sha512-uYixubwmqJZH+KLVYIVKY1JQt7tysXhtj21WSvjcSmU5SVNzMus1bgLe+pAt816yQ8opKfheVVoPLqvVMGejYw==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+    hasBin: true
+    peerDependencies:
+      jiti: '*'
+    peerDependenciesMeta:
+      jiti:
+        optional: true
+
+  eslint@9.39.4:
+    resolution: {integrity: sha512-XoMjdBOwe/esVgEvLmNsD3IRHkm7fbKIUGvrleloJXUZgDHig2IPWNniv+GwjyJXzuNqVjlr5+4yVUZjycJwfQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    hasBin: true
+    peerDependencies:
+      jiti: '*'
+    peerDependenciesMeta:
+      jiti:
+        optional: true
+
+  espree@10.4.0:
+    resolution: {integrity: sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  espree@11.1.1:
+    resolution: {integrity: sha512-AVHPqQoZYc+RUM4/3Ly5udlZY/U4LS8pIG05jEjWM2lQMU/oaZ7qshzAl2YP1tfNmXfftH3ohurfwNAug+MnsQ==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  esprima@4.0.1:
+    resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==}
+    engines: {node: '>=4'}
+    hasBin: true
+
+  esquery@1.7.0:
+    resolution: {integrity: sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==}
+    engines: {node: '>=0.10'}
+
+  esrecurse@4.3.0:
+    resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==}
+    engines: {node: '>=4.0'}
+
+  estraverse@5.3.0:
+    resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==}
+    engines: {node: '>=4.0'}
+
+  estree-util-attach-comments@3.0.0:
+    resolution: {integrity: sha512-cKUwm/HUcTDsYh/9FgnuFqpfquUbwIqwKM26BVCGDPVgvaCl/nDCCjUfiLlx6lsEZ3Z4RFxNbOQ60pkaEwFxGw==}
+
+  estree-util-build-jsx@3.0.1:
+    resolution: {integrity: sha512-8U5eiL6BTrPxp/CHbs2yMgP8ftMhR5ww1eIKoWRMlqvltHF8fZn5LRDvTKuxD3DUn+shRbLGqXemcP51oFCsGQ==}
+
+  estree-util-is-identifier-name@3.0.0:
+    resolution: {integrity: sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg==}
+
+  estree-util-scope@1.0.0:
+    resolution: {integrity: sha512-2CAASclonf+JFWBNJPndcOpA8EMJwa0Q8LUFJEKqXLW6+qBvbFZuF5gItbQOs/umBUkjviCSDCbBwU2cXbmrhQ==}
+
+  estree-util-to-js@2.0.0:
+    resolution: {integrity: sha512-WDF+xj5rRWmD5tj6bIqRi6CkLIXbbNQUcxQHzGysQzvHmdYG2G7p/Tf0J0gpxGgkeMZNTIjT/AoSvC9Xehcgdg==}
+
+  estree-util-visit@2.0.0:
+    resolution: {integrity: sha512-m5KgiH85xAhhW8Wta0vShLcUvOsh3LLPI2YVwcbio1l7E09NTLL1EyMZFM1OyWowoH0skScNbhOPl4kcBgzTww==}
+
+  estree-walker@3.0.3:
+    resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
+
+  esutils@2.0.3:
+    resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
+    engines: {node: '>=0.10.0'}
+
+  etag@1.8.1:
+    resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==}
+    engines: {node: '>= 0.6'}
+
+  event-target-shim@5.0.1:
+    resolution: {integrity: sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==}
+    engines: {node: '>=6'}
+
+  eventemitter3@4.0.7:
+    resolution: {integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==}
+
+  events@3.3.0:
+    resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==}
+    engines: {node: '>=0.8.x'}
+
+  eventsource-parser@1.1.2:
+    resolution: {integrity: sha512-v0eOBUbiaFojBu2s2NPBfYUoRR9GjcDNvCXVaqEf5vVfpIAh9f8RCo4vXTP8c63QRKCFwoLpMpTdPwwhEKVgzA==}
+    engines: {node: '>=14.18'}
+
+  eventsource-parser@3.0.6:
+    resolution: {integrity: sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg==}
+    engines: {node: '>=18.0.0'}
+
+  eventsource@3.0.7:
+    resolution: {integrity: sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==}
+    engines: {node: '>=18.0.0'}
+
+  execa@8.0.1:
+    resolution: {integrity: sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==}
+    engines: {node: '>=16.17'}
+
+  expect-type@1.2.2:
+    resolution: {integrity: sha512-JhFGDVJ7tmDJItKhYgJCGLOWjuK9vPxiXoUFLwLDc99NlmklilbiQJwoctZtt13+xMw91MCk/REan6MWHqDjyA==}
+    engines: {node: '>=12.0.0'}
+
+  express-rate-limit@7.5.1:
+    resolution: {integrity: sha512-7iN8iPMDzOMHPUYllBEsQdWVB6fPDMPqwjBaFrgr4Jgr/+okjvzAy+UHlYYL/Vs0OsOrMkwS6PJDkFlJwoxUnw==}
+    engines: {node: '>= 16'}
+    peerDependencies:
+      express: '>= 4.11'
+
+  express@4.21.2:
+    resolution: {integrity: sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==}
+    engines: {node: '>= 0.10.0'}
+
+  express@5.1.0:
+    resolution: {integrity: sha512-DT9ck5YIRU+8GYzzU5kT3eHGA5iL+1Zd0EutOmTE9Dtk+Tvuzd23VBU+ec7HPNSTxXYO55gPV/hq4pSBJDjFpA==}
+    engines: {node: '>= 18'}
+
+  extend-shallow@2.0.1:
+    resolution: {integrity: sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==}
+    engines: {node: '>=0.10.0'}
+
+  extend@3.0.2:
+    resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==}
+
+  extendable-error@0.1.7:
+    resolution: {integrity: sha512-UOiS2in6/Q0FK0R0q6UY9vYpQ21mr/Qn1KOnte7vsACuNJf514WvCCUHSRCPcgjPT2bAhNIJdlE6bVap1GKmeg==}
+
+  external-editor@3.1.0:
+    resolution: {integrity: sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==}
+    engines: {node: '>=4'}
+
+  extract-zip@2.0.1:
+    resolution: {integrity: sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==}
+    engines: {node: '>= 10.17.0'}
+    hasBin: true
+
+  fast-copy@3.0.2:
+    resolution: {integrity: sha512-dl0O9Vhju8IrcLndv2eU4ldt1ftXMqqfgN4H1cpmGV7P6jeB9FwpN9a2c8DPGE1Ys88rNUJVYDHq73CGAGOPfQ==}
+
+  fast-decode-uri-component@1.0.1:
+    resolution: {integrity: sha512-WKgKWg5eUxvRZGwW8FvfbaH7AXSh2cL+3j5fMGzUMCxWBJ3dV3a7Wz8y2f/uQ0e3B6WmodD3oS54jTQ9HVTIIg==}
+
+  fast-deep-equal@3.1.3:
+    resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
+
+  fast-fifo@1.3.2:
+    resolution: {integrity: sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==}
+
+  fast-glob@3.3.3:
+    resolution: {integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==}
+    engines: {node: '>=8.6.0'}
+
+  fast-json-stable-stringify@2.1.0:
+    resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==}
+
+  fast-json-stringify@6.1.1:
+    resolution: {integrity: sha512-DbgptncYEXZqDUOEl4krff4mUiVrTZZVI7BBrQR/T3BqMj/eM1flTC1Uk2uUoLcWCxjT95xKulV/Lc6hhOZsBQ==}
+
+  fast-levenshtein@2.0.6:
+    resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==}
+
+  fast-memoize@2.5.2:
+    resolution: {integrity: sha512-Ue0LwpDYErFbmNnZSF0UH6eImUwDmogUO1jyE+JbN2gsQz/jICm1Ve7t9QT0rNSsfJt+Hs4/S3GnsDVjL4HVrw==}
+
+  fast-querystring@1.1.2:
+    resolution: {integrity: sha512-g6KuKWmFXc0fID8WWH0jit4g0AGBoJhCkJMb1RmbsSEUNvQ+ZC8D6CUZ+GtF8nMzSPXnhiePyyqqipzNNEnHjg==}
+
+  fast-safe-stringify@2.1.1:
+    resolution: {integrity: sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==}
+
+  fast-uri@3.0.6:
+    resolution: {integrity: sha512-Atfo14OibSv5wAp4VWNsFYE1AchQRTv9cBGWET4pZWHzYshFSS9NQI6I57rdKn9croWVMbYFbLhJ+yJvmZIIHw==}
+
+  fastify-metrics@12.1.0:
+    resolution: {integrity: sha512-EpbT+W1jm8kMbkCPvfW4j23y3BZlXGOcO6+75EFTKDxbJIyXbldrFIoVoP0oD4CsqrKeIARvrOjbZNqK5MdRwQ==}
+    peerDependencies:
+      fastify: '>=5'
+
+  fastify-plugin@4.5.1:
+    resolution: {integrity: sha512-stRHYGeuqpEZTL1Ef0Ovr2ltazUT9g844X5z/zEBFLG8RYlpDiOCIG+ATvYEp+/zmc7sN29mcIMp8gvYplYPIQ==}
+
+  fastify-plugin@5.1.0:
+    resolution: {integrity: sha512-FAIDA8eovSt5qcDgcBvDuX/v0Cjz0ohGhENZ/wpc3y+oZCY2afZ9Baqql3g/lC+OHRnciQol4ww7tuthOb9idw==}
+
+  fastify-zod-openapi@5.5.0:
+    resolution: {integrity: sha512-b6AhZuz68AiywJxTkxTGtBQonrgxp6udRRKapcimBn4b8iBulQmMYmjjwe8FKwY8LMAXbf8lPPfgwC6apWPa/g==}
+    engines: {node: '>=20'}
+    peerDependencies:
+      '@fastify/swagger': ^9.0.0
+      '@fastify/swagger-ui': ^5.0.1
+      fastify: '5'
+      zod: ^3.25.74 || ^4.0.0
+    peerDependenciesMeta:
+      '@fastify/swagger':
+        optional: true
+      '@fastify/swagger-ui':
+        optional: true
+
+  fastify@5.6.2:
+    resolution: {integrity: sha512-dPugdGnsvYkBlENLhCgX8yhyGCsCPrpA8lFWbTNU428l+YOnLgYHR69hzV8HWPC79n536EqzqQtvhtdaCE0dKg==}
+
+  fastq@1.19.1:
+    resolution: {integrity: sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==}
+
+  fault@2.0.1:
+    resolution: {integrity: sha512-WtySTkS4OKev5JtpHXnib4Gxiurzh5NCGvWrFaZ34m6JehfTUhKZvn9njTfw48t6JumVQOmrKqpmGcdwxnhqBQ==}
+
+  favicons@7.2.0:
+    resolution: {integrity: sha512-k/2rVBRIRzOeom3wI9jBPaSEvoTSQEW4iM0EveBmBBKFxO8mSyyRWtDlfC3VnEfu0avmjrMzy8/ZFPSe6F71Hw==}
+    engines: {node: '>=14.0.0'}
+
+  fd-slicer@1.1.0:
+    resolution: {integrity: sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==}
+
+  fdir@6.5.0:
+    resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==}
+    engines: {node: '>=12.0.0'}
+    peerDependencies:
+      picomatch: ^3 || ^4
+    peerDependenciesMeta:
+      picomatch:
+        optional: true
+
+  fetch-blob@3.2.0:
+    resolution: {integrity: sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==}
+    engines: {node: ^12.20 || >= 14.13}
+
+  fetch-cookie@3.1.0:
+    resolution: {integrity: sha512-s/XhhreJpqH0ftkGVcQt8JE9bqk+zRn4jF5mPJXWZeQMCI5odV9K+wEWYbnzFPHgQZlvPSMjS4n4yawWE8RINw==}
+
+  file-entry-cache@8.0.0:
+    resolution: {integrity: sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==}
+    engines: {node: '>=16.0.0'}
+
+  fill-range@7.1.1:
+    resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
+    engines: {node: '>=8'}
+
+  finalhandler@1.3.1:
+    resolution: {integrity: sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==}
+    engines: {node: '>= 0.8'}
+
+  finalhandler@2.1.0:
+    resolution: {integrity: sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==}
+    engines: {node: '>= 0.8'}
+
+  find-my-way@9.3.0:
+    resolution: {integrity: sha512-eRoFWQw+Yv2tuYlK2pjFS2jGXSxSppAs3hSQjfxVKxM5amECzIgYYc1FEI8ZmhSh/Ig+FrKEz43NLRKJjYCZVg==}
+    engines: {node: '>=20'}
+
+  find-up@4.1.0:
+    resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==}
+    engines: {node: '>=8'}
+
+  find-up@5.0.0:
+    resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==}
+    engines: {node: '>=10'}
+
+  fix-dts-default-cjs-exports@1.0.1:
+    resolution: {integrity: sha512-pVIECanWFC61Hzl2+oOCtoJ3F17kglZC/6N94eRWycFgBH35hHx0Li604ZIzhseh97mf2p0cv7vVrOZGoqhlEg==}
+
+  flat-cache@4.0.1:
+    resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==}
+    engines: {node: '>=16'}
+
+  flatted@3.3.3:
+    resolution: {integrity: sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==}
+
+  follow-redirects@1.15.9:
+    resolution: {integrity: sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==}
+    engines: {node: '>=4.0'}
+    peerDependencies:
+      debug: '*'
+    peerDependenciesMeta:
+      debug:
+        optional: true
+
+  for-each@0.3.5:
+    resolution: {integrity: sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==}
+    engines: {node: '>= 0.4'}
+
+  foreground-child@3.3.1:
+    resolution: {integrity: sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==}
+    engines: {node: '>=14'}
+
+  form-data-encoder@1.7.2:
+    resolution: {integrity: sha512-qfqtYan3rxrnCk1VYaA4H+Ms9xdpPqvLZa6xmMgFvhO32x7/3J/ExcTd6qpxM0vH2GdMI+poehyBZvqfMTto8A==}
+
+  form-data-encoder@2.1.4:
+    resolution: {integrity: sha512-yDYSgNMraqvnxiEXO4hi88+YZxaHC6QKzb5N84iRCTDeRO7ZALpir/lVmf/uXUhnwUr2O4HU8s/n6x+yNjQkHw==}
+    engines: {node: '>= 14.17'}
+
+  form-data@4.0.2:
+    resolution: {integrity: sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w==}
+    engines: {node: '>= 6'}
+
+  format@0.2.2:
+    resolution: {integrity: sha512-wzsgA6WOq+09wrU1tsJ09udeR/YZRaeArL9e1wPbFg3GG2yDnC2ldKpxs4xunpFF9DgqCqOIra3bc1HWrJ37Ww==}
+    engines: {node: '>=0.4.x'}
+
+  formdata-node@4.4.1:
+    resolution: {integrity: sha512-0iirZp3uVDjVGt9p49aTaqjk84TrglENEDuqfdlZQ1roC9CWlPk6Avf8EEnZNcAqPonwkG35x4n3ww/1THYAeQ==}
+    engines: {node: '>= 12.20'}
+
+  formdata-polyfill@4.0.10:
+    resolution: {integrity: sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==}
+    engines: {node: '>=12.20.0'}
+
+  forwarded@0.2.0:
+    resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==}
+    engines: {node: '>= 0.6'}
+
+  fresh@0.5.2:
+    resolution: {integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==}
+    engines: {node: '>= 0.6'}
+
+  fresh@2.0.0:
+    resolution: {integrity: sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==}
+    engines: {node: '>= 0.8'}
+
+  fs-extra@11.3.0:
+    resolution: {integrity: sha512-Z4XaCL6dUDHfP/jT25jJKMmtxvuwbkrD1vNSMFlo9lNLY2c5FHYSQgHPRZUjAB26TpDEoW9HCOgplrdbaPV/ew==}
+    engines: {node: '>=14.14'}
+
+  fs-extra@7.0.1:
+    resolution: {integrity: sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==}
+    engines: {node: '>=6 <7 || >=8'}
+
+  fs-extra@8.1.0:
+    resolution: {integrity: sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==}
+    engines: {node: '>=6 <7 || >=8'}
+
+  fs-minipass@2.1.0:
+    resolution: {integrity: sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==}
+    engines: {node: '>= 8'}
+
+  fsevents@2.3.2:
+    resolution: {integrity: sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
+  fsevents@2.3.3:
+    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
+  function-bind@1.1.2:
+    resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==}
+
+  function.prototype.name@1.1.8:
+    resolution: {integrity: sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q==}
+    engines: {node: '>= 0.4'}
+
+  functions-have-names@1.2.3:
+    resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==}
+
+  gaxios@6.7.1:
+    resolution: {integrity: sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==}
+    engines: {node: '>=14'}
+
+  gaxios@7.1.3:
+    resolution: {integrity: sha512-YGGyuEdVIjqxkxVH1pUTMY/XtmmsApXrCVv5EU25iX6inEPbV+VakJfLealkBtJN69AQmh1eGOdCl9Sm1UP6XQ==}
+    engines: {node: '>=18'}
+
+  gcd@0.0.1:
+    resolution: {integrity: sha512-VNx3UEGr+ILJTiMs1+xc5SX1cMgJCrXezKPa003APUWNqQqaF6n25W8VcR7nHN6yRWbvvUTwCpZCFJeWC2kXlw==}
+
+  gcp-metadata@6.1.1:
+    resolution: {integrity: sha512-a4tiq7E0/5fTjxPAaH4jpjkSv/uCaU2p5KC6HVGrvl0cDjA8iBZv4vv1gyzlmK0ZUKqwpOyQMKzZQe3lTit77A==}
+    engines: {node: '>=14'}
+
+  gcp-metadata@8.1.2:
+    resolution: {integrity: sha512-zV/5HKTfCeKWnxG0Dmrw51hEWFGfcF2xiXqcA3+J90WDuP0SvoiSO5ORvcBsifmx/FoIjgQN3oNOGaQ5PhLFkg==}
+    engines: {node: '>=18'}
+
+  get-caller-file@2.0.5:
+    resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==}
+    engines: {node: 6.* || 8.* || >= 10.*}
+
+  get-east-asian-width@1.3.0:
+    resolution: {integrity: sha512-vpeMIQKxczTD/0s2CdEWHcb0eeJe6TFjxb+J5xgX7hScxqrGuyjmv4c1D4A/gelKfyox0gJJwIHF+fLjeaM8kQ==}
+    engines: {node: '>=18'}
+
+  get-func-name@2.0.2:
+    resolution: {integrity: sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==}
+
+  get-intrinsic@1.3.0:
+    resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==}
+    engines: {node: '>= 0.4'}
+
+  get-proto@1.0.1:
+    resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==}
+    engines: {node: '>= 0.4'}
+
+  get-stream@5.2.0:
+    resolution: {integrity: sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==}
+    engines: {node: '>=8'}
+
+  get-stream@6.0.1:
+    resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==}
+    engines: {node: '>=10'}
+
+  get-stream@8.0.1:
+    resolution: {integrity: sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==}
+    engines: {node: '>=16'}
+
+  get-symbol-description@1.1.0:
+    resolution: {integrity: sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==}
+    engines: {node: '>= 0.4'}
+
+  get-tsconfig@4.10.0:
+    resolution: {integrity: sha512-kGzZ3LWWQcGIAmg6iWvXn0ei6WDtV26wzHRMwDSzmAbcXrTEXxHy6IehI6/4eT6VRKyMP1eF1VqwrVUmE/LR7A==}
+
+  get-uri@6.0.4:
+    resolution: {integrity: sha512-E1b1lFFLvLgak2whF2xDBcOy6NLVGZBqqjJjsIhvopKfWWEi64pLVTWWehV8KlLerZkfNTA95sTe2OdJKm1OzQ==}
+    engines: {node: '>= 14'}
+
+  glob-parent@5.1.2:
+    resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
+    engines: {node: '>= 6'}
+
+  glob-parent@6.0.2:
+    resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==}
+    engines: {node: '>=10.13.0'}
+
+  glob@10.4.5:
+    resolution: {integrity: sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==}
+    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
+    hasBin: true
+
+  glob@11.1.0:
+    resolution: {integrity: sha512-vuNwKSaKiqm7g0THUBu2x7ckSs3XJLXE+2ssL7/MfTGPLLcrJQ/4Uq1CjPTtO5cCIiRxqvN6Twy1qOwhL0Xjcw==}
+    engines: {node: 20 || >=22}
+    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
+    hasBin: true
+
+  globals@14.0.0:
+    resolution: {integrity: sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==}
+    engines: {node: '>=18'}
+
+  globals@15.15.0:
+    resolution: {integrity: sha512-7ACyT3wmyp3I61S4fG682L0VA2RGD9otkqGJIwNUMF1SWUombIIk+af1unuDYgMm082aHYwD+mzJvv9Iu8dsgg==}
+    engines: {node: '>=18'}
+
+  globalthis@1.0.4:
+    resolution: {integrity: sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==}
+    engines: {node: '>= 0.4'}
+
+  globby@11.1.0:
+    resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==}
+    engines: {node: '>=10'}
+
+  google-auth-library@10.5.0:
+    resolution: {integrity: sha512-7ABviyMOlX5hIVD60YOfHw4/CxOfBhyduaYB+wbFWCWoni4N7SLcV46hrVRktuBbZjFC9ONyqamZITN7q3n32w==}
+    engines: {node: '>=18'}
+
+  google-auth-library@9.15.1:
+    resolution: {integrity: sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==}
+    engines: {node: '>=14'}
+
+  google-logging-utils@0.0.2:
+    resolution: {integrity: sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ==}
+    engines: {node: '>=14'}
+
+  google-logging-utils@1.1.3:
+    resolution: {integrity: sha512-eAmLkjDjAFCVXg7A1unxHsLf961m6y17QFqXqAXGj/gVkKFrEICfStRfwUlGNfeCEjNRa32JEWOUTlYXPyyKvA==}
+    engines: {node: '>=14'}
+
+  gopd@1.2.0:
+    resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==}
+    engines: {node: '>= 0.4'}
+
+  got@12.6.1:
+    resolution: {integrity: sha512-mThBblvlAF1d4O5oqyvN+ZxLAYwIJK7bpMxgYqPD9okW0C3qm5FFn7k811QrcuEBwaogR3ngOFoCfs6mRv7teQ==}
+    engines: {node: '>=14.16'}
+
+  got@13.0.0:
+    resolution: {integrity: sha512-XfBk1CxOOScDcMr9O1yKkNaQyy865NbYs+F7dr4H0LZMVgCj2Le59k6PqbNHoL5ToeaEQUYh6c6yMfVcc6SJxA==}
+    engines: {node: '>=16'}
+
+  graceful-fs@4.2.11:
+    resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
+
+  gray-matter@4.0.3:
+    resolution: {integrity: sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q==}
+    engines: {node: '>=6.0'}
+
+  gtoken@7.1.0:
+    resolution: {integrity: sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==}
+    engines: {node: '>=14.0.0'}
+
+  gtoken@8.0.0:
+    resolution: {integrity: sha512-+CqsMbHPiSTdtSO14O51eMNlrp9N79gmeqmXeouJOhfucAedHw9noVe/n5uJk3tbKE6a+6ZCQg3RPhVhHByAIw==}
+    engines: {node: '>=18'}
+
+  has-bigints@1.1.0:
+    resolution: {integrity: sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==}
+    engines: {node: '>= 0.4'}
+
+  has-flag@4.0.0:
+    resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
+    engines: {node: '>=8'}
+
+  has-property-descriptors@1.0.2:
+    resolution: {integrity: sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==}
+
+  has-proto@1.2.0:
+    resolution: {integrity: sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==}
+    engines: {node: '>= 0.4'}
+
+  has-symbols@1.1.0:
+    resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==}
+    engines: {node: '>= 0.4'}
+
+  has-tostringtag@1.0.2:
+    resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==}
+    engines: {node: '>= 0.4'}
+
+  hasown@2.0.2:
+    resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
+    engines: {node: '>= 0.4'}
+
+  hast-util-embedded@3.0.0:
+    resolution: {integrity: sha512-naH8sld4Pe2ep03qqULEtvYr7EjrLK2QHY8KJR6RJkTUjPGObe1vnx585uzem2hGra+s1q08DZZpfgDVYRbaXA==}
+
+  hast-util-from-dom@5.0.1:
+    resolution: {integrity: sha512-N+LqofjR2zuzTjCPzyDUdSshy4Ma6li7p/c3pA78uTwzFgENbgbUrm2ugwsOdcjI1muO+o6Dgzp9p8WHtn/39Q==}
+
+  hast-util-from-html-isomorphic@2.0.0:
+    resolution: {integrity: sha512-zJfpXq44yff2hmE0XmwEOzdWin5xwH+QIhMLOScpX91e/NSGPsAzNCvLQDIEPyO2TXi+lBmU6hjLIhV8MwP2kw==}
+
+  hast-util-from-html@2.0.3:
+    resolution: {integrity: sha512-CUSRHXyKjzHov8yKsQjGOElXy/3EKpyX56ELnkHH34vDVw1N1XSQ1ZcAvTyAPtGqLTuKP/uxM+aLkSPqF/EtMw==}
+
+  hast-util-from-parse5@8.0.3:
+    resolution: {integrity: sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg==}
+
+  hast-util-has-property@3.0.0:
+    resolution: {integrity: sha512-MNilsvEKLFpV604hwfhVStK0usFY/QmM5zX16bo7EjnAEGofr5YyI37kzopBlZJkHD4t887i+q/C8/tr5Q94cA==}
+
+  hast-util-is-body-ok-link@3.0.1:
+    resolution: {integrity: sha512-0qpnzOBLztXHbHQenVB8uNuxTnm/QBFUOmdOSsEn7GnBtyY07+ENTWVFBAnXd/zEgd9/SUG3lRY7hSIBWRgGpQ==}
+
+  hast-util-is-element@3.0.0:
+    resolution: {integrity: sha512-Val9mnv2IWpLbNPqc/pUem+a7Ipj2aHacCwgNfTiK0vJKl0LF+4Ba4+v1oPHFpf3bLYmreq0/l3Gud9S5OH42g==}
+
+  hast-util-minify-whitespace@1.0.1:
+    resolution: {integrity: sha512-L96fPOVpnclQE0xzdWb/D12VT5FabA7SnZOUMtL1DbXmYiHJMXZvFkIZfiMmTCNJHUeO2K9UYNXoVyfz+QHuOw==}
+
+  hast-util-parse-selector@4.0.0:
+    resolution: {integrity: sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==}
+
+  hast-util-phrasing@3.0.1:
+    resolution: {integrity: sha512-6h60VfI3uBQUxHqTyMymMZnEbNl1XmEGtOxxKYL7stY2o601COo62AWAYBQR9lZbYXYSBoxag8UpPRXK+9fqSQ==}
+
+  hast-util-to-estree@3.1.3:
+    resolution: {integrity: sha512-48+B/rJWAp0jamNbAAf9M7Uf//UVqAoMmgXhBdxTDJLGKY+LRnZ99qcG+Qjl5HfMpYNzS5v4EAwVEF34LeAj7w==}
+
+  hast-util-to-html@9.0.5:
+    resolution: {integrity: sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw==}
+
+  hast-util-to-jsx-runtime@2.3.6:
+    resolution: {integrity: sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==}
+
+  hast-util-to-mdast@10.1.2:
+    resolution: {integrity: sha512-FiCRI7NmOvM4y+f5w32jPRzcxDIz+PUqDwEqn1A+1q2cdp3B8Gx7aVrXORdOKjMNDQsD1ogOr896+0jJHW1EFQ==}
+
+  hast-util-to-string@3.0.1:
+    resolution: {integrity: sha512-XelQVTDWvqcl3axRfI0xSeoVKzyIFPwsAGSLIsKdJKQMXDYJS4WYrBNF/8J7RdhIcFI2BOHgAifggsvsxp/3+A==}
+
+  hast-util-to-text@4.0.2:
+    resolution: {integrity: sha512-KK6y/BN8lbaq654j7JgBydev7wuNMcID54lkRav1P0CaE1e47P72AWWPiGKXTJU271ooYzcvTAn/Zt0REnvc7A==}
+
+  hast-util-whitespace@3.0.0:
+    resolution: {integrity: sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==}
+
+  hastscript@9.0.1:
+    resolution: {integrity: sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==}
+
+  help-me@5.0.0:
+    resolution: {integrity: sha512-7xgomUX6ADmcYzFik0HzAxh/73YlKR9bmFzf51CZwR+b6YtzU2m0u49hQCqV6SvlqIqsaxovfwdvbnsw3b/zpg==}
+
+  html-encoding-sniffer@4.0.0:
+    resolution: {integrity: sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==}
+    engines: {node: '>=18'}
+
+  html-escaper@2.0.2:
+    resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==}
+
+  html-void-elements@3.0.0:
+    resolution: {integrity: sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==}
+
+  http-cache-semantics@4.1.1:
+    resolution: {integrity: sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==}
+
+  http-errors@2.0.0:
+    resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==}
+    engines: {node: '>= 0.8'}
+
+  http-proxy-agent@7.0.2:
+    resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==}
+    engines: {node: '>= 14'}
+
+  http-status-codes@2.3.0:
+    resolution: {integrity: sha512-RJ8XvFvpPM/Dmc5SV+dC4y5PCeOhT3x1Hq0NU3rjGeg5a/CqlhZ7uudknPwZFz4aeAXDcbAyaeP7GAo9lvngtA==}
+
+  http2-wrapper@2.2.1:
+    resolution: {integrity: sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ==}
+    engines: {node: '>=10.19.0'}
+
+  https-proxy-agent@7.0.6:
+    resolution: {integrity: sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==}
+    engines: {node: '>= 14'}
+
+  human-id@4.1.1:
+    resolution: {integrity: sha512-3gKm/gCSUipeLsRYZbbdA1BD83lBoWUkZ7G9VFrhWPAU76KwYo5KR8V28bpoPm/ygy0x5/GCbpRQdY7VLYCoIg==}
+    hasBin: true
+
+  human-signals@5.0.0:
+    resolution: {integrity: sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==}
+    engines: {node: '>=16.17.0'}
+
+  humanize-ms@1.2.1:
+    resolution: {integrity: sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==}
+
+  iconv-lite@0.4.24:
+    resolution: {integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==}
+    engines: {node: '>=0.10.0'}
+
+  iconv-lite@0.6.3:
+    resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==}
+    engines: {node: '>=0.10.0'}
+
+  ieee754@1.2.1:
+    resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==}
+
+  ignore@5.3.2:
+    resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
+    engines: {node: '>= 4'}
+
+  ignore@7.0.5:
+    resolution: {integrity: sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==}
+    engines: {node: '>= 4'}
+
+  immer@9.0.21:
+    resolution: {integrity: sha512-bc4NBHqOqSfRW7POMkHd51LvClaeMXpm8dx0e8oE2GORbq5aRK7Bxl4FyzVLdGtLmvLKL7BTDBG5ACQm4HWjTA==}
+
+  import-fresh@3.3.1:
+    resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==}
+    engines: {node: '>=6'}
+
+  imurmurhash@0.1.4:
+    resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==}
+    engines: {node: '>=0.8.19'}
+
+  indent-string@5.0.0:
+    resolution: {integrity: sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg==}
+    engines: {node: '>=12'}
+
+  inherits@2.0.4:
+    resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
+
+  ink-spinner@5.0.0:
+    resolution: {integrity: sha512-EYEasbEjkqLGyPOUc8hBJZNuC5GvXGMLu0w5gdTNskPc7Izc5vO3tdQEYnzvshucyGCBXc86ig0ujXPMWaQCdA==}
+    engines: {node: '>=14.16'}
+    peerDependencies:
+      ink: '>=4.0.0'
+      react: '>=18.0.0'
+
+  ink@5.2.1:
+    resolution: {integrity: sha512-BqcUyWrG9zq5HIwW6JcfFHsIYebJkWWb4fczNah1goUO0vv5vneIlfwuS85twyJ5hYR/y18FlAYUxrO9ChIWVg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/react': '>=18.0.0'
+      react: '>=18.0.0'
+      react-devtools-core: ^4.19.1
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      react-devtools-core:
+        optional: true
+
+  inline-style-parser@0.2.4:
+    resolution: {integrity: sha512-0aO8FkhNZlj/ZIbNi7Lxxr12obT7cL1moPfE4tg1LkX7LlLfC6DeX4l2ZEud1ukP9jNQyNnfzQVqwbwmAATY4Q==}
+
+  inquirer@12.6.0:
+    resolution: {integrity: sha512-3zmmccQd/8o65nPOZJZ+2wqt76Ghw3+LaMrmc6JE/IzcvQhJ1st+QLCOo/iLS85/tILU0myG31a2TAZX0ysAvg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  internal-slot@1.1.0:
+    resolution: {integrity: sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==}
+    engines: {node: '>= 0.4'}
+
+  ip-address@9.0.5:
+    resolution: {integrity: sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==}
+    engines: {node: '>= 12'}
+
+  ip-regex@4.3.0:
+    resolution: {integrity: sha512-B9ZWJxHHOHUhUjCPrMpLD4xEq35bUTClHM1S6CBU5ixQnkZmwipwgc96vAd7AAGM9TGHvJR+Uss+/Ak6UphK+Q==}
+    engines: {node: '>=8'}
+
+  ipaddr.js@1.9.1:
+    resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==}
+    engines: {node: '>= 0.10'}
+
+  ipaddr.js@2.3.0:
+    resolution: {integrity: sha512-Zv/pA+ciVFbCSBBjGfaKUya/CcGmUHzTydLMaTwrUUEM2DIEO3iZvueGxmacvmN50fGpGVKeTXpb2LcYQxeVdg==}
+    engines: {node: '>= 10'}
+
+  is-alphabetical@2.0.1:
+    resolution: {integrity: sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ==}
+
+  is-alphanumerical@2.0.1:
+    resolution: {integrity: sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==}
+
+  is-array-buffer@3.0.5:
+    resolution: {integrity: sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==}
+    engines: {node: '>= 0.4'}
+
+  is-arrayish@0.2.1:
+    resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==}
+
+  is-arrayish@0.3.2:
+    resolution: {integrity: sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ==}
+
+  is-async-function@2.1.1:
+    resolution: {integrity: sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==}
+    engines: {node: '>= 0.4'}
+
+  is-bigint@1.1.0:
+    resolution: {integrity: sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==}
+    engines: {node: '>= 0.4'}
+
+  is-binary-path@2.1.0:
+    resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==}
+    engines: {node: '>=8'}
+
+  is-boolean-object@1.2.2:
+    resolution: {integrity: sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==}
+    engines: {node: '>= 0.4'}
+
+  is-callable@1.2.7:
+    resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==}
+    engines: {node: '>= 0.4'}
+
+  is-core-module@2.16.1:
+    resolution: {integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==}
+    engines: {node: '>= 0.4'}
+
+  is-data-view@1.0.2:
+    resolution: {integrity: sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==}
+    engines: {node: '>= 0.4'}
+
+  is-date-object@1.1.0:
+    resolution: {integrity: sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==}
+    engines: {node: '>= 0.4'}
+
+  is-decimal@2.0.1:
+    resolution: {integrity: sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A==}
+
+  is-docker@2.2.1:
+    resolution: {integrity: sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==}
+    engines: {node: '>=8'}
+    hasBin: true
+
+  is-extendable@0.1.1:
+    resolution: {integrity: sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==}
+    engines: {node: '>=0.10.0'}
+
+  is-extglob@2.1.1:
+    resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
+    engines: {node: '>=0.10.0'}
+
+  is-finalizationregistry@1.1.1:
+    resolution: {integrity: sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==}
+    engines: {node: '>= 0.4'}
+
+  is-fullwidth-code-point@3.0.0:
+    resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==}
+    engines: {node: '>=8'}
+
+  is-fullwidth-code-point@4.0.0:
+    resolution: {integrity: sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==}
+    engines: {node: '>=12'}
+
+  is-fullwidth-code-point@5.0.0:
+    resolution: {integrity: sha512-OVa3u9kkBbw7b8Xw5F9P+D/T9X+Z4+JruYVNapTjPYZYUznQ5YfWeFkOj606XYYW8yugTfC8Pj0hYqvi4ryAhA==}
+    engines: {node: '>=18'}
+
+  is-generator-function@1.1.0:
+    resolution: {integrity: sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ==}
+    engines: {node: '>= 0.4'}
+
+  is-glob@4.0.3:
+    resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
+    engines: {node: '>=0.10.0'}
+
+  is-hexadecimal@2.0.1:
+    resolution: {integrity: sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg==}
+
+  is-in-ci@1.0.0:
+    resolution: {integrity: sha512-eUuAjybVTHMYWm/U+vBO1sY/JOCgoPCXRxzdju0K+K0BiGW0SChEL1MLC0PoCIR1OlPo5YAp8HuQoUlsWEICwg==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  is-ip@3.1.0:
+    resolution: {integrity: sha512-35vd5necO7IitFPjd/YBeqwWnyDWbuLH9ZXQdMfDA8TEo7pv5X8yfrvVO3xbJbLUlERCMvf6X0hTUamQxCYJ9Q==}
+    engines: {node: '>=8'}
+
+  is-map@2.0.3:
+    resolution: {integrity: sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==}
+    engines: {node: '>= 0.4'}
+
+  is-number-object@1.1.1:
+    resolution: {integrity: sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==}
+    engines: {node: '>= 0.4'}
+
+  is-number@7.0.0:
+    resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
+    engines: {node: '>=0.12.0'}
+
+  is-online@10.0.0:
+    resolution: {integrity: sha512-WCPdKwNDjXJJmUubf2VHLMDBkUZEtuOvpXUfUnUFbEnM6In9ByiScL4f4jKACz/fsb2qDkesFerW3snf/AYz3A==}
+    engines: {node: '>=14.16'}
+
+  is-plain-obj@4.1.0:
+    resolution: {integrity: sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==}
+    engines: {node: '>=12'}
+
+  is-potential-custom-element-name@1.0.1:
+    resolution: {integrity: sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==}
+
+  is-promise@4.0.0:
+    resolution: {integrity: sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==}
+
+  is-regex@1.2.1:
+    resolution: {integrity: sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==}
+    engines: {node: '>= 0.4'}
+
+  is-set@2.0.3:
+    resolution: {integrity: sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==}
+    engines: {node: '>= 0.4'}
+
+  is-shared-array-buffer@1.0.4:
+    resolution: {integrity: sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==}
+    engines: {node: '>= 0.4'}
+
+  is-stream@2.0.1:
+    resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==}
+    engines: {node: '>=8'}
+
+  is-stream@3.0.0:
+    resolution: {integrity: sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  is-string@1.1.1:
+    resolution: {integrity: sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==}
+    engines: {node: '>= 0.4'}
+
+  is-subdir@1.2.0:
+    resolution: {integrity: sha512-2AT6j+gXe/1ueqbW6fLZJiIw3F8iXGJtt0yDrZaBhAZEG1raiTxKWU+IPqMCzQAXOUCKdA4UDMgacKH25XG2Cw==}
+    engines: {node: '>=4'}
+
+  is-symbol@1.1.1:
+    resolution: {integrity: sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==}
+    engines: {node: '>= 0.4'}
+
+  is-typed-array@1.1.15:
+    resolution: {integrity: sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==}
+    engines: {node: '>= 0.4'}
+
+  is-weakmap@2.0.2:
+    resolution: {integrity: sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==}
+    engines: {node: '>= 0.4'}
+
+  is-weakref@1.1.1:
+    resolution: {integrity: sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==}
+    engines: {node: '>= 0.4'}
+
+  is-weakset@2.0.4:
+    resolution: {integrity: sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==}
+    engines: {node: '>= 0.4'}
+
+  is-windows@1.0.2:
+    resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==}
+    engines: {node: '>=0.10.0'}
+
+  is-wsl@2.2.0:
+    resolution: {integrity: sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==}
+    engines: {node: '>=8'}
+
+  isarray@2.0.5:
+    resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==}
+
+  isexe@2.0.0:
+    resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
+
+  istanbul-lib-coverage@3.2.2:
+    resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==}
+    engines: {node: '>=8'}
+
+  istanbul-lib-report@3.0.1:
+    resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==}
+    engines: {node: '>=10'}
+
+  istanbul-reports@3.2.0:
+    resolution: {integrity: sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==}
+    engines: {node: '>=8'}
+
+  jackspeak@3.4.3:
+    resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==}
+
+  jackspeak@4.1.1:
+    resolution: {integrity: sha512-zptv57P3GpL+O0I7VdMJNBZCu+BPHVQUk55Ft8/QCJjTVxrnJHuVuX/0Bl2A6/+2oyR/ZMEuFKwmzqqZ/U5nPQ==}
+    engines: {node: 20 || >=22}
+
+  jiti@1.21.7:
+    resolution: {integrity: sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==}
+    hasBin: true
+
+  joycon@3.1.1:
+    resolution: {integrity: sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==}
+    engines: {node: '>=10'}
+
+  js-tiktoken@1.0.20:
+    resolution: {integrity: sha512-Xlaqhhs8VfCd6Sh7a1cFkZHQbYTLCwVJJWiHVxBYzLPxW0XsoxBy1hitmjkdIjD3Aon5BXLHFwU5O8WUx6HH+A==}
+
+  js-tokens@10.0.0:
+    resolution: {integrity: sha512-lM/UBzQmfJRo9ABXbPWemivdCW8V2G8FHaHdypQaIy523snUjog0W71ayWXTjiR+ixeMyVHN2XcpnTd/liPg/Q==}
+
+  js-tokens@4.0.0:
+    resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
+
+  js-tokens@9.0.1:
+    resolution: {integrity: sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==}
+
+  js-yaml@3.14.1:
+    resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==}
+    hasBin: true
+
+  js-yaml@4.1.0:
+    resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==}
+    hasBin: true
+
+  js-yaml@4.1.1:
+    resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==}
+    hasBin: true
+
+  jsbn@1.1.0:
+    resolution: {integrity: sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==}
+
+  jsdom@24.1.3:
+    resolution: {integrity: sha512-MyL55p3Ut3cXbeBEG7Hcv0mVM8pp8PBNWxRqchZnSfAiES1v1mRnMeFfaHWIPULpwsYfvO+ZmMZz5tGCnjzDUQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      canvas: ^2.11.2
+    peerDependenciesMeta:
+      canvas:
+        optional: true
+
+  jsep@1.4.0:
+    resolution: {integrity: sha512-B7qPcEVE3NVkmSJbaYxvv4cHkVW7DQsZz13pUMrfS8z8Q/BuShN+gcTXrUlPiGqM2/t/EEaI030bpxMqY8gMlw==}
+    engines: {node: '>= 10.16.0'}
+
+  json-bigint@1.0.0:
+    resolution: {integrity: sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==}
+
+  json-buffer@3.0.1:
+    resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==}
+
+  json-parse-even-better-errors@2.3.1:
+    resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==}
+
+  json-schema-ref-resolver@3.0.0:
+    resolution: {integrity: sha512-hOrZIVL5jyYFjzk7+y7n5JDzGlU8rfWDuYyHwGa2WA8/pcmMHezp2xsVwxrebD/Q9t8Nc5DboieySDpCp4WG4A==}
+
+  json-schema-resolver@3.0.0:
+    resolution: {integrity: sha512-HqMnbz0tz2DaEJ3ntsqtx3ezzZyDE7G56A/pPY/NGmrPu76UzsWquOpHFRAf5beTNXoH2LU5cQePVvRli1nchA==}
+    engines: {node: '>=20'}
+
+  json-schema-traverse@0.4.1:
+    resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==}
+
+  json-schema-traverse@1.0.0:
+    resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==}
+
+  json-schema@0.4.0:
+    resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==}
+
+  json-stable-stringify-without-jsonify@1.0.1:
+    resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==}
+
+  jsonc-parser@2.2.1:
+    resolution: {integrity: sha512-o6/yDBYccGvTz1+QFevz6l6OBZ2+fMVu2JZ9CIhzsYRX4mjaK5IyX9eldUdCmga16zlgQxyrj5pt9kzuj2C02w==}
+
+  jsonfile@4.0.0:
+    resolution: {integrity: sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==}
+
+  jsonfile@6.1.0:
+    resolution: {integrity: sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==}
+
+  jsonpath-plus@10.3.0:
+    resolution: {integrity: sha512-8TNmfeTCk2Le33A3vRRwtuworG/L5RrgMvdjhKZxvyShO+mBu2fP50OWUjRLNtvw344DdDarFh9buFAZs5ujeA==}
+    engines: {node: '>=18.0.0'}
+    hasBin: true
+
+  jsonpointer@5.0.1:
+    resolution: {integrity: sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==}
+    engines: {node: '>=0.10.0'}
+
+  junit-to-ctrf@0.0.14:
+    resolution: {integrity: sha512-gVrJaMKhE2tKuHh9Of/Le1Y6s6U8aZy9HUapW+IjbltyvomsGBoabv0Ul7xfTlZshYCYGbwx6OWFNm2Q66EaHA==}
+    engines: {node: '>=20.0.0'}
+    hasBin: true
+
+  jwa@2.0.1:
+    resolution: {integrity: sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==}
+
+  jws@4.0.0:
+    resolution: {integrity: sha512-KDncfTmOZoOMTFG4mBlG0qUIOlc03fmzH+ru6RgYVZhPkyiy/92Owlt/8UEN+a4TXR1FQetfIpJE8ApdvdVxTg==}
+
+  katex@0.16.22:
+    resolution: {integrity: sha512-XCHRdUw4lf3SKBaJe4EvgqIuWwkPSo9XoeO8GjQW94Bp7TWv9hNhzZjZ+OH9yf1UmLygb7DIT5GSFQiyt16zYg==}
+    hasBin: true
+
+  keyv@4.5.4:
+    resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
+
+  kind-of@6.0.3:
+    resolution: {integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==}
+    engines: {node: '>=0.10.0'}
+
+  langsmith@0.3.23:
+    resolution: {integrity: sha512-6gfotO1YS3vqznSJutdFmJXL2Vxy27/RV2JA7YTsfWoJtxlmBR/1QE7kMIyEvuoEE5KGFHyZMuAh/fVeiRffLA==}
+    peerDependencies:
+      openai: '*'
+    peerDependenciesMeta:
+      openai:
+        optional: true
+
+  lcm@0.0.3:
+    resolution: {integrity: sha512-TB+ZjoillV6B26Vspf9l2L/vKaRY/4ep3hahcyVkCGFgsTNRUQdc24bQeNFiZeoxH0vr5+7SfNRMQuPHv/1IrQ==}
+
+  leven@3.1.0:
+    resolution: {integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==}
+    engines: {node: '>=6'}
+
+  leven@4.0.0:
+    resolution: {integrity: sha512-puehA3YKku3osqPlNuzGDUHq8WpwXupUg1V6NXdV38G+gr+gkBwFC8g1b/+YcIvp8gnqVIus+eJCH/eGsRmJNw==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  levn@0.4.1:
+    resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
+    engines: {node: '>= 0.8.0'}
+
+  light-my-request@6.6.0:
+    resolution: {integrity: sha512-CHYbu8RtboSIoVsHZ6Ye4cj4Aw/yg2oAFimlF7mNvfDV192LR7nDiKtSIfCuLT7KokPSTn/9kfVLm5OGN0A28A==}
+
+  lighthouse-logger@2.0.2:
+    resolution: {integrity: sha512-vWl2+u5jgOQuZR55Z1WM0XDdrJT6mzMP8zHUct7xTlWhuQs+eV0g+QL0RQdFjT54zVmbhLCP8vIVpy1wGn/gCg==}
+
+  lilconfig@3.1.3:
+    resolution: {integrity: sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==}
+    engines: {node: '>=14'}
+
+  lines-and-columns@1.2.4:
+    resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
+
+  load-tsconfig@0.2.5:
+    resolution: {integrity: sha512-IXO6OCs9yg8tMKzfPZ1YmheJbZCiEsnBdcB03l0OcfK9prKnJb96siuHCr5Fl37/yo9DnKU+TLpxzTUspw9shg==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  local-pkg@0.5.1:
+    resolution: {integrity: sha512-9rrA30MRRP3gBD3HTGnC6cDFpaE1kVDWxWgqWJUN0RvDNAo+Nz/9GxB+nHOH0ifbVFy0hSA1V6vFDvnx54lTEQ==}
+    engines: {node: '>=14'}
+
+  locate-path@5.0.0:
+    resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==}
+    engines: {node: '>=8'}
+
+  locate-path@6.0.0:
+    resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==}
+    engines: {node: '>=10'}
+
+  lodash.merge@4.6.2:
+    resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==}
+
+  lodash.startcase@4.4.0:
+    resolution: {integrity: sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==}
+
+  lodash.topath@4.5.2:
+    resolution: {integrity: sha512-1/W4dM+35DwvE/iEd1M9ekewOSTlpFekhw9mhAtrwjVqUr83/ilQiyAvmg4tVX7Unkcfl1KC+i9WdaT4B6aQcg==}
+
+  lodash@4.17.21:
+    resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==}
+
+  longest-streak@3.1.0:
+    resolution: {integrity: sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==}
+
+  loose-envify@1.4.0:
+    resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==}
+    hasBin: true
+
+  loupe@2.3.7:
+    resolution: {integrity: sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==}
+
+  lowercase-keys@3.0.0:
+    resolution: {integrity: sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  lru-cache@10.4.3:
+    resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
+
+  lru-cache@11.2.4:
+    resolution: {integrity: sha512-B5Y16Jr9LB9dHVkh6ZevG+vAbOsNOYCX+sXvFWFu7B3Iz5mijW3zdbMyhsh8ANd2mSWBYdJgnqi+mL7/LrOPYg==}
+    engines: {node: 20 || >=22}
+
+  lru-cache@7.18.3:
+    resolution: {integrity: sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==}
+    engines: {node: '>=12'}
+
+  magic-string@0.30.21:
+    resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
+
+  magicast@0.5.2:
+    resolution: {integrity: sha512-E3ZJh4J3S9KfwdjZhe2afj6R9lGIN5Pher1pF39UGrXRqq/VDaGVIGN13BjHd2u8B61hArAGOnso7nBOouW3TQ==}
+
+  make-dir@4.0.0:
+    resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==}
+    engines: {node: '>=10'}
+
+  markdown-extensions@2.0.0:
+    resolution: {integrity: sha512-o5vL7aDWatOTX8LzaS1WMoaoxIiLRQJuIKKe2wAw6IeULDHaqbiqiggmx+pKvZDb1Sj+pE46Sn1T7lCqfFtg1Q==}
+    engines: {node: '>=16'}
+
+  markdown-table@3.0.4:
+    resolution: {integrity: sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw==}
+
+  marky@1.3.0:
+    resolution: {integrity: sha512-ocnPZQLNpvbedwTy9kNrQEsknEfgvcLMvOtz3sFeWApDq1MXH1TqkCIx58xlpESsfwQOnuBO9beyQuNGzVvuhQ==}
+
+  math-intrinsics@1.1.0:
+    resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}
+    engines: {node: '>= 0.4'}
+
+  mdast-util-find-and-replace@3.0.2:
+    resolution: {integrity: sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg==}
+
+  mdast-util-from-markdown@2.0.2:
+    resolution: {integrity: sha512-uZhTV/8NBuw0WHkPTrCqDOl0zVe1BIng5ZtHoDk49ME1qqcjYmmLmOf0gELgcRMxN4w2iuIeVso5/6QymSrgmA==}
+
+  mdast-util-frontmatter@2.0.1:
+    resolution: {integrity: sha512-LRqI9+wdgC25P0URIJY9vwocIzCcksduHQ9OF2joxQoyTNVduwLAFUzjoopuRJbJAReaKrNQKAZKL3uCMugWJA==}
+
+  mdast-util-gfm-autolink-literal@2.0.1:
+    resolution: {integrity: sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ==}
+
+  mdast-util-gfm-footnote@2.1.0:
+    resolution: {integrity: sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ==}
+
+  mdast-util-gfm-strikethrough@2.0.0:
+    resolution: {integrity: sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg==}
+
+  mdast-util-gfm-table@2.0.0:
+    resolution: {integrity: sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg==}
+
+  mdast-util-gfm-task-list-item@2.0.0:
+    resolution: {integrity: sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ==}
+
+  mdast-util-gfm@3.1.0:
+    resolution: {integrity: sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==}
+
+  mdast-util-math@3.0.0:
+    resolution: {integrity: sha512-Tl9GBNeG/AhJnQM221bJR2HPvLOSnLE/T9cJI9tlc6zwQk2nPk/4f0cHkOdEixQPC/j8UtKDdITswvLAy1OZ1w==}
+
+  mdast-util-mdx-expression@2.0.1:
+    resolution: {integrity: sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==}
+
+  mdast-util-mdx-jsx@3.2.0:
+    resolution: {integrity: sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==}
+
+  mdast-util-mdx@3.0.0:
+    resolution: {integrity: sha512-JfbYLAW7XnYTTbUsmpu0kdBUVe+yKVJZBItEjwyYJiDJuZ9w4eeaqks4HQO+R7objWgS2ymV60GYpI14Ug554w==}
+
+  mdast-util-mdxjs-esm@2.0.1:
+    resolution: {integrity: sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg==}
+
+  mdast-util-phrasing@4.1.0:
+    resolution: {integrity: sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==}
+
+  mdast-util-to-hast@13.2.0:
+    resolution: {integrity: sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA==}
+
+  mdast-util-to-markdown@2.1.2:
+    resolution: {integrity: sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==}
+
+  mdast-util-to-string@4.0.0:
+    resolution: {integrity: sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==}
+
+  mdast@3.0.0:
+    resolution: {integrity: sha512-xySmf8g4fPKMeC07jXGz971EkLbWAJ83s4US2Tj9lEdnZ142UP5grN73H1Xd3HzrdbU5o9GYYP/y8F9ZSwLE9g==}
+    deprecated: '`mdast` was renamed to `remark`'
+
+  media-typer@0.3.0:
+    resolution: {integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==}
+    engines: {node: '>= 0.6'}
+
+  media-typer@1.1.0:
+    resolution: {integrity: sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==}
+    engines: {node: '>= 0.8'}
+
+  merge-descriptors@1.0.3:
+    resolution: {integrity: sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==}
+
+  merge-descriptors@2.0.0:
+    resolution: {integrity: sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==}
+    engines: {node: '>=18'}
+
+  merge-stream@2.0.0:
+    resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==}
+
+  merge2@1.4.1:
+    resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
+    engines: {node: '>= 8'}
+
+  methods@1.1.2:
+    resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==}
+    engines: {node: '>= 0.6'}
+
+  micromark-core-commonmark@2.0.3:
+    resolution: {integrity: sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==}
+
+  micromark-extension-frontmatter@2.0.0:
+    resolution: {integrity: sha512-C4AkuM3dA58cgZha7zVnuVxBhDsbttIMiytjgsM2XbHAB2faRVaHRle40558FBN+DJcrLNCoqG5mlrpdU4cRtg==}
+
+  micromark-extension-gfm-autolink-literal@2.1.0:
+    resolution: {integrity: sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw==}
+
+  micromark-extension-gfm-footnote@2.1.0:
+    resolution: {integrity: sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw==}
+
+  micromark-extension-gfm-strikethrough@2.1.0:
+    resolution: {integrity: sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw==}
+
+  micromark-extension-gfm-table@2.1.1:
+    resolution: {integrity: sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg==}
+
+  micromark-extension-gfm-tagfilter@2.0.0:
+    resolution: {integrity: sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg==}
+
+  micromark-extension-gfm-task-list-item@2.1.0:
+    resolution: {integrity: sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw==}
+
+  micromark-extension-gfm@3.0.0:
+    resolution: {integrity: sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w==}
+
+  micromark-extension-math@3.1.0:
+    resolution: {integrity: sha512-lvEqd+fHjATVs+2v/8kg9i5Q0AP2k85H0WUOwpIVvUML8BapsMvh1XAogmQjOCsLpoKRCVQqEkQBB3NhVBcsOg==}
+
+  micromark-extension-mdx-expression@3.0.1:
+    resolution: {integrity: sha512-dD/ADLJ1AeMvSAKBwO22zG22N4ybhe7kFIZ3LsDI0GlsNr2A3KYxb0LdC1u5rj4Nw+CHKY0RVdnHX8vj8ejm4Q==}
+
+  micromark-extension-mdx-jsx@3.0.2:
+    resolution: {integrity: sha512-e5+q1DjMh62LZAJOnDraSSbDMvGJ8x3cbjygy2qFEi7HCeUT4BDKCvMozPozcD6WmOt6sVvYDNBKhFSz3kjOVQ==}
+
+  micromark-extension-mdx-md@2.0.0:
+    resolution: {integrity: sha512-EpAiszsB3blw4Rpba7xTOUptcFeBFi+6PY8VnJ2hhimH+vCQDirWgsMpz7w1XcZE7LVrSAUGb9VJpG9ghlYvYQ==}
+
+  micromark-extension-mdxjs-esm@3.0.0:
+    resolution: {integrity: sha512-DJFl4ZqkErRpq/dAPyeWp15tGrcrrJho1hKK5uBS70BCtfrIFg81sqcTVu3Ta+KD1Tk5vAtBNElWxtAa+m8K9A==}
+
+  micromark-extension-mdxjs@3.0.0:
+    resolution: {integrity: sha512-A873fJfhnJ2siZyUrJ31l34Uqwy4xIFmvPY1oj+Ean5PHcPBYzEsvqvWGaWcfEIr11O5Dlw3p2y0tZWpKHDejQ==}
+
+  micromark-factory-destination@2.0.1:
+    resolution: {integrity: sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==}
+
+  micromark-factory-label@2.0.1:
+    resolution: {integrity: sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==}
+
+  micromark-factory-mdx-expression@2.0.3:
+    resolution: {integrity: sha512-kQnEtA3vzucU2BkrIa8/VaSAsP+EJ3CKOvhMuJgOEGg9KDC6OAY6nSnNDVRiVNRqj7Y4SlSzcStaH/5jge8JdQ==}
+
+  micromark-factory-space@2.0.1:
+    resolution: {integrity: sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==}
+
+  micromark-factory-title@2.0.1:
+    resolution: {integrity: sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==}
+
+  micromark-factory-whitespace@2.0.1:
+    resolution: {integrity: sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==}
+
+  micromark-util-character@2.1.1:
+    resolution: {integrity: sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==}
+
+  micromark-util-chunked@2.0.1:
+    resolution: {integrity: sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==}
+
+  micromark-util-classify-character@2.0.1:
+    resolution: {integrity: sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==}
+
+  micromark-util-combine-extensions@2.0.1:
+    resolution: {integrity: sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==}
+
+  micromark-util-decode-numeric-character-reference@2.0.2:
+    resolution: {integrity: sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==}
+
+  micromark-util-decode-string@2.0.1:
+    resolution: {integrity: sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==}
+
+  micromark-util-encode@2.0.1:
+    resolution: {integrity: sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==}
+
+  micromark-util-events-to-acorn@2.0.3:
+    resolution: {integrity: sha512-jmsiEIiZ1n7X1Rr5k8wVExBQCg5jy4UXVADItHmNk1zkwEVhBuIUKRu3fqv+hs4nxLISi2DQGlqIOGiFxgbfHg==}
+
+  micromark-util-html-tag-name@2.0.1:
+    resolution: {integrity: sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA==}
+
+  micromark-util-normalize-identifier@2.0.1:
+    resolution: {integrity: sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==}
+
+  micromark-util-resolve-all@2.0.1:
+    resolution: {integrity: sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==}
+
+  micromark-util-sanitize-uri@2.0.1:
+    resolution: {integrity: sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==}
+
+  micromark-util-subtokenize@2.1.0:
+    resolution: {integrity: sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA==}
+
+  micromark-util-symbol@2.0.1:
+    resolution: {integrity: sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==}
+
+  micromark-util-types@2.0.2:
+    resolution: {integrity: sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==}
+
+  micromark@4.0.2:
+    resolution: {integrity: sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA==}
+
+  micromatch@4.0.8:
+    resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
+    engines: {node: '>=8.6'}
+
+  mime-db@1.52.0:
+    resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==}
+    engines: {node: '>= 0.6'}
+
+  mime-db@1.54.0:
+    resolution: {integrity: sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==}
+    engines: {node: '>= 0.6'}
+
+  mime-types@2.1.35:
+    resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==}
+    engines: {node: '>= 0.6'}
+
+  mime-types@3.0.1:
+    resolution: {integrity: sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA==}
+    engines: {node: '>= 0.6'}
+
+  mime@1.6.0:
+    resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==}
+    engines: {node: '>=4'}
+    hasBin: true
+
+  mime@3.0.0:
+    resolution: {integrity: sha512-jSCU7/VB1loIWBZe14aEYHU/+1UMEHoaO7qxCOVJOw9GgH72VAWppxNcjU+x9a2k3GSIBXNKxXQFqRvvZ7vr3A==}
+    engines: {node: '>=10.0.0'}
+    hasBin: true
+
+  mimic-fn@2.1.0:
+    resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==}
+    engines: {node: '>=6'}
+
+  mimic-fn@4.0.0:
+    resolution: {integrity: sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==}
+    engines: {node: '>=12'}
+
+  mimic-response@3.1.0:
+    resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==}
+    engines: {node: '>=10'}
+
+  mimic-response@4.0.0:
+    resolution: {integrity: sha512-e5ISH9xMYU0DzrT+jl8q2ze9D6eWBto+I8CNpe+VI+K2J/F/k3PdkdTdz4wvGVH4NTpo+NRYTVIuMQEMMcsLqg==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  minimatch@10.1.1:
+    resolution: {integrity: sha512-enIvLvRAFZYXJzkCYG5RKmPfrFArdLv+R+lbQ53BmIMLIry74bjKzX6iHAm8WYamJkhSSEabrWN5D97XnKObjQ==}
+    engines: {node: 20 || >=22}
+
+  minimatch@10.2.2:
+    resolution: {integrity: sha512-+G4CpNBxa5MprY+04MbgOw1v7So6n5JY166pFi9KfYwT78fxScCeSNQSNzp6dpPSW2rONOps6Ocam1wFhCgoVw==}
+    engines: {node: 18 || 20 || >=22}
+
+  minimatch@3.1.2:
+    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
+
+  minimatch@3.1.5:
+    resolution: {integrity: sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==}
+
+  minimatch@9.0.5:
+    resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==}
+    engines: {node: '>=16 || 14 >=14.17'}
+
+  minimist@1.2.8:
+    resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==}
+
+  minipass@3.3.6:
+    resolution: {integrity: sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==}
+    engines: {node: '>=8'}
+
+  minipass@5.0.0:
+    resolution: {integrity: sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==}
+    engines: {node: '>=8'}
+
+  minipass@7.1.2:
+    resolution: {integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==}
+    engines: {node: '>=16 || 14 >=14.17'}
+
+  minizlib@2.1.2:
+    resolution: {integrity: sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==}
+    engines: {node: '>= 8'}
+
+  mintlify@4.2.78:
+    resolution: {integrity: sha512-g3naXSI7RsmxUNJ87mKzRefKaMdqbAhxfaPaMkApwmeDB0TROwwUO0CS6ZDsbV5Qq3Sm5kH4mEDieEpAE6JG8A==}
+    engines: {node: '>=18.0.0'}
+    deprecated: This version is deprecated. Please upgrade to version 4.0.423 or later.
+    hasBin: true
+
+  mitt@3.0.1:
+    resolution: {integrity: sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==}
+
+  mkdirp@1.0.4:
+    resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  mlly@1.8.1:
+    resolution: {integrity: sha512-SnL6sNutTwRWWR/vcmCYHSADjiEesp5TGQQ0pXyLhW5IoeibRlF/CbSLailbB3CNqJUk9cVJ9dUDnbD7GrcHBQ==}
+
+  mri@1.2.0:
+    resolution: {integrity: sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==}
+    engines: {node: '>=4'}
+
+  ms@2.0.0:
+    resolution: {integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==}
+
+  ms@2.1.3:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+
+  mustache@4.2.0:
+    resolution: {integrity: sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==}
+    hasBin: true
+
+  mute-stream@2.0.0:
+    resolution: {integrity: sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA==}
+    engines: {node: ^18.17.0 || >=20.5.0}
+
+  mylas@2.1.14:
+    resolution: {integrity: sha512-BzQguy9W9NJgoVn2mRWzbFrFWWztGCcng2QI9+41frfk+Athwgx3qhqhvStz7ExeUUu7Kzw427sNzHpEZNINog==}
+    engines: {node: '>=16.0.0'}
+
+  mz@2.7.0:
+    resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==}
+
+  nanoid@3.3.11:
+    resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+
+  natural-compare@1.4.0:
+    resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==}
+
+  negotiator@0.6.3:
+    resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==}
+    engines: {node: '>= 0.6'}
+
+  negotiator@1.0.0:
+    resolution: {integrity: sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==}
+    engines: {node: '>= 0.6'}
+
+  neotraverse@0.6.18:
+    resolution: {integrity: sha512-Z4SmBUweYa09+o6pG+eASabEpP6QkQ70yHj351pQoEXIs8uHbaU2DWVmzBANKgflPa47A50PtB2+NgRpQvr7vA==}
+    engines: {node: '>= 10'}
+
+  netmask@2.0.2:
+    resolution: {integrity: sha512-dBpDMdxv9Irdq66304OLfEmQ9tbNRFnFTuZiLo+bD+r332bBmMJ8GBLXklIXXgxd3+v9+KUnZaUR5PJMa75Gsg==}
+    engines: {node: '>= 0.4.0'}
+
+  next-mdx-remote-client@1.1.1:
+    resolution: {integrity: sha512-cJnJGaRiHc1gn4aCzDmY9zmcCjEw+zMCpCYIy45Kjs8HzeQpdGcaO5GrgIcX/DFkuCVrrzc69wi2gGnExXbv/A==}
+    engines: {node: '>=18.18.0'}
+    peerDependencies:
+      react: '>= 18.3.0 < 19.0.0'
+      react-dom: '>= 18.3.0 < 19.0.0'
+
+  nimma@0.2.3:
+    resolution: {integrity: sha512-1ZOI8J+1PKKGceo/5CT5GfQOG6H8I2BencSK06YarZ2wXwH37BSSUWldqJmMJYA5JfqDqffxDXynt6f11AyKcA==}
+    engines: {node: ^12.20 || >=14.13}
+
+  nlcst-to-string@4.0.0:
+    resolution: {integrity: sha512-YKLBCcUYKAg0FNlOBT6aI91qFmSiFKiluk655WzPF+DDMA02qIyy8uiRqI8QXtcFpEvll12LpL5MXqEmAZ+dcA==}
+
+  node-domexception@1.0.0:
+    resolution: {integrity: sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==}
+    engines: {node: '>=10.5.0'}
+    deprecated: Use your platform's native DOMException instead
+
+  node-fetch@2.6.7:
+    resolution: {integrity: sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==}
+    engines: {node: 4.x || >=6.0.0}
+    peerDependencies:
+      encoding: ^0.1.0
+    peerDependenciesMeta:
+      encoding:
+        optional: true
+
+  node-fetch@2.7.0:
+    resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==}
+    engines: {node: 4.x || >=6.0.0}
+    peerDependencies:
+      encoding: ^0.1.0
+    peerDependenciesMeta:
+      encoding:
+        optional: true
+
+  node-fetch@3.3.2:
+    resolution: {integrity: sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  node-gyp-build@4.8.4:
+    resolution: {integrity: sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==}
+    hasBin: true
+
+  normalize-path@3.0.0:
+    resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
+    engines: {node: '>=0.10.0'}
+
+  normalize-url@8.0.1:
+    resolution: {integrity: sha512-IO9QvjUMWxPQQhs60oOu10CRkWCiZzSUkzbXGGV9pviYl1fXYcvkzQ5jV9z8Y6un8ARoVRl4EtC6v6jNqbaJ/w==}
+    engines: {node: '>=14.16'}
+
+  npm-run-path@5.3.0:
+    resolution: {integrity: sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  nwsapi@2.2.23:
+    resolution: {integrity: sha512-7wfH4sLbt4M0gCDzGE6vzQBo0bfTKjU7Sfpqy/7gs1qBfYz2vEJH6vXcBKpO3+6Yu1telwd0t9HpyOoLEQQbIQ==}
+
+  object-assign@4.1.1:
+    resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==}
+    engines: {node: '>=0.10.0'}
+
+  object-hash@3.0.0:
+    resolution: {integrity: sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==}
+    engines: {node: '>= 6'}
+
+  object-inspect@1.13.4:
+    resolution: {integrity: sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==}
+    engines: {node: '>= 0.4'}
+
+  object-keys@1.1.1:
+    resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==}
+    engines: {node: '>= 0.4'}
+
+  object.assign@4.1.7:
+    resolution: {integrity: sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==}
+    engines: {node: '>= 0.4'}
+
+  obug@2.1.1:
+    resolution: {integrity: sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==}
+
+  ollama-ai-provider-v2@1.5.0:
+    resolution: {integrity: sha512-o8nR80AaENpetYdCtlnZGEwO47N6Z6eEsBetitrh4nTXrbfWdRF4OWE5p5oHyo0R8sxg4zdxUsjmGVzPd3zBUQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^4.0.16
+
+  on-exit-leak-free@2.1.2:
+    resolution: {integrity: sha512-0eJJY6hXLGf1udHwfNftBqH+g73EU4B504nZeKpz1sYRKafAghwxEJunB2O7rDZkL4PGfsMVnTXZ2EjibbqcsA==}
+    engines: {node: '>=14.0.0'}
+
+  on-finished@2.4.1:
+    resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==}
+    engines: {node: '>= 0.8'}
+
+  once@1.4.0:
+    resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
+
+  onetime@5.1.2:
+    resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==}
+    engines: {node: '>=6'}
+
+  onetime@6.0.0:
+    resolution: {integrity: sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==}
+    engines: {node: '>=12'}
+
+  oniguruma-parser@0.12.1:
+    resolution: {integrity: sha512-8Unqkvk1RYc6yq2WBYRj4hdnsAxVze8i7iPfQr8e4uSP3tRv0rpZcbGUDvxfQQcdwHt/e9PrMvGCsa8OqG9X3w==}
+
+  oniguruma-to-es@4.3.3:
+    resolution: {integrity: sha512-rPiZhzC3wXwE59YQMRDodUwwT9FZ9nNBwQQfsd1wfdtlKEyCdRV0avrTcSZ5xlIvGRVPd/cx6ZN45ECmS39xvg==}
+
+  open@8.4.2:
+    resolution: {integrity: sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==}
+    engines: {node: '>=12'}
+
+  openai@4.87.1:
+    resolution: {integrity: sha512-mwZ4N4KKGUE5JSTR4IdQZzuxFyStJFqSR62JuWob7ka286tbFacYkOf+Ypk/2IPAUCmhzft5C3UqzcFYaliVMA==}
+    hasBin: true
+    peerDependencies:
+      ws: ^8.18.0
+      zod: ^3.23.8
+    peerDependenciesMeta:
+      ws:
+        optional: true
+      zod:
+        optional: true
+
+  openai@4.96.2:
+    resolution: {integrity: sha512-R2XnxvMsizkROr7BV3uNp1q/3skwPZ7fmPjO1bXLnfB4Tu5xKxrT1EVwzjhxn0MZKBKAvOaGWS63jTMN6KrIXA==}
+    hasBin: true
+    peerDependencies:
+      ws: ^8.18.0
+      zod: ^3.23.8
+    peerDependenciesMeta:
+      ws:
+        optional: true
+      zod:
+        optional: true
+
+  openapi-types@12.1.3:
+    resolution: {integrity: sha512-N4YtSYJqghVu4iek2ZUvcN/0aqH1kRDuNqzcycDxhOUpg7GdvLa2F3DgS6yBNhInhv2r/6I0Flkn7CqL8+nIcw==}
+
+  optionator@0.9.4:
+    resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==}
+    engines: {node: '>= 0.8.0'}
+
+  os-tmpdir@1.0.2:
+    resolution: {integrity: sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==}
+    engines: {node: '>=0.10.0'}
+
+  outdent@0.5.0:
+    resolution: {integrity: sha512-/jHxFIzoMXdqPzTaCpFzAAWhpkSjZPF4Vsn6jAfNpmbH/ymsmd7Qc6VE9BGn0L6YMj6uwpQLxCECpus4ukKS9Q==}
+
+  own-keys@1.0.1:
+    resolution: {integrity: sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==}
+    engines: {node: '>= 0.4'}
+
+  p-any@4.0.0:
+    resolution: {integrity: sha512-S/B50s+pAVe0wmEZHmBs/9yJXeZ5KhHzOsgKzt0hRdgkoR3DxW9ts46fcsWi/r3VnzsnkKS7q4uimze+zjdryw==}
+    engines: {node: '>=12.20'}
+
+  p-cancelable@3.0.0:
+    resolution: {integrity: sha512-mlVgR3PGuzlo0MmTdk4cXqXWlwQDLnONTAg6sm62XkMJEiRxN3GL3SffkYvqwonbkJBcrI7Uvv5Zh9yjvn2iUw==}
+    engines: {node: '>=12.20'}
+
+  p-filter@2.1.0:
+    resolution: {integrity: sha512-ZBxxZ5sL2HghephhpGAQdoskxplTwr7ICaehZwLIlfL6acuVgZPm8yBNuRAFBGEqtD/hmUeq9eqLg2ys9Xr/yw==}
+    engines: {node: '>=8'}
+
+  p-finally@1.0.0:
+    resolution: {integrity: sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==}
+    engines: {node: '>=4'}
+
+  p-limit@2.3.0:
+    resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==}
+    engines: {node: '>=6'}
+
+  p-limit@3.1.0:
+    resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==}
+    engines: {node: '>=10'}
+
+  p-limit@5.0.0:
+    resolution: {integrity: sha512-/Eaoq+QyLSiXQ4lyYV23f14mZRQcXnxfHrN0vCai+ak9G0pp9iEQukIIZq5NccEvwRB8PUnZT0KsOoDCINS1qQ==}
+    engines: {node: '>=18'}
+
+  p-locate@4.1.0:
+    resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==}
+    engines: {node: '>=8'}
+
+  p-locate@5.0.0:
+    resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==}
+    engines: {node: '>=10'}
+
+  p-map@2.1.0:
+    resolution: {integrity: sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw==}
+    engines: {node: '>=6'}
+
+  p-queue@6.6.2:
+    resolution: {integrity: sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==}
+    engines: {node: '>=8'}
+
+  p-retry@4.6.2:
+    resolution: {integrity: sha512-312Id396EbJdvRONlngUx0NydfrIQ5lsYu0znKVUzVvArzEIt08V1qhtyESbGVd1FGX7UKtiFp5uwKZdM8wIuQ==}
+    engines: {node: '>=8'}
+
+  p-some@6.0.0:
+    resolution: {integrity: sha512-CJbQCKdfSX3fIh8/QKgS+9rjm7OBNUTmwWswAFQAhc8j1NR1dsEDETUEuVUtQHZpV+J03LqWBEwvu0g1Yn+TYg==}
+    engines: {node: '>=12.20'}
+
+  p-timeout@3.2.0:
+    resolution: {integrity: sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==}
+    engines: {node: '>=8'}
+
+  p-timeout@5.1.0:
+    resolution: {integrity: sha512-auFDyzzzGZZZdHz3BtET9VEz0SE/uMEAx7uWfGPucfzEwwe/xH0iVeZibQmANYE/hp9T2+UUZT5m+BKyrDp3Ew==}
+    engines: {node: '>=12'}
+
+  p-try@2.2.0:
+    resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==}
+    engines: {node: '>=6'}
+
+  pac-proxy-agent@7.2.0:
+    resolution: {integrity: sha512-TEB8ESquiLMc0lV8vcd5Ql/JAKAoyzHFXaStwjkzpOpC5Yv+pIzLfHvjTSdf3vpa2bMiUQrg9i6276yn8666aA==}
+    engines: {node: '>= 14'}
+
+  pac-resolver@7.0.1:
+    resolution: {integrity: sha512-5NPgf87AT2STgwa2ntRMr45jTKrYBGkVU36yT0ig/n/GMAa3oPqhZfIQ2kMEimReg0+t9kZViDVZ83qfVUlckg==}
+    engines: {node: '>= 14'}
+
+  package-json-from-dist@1.0.1:
+    resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==}
+
+  package-manager-detector@0.2.11:
+    resolution: {integrity: sha512-BEnLolu+yuz22S56CU1SUKq3XC3PkwD5wv4ikR4MfGvnRVcmzXR9DwSlW2fEamyTPyXHomBJRzgapeuBvRNzJQ==}
+
+  parent-module@1.0.1:
+    resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
+    engines: {node: '>=6'}
+
+  parse-entities@4.0.2:
+    resolution: {integrity: sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw==}
+
+  parse-json@5.2.0:
+    resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==}
+    engines: {node: '>=8'}
+
+  parse-latin@7.0.0:
+    resolution: {integrity: sha512-mhHgobPPua5kZ98EF4HWiH167JWBfl4pvAIXXdbaVohtK7a6YBOy56kvhCqduqyo/f3yrHFWmqmiMg/BkBkYYQ==}
+
+  parse5@7.3.0:
+    resolution: {integrity: sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==}
+
+  parseurl@1.3.3:
+    resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==}
+    engines: {node: '>= 0.8'}
+
+  patch-console@2.0.0:
+    resolution: {integrity: sha512-0YNdUceMdaQwoKce1gatDScmMo5pu/tfABfnzEqeG0gtTmd7mh/WcwgUjtAeOU7N8nFFlbQBnFK2gXW5fGvmMA==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  patchright-core@1.55.2:
+    resolution: {integrity: sha512-mZEQkbW8fDUbI062VbP04bqK7E3qqxjI6MCOvPTRlD9R5s3vWYcERuXmP/zR7Es4nIX9DP4vEpvT9s8zao/A9w==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  path-exists@4.0.0:
+    resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==}
+    engines: {node: '>=8'}
+
+  path-key@3.1.1:
+    resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}
+    engines: {node: '>=8'}
+
+  path-key@4.0.0:
+    resolution: {integrity: sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==}
+    engines: {node: '>=12'}
+
+  path-parse@1.0.7:
+    resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==}
+
+  path-scurry@1.11.1:
+    resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==}
+    engines: {node: '>=16 || 14 >=14.18'}
+
+  path-scurry@2.0.1:
+    resolution: {integrity: sha512-oWyT4gICAu+kaA7QWk/jvCHWarMKNs6pXOGWKDTr7cw4IGcUbW+PeTfbaQiLGheFRpjo6O9J0PmyMfQPjH71oA==}
+    engines: {node: 20 || >=22}
+
+  path-to-regexp@0.1.12:
+    resolution: {integrity: sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==}
+
+  path-to-regexp@8.2.0:
+    resolution: {integrity: sha512-TdrF7fW9Rphjq4RjrW0Kp2AW0Ahwu9sRGTkS6bvDi0SCwZlEZYmcfDbEsTz8RVk0EHIS/Vd1bv3JhG+1xZuAyQ==}
+    engines: {node: '>=16'}
+
+  path-type@4.0.0:
+    resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==}
+    engines: {node: '>=8'}
+
+  pathe@1.1.2:
+    resolution: {integrity: sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==}
+
+  pathe@2.0.3:
+    resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==}
+
+  pathval@1.1.1:
+    resolution: {integrity: sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==}
+
+  pend@1.2.0:
+    resolution: {integrity: sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==}
+
+  picocolors@1.1.1:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+  picomatch@2.3.1:
+    resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
+    engines: {node: '>=8.6'}
+
+  picomatch@4.0.3:
+    resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
+    engines: {node: '>=12'}
+
+  pify@2.3.0:
+    resolution: {integrity: sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==}
+    engines: {node: '>=0.10.0'}
+
+  pify@4.0.1:
+    resolution: {integrity: sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==}
+    engines: {node: '>=6'}
+
+  pino-abstract-transport@2.0.0:
+    resolution: {integrity: sha512-F63x5tizV6WCh4R6RHyi2Ml+M70DNRXt/+HANowMflpgGFMAym/VKm6G7ZOQRjqN7XbGxK1Lg9t6ZrtzOaivMw==}
+
+  pino-pretty@11.3.0:
+    resolution: {integrity: sha512-oXwn7ICywaZPHmu3epHGU2oJX4nPmKvHvB/bwrJHlGcbEWaVcotkpyVHMKLKmiVryWYByNp0jpgAcXpFJDXJzA==}
+    hasBin: true
+
+  pino-pretty@13.0.0:
+    resolution: {integrity: sha512-cQBBIVG3YajgoUjo1FdKVRX6t9XPxwB9lcNJVD5GCnNM4Y6T12YYx8c6zEejxQsU0wrg9TwmDulcE9LR7qcJqA==}
+    hasBin: true
+
+  pino-std-serializers@7.0.0:
+    resolution: {integrity: sha512-e906FRY0+tV27iq4juKzSYPbUj2do2X2JX4EzSca1631EB2QJQUqGbDuERal7LCtOpxl6x3+nvo9NPZcmjkiFA==}
+
+  pino@10.1.0:
+    resolution: {integrity: sha512-0zZC2ygfdqvqK8zJIr1e+wT1T/L+LF6qvqvbzEQ6tiMAoTqEVK9a1K3YRu8HEUvGEvNqZyPJTtb2sNIoTkB83w==}
+    hasBin: true
+
+  pino@9.14.0:
+    resolution: {integrity: sha512-8OEwKp5juEvb/MjpIc4hjqfgCNysrS94RIOMXYvpYCdm/jglrKEiAYmiumbmGhCvs+IcInsphYDFwqrjr7398w==}
+    hasBin: true
+
+  pirates@4.0.7:
+    resolution: {integrity: sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==}
+    engines: {node: '>= 6'}
+
+  pkce-challenge@5.0.0:
+    resolution: {integrity: sha512-ueGLflrrnvwB3xuo/uGob5pd5FN7l0MsLf0Z87o/UQmRtwjvfylfc9MurIxRAWywCYTgrvpXBcqjV4OfCYGCIQ==}
+    engines: {node: '>=16.20.0'}
+
+  pkg-types@1.3.1:
+    resolution: {integrity: sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==}
+
+  playwright-core@1.52.0:
+    resolution: {integrity: sha512-l2osTgLXSMeuLZOML9qYODUQoPPnUsKsb5/P6LJ2e6uPKXUdPK5WYhN4z03G+YNbWmGDY4YENauNu4ZKczreHg==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  playwright-core@1.54.2:
+    resolution: {integrity: sha512-n5r4HFbMmWsB4twG7tJLDN9gmBUeSPcsBZiWSE4DnYz9mJMAFqr2ID7+eGC9kpEnxExJ1epttwR59LEWCk8mtA==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  playwright@1.52.0:
+    resolution: {integrity: sha512-JAwMNMBlxJ2oD1kce4KPtMkDeKGHQstdpFPcPH3maElAXon/QZeTvtsfXmTMRyO9TslfoYOXkSsvao2nE1ilTw==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  playwright@1.54.2:
+    resolution: {integrity: sha512-Hu/BMoA1NAdRUuulyvQC0pEqZ4vQbGfn8f7wPXcnqQmM+zct9UliKxsIkLNmz/ku7LElUNqmaiv1TG/aL5ACsw==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  plimit-lit@1.6.1:
+    resolution: {integrity: sha512-B7+VDyb8Tl6oMJT9oSO2CW8XC/T4UcJGrwOVoNGwOQsQYhlpfajmrMj5xeejqaASq3V/EqThyOeATEOMuSEXiA==}
+    engines: {node: '>=12'}
+
+  pluralize@8.0.0:
+    resolution: {integrity: sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==}
+    engines: {node: '>=4'}
+
+  pony-cause@1.1.1:
+    resolution: {integrity: sha512-PxkIc/2ZpLiEzQXu5YRDOUgBlfGYBY8156HY5ZcRAwwonMk5W/MrJP2LLkG/hF7GEQzaHo2aS7ho6ZLCOvf+6g==}
+    engines: {node: '>=12.0.0'}
+
+  possible-typed-array-names@1.1.0:
+    resolution: {integrity: sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==}
+    engines: {node: '>= 0.4'}
+
+  postcss-import@15.1.0:
+    resolution: {integrity: sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      postcss: ^8.0.0
+
+  postcss-js@4.0.1:
+    resolution: {integrity: sha512-dDLF8pEO191hJMtlHFPRa8xsizHaM82MLfNkUHdUtVEV3tgTp5oj+8qbEqYM57SLfc74KSbw//4SeJma2LRVIw==}
+    engines: {node: ^12 || ^14 || >= 16}
+    peerDependencies:
+      postcss: ^8.4.21
+
+  postcss-load-config@4.0.2:
+    resolution: {integrity: sha512-bSVhyJGL00wMVoPUzAVAnbEoWyqRxkjv64tUl427SKnPrENtq6hJwUojroMz2VB+Q1edmi4IfrAPpami5VVgMQ==}
+    engines: {node: '>= 14'}
+    peerDependencies:
+      postcss: '>=8.0.9'
+      ts-node: '>=9.0.0'
+    peerDependenciesMeta:
+      postcss:
+        optional: true
+      ts-node:
+        optional: true
+
+  postcss-load-config@6.0.1:
+    resolution: {integrity: sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==}
+    engines: {node: '>= 18'}
+    peerDependencies:
+      jiti: '>=1.21.0'
+      postcss: '>=8.0.9'
+      tsx: ^4.8.1
+      yaml: ^2.4.2
+    peerDependenciesMeta:
+      jiti:
+        optional: true
+      postcss:
+        optional: true
+      tsx:
+        optional: true
+      yaml:
+        optional: true
+
+  postcss-nested@6.2.0:
+    resolution: {integrity: sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==}
+    engines: {node: '>=12.0'}
+    peerDependencies:
+      postcss: ^8.2.14
+
+  postcss-selector-parser@6.1.2:
+    resolution: {integrity: sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==}
+    engines: {node: '>=4'}
+
+  postcss-value-parser@4.2.0:
+    resolution: {integrity: sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==}
+
+  postcss@8.5.6:
+    resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
+    engines: {node: ^10 || ^12 || >=14}
+
+  postject@1.0.0-alpha.6:
+    resolution: {integrity: sha512-b9Eb8h2eVqNE8edvKdwqkrY6O7kAwmI8kcnBv1NScolYJbo59XUF0noFq+lxbC1yN20bmC0WBEbDC5H/7ASb0A==}
+    engines: {node: '>=14.0.0'}
+    hasBin: true
+
+  prelude-ls@1.2.1:
+    resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
+    engines: {node: '>= 0.8.0'}
+
+  prettier@2.8.8:
+    resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==}
+    engines: {node: '>=10.13.0'}
+    hasBin: true
+
+  prettier@3.5.3:
+    resolution: {integrity: sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw==}
+    engines: {node: '>=14'}
+    hasBin: true
+
+  pretty-format@29.7.0:
+    resolution: {integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
+  process-warning@4.0.1:
+    resolution: {integrity: sha512-3c2LzQ3rY9d0hc1emcsHhfT9Jwz0cChib/QN89oME2R451w5fy3f0afAhERFZAwrbDU43wk12d0ORBpDVME50Q==}
+
+  process-warning@5.0.0:
+    resolution: {integrity: sha512-a39t9ApHNx2L4+HBnQKqxxHNs1r7KF+Intd8Q/g1bUh6q0WIp9voPXJ/x0j+ZL45KF1pJd9+q2jLIRMfvEshkA==}
+
+  process@0.11.10:
+    resolution: {integrity: sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==}
+    engines: {node: '>= 0.6.0'}
+
+  progress@2.0.3:
+    resolution: {integrity: sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==}
+    engines: {node: '>=0.4.0'}
+
+  prom-client@15.1.3:
+    resolution: {integrity: sha512-6ZiOBfCywsD4k1BN9IX0uZhF+tJkV8q8llP64G5Hajs4JOeVLPCwpPVcpXy3BwYiUGgyJzsJJQeOIv7+hDSq8g==}
+    engines: {node: ^16 || ^18 || >=20}
+
+  property-information@7.0.0:
+    resolution: {integrity: sha512-7D/qOz/+Y4X/rzSB6jKxKUsQnphO046ei8qxG59mtM3RG3DHgTK81HrxrmoDVINJb8NKT5ZsRbwHvQ6B68Iyhg==}
+
+  proxy-addr@2.0.7:
+    resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==}
+    engines: {node: '>= 0.10'}
+
+  proxy-agent@6.5.0:
+    resolution: {integrity: sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A==}
+    engines: {node: '>= 14'}
+
+  proxy-from-env@1.1.0:
+    resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==}
+
+  psl@1.15.0:
+    resolution: {integrity: sha512-JZd3gMVBAVQkSs6HdNZo9Sdo0LNcQeMNP3CozBJb3JYC/QUYZTnKxP+f8oWRX4rHP5EurWxqAHTSwUCjlNKa1w==}
+
+  public-ip@5.0.0:
+    resolution: {integrity: sha512-xaH3pZMni/R2BG7ZXXaWS9Wc9wFlhyDVJF47IJ+3ali0TGv+2PsckKxbmo+rnx3ZxiV2wblVhtdS3bohAP6GGw==}
+    engines: {node: ^14.13.1 || >=16.0.0}
+
+  pump@3.0.2:
+    resolution: {integrity: sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw==}
+
+  punycode@2.3.1:
+    resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
+    engines: {node: '>=6'}
+
+  puppeteer-core@22.15.0:
+    resolution: {integrity: sha512-cHArnywCiAAVXa3t4GGL2vttNxh7GqXtIYGym99egkNJ3oG//wL9LkvO4WE8W1TJe95t1F1ocu9X4xWaGsOKOA==}
+    engines: {node: '>=18'}
+
+  puppeteer@22.15.0:
+    resolution: {integrity: sha512-XjCY1SiSEi1T7iSYuxS82ft85kwDJUS7wj1Z0eGVXKdtr5g4xnVcbjwxhq5xBnpK/E7x1VZZoJDxpjAOasHT4Q==}
+    engines: {node: '>=18'}
+    deprecated: < 24.15.0 is no longer supported
+    hasBin: true
+
+  qs@6.13.0:
+    resolution: {integrity: sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==}
+    engines: {node: '>=0.6'}
+
+  qs@6.14.0:
+    resolution: {integrity: sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==}
+    engines: {node: '>=0.6'}
+
+  quansync@0.2.10:
+    resolution: {integrity: sha512-t41VRkMYbkHyCYmOvx/6URnN80H7k4X0lLdBMGsz+maAwrJQYB1djpV6vHrQIBE0WBSGqhtEHrK9U3DWWH8v7A==}
+
+  querystringify@2.2.0:
+    resolution: {integrity: sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ==}
+
+  queue-lit@1.5.2:
+    resolution: {integrity: sha512-tLc36IOPeMAubu8BkW8YDBV+WyIgKlYU7zUNs0J5Vk9skSZ4JfGlPOqplP0aHdfv7HL0B2Pg6nwiq60Qc6M2Hw==}
+    engines: {node: '>=12'}
+
+  queue-microtask@1.2.3:
+    resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
+
+  quick-format-unescaped@4.0.4:
+    resolution: {integrity: sha512-tYC1Q1hgyRuHgloV/YXs2w15unPVh8qfu/qCTfhTYamaw7fyhumKa2yGpdSo87vY32rIclj+4fWYQXUMs9EHvg==}
+
+  quick-lru@5.1.1:
+    resolution: {integrity: sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==}
+    engines: {node: '>=10'}
+
+  range-parser@1.2.1:
+    resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==}
+    engines: {node: '>= 0.6'}
+
+  raw-body@2.5.2:
+    resolution: {integrity: sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==}
+    engines: {node: '>= 0.8'}
+
+  raw-body@3.0.0:
+    resolution: {integrity: sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g==}
+    engines: {node: '>= 0.8'}
+
+  react-dom@18.3.1:
+    resolution: {integrity: sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==}
+    peerDependencies:
+      react: ^18.3.1
+
+  react-is@18.3.1:
+    resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==}
+
+  react-reconciler@0.29.2:
+    resolution: {integrity: sha512-zZQqIiYgDCTP/f1N/mAR10nJGrPD2ZR+jDSEsKWJHYC7Cm2wodlwbR3upZRdC3cjIjSlTLNVyO7Iu0Yy7t2AYg==}
+    engines: {node: '>=0.10.0'}
+    peerDependencies:
+      react: ^18.3.1
+
+  react@18.3.1:
+    resolution: {integrity: sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==}
+    engines: {node: '>=0.10.0'}
+
+  read-cache@1.0.0:
+    resolution: {integrity: sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==}
+
+  read-yaml-file@1.1.0:
+    resolution: {integrity: sha512-VIMnQi/Z4HT2Fxuwg5KrY174U1VdUIASQVWXXyqtNRtxSr9IYkn1rsI6Tb6HsrHCmB7gVpNwX6JxPTHcH6IoTA==}
+    engines: {node: '>=6'}
+
+  readable-stream@4.7.0:
+    resolution: {integrity: sha512-oIGGmcpTLwPga8Bn6/Z75SVaH1z5dUut2ibSyAMVhmUggWpmDn2dapB0n7f8nwaSiRtepAsfJyfXIO5DCVAODg==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+
+  readdirp@3.6.0:
+    resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==}
+    engines: {node: '>=8.10.0'}
+
+  readdirp@4.1.2:
+    resolution: {integrity: sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==}
+    engines: {node: '>= 14.18.0'}
+
+  real-require@0.2.0:
+    resolution: {integrity: sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg==}
+    engines: {node: '>= 12.13.0'}
+
+  recma-build-jsx@1.0.0:
+    resolution: {integrity: sha512-8GtdyqaBcDfva+GUKDr3nev3VpKAhup1+RvkMvUxURHpW7QyIvk9F5wz7Vzo06CEMSilw6uArgRqhpiUcWp8ew==}
+
+  recma-jsx@1.0.0:
+    resolution: {integrity: sha512-5vwkv65qWwYxg+Atz95acp8DMu1JDSqdGkA2Of1j6rCreyFUE/gp15fC8MnGEuG1W68UKjM6x6+YTWIh7hZM/Q==}
+
+  recma-parse@1.0.0:
+    resolution: {integrity: sha512-OYLsIGBB5Y5wjnSnQW6t3Xg7q3fQ7FWbw/vcXtORTnyaSFscOtABg+7Pnz6YZ6c27fG1/aN8CjfwoUEUIdwqWQ==}
+
+  recma-stringify@1.0.0:
+    resolution: {integrity: sha512-cjwII1MdIIVloKvC9ErQ+OgAtwHBmcZ0Bg4ciz78FtbT8In39aAYbaA7zvxQ61xVMSPE8WxhLwLbhif4Js2C+g==}
+
+  reflect.getprototypeof@1.0.10:
+    resolution: {integrity: sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==}
+    engines: {node: '>= 0.4'}
+
+  regex-recursion@6.0.2:
+    resolution: {integrity: sha512-0YCaSCq2VRIebiaUviZNs0cBz1kg5kVS2UKUfNIx8YVs1cN3AV7NTctO5FOKBA+UT2BPJIWZauYHPqJODG50cg==}
+
+  regex-utilities@2.3.0:
+    resolution: {integrity: sha512-8VhliFJAWRaUiVvREIiW2NXXTmHs4vMNnSzuJVhscgmGav3g9VDxLrQndI3dZZVVdp0ZO/5v0xmX516/7M9cng==}
+
+  regex@6.0.1:
+    resolution: {integrity: sha512-uorlqlzAKjKQZ5P+kTJr3eeJGSVroLKoHmquUj4zHWuR+hEyNqlXsSKlYYF5F4NI6nl7tWCs0apKJ0lmfsXAPA==}
+
+  regexp-tree@0.1.27:
+    resolution: {integrity: sha512-iETxpjK6YoRWJG5o6hXLwvjYAoW+FEZn9os0PD/b6AP6xQwsa/Y7lCVgIixBbUPMfhu+i2LtdeAqVTgGlQarfA==}
+    hasBin: true
+
+  regexp.prototype.flags@1.5.4:
+    resolution: {integrity: sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==}
+    engines: {node: '>= 0.4'}
+
+  rehype-katex@7.0.1:
+    resolution: {integrity: sha512-OiM2wrZ/wuhKkigASodFoo8wimG3H12LWQaH8qSPVJn9apWKFSH3YOCtbKpBorTVw/eI7cuT21XBbvwEswbIOA==}
+
+  rehype-minify-whitespace@6.0.2:
+    resolution: {integrity: sha512-Zk0pyQ06A3Lyxhe9vGtOtzz3Z0+qZ5+7icZ/PL/2x1SHPbKao5oB/g/rlc6BCTajqBb33JcOe71Ye1oFsuYbnw==}
+
+  rehype-parse@9.0.1:
+    resolution: {integrity: sha512-ksCzCD0Fgfh7trPDxr2rSylbwq9iYDkSn8TCDmEJ49ljEUBxDVCzCHv7QNzZOfODanX4+bWQ4WZqLCRWYLfhag==}
+
+  rehype-recma@1.0.0:
+    resolution: {integrity: sha512-lqA4rGUf1JmacCNWWZx0Wv1dHqMwxzsDWYMTowuplHF3xH0N/MmrZ/G3BDZnzAkRmxDadujCjaKM2hqYdCBOGw==}
+
+  remark-frontmatter@5.0.0:
+    resolution: {integrity: sha512-XTFYvNASMe5iPN0719nPrdItC9aU0ssC4v14mH1BCi1u0n1gAocqcujWUrByftZTbLhRtiKRyjYTSIOcr69UVQ==}
+
+  remark-gfm@4.0.1:
+    resolution: {integrity: sha512-1quofZ2RQ9EWdeN34S79+KExV1764+wCUGop5CPL1WGdD0ocPpu91lzPGbwWMECpEpd42kJGQwzRfyov9j4yNg==}
+
+  remark-math@6.0.0:
+    resolution: {integrity: sha512-MMqgnP74Igy+S3WwnhQ7kqGlEerTETXMvJhrUzDikVZ2/uogJCb+WHUg97hK9/jcfc0dkD73s3LN8zU49cTEtA==}
+
+  remark-mdx-remove-esm@1.1.0:
+    resolution: {integrity: sha512-oN3F9QRuPKSdzZi+wvEodBVjKwya63sl403pWzJvm0+c503iUjCDR+JAnP3Ho/4205IWbQ2NujPQi/B9kU6ZrA==}
+
+  remark-mdx@3.1.0:
+    resolution: {integrity: sha512-Ngl/H3YXyBV9RcRNdlYsZujAmhsxwzxpDzpDEhFBVAGthS4GDgnctpDjgFl/ULx5UEDzqtW1cyBSNKqYYrqLBA==}
+
+  remark-parse@11.0.0:
+    resolution: {integrity: sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==}
+
+  remark-rehype@11.1.2:
+    resolution: {integrity: sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw==}
+
+  remark-smartypants@3.0.2:
+    resolution: {integrity: sha512-ILTWeOriIluwEvPjv67v7Blgrcx+LZOkAUVtKI3putuhlZm84FnqDORNXPPm+HY3NdZOMhyDwZ1E+eZB/Df5dA==}
+    engines: {node: '>=16.0.0'}
+
+  remark-stringify@11.0.0:
+    resolution: {integrity: sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw==}
+
+  remark@15.0.1:
+    resolution: {integrity: sha512-Eht5w30ruCXgFmxVUSlNWQ9iiimq07URKeFS3hNc8cUWy1llX4KDWfyEDZRycMc+znsN9Ux5/tJ/BFdgdOwA3A==}
+
+  require-directory@2.1.1:
+    resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==}
+    engines: {node: '>=0.10.0'}
+
+  require-from-string@2.0.2:
+    resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==}
+    engines: {node: '>=0.10.0'}
+
+  requires-port@1.0.0:
+    resolution: {integrity: sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==}
+
+  resolve-alpn@1.2.1:
+    resolution: {integrity: sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==}
+
+  resolve-from@4.0.0:
+    resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
+    engines: {node: '>=4'}
+
+  resolve-from@5.0.0:
+    resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==}
+    engines: {node: '>=8'}
+
+  resolve-pkg-maps@1.0.0:
+    resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
+
+  resolve@1.22.10:
+    resolution: {integrity: sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==}
+    engines: {node: '>= 0.4'}
+    hasBin: true
+
+  responselike@3.0.0:
+    resolution: {integrity: sha512-40yHxbNcl2+rzXvZuVkrYohathsSJlMTXKryG5y8uciHv1+xDLHQpgjG64JUO9nrEq2jGLH6IZ8BcZyw3wrweg==}
+    engines: {node: '>=14.16'}
+
+  restore-cursor@4.0.0:
+    resolution: {integrity: sha512-I9fPXU9geO9bHOt9pHHOhOkYerIMsmVaWB0rA2AI9ERh/+x/i7MV5HKBNrg+ljO5eoPVgCcnFuRjJ9uH6I/3eg==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  ret@0.5.0:
+    resolution: {integrity: sha512-I1XxrZSQ+oErkRR4jYbAyEEu2I0avBvvMM5JN+6EBprOGRCs63ENqZ3vjavq8fBw2+62G5LF5XelKwuJpcvcxw==}
+    engines: {node: '>=10'}
+
+  retext-latin@4.0.0:
+    resolution: {integrity: sha512-hv9woG7Fy0M9IlRQloq/N6atV82NxLGveq+3H2WOi79dtIYWN8OaxogDm77f8YnVXJL2VD3bbqowu5E3EMhBYA==}
+
+  retext-smartypants@6.2.0:
+    resolution: {integrity: sha512-kk0jOU7+zGv//kfjXEBjdIryL1Acl4i9XNkHxtM7Tm5lFiCog576fjNC9hjoR7LTKQ0DsPWy09JummSsH1uqfQ==}
+
+  retext-stringify@4.0.0:
+    resolution: {integrity: sha512-rtfN/0o8kL1e+78+uxPTqu1Klt0yPzKuQ2BfWwwfgIUSayyzxpM1PJzkKt4V8803uB9qSy32MvI7Xep9khTpiA==}
+
+  retext@9.0.0:
+    resolution: {integrity: sha512-sbMDcpHCNjvlheSgMfEcVrZko3cDzdbe1x/e7G66dFp0Ff7Mldvi2uv6JkJQzdRcvLYE8CA8Oe8siQx8ZOgTcA==}
+
+  retry@0.13.1:
+    resolution: {integrity: sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==}
+    engines: {node: '>= 4'}
+
+  reusify@1.1.0:
+    resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==}
+    engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
+
+  rfdc@1.4.1:
+    resolution: {integrity: sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==}
+
+  rimraf@5.0.10:
+    resolution: {integrity: sha512-l0OE8wL34P4nJH/H2ffoaniAokM2qSmrtXHmlpvYr5AVVX8msAyW0l8NVJFDxlSK4u3Uh/f41cQheDVdnYijwQ==}
+    hasBin: true
+
+  rollup@4.53.2:
+    resolution: {integrity: sha512-MHngMYwGJVi6Fmnk6ISmnk7JAHRNF0UkuucA0CUW3N3a4KnONPEZz+vUanQP/ZC/iY1Qkf3bwPWzyY84wEks1g==}
+    engines: {node: '>=18.0.0', npm: '>=8.0.0'}
+    hasBin: true
+
+  router@2.2.0:
+    resolution: {integrity: sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==}
+    engines: {node: '>= 18'}
+
+  rrweb-cssom@0.7.1:
+    resolution: {integrity: sha512-TrEMa7JGdVm0UThDJSx7ddw5nVm3UJS9o9CCIZ72B1vSyEZoziDqBYP3XIoi/12lKrJR8rE3jeFHMok2F/Mnsg==}
+
+  rrweb-cssom@0.8.0:
+    resolution: {integrity: sha512-guoltQEx+9aMf2gDZ0s62EcV8lsXR+0w8915TC3ITdn2YueuNjdAYh/levpU9nFaoChh9RUS5ZdQMrKfVEN9tw==}
+
+  run-async@3.0.0:
+    resolution: {integrity: sha512-540WwVDOMxA6dN6We19EcT9sc3hkXPw5mzRNGM3FkdN/vtE9NFvj5lFAPNwUDmJjXidm3v7TC1cTE7t17Ulm1Q==}
+    engines: {node: '>=0.12.0'}
+
+  run-parallel@1.2.0:
+    resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
+
+  rxjs@7.8.2:
+    resolution: {integrity: sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==}
+
+  safe-array-concat@1.1.3:
+    resolution: {integrity: sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==}
+    engines: {node: '>=0.4'}
+
+  safe-buffer@5.2.1:
+    resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}
+
+  safe-push-apply@1.0.0:
+    resolution: {integrity: sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==}
+    engines: {node: '>= 0.4'}
+
+  safe-regex-test@1.1.0:
+    resolution: {integrity: sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==}
+    engines: {node: '>= 0.4'}
+
+  safe-regex2@5.0.0:
+    resolution: {integrity: sha512-YwJwe5a51WlK7KbOJREPdjNrpViQBI3p4T50lfwPuDhZnE3XGVTlGvi+aolc5+RvxDD6bnUmjVsU9n1eboLUYw==}
+
+  safe-regex@2.1.1:
+    resolution: {integrity: sha512-rx+x8AMzKb5Q5lQ95Zoi6ZbJqwCLkqi3XuJXp5P3rT8OEc6sZCJG5AE5dU3lsgRr/F4Bs31jSlVN+j5KrsGu9A==}
+
+  safe-stable-stringify@1.1.1:
+    resolution: {integrity: sha512-ERq4hUjKDbJfE4+XtZLFPCDi8Vb1JqaxAPTxWFLBx8XcAlf9Bda/ZJdVezs/NAfsMQScyIlUMx+Yeu7P7rx5jw==}
+
+  safe-stable-stringify@2.5.0:
+    resolution: {integrity: sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==}
+    engines: {node: '>=10'}
+
+  safer-buffer@2.1.2:
+    resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
+
+  sax@1.4.1:
+    resolution: {integrity: sha512-+aWOz7yVScEGoKNd4PA10LZ8sk0A/z5+nXQG5giUO5rprX9jgYsTdov9qCchZiPIZezbZH+jRut8nPodFAX4Jg==}
+
+  saxes@6.0.0:
+    resolution: {integrity: sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==}
+    engines: {node: '>=v12.22.7'}
+
+  scheduler@0.23.2:
+    resolution: {integrity: sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==}
+
+  section-matter@1.0.0:
+    resolution: {integrity: sha512-vfD3pmTzGpufjScBh50YHKzEu2lxBWhVEHsNGoEXmCmn2hKGfeNLYMzCJpe8cD7gqX7TJluOVpBkAequ6dgMmA==}
+    engines: {node: '>=4'}
+
+  secure-json-parse@2.7.0:
+    resolution: {integrity: sha512-6aU+Rwsezw7VR8/nyvKTx8QpWH9FrcYiXXlqC4z5d5XQBDRqtbfsRjnwGyqbi3gddNtWHuEk9OANUotL26qKUw==}
+
+  secure-json-parse@4.1.0:
+    resolution: {integrity: sha512-l4KnYfEyqYJxDwlNVyRfO2E4NTHfMKAWdUuA8J0yve2Dz/E/PdBepY03RvyJpssIpRFwJoCD55wA+mEDs6ByWA==}
+
+  semver@7.7.3:
+    resolution: {integrity: sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  send@0.19.0:
+    resolution: {integrity: sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==}
+    engines: {node: '>= 0.8.0'}
+
+  send@1.2.0:
+    resolution: {integrity: sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw==}
+    engines: {node: '>= 18'}
+
+  serialize-error@12.0.0:
+    resolution: {integrity: sha512-ZYkZLAvKTKQXWuh5XpBw7CdbSzagarX39WyZ2H07CDLC5/KfsRGlIXV8d4+tfqX1M7916mRqR1QfNHSij+c9Pw==}
+    engines: {node: '>=18'}
+
+  serve-static@1.16.2:
+    resolution: {integrity: sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==}
+    engines: {node: '>= 0.8.0'}
+
+  serve-static@2.2.0:
+    resolution: {integrity: sha512-61g9pCh0Vnh7IutZjtLGGpTA355+OPn2TyDv/6ivP2h/AdAVX9azsoxmg2/M6nZeQZNYBEwIcsne1mJd9oQItQ==}
+    engines: {node: '>= 18'}
+
+  set-cookie-parser@2.7.1:
+    resolution: {integrity: sha512-IOc8uWeOZgnb3ptbCURJWNjWUPcO3ZnTTdzsurqERrP6nPyv+paC55vJM0LpOlT2ne+Ix+9+CRG1MNLlyZ4GjQ==}
+
+  set-function-length@1.2.2:
+    resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==}
+    engines: {node: '>= 0.4'}
+
+  set-function-name@2.0.2:
+    resolution: {integrity: sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==}
+    engines: {node: '>= 0.4'}
+
+  set-proto@1.0.0:
+    resolution: {integrity: sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==}
+    engines: {node: '>= 0.4'}
+
+  setprototypeof@1.2.0:
+    resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==}
+
+  sharp@0.33.5:
+    resolution: {integrity: sha512-haPVm1EkS9pgvHrQ/F3Xy+hgcuMV0Wm9vfIBSiwZ05k+xgb0PkBQpGsAA/oWdDobNaZTH5ppvHtzCFbnSEwHVw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+
+  sharp@0.34.5:
+    resolution: {integrity: sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+
+  shebang-command@2.0.0:
+    resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
+    engines: {node: '>=8'}
+
+  shebang-regex@3.0.0:
+    resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
+    engines: {node: '>=8'}
+
+  shiki@3.11.0:
+    resolution: {integrity: sha512-VgKumh/ib38I1i3QkMn6mAQA6XjjQubqaAYhfge71glAll0/4xnt8L2oSuC45Qcr/G5Kbskj4RliMQddGmy/Og==}
+
+  side-channel-list@1.0.0:
+    resolution: {integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==}
+    engines: {node: '>= 0.4'}
+
+  side-channel-map@1.0.1:
+    resolution: {integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==}
+    engines: {node: '>= 0.4'}
+
+  side-channel-weakmap@1.0.2:
+    resolution: {integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==}
+    engines: {node: '>= 0.4'}
+
+  side-channel@1.1.0:
+    resolution: {integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==}
+    engines: {node: '>= 0.4'}
+
+  siginfo@2.0.0:
+    resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==}
+
+  signal-exit@3.0.7:
+    resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==}
+
+  signal-exit@4.1.0:
+    resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
+    engines: {node: '>=14'}
+
+  simple-eval@1.0.1:
+    resolution: {integrity: sha512-LH7FpTAkeD+y5xQC4fzS+tFtaNlvt3Ib1zKzvhjv/Y+cioV4zIuw4IZr2yhRLu67CWL7FR9/6KXKnjRoZTvGGQ==}
+    engines: {node: '>=12'}
+
+  simple-git@3.27.0:
+    resolution: {integrity: sha512-ivHoFS9Yi9GY49ogc6/YAi3Fl9ROnF4VyubNylgCkA+RVqLaKWnDSzXOVzya8csELIaWaYNutsEuAhZrtOjozA==}
+
+  simple-swizzle@0.2.2:
+    resolution: {integrity: sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg==}
+
+  simple-wcswidth@1.0.1:
+    resolution: {integrity: sha512-xMO/8eNREtaROt7tJvWJqHBDTMFN4eiQ5I4JRMuilwfnFcV5W9u7RUkueNkdw0jPqGMX36iCywelS5yilTuOxg==}
+
+  slash@3.0.0:
+    resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==}
+    engines: {node: '>=8'}
+
+  slice-ansi@5.0.0:
+    resolution: {integrity: sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ==}
+    engines: {node: '>=12'}
+
+  slice-ansi@7.1.0:
+    resolution: {integrity: sha512-bSiSngZ/jWeX93BqeIAbImyTbEihizcwNjFoRUIY/T1wWQsfsm2Vw1agPKylXvQTU7iASGdHhyqRlqQzfz+Htg==}
+    engines: {node: '>=18'}
+
+  slugify@1.6.6:
+    resolution: {integrity: sha512-h+z7HKHYXj6wJU+AnS/+IH8Uh9fdcX1Lrhg1/VMdf9PwoBQXFcXiAdsy2tSK0P6gKwJLXp02r90ahUCqHk9rrw==}
+    engines: {node: '>=8.0.0'}
+
+  smart-buffer@4.2.0:
+    resolution: {integrity: sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==}
+    engines: {node: '>= 6.0.0', npm: '>= 3.0.0'}
+
+  socket.io-adapter@2.5.5:
+    resolution: {integrity: sha512-eLDQas5dzPgOWCk9GuuJC2lBqItuhKI4uxGgo9aIV7MYbk2h9Q6uULEh8WBzThoI7l+qU9Ast9fVUmkqPP9wYg==}
+
+  socket.io-parser@4.2.4:
+    resolution: {integrity: sha512-/GbIKmo8ioc+NIWIhwdecY0ge+qVBSMdgxGygevmdHj24bsfgtCmcUUcQ5ZzcylGFHsN3k4HB4Cgkl96KVnuew==}
+    engines: {node: '>=10.0.0'}
+
+  socket.io@4.8.1:
+    resolution: {integrity: sha512-oZ7iUCxph8WYRHHcjBEc9unw3adt5CmSNlppj/5Q4k2RIrhl8Z5yY2Xr4j9zj0+wzVZ0bxmYoGSzKJnRl6A4yg==}
+    engines: {node: '>=10.2.0'}
+
+  socks-proxy-agent@8.0.5:
+    resolution: {integrity: sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==}
+    engines: {node: '>= 14'}
+
+  socks@2.8.4:
+    resolution: {integrity: sha512-D3YaD0aRxR3mEcqnidIs7ReYJFVzWdd6fXJYUM8ixcQcJRGTka/b3saV0KflYhyVJXKhb947GndU35SxYNResQ==}
+    engines: {node: '>= 10.0.0', npm: '>= 3.0.0'}
+
+  sonic-boom@4.2.0:
+    resolution: {integrity: sha512-INb7TM37/mAcsGmc9hyyI6+QR3rR1zVRu36B0NeGXKnOOLiZOfER5SA+N7X7k3yUYRzLWafduTDvJAfDswwEww==}
+
+  source-map-js@1.2.1:
+    resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
+    engines: {node: '>=0.10.0'}
+
+  source-map@0.6.1:
+    resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
+    engines: {node: '>=0.10.0'}
+
+  source-map@0.7.4:
+    resolution: {integrity: sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA==}
+    engines: {node: '>= 8'}
+
+  source-map@0.7.6:
+    resolution: {integrity: sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==}
+    engines: {node: '>= 12'}
+
+  space-separated-tokens@2.0.2:
+    resolution: {integrity: sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==}
+
+  spawndamnit@3.0.1:
+    resolution: {integrity: sha512-MmnduQUuHCoFckZoWnXsTg7JaiLBJrKFj9UI2MbRPGaJeVpsLcVBu6P/IGZovziM/YBsellCmsprgNA+w0CzVg==}
+
+  split2@4.2.0:
+    resolution: {integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==}
+    engines: {node: '>= 10.x'}
+
+  sprintf-js@1.0.3:
+    resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
+
+  sprintf-js@1.1.3:
+    resolution: {integrity: sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==}
+
+  stack-utils@2.0.6:
+    resolution: {integrity: sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==}
+    engines: {node: '>=10'}
+
+  stackback@0.0.2:
+    resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==}
+
+  statuses@2.0.1:
+    resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==}
+    engines: {node: '>= 0.8'}
+
+  std-env@3.10.0:
+    resolution: {integrity: sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==}
+
+  streamx@2.22.0:
+    resolution: {integrity: sha512-sLh1evHOzBy/iWRiR6d1zRcLao4gGZr3C1kzNz4fopCOKJb6xD9ub8Mpi9Mr1R6id5o43S+d93fI48UC5uM9aw==}
+
+  string-comparison@1.3.0:
+    resolution: {integrity: sha512-46aD+slEwybxAMPRII83ATbgMgTiz5P8mVd7Z6VJsCzSHFjdt1hkAVLeFxPIyEb11tc6ihpJTlIqoO0MCF6NPw==}
+    engines: {node: ^16.0.0 || >=18.0.0}
+
+  string-width@4.2.3:
+    resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
+    engines: {node: '>=8'}
+
+  string-width@5.1.2:
+    resolution: {integrity: sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==}
+    engines: {node: '>=12'}
+
+  string-width@7.2.0:
+    resolution: {integrity: sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==}
+    engines: {node: '>=18'}
+
+  string.prototype.trim@1.2.10:
+    resolution: {integrity: sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==}
+    engines: {node: '>= 0.4'}
+
+  string.prototype.trimend@1.0.9:
+    resolution: {integrity: sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==}
+    engines: {node: '>= 0.4'}
+
+  string.prototype.trimstart@1.0.8:
+    resolution: {integrity: sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==}
+    engines: {node: '>= 0.4'}
+
+  string_decoder@1.3.0:
+    resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==}
+
+  stringify-entities@4.0.4:
+    resolution: {integrity: sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==}
+
+  strip-ansi@6.0.1:
+    resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
+    engines: {node: '>=8'}
+
+  strip-ansi@7.1.0:
+    resolution: {integrity: sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==}
+    engines: {node: '>=12'}
+
+  strip-bom-string@1.0.0:
+    resolution: {integrity: sha512-uCC2VHvQRYu+lMh4My/sFNmF2klFymLX1wHJeXnbEJERpV/ZsVuonzerjfrGpIGF7LBVa1O7i9kjiWvJiFck8g==}
+    engines: {node: '>=0.10.0'}
+
+  strip-bom@3.0.0:
+    resolution: {integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==}
+    engines: {node: '>=4'}
+
+  strip-final-newline@3.0.0:
+    resolution: {integrity: sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==}
+    engines: {node: '>=12'}
+
+  strip-json-comments@3.1.1:
+    resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
+    engines: {node: '>=8'}
+
+  strip-literal@2.1.1:
+    resolution: {integrity: sha512-631UJ6O00eNGfMiWG78ck80dfBab8X6IVFB51jZK5Icd7XAs60Z5y7QdSd/wGIklnWvRbUNloVzhOKKmutxQ6Q==}
+
+  style-to-js@1.1.16:
+    resolution: {integrity: sha512-/Q6ld50hKYPH3d/r6nr117TZkHR0w0kGGIVfpG9N6D8NymRPM9RqCUv4pRpJ62E5DqOYx2AFpbZMyCPnjQCnOw==}
+
+  style-to-object@1.0.8:
+    resolution: {integrity: sha512-xT47I/Eo0rwJmaXC4oilDGDWLohVhR6o/xAQcPQN8q6QBuZVL8qMYL85kLmST5cPjAorwvqIA4qXTRQoYHaL6g==}
+
+  sucrase@3.35.0:
+    resolution: {integrity: sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==}
+    engines: {node: '>=16 || 14 >=14.17'}
+    hasBin: true
+
+  supports-color@7.2.0:
+    resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
+    engines: {node: '>=8'}
+
+  supports-preserve-symlinks-flag@1.0.0:
+    resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==}
+    engines: {node: '>= 0.4'}
+
+  symbol-tree@3.2.4:
+    resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}
+
+  tailwindcss@3.4.17:
+    resolution: {integrity: sha512-w33E2aCvSDP0tW9RZuNXadXlkHXqFzSkQew/aIa2i/Sj8fThxwovwlXHSPXTbAHwEIhBFXAedUhP2tueAKP8Og==}
+    engines: {node: '>=14.0.0'}
+    hasBin: true
+
+  tar-fs@3.1.0:
+    resolution: {integrity: sha512-5Mty5y/sOF1YWj1J6GiBodjlDc05CUR8PKXrsnFAiSG0xA+GHeWLovaZPYUDXkH/1iKRf2+M5+OrRgzC7O9b7w==}
+
+  tar-stream@3.1.7:
+    resolution: {integrity: sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==}
+
+  tar@6.2.1:
+    resolution: {integrity: sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==}
+    engines: {node: '>=10'}
+    deprecated: Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
+
+  tdigest@0.1.2:
+    resolution: {integrity: sha512-+G0LLgjjo9BZX2MfdvPfH+MKLCrxlXSYec5DaPYP1fe6Iyhf0/fSmJ0bFiZ1F8BT6cGXl2LpltQptzjXKWEkKA==}
+
+  term-size@2.2.1:
+    resolution: {integrity: sha512-wK0Ri4fOGjv/XPy8SBHZChl8CM7uMc5VML7SqiQ0zG7+J5Vr+RMQDoHa2CNT6KHUnTGIXH34UDMkPzAUyapBZg==}
+    engines: {node: '>=8'}
+
+  test-exclude@7.0.1:
+    resolution: {integrity: sha512-pFYqmTw68LXVjeWJMST4+borgQP2AyMNbg1BpZh9LbyhUeNkeaPF9gzfPGUAnSMV3qPYdWUwDIjjCLiSDOl7vg==}
+    engines: {node: '>=18'}
+
+  text-decoder@1.2.3:
+    resolution: {integrity: sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA==}
+
+  thenify-all@1.6.0:
+    resolution: {integrity: sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==}
+    engines: {node: '>=0.8'}
+
+  thenify@3.3.1:
+    resolution: {integrity: sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==}
+
+  thread-stream@3.1.0:
+    resolution: {integrity: sha512-OqyPZ9u96VohAyMfJykzmivOrY2wfMSf3C5TtFJVgN+Hm6aj+voFhlK+kZEIv2FBh1X6Xp3DlnCOfEQ3B2J86A==}
+
+  through@2.3.8:
+    resolution: {integrity: sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==}
+
+  tinybench@2.9.0:
+    resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==}
+
+  tinyexec@0.3.2:
+    resolution: {integrity: sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==}
+
+  tinyglobby@0.2.15:
+    resolution: {integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==}
+    engines: {node: '>=12.0.0'}
+
+  tinypool@0.8.4:
+    resolution: {integrity: sha512-i11VH5gS6IFeLY3gMBQ00/MmLncVP7JLXOw1vlgkytLmJK7QnEr7NXf0LBdxfmNPAeyetukOk0bOYrJrFGjYJQ==}
+    engines: {node: '>=14.0.0'}
+
+  tinyrainbow@3.0.3:
+    resolution: {integrity: sha512-PSkbLUoxOFRzJYjjxHJt9xro7D+iilgMX/C9lawzVuYiIdcihh9DXmVibBe8lmcFrRi/VzlPjBxbN7rH24q8/Q==}
+    engines: {node: '>=14.0.0'}
+
+  tinyspy@2.2.1:
+    resolution: {integrity: sha512-KYad6Vy5VDWV4GH3fjpseMQ/XU2BhIYP7Vzd0LG44qRWm/Yt2WCOTicFdvmgo6gWaqooMQCawTtILVQJupKu7A==}
+    engines: {node: '>=14.0.0'}
+
+  tldts-core@6.1.86:
+    resolution: {integrity: sha512-Je6p7pkk+KMzMv2XXKmAE3McmolOQFdxkKw0R8EYNr7sELW46JqnNeTX8ybPiQgvg1ymCoF8LXs5fzFaZvJPTA==}
+
+  tldts@6.1.86:
+    resolution: {integrity: sha512-WMi/OQ2axVTf/ykqCQgXiIct+mSQDFdH2fkwhPwgEwvJ1kSzZRiinb0zF2Xb8u4+OqPChmyI6MEu4EezNJz+FQ==}
+    hasBin: true
+
+  tmp@0.0.33:
+    resolution: {integrity: sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==}
+    engines: {node: '>=0.6.0'}
+
+  to-regex-range@5.0.1:
+    resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
+    engines: {node: '>=8.0'}
+
+  toad-cache@3.7.0:
+    resolution: {integrity: sha512-/m8M+2BJUpoJdgAHoG+baCwBT+tf2VraSfkBgl0Y00qIWt41DJ8R5B8nsEw0I58YwF5IZH6z24/2TobDKnqSWw==}
+    engines: {node: '>=12'}
+
+  toidentifier@1.0.1:
+    resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==}
+    engines: {node: '>=0.6'}
+
+  tough-cookie@4.1.4:
+    resolution: {integrity: sha512-Loo5UUvLD9ScZ6jh8beX1T6sO1w2/MpCRpEP7V280GKMVUQ0Jzar2U3UJPsrdbziLEMMhu3Ujnq//rhiFuIeag==}
+    engines: {node: '>=6'}
+
+  tough-cookie@5.1.2:
+    resolution: {integrity: sha512-FVDYdxtnj0G6Qm/DhNPSb8Ju59ULcup3tuJxkFb5K8Bv2pUXILbf0xZWU8PX8Ov19OXljbUyveOFwRMwkXzO+A==}
+    engines: {node: '>=16'}
+
+  tr46@0.0.3:
+    resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==}
+
+  tr46@5.1.1:
+    resolution: {integrity: sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==}
+    engines: {node: '>=18'}
+
+  tree-kill@1.2.2:
+    resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==}
+    hasBin: true
+
+  trim-lines@3.0.1:
+    resolution: {integrity: sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==}
+
+  trim-trailing-lines@2.1.0:
+    resolution: {integrity: sha512-5UR5Biq4VlVOtzqkm2AZlgvSlDJtME46uV0br0gENbwN4l5+mMKT4b9gJKqWtuL2zAIqajGJGuvbCbcAJUZqBg==}
+
+  trough@2.2.0:
+    resolution: {integrity: sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==}
+
+  ts-api-utils@2.4.0:
+    resolution: {integrity: sha512-3TaVTaAv2gTiMB35i3FiGJaRfwb3Pyn/j3m/bfAvGe8FB7CF6u+LMYqYlDh7reQf7UNvoTvdfAqHGmPGOSsPmA==}
+    engines: {node: '>=18.12'}
+    peerDependencies:
+      typescript: '>=4.8.4'
+
+  ts-interface-checker@0.1.13:
+    resolution: {integrity: sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==}
+
+  tsc-alias@1.8.16:
+    resolution: {integrity: sha512-QjCyu55NFyRSBAl6+MTFwplpFcnm2Pq01rR/uxfqJoLMm6X3O14KEGtaSDZpJYaE1bJBGDjD0eSuiIWPe2T58g==}
+    engines: {node: '>=16.20.2'}
+    hasBin: true
+
+  tslib@1.14.1:
+    resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==}
+
+  tslib@2.8.1:
+    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
+
+  tsup@8.5.1:
+    resolution: {integrity: sha512-xtgkqwdhpKWr3tKPmCkvYmS9xnQK3m3XgxZHwSUjvfTjp7YfXe5tT3GgWi0F2N+ZSMsOeWeZFh7ZZFg5iPhing==}
+    engines: {node: '>=18'}
+    hasBin: true
+    peerDependencies:
+      '@microsoft/api-extractor': ^7.36.0
+      '@swc/core': ^1
+      postcss: ^8.4.12
+      typescript: '>=4.5.0'
+    peerDependenciesMeta:
+      '@microsoft/api-extractor':
+        optional: true
+      '@swc/core':
+        optional: true
+      postcss:
+        optional: true
+      typescript:
+        optional: true
+
+  tsx@4.19.4:
+    resolution: {integrity: sha512-gK5GVzDkJK1SI1zwHf32Mqxf2tSJkNx+eYcNly5+nHvWqXUJYUkWBQtKauoESz3ymezAI++ZwT855x5p5eop+Q==}
+    engines: {node: '>=18.0.0'}
+    hasBin: true
+
+  turbo-darwin-64@2.8.10:
+    resolution: {integrity: sha512-A03fXh+B7S8mL3PbdhTd+0UsaGrhfyPkODvzBDpKRY7bbeac4MDFpJ7I+Slf2oSkCEeSvHKR7Z4U71uKRUfX7g==}
+    cpu: [x64]
+    os: [darwin]
+
+  turbo-darwin-arm64@2.8.10:
+    resolution: {integrity: sha512-sidzowgWL3s5xCHLeqwC9M3s9M0i16W1nuQF3Mc7fPHpZ+YPohvcbVFBB2uoRRHYZg6yBnwD4gyUHKTeXfwtXA==}
+    cpu: [arm64]
+    os: [darwin]
+
+  turbo-linux-64@2.8.10:
+    resolution: {integrity: sha512-YK9vcpL3TVtqonB021XwgaQhY9hJJbKKUhLv16osxV0HkcQASQWUqR56yMge7puh6nxU67rQlTq1b7ksR1T3KA==}
+    cpu: [x64]
+    os: [linux]
+
+  turbo-linux-arm64@2.8.10:
+    resolution: {integrity: sha512-3+j2tL0sG95iBJTm+6J8/45JsETQABPqtFyYjVjBbi6eVGdtNTiBmHNKrbvXRlQ3ZbUG75bKLaSSDHSEEN+btQ==}
+    cpu: [arm64]
+    os: [linux]
+
+  turbo-windows-64@2.8.10:
+    resolution: {integrity: sha512-hdeF5qmVY/NFgiucf8FW0CWJWtyT2QPm5mIsX0W1DXAVzqKVXGq+Zf+dg4EUngAFKjDzoBeN6ec2Fhajwfztkw==}
+    cpu: [x64]
+    os: [win32]
+
+  turbo-windows-arm64@2.8.10:
+    resolution: {integrity: sha512-QGdr/Q8LWmj+ITMkSvfiz2glf0d7JG0oXVzGL3jxkGqiBI1zXFj20oqVY0qWi+112LO9SVrYdpHS0E/oGFrMbQ==}
+    cpu: [arm64]
+    os: [win32]
+
+  turbo@2.8.10:
+    resolution: {integrity: sha512-OxbzDES66+x7nnKGg2MwBA1ypVsZoDTLHpeaP4giyiHSixbsiTaMyeJqbEyvBdp5Cm28fc+8GG6RdQtic0ijwQ==}
+    hasBin: true
+
+  type-check@0.4.0:
+    resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
+    engines: {node: '>= 0.8.0'}
+
+  type-detect@4.1.0:
+    resolution: {integrity: sha512-Acylog8/luQ8L7il+geoSxhEkazvkslg7PSNKOX59mbB9cOveP5aq9h74Y7YU8yDpJwetzQQrfIwtf4Wp4LKcw==}
+    engines: {node: '>=4'}
+
+  type-fest@0.21.3:
+    resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==}
+    engines: {node: '>=10'}
+
+  type-fest@4.41.0:
+    resolution: {integrity: sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==}
+    engines: {node: '>=16'}
+
+  type-is@1.6.18:
+    resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==}
+    engines: {node: '>= 0.6'}
+
+  type-is@2.0.1:
+    resolution: {integrity: sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==}
+    engines: {node: '>= 0.6'}
+
+  typed-array-buffer@1.0.3:
+    resolution: {integrity: sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==}
+    engines: {node: '>= 0.4'}
+
+  typed-array-byte-length@1.0.3:
+    resolution: {integrity: sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==}
+    engines: {node: '>= 0.4'}
+
+  typed-array-byte-offset@1.0.4:
+    resolution: {integrity: sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==}
+    engines: {node: '>= 0.4'}
+
+  typed-array-length@1.0.7:
+    resolution: {integrity: sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==}
+    engines: {node: '>= 0.4'}
+
+  typescript-eslint@8.56.1:
+    resolution: {integrity: sha512-U4lM6pjmBX7J5wk4szltF7I1cGBHXZopnAXCMXb3+fZ3B/0Z3hq3wS/CCUB2NZBNAExK92mCU2tEohWuwVMsDQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+      typescript: '>=4.8.4 <6.0.0'
+
+  typescript@5.8.3:
+    resolution: {integrity: sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  typescript@5.9.3:
+    resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  ufo@1.6.3:
+    resolution: {integrity: sha512-yDJTmhydvl5lJzBmy/hyOAA0d+aqCBuwl818haVdYCRrWV84o7YyeVm4QlVHStqNrrJSTb6jKuFAVqAFsr+K3Q==}
+
+  unbox-primitive@1.1.0:
+    resolution: {integrity: sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==}
+    engines: {node: '>= 0.4'}
+
+  unbzip2-stream@1.4.3:
+    resolution: {integrity: sha512-mlExGW4w71ebDJviH16lQLtZS32VKqsSfk80GCfUlwT/4/hNRFsoscrF/c++9xinkMzECL1uL9DDwXqFWkruPg==}
+
+  undici-types@5.26.5:
+    resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==}
+
+  undici-types@6.19.8:
+    resolution: {integrity: sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==}
+
+  undici-types@6.20.0:
+    resolution: {integrity: sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==}
+
+  unified@11.0.5:
+    resolution: {integrity: sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==}
+
+  unist-builder@4.0.0:
+    resolution: {integrity: sha512-wmRFnH+BLpZnTKpc5L7O67Kac89s9HMrtELpnNaE6TAobq5DTZZs5YaTQfAZBA9bFPECx2uVAPO31c+GVug8mg==}
+
+  unist-util-find-after@5.0.0:
+    resolution: {integrity: sha512-amQa0Ep2m6hE2g72AugUItjbuM8X8cGQnFoHk0pGfrFeT9GZhzN5SW8nRsiGKK7Aif4CrACPENkA6P/Lw6fHGQ==}
+
+  unist-util-is@5.2.1:
+    resolution: {integrity: sha512-u9njyyfEh43npf1M+yGKDGVPbY/JWEemg5nH05ncKPfi+kBbKBJoTdsogMu33uhytuLlv9y0O7GH7fEdwLdLQw==}
+
+  unist-util-is@6.0.0:
+    resolution: {integrity: sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw==}
+
+  unist-util-map@4.0.0:
+    resolution: {integrity: sha512-HJs1tpkSmRJUzj6fskQrS5oYhBYlmtcvy4SepdDEEsL04FjBrgF0Mgggvxc1/qGBGgW7hRh9+UBK1aqTEnBpIA==}
+
+  unist-util-modify-children@4.0.0:
+    resolution: {integrity: sha512-+tdN5fGNddvsQdIzUF3Xx82CU9sMM+fA0dLgR9vOmT0oPT2jH+P1nd5lSqfCfXAw+93NhcXNY2qqvTUtE4cQkw==}
+
+  unist-util-position-from-estree@2.0.0:
+    resolution: {integrity: sha512-KaFVRjoqLyF6YXCbVLNad/eS4+OfPQQn2yOd7zF/h5T/CSL2v8NpN6a5TPvtbXthAGw5nG+PuTtq+DdIZr+cRQ==}
+
+  unist-util-position@5.0.0:
+    resolution: {integrity: sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==}
+
+  unist-util-remove-position@5.0.0:
+    resolution: {integrity: sha512-Hp5Kh3wLxv0PHj9m2yZhhLt58KzPtEYKQQ4yxfYFEO7EvHwzyDYnduhHnY1mDxoqr7VUwVuHXk9RXKIiYS1N8Q==}
+
+  unist-util-remove@4.0.0:
+    resolution: {integrity: sha512-b4gokeGId57UVRX/eVKej5gXqGlc9+trkORhFJpu9raqZkZhU0zm8Doi05+HaiBsMEIJowL+2WtQ5ItjsngPXg==}
+
+  unist-util-stringify-position@4.0.0:
+    resolution: {integrity: sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==}
+
+  unist-util-visit-children@3.0.0:
+    resolution: {integrity: sha512-RgmdTfSBOg04sdPcpTSD1jzoNBjt9a80/ZCzp5cI9n1qPzLZWF9YdvWGN2zmTumP1HWhXKdUWexjy/Wy/lJ7tA==}
+
+  unist-util-visit-parents@5.1.3:
+    resolution: {integrity: sha512-x6+y8g7wWMyQhL1iZfhIPhDAs7Xwbn9nRosDXl7qoPTSCy0yNxnKc+hWokFifWQIDGi154rdUqKvbCa4+1kLhg==}
+
+  unist-util-visit-parents@6.0.1:
+    resolution: {integrity: sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw==}
+
+  unist-util-visit@4.1.2:
+    resolution: {integrity: sha512-MSd8OUGISqHdVvfY9TPhyK2VdUrPgxkUtWSuMHF6XAAFuL4LokseigBnZtPnJMu+FbynTkFNnFlyjxpVKujMRg==}
+
+  unist-util-visit@5.0.0:
+    resolution: {integrity: sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==}
+
+  universalify@0.1.2:
+    resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==}
+    engines: {node: '>= 4.0.0'}
+
+  universalify@0.2.0:
+    resolution: {integrity: sha512-CJ1QgKmNg3CwvAv/kOFmtnEN05f0D/cn9QntgNOQlQF9dgvVTHj3t+8JPdjqawCHk7V/KA+fbUqzZ9XWhcqPUg==}
+    engines: {node: '>= 4.0.0'}
+
+  universalify@2.0.1:
+    resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==}
+    engines: {node: '>= 10.0.0'}
+
+  unpipe@1.0.0:
+    resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==}
+    engines: {node: '>= 0.8'}
+
+  uri-js@4.4.1:
+    resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
+
+  urijs@1.19.11:
+    resolution: {integrity: sha512-HXgFDgDommxn5/bIv0cnQZsPhHDA90NPHD6+c/v21U5+Sx5hoP8+dP9IZXBU1gIfvdRfhG8cel9QNPeionfcCQ==}
+
+  url-parse@1.5.10:
+    resolution: {integrity: sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==}
+
+  urlpattern-polyfill@10.0.0:
+    resolution: {integrity: sha512-H/A06tKD7sS1O1X2SshBVeA5FLycRpjqiBeqGKmBwBDBy28EnRjORxTNe269KSSr5un5qyWi1iL61wLxpd+ZOg==}
+
+  util-deprecate@1.0.2:
+    resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}
+
+  utility-types@3.11.0:
+    resolution: {integrity: sha512-6Z7Ma2aVEWisaL6TvBCy7P8rm2LQoPv6dJ7ecIaIixHcwfbJ0x7mWdbcwlIM5IGQxPZSFYeqRCqlOOeKoJYMkw==}
+    engines: {node: '>= 4'}
+
+  utils-merge@1.0.1:
+    resolution: {integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==}
+    engines: {node: '>= 0.4.0'}
+
+  uuid@10.0.0:
+    resolution: {integrity: sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==}
+    hasBin: true
+
+  uuid@11.1.0:
+    resolution: {integrity: sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==}
+    hasBin: true
+
+  uuid@9.0.1:
+    resolution: {integrity: sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==}
+    hasBin: true
+
+  v8-to-istanbul@9.3.0:
+    resolution: {integrity: sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==}
+    engines: {node: '>=10.12.0'}
+
+  vary@1.1.2:
+    resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==}
+    engines: {node: '>= 0.8'}
+
+  vfile-location@5.0.3:
+    resolution: {integrity: sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg==}
+
+  vfile-matter@5.0.1:
+    resolution: {integrity: sha512-o6roP82AiX0XfkyTHyRCMXgHfltUNlXSEqCIS80f+mbAyiQBE2fxtDVMtseyytGx75sihiJFo/zR6r/4LTs2Cw==}
+
+  vfile-message@4.0.2:
+    resolution: {integrity: sha512-jRDZ1IMLttGj41KcZvlrYAaI3CfqpLpfpf+Mfig13viT6NKvRzWZ+lXz0Y5D60w6uJIBAOGq9mSHf0gktF0duw==}
+
+  vfile@6.0.3:
+    resolution: {integrity: sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==}
+
+  vite-node@1.6.1:
+    resolution: {integrity: sha512-YAXkfvGtuTzwWbDSACdJSg4A4DZiAqckWe90Zapc/sEX3XvHcw1NdurM/6od8J207tSDqNbSsgdCacBgvJKFuA==}
+    engines: {node: ^18.0.0 || >=20.0.0}
+    hasBin: true
+
+  vite@5.4.21:
+    resolution: {integrity: sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==}
+    engines: {node: ^18.0.0 || >=20.0.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^18.0.0 || >=20.0.0
+      less: '*'
+      lightningcss: ^1.21.0
+      sass: '*'
+      sass-embedded: '*'
+      stylus: '*'
+      sugarss: '*'
+      terser: ^5.4.0
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      sass-embedded:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+
+  vite@7.2.2:
+    resolution: {integrity: sha512-BxAKBWmIbrDgrokdGZH1IgkIk/5mMHDreLDmCJ0qpyJaAteP8NvMhkwr/ZCQNqNH97bw/dANTE9PDzqwJghfMQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^20.19.0 || >=22.12.0
+      jiti: '>=1.21.0'
+      less: ^4.0.0
+      lightningcss: ^1.21.0
+      sass: ^1.70.0
+      sass-embedded: ^1.70.0
+      stylus: '>=0.54.8'
+      sugarss: ^5.0.0
+      terser: ^5.16.0
+      tsx: ^4.8.1
+      yaml: ^2.4.2
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      jiti:
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      sass-embedded:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+      tsx:
+        optional: true
+      yaml:
+        optional: true
+
+  vitest@1.6.1:
+    resolution: {integrity: sha512-Ljb1cnSJSivGN0LqXd/zmDbWEM0RNNg2t1QW/XUhYl/qPqyu7CsqeWtqQXHVaJsecLPuDoak2oJcZN2QoRIOag==}
+    engines: {node: ^18.0.0 || >=20.0.0}
+    hasBin: true
+    peerDependencies:
+      '@edge-runtime/vm': '*'
+      '@types/node': ^18.0.0 || >=20.0.0
+      '@vitest/browser': 1.6.1
+      '@vitest/ui': 1.6.1
+      happy-dom: '*'
+      jsdom: '*'
+    peerDependenciesMeta:
+      '@edge-runtime/vm':
+        optional: true
+      '@types/node':
+        optional: true
+      '@vitest/browser':
+        optional: true
+      '@vitest/ui':
+        optional: true
+      happy-dom:
+        optional: true
+      jsdom:
+        optional: true
+
+  vitest@4.0.8:
+    resolution: {integrity: sha512-urzu3NCEV0Qa0Y2PwvBtRgmNtxhj5t5ULw7cuKhIHh3OrkKTLlut0lnBOv9qe5OvbkMH2g38G7KPDCTpIytBVg==}
+    engines: {node: ^20.0.0 || ^22.0.0 || >=24.0.0}
+    hasBin: true
+    peerDependencies:
+      '@edge-runtime/vm': '*'
+      '@types/debug': ^4.1.12
+      '@types/node': ^20.0.0 || ^22.0.0 || >=24.0.0
+      '@vitest/browser-playwright': 4.0.8
+      '@vitest/browser-preview': 4.0.8
+      '@vitest/browser-webdriverio': 4.0.8
+      '@vitest/ui': 4.0.8
+      happy-dom: '*'
+      jsdom: '*'
+    peerDependenciesMeta:
+      '@edge-runtime/vm':
+        optional: true
+      '@types/debug':
+        optional: true
+      '@types/node':
+        optional: true
+      '@vitest/browser-playwright':
+        optional: true
+      '@vitest/browser-preview':
+        optional: true
+      '@vitest/browser-webdriverio':
+        optional: true
+      '@vitest/ui':
+        optional: true
+      happy-dom:
+        optional: true
+      jsdom:
+        optional: true
+
+  w3c-xmlserializer@5.0.0:
+    resolution: {integrity: sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==}
+    engines: {node: '>=18'}
+
+  web-namespaces@2.0.1:
+    resolution: {integrity: sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==}
+
+  web-streams-polyfill@3.3.3:
+    resolution: {integrity: sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==}
+    engines: {node: '>= 8'}
+
+  web-streams-polyfill@4.0.0-beta.3:
+    resolution: {integrity: sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug==}
+    engines: {node: '>= 14'}
+
+  webidl-conversions@3.0.1:
+    resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
+
+  webidl-conversions@7.0.0:
+    resolution: {integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==}
+    engines: {node: '>=12'}
+
+  whatwg-encoding@3.1.1:
+    resolution: {integrity: sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==}
+    engines: {node: '>=18'}
+    deprecated: Use @exodus/bytes instead for a more spec-conformant and faster implementation
+
+  whatwg-mimetype@4.0.0:
+    resolution: {integrity: sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==}
+    engines: {node: '>=18'}
+
+  whatwg-url@14.2.0:
+    resolution: {integrity: sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==}
+    engines: {node: '>=18'}
+
+  whatwg-url@5.0.0:
+    resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==}
+
+  which-boxed-primitive@1.1.1:
+    resolution: {integrity: sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==}
+    engines: {node: '>= 0.4'}
+
+  which-builtin-type@1.2.1:
+    resolution: {integrity: sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==}
+    engines: {node: '>= 0.4'}
+
+  which-collection@1.0.2:
+    resolution: {integrity: sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==}
+    engines: {node: '>= 0.4'}
+
+  which-typed-array@1.1.19:
+    resolution: {integrity: sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==}
+    engines: {node: '>= 0.4'}
+
+  which@2.0.2:
+    resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}
+    engines: {node: '>= 8'}
+    hasBin: true
+
+  why-is-node-running@2.3.0:
+    resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==}
+    engines: {node: '>=8'}
+    hasBin: true
+
+  widest-line@5.0.0:
+    resolution: {integrity: sha512-c9bZp7b5YtRj2wOe6dlj32MK+Bx/M/d+9VB2SHM1OtsUHR0aV0tdP6DWh/iMt0kWi1t5g1Iudu6hQRNd1A4PVA==}
+    engines: {node: '>=18'}
+
+  word-wrap@1.2.5:
+    resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==}
+    engines: {node: '>=0.10.0'}
+
+  wrap-ansi@6.2.0:
+    resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==}
+    engines: {node: '>=8'}
+
+  wrap-ansi@7.0.0:
+    resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==}
+    engines: {node: '>=10'}
+
+  wrap-ansi@8.1.0:
+    resolution: {integrity: sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==}
+    engines: {node: '>=12'}
+
+  wrap-ansi@9.0.0:
+    resolution: {integrity: sha512-G8ura3S+3Z2G+mkgNRq8dqaFZAuxfsxpBB8OCTGRTCtp+l/v9nbFNmCUP1BZMts3G1142MsZfn6eeUKrr4PD1Q==}
+    engines: {node: '>=18'}
+
+  wrappy@1.0.2:
+    resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
+
+  ws@8.17.1:
+    resolution: {integrity: sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==}
+    engines: {node: '>=10.0.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: '>=5.0.2'
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+
+  ws@8.18.3:
+    resolution: {integrity: sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==}
+    engines: {node: '>=10.0.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: '>=5.0.2'
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+
+  xml-name-validator@5.0.0:
+    resolution: {integrity: sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==}
+    engines: {node: '>=18'}
+
+  xml2js@0.6.2:
+    resolution: {integrity: sha512-T4rieHaC1EXcES0Kxxj4JWgaUQHDk+qwHcYOCFHfiwKz7tOVPLq7Hjq9dM1WCMhylqMEfP7hMcOIChvotiZegA==}
+    engines: {node: '>=4.0.0'}
+
+  xmlbuilder@11.0.1:
+    resolution: {integrity: sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA==}
+    engines: {node: '>=4.0'}
+
+  xmlchars@2.2.0:
+    resolution: {integrity: sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==}
+
+  y18n@5.0.8:
+    resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==}
+    engines: {node: '>=10'}
+
+  yallist@4.0.0:
+    resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==}
+
+  yaml@2.7.1:
+    resolution: {integrity: sha512-10ULxpnOCQXxJvBgxsn9ptjq6uviG/htZKk9veJGhlqn3w/DxQ631zFF+nlQXLwmImeS5amR2dl2U8sg6U9jsQ==}
+    engines: {node: '>= 14'}
+    hasBin: true
+
+  yargs-parser@21.1.1:
+    resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==}
+    engines: {node: '>=12'}
+
+  yargs-parser@22.0.0:
+    resolution: {integrity: sha512-rwu/ClNdSMpkSrUb+d6BRsSkLUq1fmfsY6TOpYzTwvwkg1/NRG85KBy3kq++A8LKQwX6lsu+aWad+2khvuXrqw==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=23}
+
+  yargs@17.7.2:
+    resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==}
+    engines: {node: '>=12'}
+
+  yargs@18.0.0:
+    resolution: {integrity: sha512-4UEqdc2RYGHZc7Doyqkrqiln3p9X2DZVxaGbwhn2pi7MrRagKaOcIKe8L3OxYcbhXLgLFUS3zAYuQjKBQgmuNg==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=23}
+
+  yauzl@2.10.0:
+    resolution: {integrity: sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==}
+
+  yocto-queue@0.1.0:
+    resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
+    engines: {node: '>=10'}
+
+  yocto-queue@1.2.2:
+    resolution: {integrity: sha512-4LCcse/U2MHZ63HAJVE+v71o7yOdIe4cZ70Wpf8D/IyjDKYQLV5GD46B+hSTjJsvV5PztjvHoU580EftxjDZFQ==}
+    engines: {node: '>=12.20'}
+
+  yoctocolors-cjs@2.1.2:
+    resolution: {integrity: sha512-cYVsTjKl8b+FrnidjibDWskAv7UKOfcwaVZdp/it9n1s9fU3IkgDbhdIRKCW4JDsAlECJY0ytoVPT3sK6kideA==}
+    engines: {node: '>=18'}
+
+  yoga-layout@3.2.1:
+    resolution: {integrity: sha512-0LPOt3AxKqMdFBZA3HBAt/t/8vIKq7VaQYbuA8WxCgung+p9TVyKRYdpvCb80HcdTN2NkbIKbhNwKUfm3tQywQ==}
+
+  zod-openapi@5.4.5:
+    resolution: {integrity: sha512-DVLBNsnggh8k/Yq7qp+NeQCH6JuLIyGzUQWA1wN5+7DpQJSwC7WYR/2lE6uQDmGcS/X6l4tUyYFpeG4nk3nOpA==}
+    engines: {node: '>=20'}
+    peerDependencies:
+      zod: ^3.25.74 || ^4.0.0
+
+  zod-to-json-schema@3.25.0:
+    resolution: {integrity: sha512-HvWtU2UG41LALjajJrML6uQejQhNJx+JBO9IflpSja4R03iNWfKXrj6W2h7ljuLyc1nKS+9yDyL/9tD1U/yBnQ==}
+    peerDependencies:
+      zod: ^3.25 || ^4
+
+  zod@3.23.8:
+    resolution: {integrity: sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==}
+
+  zod@3.25.76:
+    resolution: {integrity: sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==}
+
+  zod@4.2.1:
+    resolution: {integrity: sha512-0wZ1IRqGGhMP76gLqz8EyfBXKk0J2qo2+H3fi4mcUP/KtTocoX08nmIAHl1Z2kJIZbZee8KOpBCSNPRgauucjw==}
+
+  zwitch@2.0.4:
+    resolution: {integrity: sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==}
+
+snapshots:
+
+  '@ai-sdk/amazon-bedrock@3.0.73(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/anthropic': 2.0.57(zod@4.2.1)
+      '@ai-sdk/provider': 2.0.1
+      '@ai-sdk/provider-utils': 3.0.20(zod@4.2.1)
+      '@smithy/eventstream-codec': 4.2.8
+      '@smithy/util-utf8': 4.2.0
+      aws4fetch: 1.0.20
+      zod: 4.2.1
+    optional: true
+
+  '@ai-sdk/anthropic@2.0.53(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/provider': 2.0.0
+      '@ai-sdk/provider-utils': 3.0.18(zod@4.2.1)
+      zod: 4.2.1
+    optional: true
+
+  '@ai-sdk/anthropic@2.0.57(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/provider': 2.0.1
+      '@ai-sdk/provider-utils': 3.0.20(zod@4.2.1)
+      zod: 4.2.1
+    optional: true
+
+  '@ai-sdk/azure@2.0.54(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/openai': 2.0.53(zod@4.2.1)
+      '@ai-sdk/provider': 2.0.0
+      '@ai-sdk/provider-utils': 3.0.12(zod@4.2.1)
+      zod: 4.2.1
+    optional: true
+
+  '@ai-sdk/cerebras@1.0.25(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/openai-compatible': 1.0.22(zod@4.2.1)
+      '@ai-sdk/provider': 2.0.0
+      '@ai-sdk/provider-utils': 3.0.12(zod@4.2.1)
+      zod: 4.2.1
+    optional: true
+
+  '@ai-sdk/deepseek@1.0.23(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/openai-compatible': 1.0.22(zod@4.2.1)
+      '@ai-sdk/provider': 2.0.0
+      '@ai-sdk/provider-utils': 3.0.12(zod@4.2.1)
+      zod: 4.2.1
+    optional: true
+
+  '@ai-sdk/gateway@2.0.39(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/provider': 2.0.1
+      '@ai-sdk/provider-utils': 3.0.21(zod@4.2.1)
+      '@vercel/oidc': 3.1.0
+      zod: 4.2.1
+
+  '@ai-sdk/google-vertex@3.0.85(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/anthropic': 2.0.53(zod@4.2.1)
+      '@ai-sdk/google': 2.0.44(zod@4.2.1)
+      '@ai-sdk/provider': 2.0.0
+      '@ai-sdk/provider-utils': 3.0.18(zod@4.2.1)
+      google-auth-library: 10.5.0
+      zod: 4.2.1
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
+  '@ai-sdk/google@2.0.44(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/provider': 2.0.0
+      '@ai-sdk/provider-utils': 3.0.18(zod@4.2.1)
+      zod: 4.2.1
+    optional: true
+
+  '@ai-sdk/google@2.0.53(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/provider': 2.0.1
+      '@ai-sdk/provider-utils': 3.0.21(zod@4.2.1)
+      zod: 4.2.1
+    optional: true
+
+  '@ai-sdk/groq@2.0.24(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/provider': 2.0.0
+      '@ai-sdk/provider-utils': 3.0.12(zod@4.2.1)
+      zod: 4.2.1
+    optional: true
+
+  '@ai-sdk/mistral@2.0.19(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/provider': 2.0.0
+      '@ai-sdk/provider-utils': 3.0.12(zod@4.2.1)
+      zod: 4.2.1
+    optional: true
+
+  '@ai-sdk/openai-compatible@1.0.22(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/provider': 2.0.0
+      '@ai-sdk/provider-utils': 3.0.12(zod@4.2.1)
+      zod: 4.2.1
+    optional: true
+
+  '@ai-sdk/openai@2.0.53(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/provider': 2.0.0
+      '@ai-sdk/provider-utils': 3.0.12(zod@4.2.1)
+      zod: 4.2.1
+    optional: true
+
+  '@ai-sdk/perplexity@2.0.13(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/provider': 2.0.0
+      '@ai-sdk/provider-utils': 3.0.12(zod@4.2.1)
+      zod: 4.2.1
+    optional: true
+
+  '@ai-sdk/provider-utils@3.0.12(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/provider': 2.0.0
+      '@standard-schema/spec': 1.1.0
+      eventsource-parser: 3.0.6
+      zod: 4.2.1
+    optional: true
+
+  '@ai-sdk/provider-utils@3.0.18(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/provider': 2.0.0
+      '@standard-schema/spec': 1.1.0
+      eventsource-parser: 3.0.6
+      zod: 4.2.1
+    optional: true
+
+  '@ai-sdk/provider-utils@3.0.20(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/provider': 2.0.1
+      '@standard-schema/spec': 1.1.0
+      eventsource-parser: 3.0.6
+      zod: 4.2.1
+    optional: true
+
+  '@ai-sdk/provider-utils@3.0.21(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/provider': 2.0.1
+      '@standard-schema/spec': 1.1.0
+      eventsource-parser: 3.0.6
+      zod: 4.2.1
+
+  '@ai-sdk/provider@1.1.3':
+    dependencies:
+      json-schema: 0.4.0
+
+  '@ai-sdk/provider@2.0.0':
+    dependencies:
+      json-schema: 0.4.0
+    optional: true
+
+  '@ai-sdk/provider@2.0.1':
+    dependencies:
+      json-schema: 0.4.0
+
+  '@ai-sdk/togetherai@1.0.23(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/openai-compatible': 1.0.22(zod@4.2.1)
+      '@ai-sdk/provider': 2.0.0
+      '@ai-sdk/provider-utils': 3.0.12(zod@4.2.1)
+      zod: 4.2.1
+    optional: true
+
+  '@ai-sdk/xai@2.0.26(zod@4.2.1)':
+    dependencies:
+      '@ai-sdk/openai-compatible': 1.0.22(zod@4.2.1)
+      '@ai-sdk/provider': 2.0.0
+      '@ai-sdk/provider-utils': 3.0.12(zod@4.2.1)
+      zod: 4.2.1
+    optional: true
+
+  '@alcalzone/ansi-tokenize@0.1.3':
+    dependencies:
+      ansi-styles: 6.2.1
+      is-fullwidth-code-point: 4.0.0
+
+  '@alloc/quick-lru@5.2.0': {}
+
+  '@anthropic-ai/sdk@0.39.0':
+    dependencies:
+      '@types/node': 18.19.87
+      '@types/node-fetch': 2.6.12
+      abort-controller: 3.0.0
+      agentkeepalive: 4.6.0
+      form-data-encoder: 1.7.2
+      formdata-node: 4.4.1
+      node-fetch: 2.7.0
+    transitivePeerDependencies:
+      - encoding
+
+  '@ark/schema@0.46.0':
+    dependencies:
+      '@ark/util': 0.46.0
+
+  '@ark/util@0.46.0': {}
+
+  '@asamuzakjp/css-color@3.2.0':
+    dependencies:
+      '@csstools/css-calc': 2.1.4(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)
+      '@csstools/css-color-parser': 3.1.0(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)
+      '@csstools/css-parser-algorithms': 3.0.5(@csstools/css-tokenizer@3.0.4)
+      '@csstools/css-tokenizer': 3.0.4
+      lru-cache: 10.4.3
+
+  '@asyncapi/parser@3.4.0':
+    dependencies:
+      '@asyncapi/specs': 6.8.1
+      '@openapi-contrib/openapi-schema-to-json-schema': 3.2.0
+      '@stoplight/json': 3.21.0
+      '@stoplight/json-ref-readers': 1.2.2
+      '@stoplight/json-ref-resolver': 3.1.6
+      '@stoplight/spectral-core': 1.20.0
+      '@stoplight/spectral-functions': 1.10.1
+      '@stoplight/spectral-parsers': 1.0.5
+      '@stoplight/spectral-ref-resolver': 1.0.5
+      '@stoplight/types': 13.20.0
+      '@types/json-schema': 7.0.15
+      '@types/urijs': 1.19.25
+      ajv: 8.17.1
+      ajv-errors: 3.0.0(ajv@8.17.1)
+      ajv-formats: 2.1.1(ajv@8.17.1)
+      avsc: 5.7.7
+      js-yaml: 4.1.0
+      jsonpath-plus: 10.3.0
+      node-fetch: 2.6.7
+    transitivePeerDependencies:
+      - encoding
+
+  '@asyncapi/specs@6.8.1':
+    dependencies:
+      '@types/json-schema': 7.0.15
+
+  '@aws-crypto/crc32@5.2.0':
+    dependencies:
+      '@aws-crypto/util': 5.2.0
+      '@aws-sdk/types': 3.973.1
+      tslib: 2.8.1
+    optional: true
+
+  '@aws-crypto/util@5.2.0':
+    dependencies:
+      '@aws-sdk/types': 3.973.1
+      '@smithy/util-utf8': 2.3.0
+      tslib: 2.8.1
+    optional: true
+
+  '@aws-sdk/types@3.973.1':
+    dependencies:
+      '@smithy/types': 4.12.0
+      tslib: 2.8.1
+    optional: true
+
+  '@babel/code-frame@7.27.1':
+    dependencies:
+      '@babel/helper-validator-identifier': 7.28.5
+      js-tokens: 4.0.0
+      picocolors: 1.1.1
+
+  '@babel/helper-string-parser@7.27.1': {}
+
+  '@babel/helper-validator-identifier@7.28.5': {}
+
+  '@babel/parser@7.29.0':
+    dependencies:
+      '@babel/types': 7.29.0
+
+  '@babel/runtime@7.27.1': {}
+
+  '@babel/types@7.29.0':
+    dependencies:
+      '@babel/helper-string-parser': 7.27.1
+      '@babel/helper-validator-identifier': 7.28.5
+
+  '@bcoe/v8-coverage@1.0.2': {}
+
+  '@browserbasehq/sdk@2.7.0':
+    dependencies:
+      '@types/node': 18.19.87
+      '@types/node-fetch': 2.6.12
+      abort-controller: 3.0.0
+      agentkeepalive: 4.6.0
+      form-data-encoder: 1.7.2
+      formdata-node: 4.4.1
+      node-fetch: 2.7.0
+    transitivePeerDependencies:
+      - encoding
+
+  '@cfworker/json-schema@4.1.1': {}
+
+  '@changesets/apply-release-plan@7.0.12':
+    dependencies:
+      '@changesets/config': 3.1.1
+      '@changesets/get-version-range-type': 0.4.0
+      '@changesets/git': 3.0.4
+      '@changesets/should-skip-package': 0.1.2
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+      detect-indent: 6.1.0
+      fs-extra: 7.0.1
+      lodash.startcase: 4.4.0
+      outdent: 0.5.0
+      prettier: 2.8.8
+      resolve-from: 5.0.0
+      semver: 7.7.3
+
+  '@changesets/assemble-release-plan@6.0.6':
+    dependencies:
+      '@changesets/errors': 0.2.0
+      '@changesets/get-dependents-graph': 2.1.3
+      '@changesets/should-skip-package': 0.1.2
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+      semver: 7.7.3
+
+  '@changesets/changelog-git@0.2.1':
+    dependencies:
+      '@changesets/types': 6.1.0
+
+  '@changesets/changelog-github@0.5.1':
+    dependencies:
+      '@changesets/get-github-info': 0.6.0
+      '@changesets/types': 6.1.0
+      dotenv: 8.6.0
+    transitivePeerDependencies:
+      - encoding
+
+  '@changesets/cli@2.29.2':
+    dependencies:
+      '@changesets/apply-release-plan': 7.0.12
+      '@changesets/assemble-release-plan': 6.0.6
+      '@changesets/changelog-git': 0.2.1
+      '@changesets/config': 3.1.1
+      '@changesets/errors': 0.2.0
+      '@changesets/get-dependents-graph': 2.1.3
+      '@changesets/get-release-plan': 4.0.10
+      '@changesets/git': 3.0.4
+      '@changesets/logger': 0.1.1
+      '@changesets/pre': 2.0.2
+      '@changesets/read': 0.6.5
+      '@changesets/should-skip-package': 0.1.2
+      '@changesets/types': 6.1.0
+      '@changesets/write': 0.4.0
+      '@manypkg/get-packages': 1.1.3
+      ansi-colors: 4.1.3
+      ci-info: 3.9.0
+      enquirer: 2.4.1
+      external-editor: 3.1.0
+      fs-extra: 7.0.1
+      mri: 1.2.0
+      p-limit: 2.3.0
+      package-manager-detector: 0.2.11
+      picocolors: 1.1.1
+      resolve-from: 5.0.0
+      semver: 7.7.3
+      spawndamnit: 3.0.1
+      term-size: 2.2.1
+
+  '@changesets/config@3.1.1':
+    dependencies:
+      '@changesets/errors': 0.2.0
+      '@changesets/get-dependents-graph': 2.1.3
+      '@changesets/logger': 0.1.1
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+      fs-extra: 7.0.1
+      micromatch: 4.0.8
+
+  '@changesets/errors@0.2.0':
+    dependencies:
+      extendable-error: 0.1.7
+
+  '@changesets/get-dependents-graph@2.1.3':
+    dependencies:
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+      picocolors: 1.1.1
+      semver: 7.7.3
+
+  '@changesets/get-github-info@0.6.0':
+    dependencies:
+      dataloader: 1.4.0
+      node-fetch: 2.7.0
+    transitivePeerDependencies:
+      - encoding
+
+  '@changesets/get-release-plan@4.0.10':
+    dependencies:
+      '@changesets/assemble-release-plan': 6.0.6
+      '@changesets/config': 3.1.1
+      '@changesets/pre': 2.0.2
+      '@changesets/read': 0.6.5
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+
+  '@changesets/get-version-range-type@0.4.0': {}
+
+  '@changesets/git@3.0.4':
+    dependencies:
+      '@changesets/errors': 0.2.0
+      '@manypkg/get-packages': 1.1.3
+      is-subdir: 1.2.0
+      micromatch: 4.0.8
+      spawndamnit: 3.0.1
+
+  '@changesets/logger@0.1.1':
+    dependencies:
+      picocolors: 1.1.1
+
+  '@changesets/parse@0.4.1':
+    dependencies:
+      '@changesets/types': 6.1.0
+      js-yaml: 3.14.1
+
+  '@changesets/pre@2.0.2':
+    dependencies:
+      '@changesets/errors': 0.2.0
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+      fs-extra: 7.0.1
+
+  '@changesets/read@0.6.5':
+    dependencies:
+      '@changesets/git': 3.0.4
+      '@changesets/logger': 0.1.1
+      '@changesets/parse': 0.4.1
+      '@changesets/types': 6.1.0
+      fs-extra: 7.0.1
+      p-filter: 2.1.0
+      picocolors: 1.1.1
+
+  '@changesets/should-skip-package@0.1.2':
+    dependencies:
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+
+  '@changesets/types@4.1.0': {}
+
+  '@changesets/types@6.1.0': {}
+
+  '@changesets/write@0.4.0':
+    dependencies:
+      '@changesets/types': 6.1.0
+      fs-extra: 7.0.1
+      human-id: 4.1.1
+      prettier: 2.8.8
+
+  '@csstools/color-helpers@5.1.0': {}
+
+  '@csstools/css-calc@2.1.4(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)':
+    dependencies:
+      '@csstools/css-parser-algorithms': 3.0.5(@csstools/css-tokenizer@3.0.4)
+      '@csstools/css-tokenizer': 3.0.4
+
+  '@csstools/css-color-parser@3.1.0(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)':
+    dependencies:
+      '@csstools/color-helpers': 5.1.0
+      '@csstools/css-calc': 2.1.4(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)
+      '@csstools/css-parser-algorithms': 3.0.5(@csstools/css-tokenizer@3.0.4)
+      '@csstools/css-tokenizer': 3.0.4
+
+  '@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4)':
+    dependencies:
+      '@csstools/css-tokenizer': 3.0.4
+
+  '@csstools/css-tokenizer@3.0.4': {}
+
+  '@emnapi/runtime@1.7.1':
+    dependencies:
+      tslib: 2.8.1
+    optional: true
+
+  '@esbuild/aix-ppc64@0.21.5':
+    optional: true
+
+  '@esbuild/aix-ppc64@0.25.11':
+    optional: true
+
+  '@esbuild/aix-ppc64@0.27.2':
+    optional: true
+
+  '@esbuild/android-arm64@0.21.5':
+    optional: true
+
+  '@esbuild/android-arm64@0.25.11':
+    optional: true
+
+  '@esbuild/android-arm64@0.27.2':
+    optional: true
+
+  '@esbuild/android-arm@0.21.5':
+    optional: true
+
+  '@esbuild/android-arm@0.25.11':
+    optional: true
+
+  '@esbuild/android-arm@0.27.2':
+    optional: true
+
+  '@esbuild/android-x64@0.21.5':
+    optional: true
+
+  '@esbuild/android-x64@0.25.11':
+    optional: true
+
+  '@esbuild/android-x64@0.27.2':
+    optional: true
+
+  '@esbuild/darwin-arm64@0.21.5':
+    optional: true
+
+  '@esbuild/darwin-arm64@0.25.11':
+    optional: true
+
+  '@esbuild/darwin-arm64@0.27.2':
+    optional: true
+
+  '@esbuild/darwin-x64@0.21.5':
+    optional: true
+
+  '@esbuild/darwin-x64@0.25.11':
+    optional: true
+
+  '@esbuild/darwin-x64@0.27.2':
+    optional: true
+
+  '@esbuild/freebsd-arm64@0.21.5':
+    optional: true
+
+  '@esbuild/freebsd-arm64@0.25.11':
+    optional: true
+
+  '@esbuild/freebsd-arm64@0.27.2':
+    optional: true
+
+  '@esbuild/freebsd-x64@0.21.5':
+    optional: true
+
+  '@esbuild/freebsd-x64@0.25.11':
+    optional: true
+
+  '@esbuild/freebsd-x64@0.27.2':
+    optional: true
+
+  '@esbuild/linux-arm64@0.21.5':
+    optional: true
+
+  '@esbuild/linux-arm64@0.25.11':
+    optional: true
+
+  '@esbuild/linux-arm64@0.27.2':
+    optional: true
+
+  '@esbuild/linux-arm@0.21.5':
+    optional: true
+
+  '@esbuild/linux-arm@0.25.11':
+    optional: true
+
+  '@esbuild/linux-arm@0.27.2':
+    optional: true
+
+  '@esbuild/linux-ia32@0.21.5':
+    optional: true
+
+  '@esbuild/linux-ia32@0.25.11':
+    optional: true
+
+  '@esbuild/linux-ia32@0.27.2':
+    optional: true
+
+  '@esbuild/linux-loong64@0.21.5':
+    optional: true
+
+  '@esbuild/linux-loong64@0.25.11':
+    optional: true
+
+  '@esbuild/linux-loong64@0.27.2':
+    optional: true
+
+  '@esbuild/linux-mips64el@0.21.5':
+    optional: true
+
+  '@esbuild/linux-mips64el@0.25.11':
+    optional: true
+
+  '@esbuild/linux-mips64el@0.27.2':
+    optional: true
+
+  '@esbuild/linux-ppc64@0.21.5':
+    optional: true
+
+  '@esbuild/linux-ppc64@0.25.11':
+    optional: true
+
+  '@esbuild/linux-ppc64@0.27.2':
+    optional: true
+
+  '@esbuild/linux-riscv64@0.21.5':
+    optional: true
+
+  '@esbuild/linux-riscv64@0.25.11':
+    optional: true
+
+  '@esbuild/linux-riscv64@0.27.2':
+    optional: true
+
+  '@esbuild/linux-s390x@0.21.5':
+    optional: true
+
+  '@esbuild/linux-s390x@0.25.11':
+    optional: true
+
+  '@esbuild/linux-s390x@0.27.2':
+    optional: true
+
+  '@esbuild/linux-x64@0.21.5':
+    optional: true
+
+  '@esbuild/linux-x64@0.25.11':
+    optional: true
+
+  '@esbuild/linux-x64@0.27.2':
+    optional: true
+
+  '@esbuild/netbsd-arm64@0.25.11':
+    optional: true
+
+  '@esbuild/netbsd-arm64@0.27.2':
+    optional: true
+
+  '@esbuild/netbsd-x64@0.21.5':
+    optional: true
+
+  '@esbuild/netbsd-x64@0.25.11':
+    optional: true
+
+  '@esbuild/netbsd-x64@0.27.2':
+    optional: true
+
+  '@esbuild/openbsd-arm64@0.25.11':
+    optional: true
+
+  '@esbuild/openbsd-arm64@0.27.2':
+    optional: true
+
+  '@esbuild/openbsd-x64@0.21.5':
+    optional: true
+
+  '@esbuild/openbsd-x64@0.25.11':
+    optional: true
+
+  '@esbuild/openbsd-x64@0.27.2':
+    optional: true
+
+  '@esbuild/openharmony-arm64@0.25.11':
+    optional: true
+
+  '@esbuild/openharmony-arm64@0.27.2':
+    optional: true
+
+  '@esbuild/sunos-x64@0.21.5':
+    optional: true
+
+  '@esbuild/sunos-x64@0.25.11':
+    optional: true
+
+  '@esbuild/sunos-x64@0.27.2':
+    optional: true
+
+  '@esbuild/win32-arm64@0.21.5':
+    optional: true
+
+  '@esbuild/win32-arm64@0.25.11':
+    optional: true
+
+  '@esbuild/win32-arm64@0.27.2':
+    optional: true
+
+  '@esbuild/win32-ia32@0.21.5':
+    optional: true
+
+  '@esbuild/win32-ia32@0.25.11':
+    optional: true
+
+  '@esbuild/win32-ia32@0.27.2':
+    optional: true
+
+  '@esbuild/win32-x64@0.21.5':
+    optional: true
+
+  '@esbuild/win32-x64@0.25.11':
+    optional: true
+
+  '@esbuild/win32-x64@0.27.2':
+    optional: true
+
+  '@eslint-community/eslint-utils@4.9.1(eslint@10.0.2(jiti@1.21.7))':
+    dependencies:
+      eslint: 10.0.2(jiti@1.21.7)
+      eslint-visitor-keys: 3.4.3
+
+  '@eslint-community/eslint-utils@4.9.1(eslint@9.39.4(jiti@1.21.7))':
+    dependencies:
+      eslint: 9.39.4(jiti@1.21.7)
+      eslint-visitor-keys: 3.4.3
+
+  '@eslint-community/regexpp@4.12.2': {}
+
+  '@eslint/config-array@0.21.2':
+    dependencies:
+      '@eslint/object-schema': 2.1.7
+      debug: 4.4.3
+      minimatch: 3.1.5
+    transitivePeerDependencies:
+      - supports-color
+
+  '@eslint/config-array@0.23.2':
+    dependencies:
+      '@eslint/object-schema': 3.0.2
+      debug: 4.4.3
+      minimatch: 10.2.2
+    transitivePeerDependencies:
+      - supports-color
+
+  '@eslint/config-helpers@0.4.2':
+    dependencies:
+      '@eslint/core': 0.17.0
+
+  '@eslint/config-helpers@0.5.2':
+    dependencies:
+      '@eslint/core': 1.1.0
+
+  '@eslint/core@0.17.0':
+    dependencies:
+      '@types/json-schema': 7.0.15
+
+  '@eslint/core@1.1.0':
+    dependencies:
+      '@types/json-schema': 7.0.15
+
+  '@eslint/eslintrc@3.3.5':
+    dependencies:
+      ajv: 6.14.0
+      debug: 4.4.3
+      espree: 10.4.0
+      globals: 14.0.0
+      ignore: 5.3.2
+      import-fresh: 3.3.1
+      js-yaml: 4.1.1
+      minimatch: 3.1.5
+      strip-json-comments: 3.1.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@eslint/js@10.0.1(eslint@10.0.2(jiti@1.21.7))':
+    optionalDependencies:
+      eslint: 10.0.2(jiti@1.21.7)
+
+  '@eslint/js@9.39.4': {}
+
+  '@eslint/object-schema@2.1.7': {}
+
+  '@eslint/object-schema@3.0.2': {}
+
+  '@eslint/plugin-kit@0.4.1':
+    dependencies:
+      '@eslint/core': 0.17.0
+      levn: 0.4.1
+
+  '@eslint/plugin-kit@0.6.0':
+    dependencies:
+      '@eslint/core': 1.1.0
+      levn: 0.4.1
+
+  '@fastify/accept-negotiator@2.0.1': {}
+
+  '@fastify/ajv-compiler@4.0.5':
+    dependencies:
+      ajv: 8.17.1
+      ajv-formats: 3.0.1(ajv@8.17.1)
+      fast-uri: 3.0.6
+
+  '@fastify/cors@11.1.0':
+    dependencies:
+      fastify-plugin: 5.1.0
+      toad-cache: 3.7.0
+
+  '@fastify/error@4.2.0': {}
+
+  '@fastify/fast-json-stringify-compiler@5.0.3':
+    dependencies:
+      fast-json-stringify: 6.1.1
+
+  '@fastify/forwarded@3.0.1': {}
+
+  '@fastify/merge-json-schemas@0.2.1':
+    dependencies:
+      dequal: 2.0.3
+
+  '@fastify/proxy-addr@5.1.0':
+    dependencies:
+      '@fastify/forwarded': 3.0.1
+      ipaddr.js: 2.3.0
+
+  '@fastify/send@4.1.0':
+    dependencies:
+      '@lukeed/ms': 2.0.2
+      escape-html: 1.0.3
+      fast-decode-uri-component: 1.0.1
+      http-errors: 2.0.0
+      mime: 3.0.0
+
+  '@fastify/static@8.3.0':
+    dependencies:
+      '@fastify/accept-negotiator': 2.0.1
+      '@fastify/send': 4.1.0
+      content-disposition: 0.5.4
+      fastify-plugin: 5.1.0
+      fastq: 1.19.1
+      glob: 11.1.0
+
+  '@fastify/swagger-ui@5.2.3':
+    dependencies:
+      '@fastify/static': 8.3.0
+      fastify-plugin: 5.1.0
+      openapi-types: 12.1.3
+      rfdc: 1.4.1
+      yaml: 2.7.1
+
+  '@fastify/swagger@9.6.1':
+    dependencies:
+      fastify-plugin: 5.1.0
+      json-schema-resolver: 3.0.0
+      openapi-types: 12.1.3
+      rfdc: 1.4.1
+      yaml: 2.7.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@google/genai@1.24.0(@modelcontextprotocol/sdk@1.17.2)(bufferutil@4.0.9)':
+    dependencies:
+      google-auth-library: 9.15.1
+      ws: 8.18.3(bufferutil@4.0.9)
+    optionalDependencies:
+      '@modelcontextprotocol/sdk': 1.17.2
+    transitivePeerDependencies:
+      - bufferutil
+      - encoding
+      - supports-color
+      - utf-8-validate
+
+  '@humanfs/core@0.19.1': {}
+
+  '@humanfs/node@0.16.6':
+    dependencies:
+      '@humanfs/core': 0.19.1
+      '@humanwhocodes/retry': 0.3.1
+
+  '@humanwhocodes/module-importer@1.0.1': {}
+
+  '@humanwhocodes/retry@0.3.1': {}
+
+  '@humanwhocodes/retry@0.4.2': {}
+
+  '@img/colour@1.0.0': {}
+
+  '@img/sharp-darwin-arm64@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-arm64': 1.0.4
+    optional: true
+
+  '@img/sharp-darwin-arm64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-arm64': 1.2.4
+    optional: true
+
+  '@img/sharp-darwin-x64@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-x64': 1.0.4
+    optional: true
+
+  '@img/sharp-darwin-x64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-x64': 1.2.4
+    optional: true
+
+  '@img/sharp-libvips-darwin-arm64@1.0.4':
+    optional: true
+
+  '@img/sharp-libvips-darwin-arm64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-darwin-x64@1.0.4':
+    optional: true
+
+  '@img/sharp-libvips-darwin-x64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm64@1.0.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm@1.0.5':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-ppc64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-riscv64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-s390x@1.0.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-s390x@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-x64@1.0.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-x64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linuxmusl-arm64@1.0.4':
+    optional: true
+
+  '@img/sharp-libvips-linuxmusl-arm64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linuxmusl-x64@1.0.4':
+    optional: true
+
+  '@img/sharp-libvips-linuxmusl-x64@1.2.4':
+    optional: true
+
+  '@img/sharp-linux-arm64@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm64': 1.0.4
+    optional: true
+
+  '@img/sharp-linux-arm64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm64': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-arm@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm': 1.0.5
+    optional: true
+
+  '@img/sharp-linux-arm@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-ppc64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-ppc64': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-riscv64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-riscv64': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-s390x@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-s390x': 1.0.4
+    optional: true
+
+  '@img/sharp-linux-s390x@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-s390x': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-x64@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-x64': 1.0.4
+    optional: true
+
+  '@img/sharp-linux-x64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-x64': 1.2.4
+    optional: true
+
+  '@img/sharp-linuxmusl-arm64@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-arm64': 1.0.4
+    optional: true
+
+  '@img/sharp-linuxmusl-arm64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-arm64': 1.2.4
+    optional: true
+
+  '@img/sharp-linuxmusl-x64@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-x64': 1.0.4
+    optional: true
+
+  '@img/sharp-linuxmusl-x64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-x64': 1.2.4
+    optional: true
+
+  '@img/sharp-wasm32@0.33.5':
+    dependencies:
+      '@emnapi/runtime': 1.7.1
+    optional: true
+
+  '@img/sharp-wasm32@0.34.5':
+    dependencies:
+      '@emnapi/runtime': 1.7.1
+    optional: true
+
+  '@img/sharp-win32-arm64@0.34.5':
+    optional: true
+
+  '@img/sharp-win32-ia32@0.33.5':
+    optional: true
+
+  '@img/sharp-win32-ia32@0.34.5':
+    optional: true
+
+  '@img/sharp-win32-x64@0.33.5':
+    optional: true
+
+  '@img/sharp-win32-x64@0.34.5':
+    optional: true
+
+  '@inquirer/checkbox@4.1.5(@types/node@22.13.1)':
+    dependencies:
+      '@inquirer/core': 10.1.10(@types/node@22.13.1)
+      '@inquirer/figures': 1.0.11
+      '@inquirer/type': 3.0.6(@types/node@22.13.1)
+      ansi-escapes: 4.3.2
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 22.13.1
+
+  '@inquirer/confirm@5.1.9(@types/node@22.13.1)':
+    dependencies:
+      '@inquirer/core': 10.1.10(@types/node@22.13.1)
+      '@inquirer/type': 3.0.6(@types/node@22.13.1)
+    optionalDependencies:
+      '@types/node': 22.13.1
+
+  '@inquirer/core@10.1.10(@types/node@22.13.1)':
+    dependencies:
+      '@inquirer/figures': 1.0.11
+      '@inquirer/type': 3.0.6(@types/node@22.13.1)
+      ansi-escapes: 4.3.2
+      cli-width: 4.1.0
+      mute-stream: 2.0.0
+      signal-exit: 4.1.0
+      wrap-ansi: 6.2.0
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 22.13.1
+
+  '@inquirer/editor@4.2.10(@types/node@22.13.1)':
+    dependencies:
+      '@inquirer/core': 10.1.10(@types/node@22.13.1)
+      '@inquirer/type': 3.0.6(@types/node@22.13.1)
+      external-editor: 3.1.0
+    optionalDependencies:
+      '@types/node': 22.13.1
+
+  '@inquirer/expand@4.0.12(@types/node@22.13.1)':
+    dependencies:
+      '@inquirer/core': 10.1.10(@types/node@22.13.1)
+      '@inquirer/type': 3.0.6(@types/node@22.13.1)
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 22.13.1
+
+  '@inquirer/figures@1.0.11': {}
+
+  '@inquirer/input@4.1.9(@types/node@22.13.1)':
+    dependencies:
+      '@inquirer/core': 10.1.10(@types/node@22.13.1)
+      '@inquirer/type': 3.0.6(@types/node@22.13.1)
+    optionalDependencies:
+      '@types/node': 22.13.1
+
+  '@inquirer/number@3.0.12(@types/node@22.13.1)':
+    dependencies:
+      '@inquirer/core': 10.1.10(@types/node@22.13.1)
+      '@inquirer/type': 3.0.6(@types/node@22.13.1)
+    optionalDependencies:
+      '@types/node': 22.13.1
+
+  '@inquirer/password@4.0.12(@types/node@22.13.1)':
+    dependencies:
+      '@inquirer/core': 10.1.10(@types/node@22.13.1)
+      '@inquirer/type': 3.0.6(@types/node@22.13.1)
+      ansi-escapes: 4.3.2
+    optionalDependencies:
+      '@types/node': 22.13.1
+
+  '@inquirer/prompts@7.5.0(@types/node@22.13.1)':
+    dependencies:
+      '@inquirer/checkbox': 4.1.5(@types/node@22.13.1)
+      '@inquirer/confirm': 5.1.9(@types/node@22.13.1)
+      '@inquirer/editor': 4.2.10(@types/node@22.13.1)
+      '@inquirer/expand': 4.0.12(@types/node@22.13.1)
+      '@inquirer/input': 4.1.9(@types/node@22.13.1)
+      '@inquirer/number': 3.0.12(@types/node@22.13.1)
+      '@inquirer/password': 4.0.12(@types/node@22.13.1)
+      '@inquirer/rawlist': 4.1.0(@types/node@22.13.1)
+      '@inquirer/search': 3.0.12(@types/node@22.13.1)
+      '@inquirer/select': 4.2.0(@types/node@22.13.1)
+    optionalDependencies:
+      '@types/node': 22.13.1
+
+  '@inquirer/rawlist@4.1.0(@types/node@22.13.1)':
+    dependencies:
+      '@inquirer/core': 10.1.10(@types/node@22.13.1)
+      '@inquirer/type': 3.0.6(@types/node@22.13.1)
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 22.13.1
+
+  '@inquirer/search@3.0.12(@types/node@22.13.1)':
+    dependencies:
+      '@inquirer/core': 10.1.10(@types/node@22.13.1)
+      '@inquirer/figures': 1.0.11
+      '@inquirer/type': 3.0.6(@types/node@22.13.1)
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 22.13.1
+
+  '@inquirer/select@4.2.0(@types/node@22.13.1)':
+    dependencies:
+      '@inquirer/core': 10.1.10(@types/node@22.13.1)
+      '@inquirer/figures': 1.0.11
+      '@inquirer/type': 3.0.6(@types/node@22.13.1)
+      ansi-escapes: 4.3.2
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 22.13.1
+
+  '@inquirer/type@3.0.6(@types/node@22.13.1)':
+    optionalDependencies:
+      '@types/node': 22.13.1
+
+  '@isaacs/balanced-match@4.0.1': {}
+
+  '@isaacs/brace-expansion@5.0.0':
+    dependencies:
+      '@isaacs/balanced-match': 4.0.1
+
+  '@isaacs/cliui@8.0.2':
+    dependencies:
+      string-width: 5.1.2
+      string-width-cjs: string-width@4.2.3
+      strip-ansi: 7.1.0
+      strip-ansi-cjs: strip-ansi@6.0.1
+      wrap-ansi: 8.1.0
+      wrap-ansi-cjs: wrap-ansi@7.0.0
+
+  '@istanbuljs/schema@0.1.3': {}
+
+  '@jest/schemas@29.6.3':
+    dependencies:
+      '@sinclair/typebox': 0.27.10
+
+  '@jridgewell/gen-mapping@0.3.8':
+    dependencies:
+      '@jridgewell/set-array': 1.2.1
+      '@jridgewell/sourcemap-codec': 1.5.5
+      '@jridgewell/trace-mapping': 0.3.31
+
+  '@jridgewell/resolve-uri@3.1.2': {}
+
+  '@jridgewell/set-array@1.2.1': {}
+
+  '@jridgewell/sourcemap-codec@1.5.5': {}
+
+  '@jridgewell/trace-mapping@0.3.31':
+    dependencies:
+      '@jridgewell/resolve-uri': 3.1.2
+      '@jridgewell/sourcemap-codec': 1.5.5
+
+  '@jsep-plugin/assignment@1.3.0(jsep@1.4.0)':
+    dependencies:
+      jsep: 1.4.0
+
+  '@jsep-plugin/regex@1.0.4(jsep@1.4.0)':
+    dependencies:
+      jsep: 1.4.0
+
+  '@jsep-plugin/ternary@1.1.4(jsep@1.4.0)':
+    dependencies:
+      jsep: 1.4.0
+
+  '@kwsites/file-exists@1.1.1':
+    dependencies:
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@kwsites/promise-deferred@1.1.1': {}
+
+  '@langchain/core@0.3.50(openai@4.87.1(ws@8.18.3(bufferutil@4.0.9))(zod@4.2.1))':
+    dependencies:
+      '@cfworker/json-schema': 4.1.1
+      ansi-styles: 5.2.0
+      camelcase: 6.3.0
+      decamelize: 1.2.0
+      js-tiktoken: 1.0.20
+      langsmith: 0.3.23(openai@4.87.1(ws@8.18.3(bufferutil@4.0.9))(zod@4.2.1))
+      mustache: 4.2.0
+      p-queue: 6.6.2
+      p-retry: 4.6.2
+      uuid: 10.0.0
+      zod: 3.25.76
+      zod-to-json-schema: 3.25.0(zod@3.25.76)
+    transitivePeerDependencies:
+      - openai
+
+  '@langchain/openai@0.4.9(@langchain/core@0.3.50(openai@4.87.1(ws@8.18.3(bufferutil@4.0.9))(zod@4.2.1)))(ws@8.18.3(bufferutil@4.0.9))':
+    dependencies:
+      '@langchain/core': 0.3.50(openai@4.87.1(ws@8.18.3(bufferutil@4.0.9))(zod@4.2.1))
+      js-tiktoken: 1.0.20
+      openai: 4.96.2(ws@8.18.3(bufferutil@4.0.9))(zod@3.25.76)
+      zod: 3.25.76
+      zod-to-json-schema: 3.25.0(zod@3.25.76)
+    transitivePeerDependencies:
+      - encoding
+      - ws
+
+  '@leichtgewicht/ip-codec@2.0.5': {}
+
+  '@lukeed/ms@2.0.2': {}
+
+  '@manypkg/find-root@1.1.0':
+    dependencies:
+      '@babel/runtime': 7.27.1
+      '@types/node': 12.20.55
+      find-up: 4.1.0
+      fs-extra: 8.1.0
+
+  '@manypkg/get-packages@1.1.3':
+    dependencies:
+      '@babel/runtime': 7.27.1
+      '@changesets/types': 4.1.0
+      '@manypkg/find-root': 1.1.0
+      fs-extra: 8.1.0
+      globby: 11.1.0
+      read-yaml-file: 1.1.0
+
+  '@mdx-js/mdx@3.1.0(acorn@8.15.0)':
+    dependencies:
+      '@types/estree': 1.0.8
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdx': 2.0.13
+      collapse-white-space: 2.1.0
+      devlop: 1.1.0
+      estree-util-is-identifier-name: 3.0.0
+      estree-util-scope: 1.0.0
+      estree-walker: 3.0.3
+      hast-util-to-jsx-runtime: 2.3.6
+      markdown-extensions: 2.0.0
+      recma-build-jsx: 1.0.0
+      recma-jsx: 1.0.0(acorn@8.15.0)
+      recma-stringify: 1.0.0
+      rehype-recma: 1.0.0
+      remark-mdx: 3.1.0
+      remark-parse: 11.0.0
+      remark-rehype: 11.1.2
+      source-map: 0.7.4
+      unified: 11.0.5
+      unist-util-position-from-estree: 2.0.0
+      unist-util-stringify-position: 4.0.0
+      unist-util-visit: 5.0.0
+      vfile: 6.0.3
+    transitivePeerDependencies:
+      - acorn
+      - supports-color
+
+  '@mdx-js/react@3.1.0(@types/react@19.1.3)(react@18.3.1)':
+    dependencies:
+      '@types/mdx': 2.0.13
+      '@types/react': 19.1.3
+      react: 18.3.1
+
+  '@mintlify/cli@4.0.682(@types/node@22.13.1)(@types/react@19.1.3)(bufferutil@4.0.9)(react-dom@18.3.1(react@18.3.1))(typescript@5.9.3)':
+    dependencies:
+      '@mintlify/common': 1.0.496(@types/react@19.1.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@mintlify/link-rot': 3.0.629(@types/react@19.1.3)(bufferutil@4.0.9)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.9.3)
+      '@mintlify/models': 0.0.219
+      '@mintlify/prebuild': 1.0.618(@types/react@19.1.3)(bufferutil@4.0.9)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.9.3)
+      '@mintlify/previewing': 4.0.665(@types/react@19.1.3)(bufferutil@4.0.9)(react-dom@18.3.1(react@18.3.1))(typescript@5.9.3)
+      '@mintlify/validation': 0.1.442
+      chalk: 5.4.1
+      detect-port: 1.6.1
+      fs-extra: 11.3.0
+      gray-matter: 4.0.3
+      ink: 5.2.1(@types/react@19.1.3)(bufferutil@4.0.9)(react@18.3.1)
+      inquirer: 12.6.0(@types/node@22.13.1)
+      js-yaml: 4.1.0
+      react: 18.3.1
+      semver: 7.7.3
+      yargs: 17.7.2
+    transitivePeerDependencies:
+      - '@types/node'
+      - '@types/react'
+      - bare-buffer
+      - bufferutil
+      - debug
+      - encoding
+      - react-devtools-core
+      - react-dom
+      - supports-color
+      - ts-node
+      - typescript
+      - utf-8-validate
+
+  '@mintlify/common@1.0.496(@types/react@19.1.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+    dependencies:
+      '@asyncapi/parser': 3.4.0
+      '@mintlify/mdx': 2.0.3(@types/react@19.1.3)(acorn@8.15.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@mintlify/models': 0.0.219
+      '@mintlify/openapi-parser': 0.0.7
+      '@mintlify/validation': 0.1.442
+      '@sindresorhus/slugify': 2.2.1
+      acorn: 8.15.0
+      acorn-jsx: 5.3.2(acorn@8.15.0)
+      estree-util-to-js: 2.0.0
+      estree-walker: 3.0.3
+      gray-matter: 4.0.3
+      hast-util-from-html: 2.0.3
+      hast-util-to-html: 9.0.5
+      hast-util-to-text: 4.0.2
+      js-yaml: 4.1.0
+      lodash: 4.17.21
+      mdast: 3.0.0
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-gfm: 3.1.0
+      mdast-util-mdx: 3.0.0
+      mdast-util-mdx-jsx: 3.2.0
+      micromark-extension-gfm: 3.0.0
+      micromark-extension-mdx-jsx: 3.0.2
+      micromark-extension-mdxjs: 3.0.0
+      openapi-types: 12.1.3
+      postcss: 8.5.6
+      remark: 15.0.1
+      remark-frontmatter: 5.0.0
+      remark-gfm: 4.0.1
+      remark-math: 6.0.0
+      remark-mdx: 3.1.0
+      remark-stringify: 11.0.0
+      tailwindcss: 3.4.17
+      unified: 11.0.5
+      unist-builder: 4.0.0
+      unist-util-map: 4.0.0
+      unist-util-remove: 4.0.0
+      unist-util-remove-position: 5.0.0
+      unist-util-visit: 5.0.0
+      unist-util-visit-parents: 6.0.1
+      vfile: 6.0.3
+    transitivePeerDependencies:
+      - '@types/react'
+      - debug
+      - encoding
+      - react
+      - react-dom
+      - supports-color
+      - ts-node
+
+  '@mintlify/link-rot@3.0.629(@types/react@19.1.3)(bufferutil@4.0.9)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.9.3)':
+    dependencies:
+      '@mintlify/common': 1.0.496(@types/react@19.1.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@mintlify/prebuild': 1.0.618(@types/react@19.1.3)(bufferutil@4.0.9)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.9.3)
+      '@mintlify/previewing': 4.0.665(@types/react@19.1.3)(bufferutil@4.0.9)(react-dom@18.3.1(react@18.3.1))(typescript@5.9.3)
+      '@mintlify/validation': 0.1.442
+      fs-extra: 11.3.0
+      unist-util-visit: 4.1.2
+    transitivePeerDependencies:
+      - '@types/react'
+      - bare-buffer
+      - bufferutil
+      - debug
+      - encoding
+      - react
+      - react-devtools-core
+      - react-dom
+      - supports-color
+      - ts-node
+      - typescript
+      - utf-8-validate
+
+  '@mintlify/mdx@2.0.3(@types/react@19.1.3)(acorn@8.15.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+    dependencies:
+      '@shikijs/transformers': 3.11.0
+      hast-util-to-string: 3.0.1
+      mdast-util-mdx-jsx: 3.2.0
+      next-mdx-remote-client: 1.1.1(@types/react@19.1.3)(acorn@8.15.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      react: 18.3.1
+      react-dom: 18.3.1(react@18.3.1)
+      rehype-katex: 7.0.1
+      remark-gfm: 4.0.1
+      remark-math: 6.0.0
+      remark-smartypants: 3.0.2
+      shiki: 3.11.0
+      unified: 11.0.5
+      unist-util-visit: 5.0.0
+    transitivePeerDependencies:
+      - '@types/react'
+      - acorn
+      - supports-color
+
+  '@mintlify/models@0.0.219':
+    dependencies:
+      axios: 1.9.0
+      openapi-types: 12.1.3
+    transitivePeerDependencies:
+      - debug
+
+  '@mintlify/openapi-parser@0.0.7':
+    dependencies:
+      ajv: 8.17.1
+      ajv-draft-04: 1.0.0(ajv@8.17.1)
+      ajv-formats: 3.0.1(ajv@8.17.1)
+      jsonpointer: 5.0.1
+      leven: 4.0.0
+      yaml: 2.7.1
+
+  '@mintlify/prebuild@1.0.618(@types/react@19.1.3)(bufferutil@4.0.9)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.9.3)':
+    dependencies:
+      '@mintlify/common': 1.0.496(@types/react@19.1.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@mintlify/openapi-parser': 0.0.7
+      '@mintlify/scraping': 4.0.354(@types/react@19.1.3)(bufferutil@4.0.9)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.9.3)
+      '@mintlify/validation': 0.1.442
+      chalk: 5.4.1
+      favicons: 7.2.0
+      fs-extra: 11.3.0
+      gray-matter: 4.0.3
+      js-yaml: 4.1.0
+      mdast: 3.0.0
+      openapi-types: 12.1.3
+      unist-util-visit: 4.1.2
+    transitivePeerDependencies:
+      - '@types/react'
+      - bare-buffer
+      - bufferutil
+      - debug
+      - encoding
+      - react
+      - react-dom
+      - supports-color
+      - ts-node
+      - typescript
+      - utf-8-validate
+
+  '@mintlify/previewing@4.0.665(@types/react@19.1.3)(bufferutil@4.0.9)(react-dom@18.3.1(react@18.3.1))(typescript@5.9.3)':
+    dependencies:
+      '@mintlify/common': 1.0.496(@types/react@19.1.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@mintlify/prebuild': 1.0.618(@types/react@19.1.3)(bufferutil@4.0.9)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.9.3)
+      '@mintlify/validation': 0.1.442
+      better-opn: 3.0.2
+      chalk: 5.4.1
+      chokidar: 3.6.0
+      express: 4.21.2
+      fs-extra: 11.3.0
+      got: 13.0.0
+      gray-matter: 4.0.3
+      ink: 5.2.1(@types/react@19.1.3)(bufferutil@4.0.9)(react@18.3.1)
+      ink-spinner: 5.0.0(ink@5.2.1(@types/react@19.1.3)(bufferutil@4.0.9)(react@18.3.1))(react@18.3.1)
+      is-online: 10.0.0
+      js-yaml: 4.1.0
+      mdast: 3.0.0
+      openapi-types: 12.1.3
+      react: 18.3.1
+      socket.io: 4.8.1(bufferutil@4.0.9)
+      tar: 6.2.1
+      unist-util-visit: 4.1.2
+      yargs: 17.7.2
+    transitivePeerDependencies:
+      - '@types/react'
+      - bare-buffer
+      - bufferutil
+      - debug
+      - encoding
+      - react-devtools-core
+      - react-dom
+      - supports-color
+      - ts-node
+      - typescript
+      - utf-8-validate
+
+  '@mintlify/scraping@4.0.354(@types/react@19.1.3)(bufferutil@4.0.9)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.9.3)':
+    dependencies:
+      '@mintlify/common': 1.0.496(@types/react@19.1.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@mintlify/openapi-parser': 0.0.7
+      fs-extra: 11.3.0
+      hast-util-to-mdast: 10.1.2
+      js-yaml: 4.1.0
+      mdast-util-mdx-jsx: 3.2.0
+      neotraverse: 0.6.18
+      puppeteer: 22.15.0(bufferutil@4.0.9)(typescript@5.9.3)
+      rehype-parse: 9.0.1
+      remark-gfm: 4.0.1
+      remark-mdx: 3.1.0
+      remark-parse: 11.0.0
+      remark-stringify: 11.0.0
+      unified: 11.0.5
+      unist-util-visit: 5.0.0
+      yargs: 17.7.2
+      zod: 3.25.76
+    transitivePeerDependencies:
+      - '@types/react'
+      - bare-buffer
+      - bufferutil
+      - debug
+      - encoding
+      - react
+      - react-dom
+      - supports-color
+      - ts-node
+      - typescript
+      - utf-8-validate
+
+  '@mintlify/validation@0.1.442':
+    dependencies:
+      '@mintlify/models': 0.0.219
+      arktype: 2.1.20
+      lcm: 0.0.3
+      lodash: 4.17.21
+      openapi-types: 12.1.3
+      zod: 3.25.76
+      zod-to-json-schema: 3.25.0(zod@3.25.76)
+    transitivePeerDependencies:
+      - debug
+
+  '@modelcontextprotocol/sdk@1.17.2':
+    dependencies:
+      ajv: 6.12.6
+      content-type: 1.0.5
+      cors: 2.8.5
+      cross-spawn: 7.0.6
+      eventsource: 3.0.7
+      eventsource-parser: 3.0.6
+      express: 5.1.0
+      express-rate-limit: 7.5.1(express@5.1.0)
+      pkce-challenge: 5.0.0
+      raw-body: 3.0.0
+      zod: 3.25.76
+      zod-to-json-schema: 3.25.0(zod@3.25.76)
+    transitivePeerDependencies:
+      - supports-color
+
+  '@next/env@14.2.28': {}
+
+  '@nodelib/fs.scandir@2.1.5':
+    dependencies:
+      '@nodelib/fs.stat': 2.0.5
+      run-parallel: 1.2.0
+
+  '@nodelib/fs.stat@2.0.5': {}
+
+  '@nodelib/fs.walk@1.2.8':
+    dependencies:
+      '@nodelib/fs.scandir': 2.1.5
+      fastq: 1.19.1
+
+  '@openapi-contrib/openapi-schema-to-json-schema@3.2.0':
+    dependencies:
+      fast-deep-equal: 3.1.3
+
+  '@opentelemetry/api@1.9.0': {}
+
+  '@pinojs/redact@0.4.0': {}
+
+  '@pkgjs/parseargs@0.11.0':
+    optional: true
+
+  '@playwright/test@1.54.2':
+    dependencies:
+      playwright: 1.54.2
+
+  '@puppeteer/browsers@2.3.0':
+    dependencies:
+      debug: 4.4.3
+      extract-zip: 2.0.1
+      progress: 2.0.3
+      proxy-agent: 6.5.0
+      semver: 7.7.3
+      tar-fs: 3.1.0
+      unbzip2-stream: 1.4.3
+      yargs: 17.7.2
+    transitivePeerDependencies:
+      - bare-buffer
+      - supports-color
+
+  '@rollup/rollup-android-arm-eabi@4.53.2':
+    optional: true
+
+  '@rollup/rollup-android-arm64@4.53.2':
+    optional: true
+
+  '@rollup/rollup-darwin-arm64@4.53.2':
+    optional: true
+
+  '@rollup/rollup-darwin-x64@4.53.2':
+    optional: true
+
+  '@rollup/rollup-freebsd-arm64@4.53.2':
+    optional: true
+
+  '@rollup/rollup-freebsd-x64@4.53.2':
+    optional: true
+
+  '@rollup/rollup-linux-arm-gnueabihf@4.53.2':
+    optional: true
+
+  '@rollup/rollup-linux-arm-musleabihf@4.53.2':
+    optional: true
+
+  '@rollup/rollup-linux-arm64-gnu@4.53.2':
+    optional: true
+
+  '@rollup/rollup-linux-arm64-musl@4.53.2':
+    optional: true
+
+  '@rollup/rollup-linux-loong64-gnu@4.53.2':
+    optional: true
+
+  '@rollup/rollup-linux-ppc64-gnu@4.53.2':
+    optional: true
+
+  '@rollup/rollup-linux-riscv64-gnu@4.53.2':
+    optional: true
+
+  '@rollup/rollup-linux-riscv64-musl@4.53.2':
+    optional: true
+
+  '@rollup/rollup-linux-s390x-gnu@4.53.2':
+    optional: true
+
+  '@rollup/rollup-linux-x64-gnu@4.53.2':
+    optional: true
+
+  '@rollup/rollup-linux-x64-musl@4.53.2':
+    optional: true
+
+  '@rollup/rollup-openharmony-arm64@4.53.2':
+    optional: true
+
+  '@rollup/rollup-win32-arm64-msvc@4.53.2':
+    optional: true
+
+  '@rollup/rollup-win32-ia32-msvc@4.53.2':
+    optional: true
+
+  '@rollup/rollup-win32-x64-gnu@4.53.2':
+    optional: true
+
+  '@rollup/rollup-win32-x64-msvc@4.53.2':
+    optional: true
+
+  '@shikijs/core@3.11.0':
+    dependencies:
+      '@shikijs/types': 3.11.0
+      '@shikijs/vscode-textmate': 10.0.2
+      '@types/hast': 3.0.4
+      hast-util-to-html: 9.0.5
+
+  '@shikijs/engine-javascript@3.11.0':
+    dependencies:
+      '@shikijs/types': 3.11.0
+      '@shikijs/vscode-textmate': 10.0.2
+      oniguruma-to-es: 4.3.3
+
+  '@shikijs/engine-oniguruma@3.11.0':
+    dependencies:
+      '@shikijs/types': 3.11.0
+      '@shikijs/vscode-textmate': 10.0.2
+
+  '@shikijs/langs@3.11.0':
+    dependencies:
+      '@shikijs/types': 3.11.0
+
+  '@shikijs/themes@3.11.0':
+    dependencies:
+      '@shikijs/types': 3.11.0
+
+  '@shikijs/transformers@3.11.0':
+    dependencies:
+      '@shikijs/core': 3.11.0
+      '@shikijs/types': 3.11.0
+
+  '@shikijs/types@3.11.0':
+    dependencies:
+      '@shikijs/vscode-textmate': 10.0.2
+      '@types/hast': 3.0.4
+
+  '@shikijs/vscode-textmate@10.0.2': {}
+
+  '@sinclair/typebox@0.27.10': {}
+
+  '@sindresorhus/is@5.6.0': {}
+
+  '@sindresorhus/slugify@2.2.1':
+    dependencies:
+      '@sindresorhus/transliterate': 1.6.0
+      escape-string-regexp: 5.0.0
+
+  '@sindresorhus/transliterate@1.6.0':
+    dependencies:
+      escape-string-regexp: 5.0.0
+
+  '@smithy/eventstream-codec@4.2.8':
+    dependencies:
+      '@aws-crypto/crc32': 5.2.0
+      '@smithy/types': 4.12.0
+      '@smithy/util-hex-encoding': 4.2.0
+      tslib: 2.8.1
+    optional: true
+
+  '@smithy/is-array-buffer@2.2.0':
+    dependencies:
+      tslib: 2.8.1
+    optional: true
+
+  '@smithy/is-array-buffer@4.2.0':
+    dependencies:
+      tslib: 2.8.1
+    optional: true
+
+  '@smithy/types@4.12.0':
+    dependencies:
+      tslib: 2.8.1
+    optional: true
+
+  '@smithy/util-buffer-from@2.2.0':
+    dependencies:
+      '@smithy/is-array-buffer': 2.2.0
+      tslib: 2.8.1
+    optional: true
+
+  '@smithy/util-buffer-from@4.2.0':
+    dependencies:
+      '@smithy/is-array-buffer': 4.2.0
+      tslib: 2.8.1
+    optional: true
+
+  '@smithy/util-hex-encoding@4.2.0':
+    dependencies:
+      tslib: 2.8.1
+    optional: true
+
+  '@smithy/util-utf8@2.3.0':
+    dependencies:
+      '@smithy/util-buffer-from': 2.2.0
+      tslib: 2.8.1
+    optional: true
+
+  '@smithy/util-utf8@4.2.0':
+    dependencies:
+      '@smithy/util-buffer-from': 4.2.0
+      tslib: 2.8.1
+    optional: true
+
+  '@socket.io/component-emitter@3.1.2': {}
+
+  '@standard-schema/spec@1.1.0': {}
+
+  '@stoplight/better-ajv-errors@1.0.3(ajv@8.17.1)':
+    dependencies:
+      ajv: 8.17.1
+      jsonpointer: 5.0.1
+      leven: 3.1.0
+
+  '@stoplight/json-ref-readers@1.2.2':
+    dependencies:
+      node-fetch: 2.7.0
+      tslib: 1.14.1
+    transitivePeerDependencies:
+      - encoding
+
+  '@stoplight/json-ref-resolver@3.1.6':
+    dependencies:
+      '@stoplight/json': 3.21.0
+      '@stoplight/path': 1.3.2
+      '@stoplight/types': 13.20.0
+      '@types/urijs': 1.19.25
+      dependency-graph: 0.11.0
+      fast-memoize: 2.5.2
+      immer: 9.0.21
+      lodash: 4.17.21
+      tslib: 2.8.1
+      urijs: 1.19.11
+
+  '@stoplight/json@3.21.0':
+    dependencies:
+      '@stoplight/ordered-object-literal': 1.0.5
+      '@stoplight/path': 1.3.2
+      '@stoplight/types': 13.20.0
+      jsonc-parser: 2.2.1
+      lodash: 4.17.21
+      safe-stable-stringify: 1.1.1
+
+  '@stoplight/ordered-object-literal@1.0.5': {}
+
+  '@stoplight/path@1.3.2': {}
+
+  '@stoplight/spectral-core@1.20.0':
+    dependencies:
+      '@stoplight/better-ajv-errors': 1.0.3(ajv@8.17.1)
+      '@stoplight/json': 3.21.0
+      '@stoplight/path': 1.3.2
+      '@stoplight/spectral-parsers': 1.0.5
+      '@stoplight/spectral-ref-resolver': 1.0.5
+      '@stoplight/spectral-runtime': 1.1.4
+      '@stoplight/types': 13.6.0
+      '@types/es-aggregate-error': 1.0.6
+      '@types/json-schema': 7.0.15
+      ajv: 8.17.1
+      ajv-errors: 3.0.0(ajv@8.17.1)
+      ajv-formats: 2.1.1(ajv@8.17.1)
+      es-aggregate-error: 1.0.13
+      jsonpath-plus: 10.3.0
+      lodash: 4.17.21
+      lodash.topath: 4.5.2
+      minimatch: 3.1.2
+      nimma: 0.2.3
+      pony-cause: 1.1.1
+      simple-eval: 1.0.1
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - encoding
+
+  '@stoplight/spectral-formats@1.8.2':
+    dependencies:
+      '@stoplight/json': 3.21.0
+      '@stoplight/spectral-core': 1.20.0
+      '@types/json-schema': 7.0.15
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - encoding
+
+  '@stoplight/spectral-functions@1.10.1':
+    dependencies:
+      '@stoplight/better-ajv-errors': 1.0.3(ajv@8.17.1)
+      '@stoplight/json': 3.21.0
+      '@stoplight/spectral-core': 1.20.0
+      '@stoplight/spectral-formats': 1.8.2
+      '@stoplight/spectral-runtime': 1.1.4
+      ajv: 8.17.1
+      ajv-draft-04: 1.0.0(ajv@8.17.1)
+      ajv-errors: 3.0.0(ajv@8.17.1)
+      ajv-formats: 2.1.1(ajv@8.17.1)
+      lodash: 4.17.21
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - encoding
+
+  '@stoplight/spectral-parsers@1.0.5':
+    dependencies:
+      '@stoplight/json': 3.21.0
+      '@stoplight/types': 14.1.1
+      '@stoplight/yaml': 4.3.0
+      tslib: 2.8.1
+
+  '@stoplight/spectral-ref-resolver@1.0.5':
+    dependencies:
+      '@stoplight/json-ref-readers': 1.2.2
+      '@stoplight/json-ref-resolver': 3.1.6
+      '@stoplight/spectral-runtime': 1.1.4
+      dependency-graph: 0.11.0
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - encoding
+
+  '@stoplight/spectral-runtime@1.1.4':
+    dependencies:
+      '@stoplight/json': 3.21.0
+      '@stoplight/path': 1.3.2
+      '@stoplight/types': 13.20.0
+      abort-controller: 3.0.0
+      lodash: 4.17.21
+      node-fetch: 2.7.0
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - encoding
+
+  '@stoplight/types@13.20.0':
+    dependencies:
+      '@types/json-schema': 7.0.15
+      utility-types: 3.11.0
+
+  '@stoplight/types@13.6.0':
+    dependencies:
+      '@types/json-schema': 7.0.15
+      utility-types: 3.11.0
+
+  '@stoplight/types@14.1.1':
+    dependencies:
+      '@types/json-schema': 7.0.15
+      utility-types: 3.11.0
+
+  '@stoplight/yaml-ast-parser@0.0.50': {}
+
+  '@stoplight/yaml@4.3.0':
+    dependencies:
+      '@stoplight/ordered-object-literal': 1.0.5
+      '@stoplight/types': 14.1.1
+      '@stoplight/yaml-ast-parser': 0.0.50
+      tslib: 2.8.1
+
+  '@szmarczak/http-timer@5.0.1':
+    dependencies:
+      defer-to-connect: 2.0.1
+
+  '@t3-oss/env-core@0.13.8(arktype@2.1.20)(typescript@5.9.3)(zod@4.2.1)':
+    optionalDependencies:
+      arktype: 2.1.20
+      typescript: 5.9.3
+      zod: 4.2.1
+
+  '@tootallnate/quickjs-emscripten@0.23.0': {}
+
+  '@types/adm-zip@0.5.7':
+    dependencies:
+      '@types/node': 20.17.32
+
+  '@types/chai@5.2.3':
+    dependencies:
+      '@types/deep-eql': 4.0.2
+      assertion-error: 2.0.1
+
+  '@types/cors@2.8.17':
+    dependencies:
+      '@types/node': 20.17.32
+
+  '@types/debug@4.1.12':
+    dependencies:
+      '@types/ms': 2.1.0
+
+  '@types/deep-eql@4.0.2': {}
+
+  '@types/es-aggregate-error@1.0.6':
+    dependencies:
+      '@types/node': 20.17.32
+
+  '@types/esrecurse@4.3.1': {}
+
+  '@types/estree-jsx@1.0.5':
+    dependencies:
+      '@types/estree': 1.0.8
+
+  '@types/estree@1.0.8': {}
+
+  '@types/hast@3.0.4':
+    dependencies:
+      '@types/unist': 3.0.3
+
+  '@types/http-cache-semantics@4.0.4': {}
+
+  '@types/istanbul-lib-coverage@2.0.6': {}
+
+  '@types/jsdom@27.0.0':
+    dependencies:
+      '@types/node': 20.17.32
+      '@types/tough-cookie': 4.0.5
+      parse5: 7.3.0
+
+  '@types/json-schema@7.0.15': {}
+
+  '@types/katex@0.16.7': {}
+
+  '@types/mdast@4.0.4':
+    dependencies:
+      '@types/unist': 3.0.3
+
+  '@types/mdx@2.0.13': {}
+
+  '@types/ms@2.1.0': {}
+
+  '@types/nlcst@2.0.3':
+    dependencies:
+      '@types/unist': 3.0.3
+
+  '@types/node-fetch@2.6.12':
+    dependencies:
+      '@types/node': 20.17.32
+      form-data: 4.0.2
+
+  '@types/node@12.20.55': {}
+
+  '@types/node@18.19.87':
+    dependencies:
+      undici-types: 5.26.5
+
+  '@types/node@20.17.32':
+    dependencies:
+      undici-types: 6.19.8
+
+  '@types/node@22.13.1':
+    dependencies:
+      undici-types: 6.20.0
+
+  '@types/react@19.1.3':
+    dependencies:
+      csstype: 3.2.3
+
+  '@types/retry@0.12.0': {}
+
+  '@types/tough-cookie@4.0.5': {}
+
+  '@types/unist@2.0.11': {}
+
+  '@types/unist@3.0.3': {}
+
+  '@types/urijs@1.19.25': {}
+
+  '@types/uuid@10.0.0': {}
+
+  '@types/ws@8.18.1':
+    dependencies:
+      '@types/node': 20.17.32
+
+  '@types/yauzl@2.10.3':
+    dependencies:
+      '@types/node': 20.17.32
+    optional: true
+
+  '@typescript-eslint/eslint-plugin@8.56.1(@typescript-eslint/parser@8.56.1(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3))(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3)':
+    dependencies:
+      '@eslint-community/regexpp': 4.12.2
+      '@typescript-eslint/parser': 8.56.1(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3)
+      '@typescript-eslint/scope-manager': 8.56.1
+      '@typescript-eslint/type-utils': 8.56.1(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3)
+      '@typescript-eslint/utils': 8.56.1(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3)
+      '@typescript-eslint/visitor-keys': 8.56.1
+      eslint: 10.0.2(jiti@1.21.7)
+      ignore: 7.0.5
+      natural-compare: 1.4.0
+      ts-api-utils: 2.4.0(typescript@5.8.3)
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/eslint-plugin@8.56.1(@typescript-eslint/parser@8.56.1(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3))(eslint@9.39.4(jiti@1.21.7))(typescript@5.8.3)':
+    dependencies:
+      '@eslint-community/regexpp': 4.12.2
+      '@typescript-eslint/parser': 8.56.1(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3)
+      '@typescript-eslint/scope-manager': 8.56.1
+      '@typescript-eslint/type-utils': 8.56.1(eslint@9.39.4(jiti@1.21.7))(typescript@5.8.3)
+      '@typescript-eslint/utils': 8.56.1(eslint@9.39.4(jiti@1.21.7))(typescript@5.8.3)
+      '@typescript-eslint/visitor-keys': 8.56.1
+      eslint: 9.39.4(jiti@1.21.7)
+      ignore: 7.0.5
+      natural-compare: 1.4.0
+      ts-api-utils: 2.4.0(typescript@5.8.3)
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/parser@8.56.1(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3)':
+    dependencies:
+      '@typescript-eslint/scope-manager': 8.56.1
+      '@typescript-eslint/types': 8.56.1
+      '@typescript-eslint/typescript-estree': 8.56.1(typescript@5.8.3)
+      '@typescript-eslint/visitor-keys': 8.56.1
+      debug: 4.4.3
+      eslint: 10.0.2(jiti@1.21.7)
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/parser@8.56.1(eslint@9.39.4(jiti@1.21.7))(typescript@5.8.3)':
+    dependencies:
+      '@typescript-eslint/scope-manager': 8.56.1
+      '@typescript-eslint/types': 8.56.1
+      '@typescript-eslint/typescript-estree': 8.56.1(typescript@5.8.3)
+      '@typescript-eslint/visitor-keys': 8.56.1
+      debug: 4.4.3
+      eslint: 9.39.4(jiti@1.21.7)
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/project-service@8.56.1(typescript@5.8.3)':
+    dependencies:
+      '@typescript-eslint/tsconfig-utils': 8.56.1(typescript@5.8.3)
+      '@typescript-eslint/types': 8.56.1
+      debug: 4.4.3
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/scope-manager@8.56.1':
+    dependencies:
+      '@typescript-eslint/types': 8.56.1
+      '@typescript-eslint/visitor-keys': 8.56.1
+
+  '@typescript-eslint/tsconfig-utils@8.56.1(typescript@5.8.3)':
+    dependencies:
+      typescript: 5.8.3
+
+  '@typescript-eslint/type-utils@8.56.1(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3)':
+    dependencies:
+      '@typescript-eslint/types': 8.56.1
+      '@typescript-eslint/typescript-estree': 8.56.1(typescript@5.8.3)
+      '@typescript-eslint/utils': 8.56.1(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3)
+      debug: 4.4.3
+      eslint: 10.0.2(jiti@1.21.7)
+      ts-api-utils: 2.4.0(typescript@5.8.3)
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/type-utils@8.56.1(eslint@9.39.4(jiti@1.21.7))(typescript@5.8.3)':
+    dependencies:
+      '@typescript-eslint/types': 8.56.1
+      '@typescript-eslint/typescript-estree': 8.56.1(typescript@5.8.3)
+      '@typescript-eslint/utils': 8.56.1(eslint@9.39.4(jiti@1.21.7))(typescript@5.8.3)
+      debug: 4.4.3
+      eslint: 9.39.4(jiti@1.21.7)
+      ts-api-utils: 2.4.0(typescript@5.8.3)
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/types@8.56.1': {}
+
+  '@typescript-eslint/typescript-estree@8.56.1(typescript@5.8.3)':
+    dependencies:
+      '@typescript-eslint/project-service': 8.56.1(typescript@5.8.3)
+      '@typescript-eslint/tsconfig-utils': 8.56.1(typescript@5.8.3)
+      '@typescript-eslint/types': 8.56.1
+      '@typescript-eslint/visitor-keys': 8.56.1
+      debug: 4.4.3
+      minimatch: 10.2.2
+      semver: 7.7.3
+      tinyglobby: 0.2.15
+      ts-api-utils: 2.4.0(typescript@5.8.3)
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/utils@8.56.1(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3)':
+    dependencies:
+      '@eslint-community/eslint-utils': 4.9.1(eslint@10.0.2(jiti@1.21.7))
+      '@typescript-eslint/scope-manager': 8.56.1
+      '@typescript-eslint/types': 8.56.1
+      '@typescript-eslint/typescript-estree': 8.56.1(typescript@5.8.3)
+      eslint: 10.0.2(jiti@1.21.7)
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/utils@8.56.1(eslint@9.39.4(jiti@1.21.7))(typescript@5.8.3)':
+    dependencies:
+      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.4(jiti@1.21.7))
+      '@typescript-eslint/scope-manager': 8.56.1
+      '@typescript-eslint/types': 8.56.1
+      '@typescript-eslint/typescript-estree': 8.56.1(typescript@5.8.3)
+      eslint: 9.39.4(jiti@1.21.7)
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/visitor-keys@8.56.1':
+    dependencies:
+      '@typescript-eslint/types': 8.56.1
+      eslint-visitor-keys: 5.0.1
+
+  '@ungap/structured-clone@1.3.0': {}
+
+  '@vercel/functions@1.6.0': {}
+
+  '@vercel/oidc@3.1.0': {}
+
+  '@vitest/coverage-v8@4.0.18(vitest@4.0.8(@types/debug@4.1.12)(@types/node@20.17.32)(jiti@1.21.7)(jsdom@24.1.3(bufferutil@4.0.9))(tsx@4.19.4)(yaml@2.7.1))':
+    dependencies:
+      '@bcoe/v8-coverage': 1.0.2
+      '@vitest/utils': 4.0.18
+      ast-v8-to-istanbul: 0.3.11
+      istanbul-lib-coverage: 3.2.2
+      istanbul-lib-report: 3.0.1
+      istanbul-reports: 3.2.0
+      magicast: 0.5.2
+      obug: 2.1.1
+      std-env: 3.10.0
+      tinyrainbow: 3.0.3
+      vitest: 4.0.8(@types/debug@4.1.12)(@types/node@20.17.32)(jiti@1.21.7)(jsdom@24.1.3(bufferutil@4.0.9))(tsx@4.19.4)(yaml@2.7.1)
+
+  '@vitest/expect@1.6.1':
+    dependencies:
+      '@vitest/spy': 1.6.1
+      '@vitest/utils': 1.6.1
+      chai: 4.5.0
+
+  '@vitest/expect@4.0.8':
+    dependencies:
+      '@standard-schema/spec': 1.1.0
+      '@types/chai': 5.2.3
+      '@vitest/spy': 4.0.8
+      '@vitest/utils': 4.0.8
+      chai: 6.2.1
+      tinyrainbow: 3.0.3
+
+  '@vitest/mocker@4.0.8(vite@7.2.2(@types/node@20.17.32)(jiti@1.21.7)(tsx@4.19.4)(yaml@2.7.1))':
+    dependencies:
+      '@vitest/spy': 4.0.8
+      estree-walker: 3.0.3
+      magic-string: 0.30.21
+    optionalDependencies:
+      vite: 7.2.2(@types/node@20.17.32)(jiti@1.21.7)(tsx@4.19.4)(yaml@2.7.1)
+
+  '@vitest/mocker@4.0.8(vite@7.2.2(@types/node@22.13.1)(jiti@1.21.7)(tsx@4.19.4)(yaml@2.7.1))':
+    dependencies:
+      '@vitest/spy': 4.0.8
+      estree-walker: 3.0.3
+      magic-string: 0.30.21
+    optionalDependencies:
+      vite: 7.2.2(@types/node@22.13.1)(jiti@1.21.7)(tsx@4.19.4)(yaml@2.7.1)
+
+  '@vitest/pretty-format@4.0.18':
+    dependencies:
+      tinyrainbow: 3.0.3
+
+  '@vitest/pretty-format@4.0.8':
+    dependencies:
+      tinyrainbow: 3.0.3
+
+  '@vitest/runner@1.6.1':
+    dependencies:
+      '@vitest/utils': 1.6.1
+      p-limit: 5.0.0
+      pathe: 1.1.2
+
+  '@vitest/runner@4.0.8':
+    dependencies:
+      '@vitest/utils': 4.0.8
+      pathe: 2.0.3
+
+  '@vitest/snapshot@1.6.1':
+    dependencies:
+      magic-string: 0.30.21
+      pathe: 1.1.2
+      pretty-format: 29.7.0
+
+  '@vitest/snapshot@4.0.8':
+    dependencies:
+      '@vitest/pretty-format': 4.0.8
+      magic-string: 0.30.21
+      pathe: 2.0.3
+
+  '@vitest/spy@1.6.1':
+    dependencies:
+      tinyspy: 2.2.1
+
+  '@vitest/spy@4.0.8': {}
+
+  '@vitest/utils@1.6.1':
+    dependencies:
+      diff-sequences: 29.6.3
+      estree-walker: 3.0.3
+      loupe: 2.3.7
+      pretty-format: 29.7.0
+
+  '@vitest/utils@4.0.18':
+    dependencies:
+      '@vitest/pretty-format': 4.0.18
+      tinyrainbow: 3.0.3
+
+  '@vitest/utils@4.0.8':
+    dependencies:
+      '@vitest/pretty-format': 4.0.8
+      tinyrainbow: 3.0.3
+
+  abort-controller@3.0.0:
+    dependencies:
+      event-target-shim: 5.0.1
+
+  abstract-logging@2.0.1: {}
+
+  accepts@1.3.8:
+    dependencies:
+      mime-types: 2.1.35
+      negotiator: 0.6.3
+
+  accepts@2.0.0:
+    dependencies:
+      mime-types: 3.0.1
+      negotiator: 1.0.0
+
+  acorn-jsx@5.3.2(acorn@8.15.0):
+    dependencies:
+      acorn: 8.15.0
+
+  acorn-jsx@5.3.2(acorn@8.16.0):
+    dependencies:
+      acorn: 8.16.0
+
+  acorn-walk@8.3.5:
+    dependencies:
+      acorn: 8.16.0
+
+  acorn@8.15.0: {}
+
+  acorn@8.16.0: {}
+
+  address@1.2.2: {}
+
+  adm-zip@0.5.16: {}
+
+  agent-base@7.1.3: {}
+
+  agentkeepalive@4.6.0:
+    dependencies:
+      humanize-ms: 1.2.1
+
+  aggregate-error@4.0.1:
+    dependencies:
+      clean-stack: 4.2.0
+      indent-string: 5.0.0
+
+  ai@5.0.133(zod@4.2.1):
+    dependencies:
+      '@ai-sdk/gateway': 2.0.39(zod@4.2.1)
+      '@ai-sdk/provider': 2.0.1
+      '@ai-sdk/provider-utils': 3.0.21(zod@4.2.1)
+      '@opentelemetry/api': 1.9.0
+      zod: 4.2.1
+
+  ajv-draft-04@1.0.0(ajv@8.17.1):
+    optionalDependencies:
+      ajv: 8.17.1
+
+  ajv-errors@3.0.0(ajv@8.17.1):
+    dependencies:
+      ajv: 8.17.1
+
+  ajv-formats@2.1.1(ajv@8.17.1):
+    optionalDependencies:
+      ajv: 8.17.1
+
+  ajv-formats@3.0.1(ajv@8.17.1):
+    optionalDependencies:
+      ajv: 8.17.1
+
+  ajv@6.12.6:
+    dependencies:
+      fast-deep-equal: 3.1.3
+      fast-json-stable-stringify: 2.1.0
+      json-schema-traverse: 0.4.1
+      uri-js: 4.4.1
+
+  ajv@6.14.0:
+    dependencies:
+      fast-deep-equal: 3.1.3
+      fast-json-stable-stringify: 2.1.0
+      json-schema-traverse: 0.4.1
+      uri-js: 4.4.1
+
+  ajv@8.17.1:
+    dependencies:
+      fast-deep-equal: 3.1.3
+      fast-uri: 3.0.6
+      json-schema-traverse: 1.0.0
+      require-from-string: 2.0.2
+
+  ansi-colors@4.1.3: {}
+
+  ansi-escapes@4.3.2:
+    dependencies:
+      type-fest: 0.21.3
+
+  ansi-escapes@7.0.0:
+    dependencies:
+      environment: 1.1.0
+
+  ansi-regex@5.0.1: {}
+
+  ansi-regex@6.1.0: {}
+
+  ansi-styles@4.3.0:
+    dependencies:
+      color-convert: 2.0.1
+
+  ansi-styles@5.2.0: {}
+
+  ansi-styles@6.2.1: {}
+
+  any-promise@1.3.0: {}
+
+  anymatch@3.1.3:
+    dependencies:
+      normalize-path: 3.0.0
+      picomatch: 2.3.1
+
+  arg@5.0.2: {}
+
+  argparse@1.0.10:
+    dependencies:
+      sprintf-js: 1.0.3
+
+  argparse@2.0.1: {}
+
+  arktype@2.1.20:
+    dependencies:
+      '@ark/schema': 0.46.0
+      '@ark/util': 0.46.0
+
+  array-buffer-byte-length@1.0.2:
+    dependencies:
+      call-bound: 1.0.4
+      is-array-buffer: 3.0.5
+
+  array-flatten@1.1.1: {}
+
+  array-iterate@2.0.1: {}
+
+  array-union@2.1.0: {}
+
+  arraybuffer.prototype.slice@1.0.4:
+    dependencies:
+      array-buffer-byte-length: 1.0.2
+      call-bind: 1.0.8
+      define-properties: 1.2.1
+      es-abstract: 1.23.9
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      is-array-buffer: 3.0.5
+
+  assertion-error@1.1.0: {}
+
+  assertion-error@2.0.1: {}
+
+  ast-types@0.13.4:
+    dependencies:
+      tslib: 2.8.1
+
+  ast-v8-to-istanbul@0.3.11:
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.31
+      estree-walker: 3.0.3
+      js-tokens: 10.0.0
+
+  astring@1.9.0: {}
+
+  async-function@1.0.0: {}
+
+  asynckit@0.4.0: {}
+
+  atomic-sleep@1.0.0: {}
+
+  auto-bind@5.0.1: {}
+
+  available-typed-arrays@1.0.7:
+    dependencies:
+      possible-typed-array-names: 1.1.0
+
+  avsc@5.7.7: {}
+
+  avvio@9.1.0:
+    dependencies:
+      '@fastify/error': 4.2.0
+      fastq: 1.19.1
+
+  aws4fetch@1.0.20:
+    optional: true
+
+  axios@1.9.0:
+    dependencies:
+      follow-redirects: 1.15.9
+      form-data: 4.0.2
+      proxy-from-env: 1.1.0
+    transitivePeerDependencies:
+      - debug
+
+  b4a@1.6.7: {}
+
+  bail@2.0.2: {}
+
+  balanced-match@1.0.2: {}
+
+  balanced-match@4.0.4: {}
+
+  bare-events@2.5.4:
+    optional: true
+
+  bare-fs@4.1.4:
+    dependencies:
+      bare-events: 2.5.4
+      bare-path: 3.0.0
+      bare-stream: 2.6.5(bare-events@2.5.4)
+    optional: true
+
+  bare-os@3.6.1:
+    optional: true
+
+  bare-path@3.0.0:
+    dependencies:
+      bare-os: 3.6.1
+    optional: true
+
+  bare-stream@2.6.5(bare-events@2.5.4):
+    dependencies:
+      streamx: 2.22.0
+    optionalDependencies:
+      bare-events: 2.5.4
+    optional: true
+
+  base64-js@1.5.1: {}
+
+  base64id@2.0.0: {}
+
+  basic-ftp@5.0.5: {}
+
+  better-opn@3.0.2:
+    dependencies:
+      open: 8.4.2
+
+  better-path-resolve@1.0.0:
+    dependencies:
+      is-windows: 1.0.2
+
+  bignumber.js@9.3.0: {}
+
+  binary-extensions@2.3.0: {}
+
+  bintrees@1.0.2: {}
+
+  body-parser@1.20.3:
+    dependencies:
+      bytes: 3.1.2
+      content-type: 1.0.5
+      debug: 2.6.9
+      depd: 2.0.0
+      destroy: 1.2.0
+      http-errors: 2.0.0
+      iconv-lite: 0.4.24
+      on-finished: 2.4.1
+      qs: 6.13.0
+      raw-body: 2.5.2
+      type-is: 1.6.18
+      unpipe: 1.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  body-parser@2.2.0:
+    dependencies:
+      bytes: 3.1.2
+      content-type: 1.0.5
+      debug: 4.4.3
+      http-errors: 2.0.0
+      iconv-lite: 0.6.3
+      on-finished: 2.4.1
+      qs: 6.14.0
+      raw-body: 3.0.0
+      type-is: 2.0.1
+    transitivePeerDependencies:
+      - supports-color
+
+  brace-expansion@1.1.11:
+    dependencies:
+      balanced-match: 1.0.2
+      concat-map: 0.0.1
+
+  brace-expansion@2.0.1:
+    dependencies:
+      balanced-match: 1.0.2
+
+  brace-expansion@5.0.3:
+    dependencies:
+      balanced-match: 4.0.4
+
+  braces@3.0.3:
+    dependencies:
+      fill-range: 7.1.1
+
+  braintrust@0.4.7(zod@4.2.1):
+    dependencies:
+      '@ai-sdk/provider': 1.1.3
+      '@next/env': 14.2.28
+      '@vercel/functions': 1.6.0
+      argparse: 2.0.1
+      chalk: 4.1.2
+      cli-progress: 3.12.0
+      cors: 2.8.5
+      dotenv: 16.4.5
+      esbuild: 0.25.11
+      eventsource-parser: 1.1.2
+      express: 4.21.2
+      graceful-fs: 4.2.11
+      http-errors: 2.0.0
+      minimatch: 9.0.5
+      mustache: 4.2.0
+      pluralize: 8.0.0
+      simple-git: 3.27.0
+      slugify: 1.6.6
+      source-map: 0.7.4
+      uuid: 9.0.1
+      zod: 4.2.1
+      zod-to-json-schema: 3.25.0(zod@4.2.1)
+    transitivePeerDependencies:
+      - '@aws-sdk/credential-provider-web-identity'
+      - supports-color
+
+  buffer-crc32@0.2.13: {}
+
+  buffer-equal-constant-time@1.0.1: {}
+
+  buffer@5.7.1:
+    dependencies:
+      base64-js: 1.5.1
+      ieee754: 1.2.1
+
+  buffer@6.0.3:
+    dependencies:
+      base64-js: 1.5.1
+      ieee754: 1.2.1
+
+  bufferutil@4.0.9:
+    dependencies:
+      node-gyp-build: 4.8.4
+    optional: true
+
+  bundle-require@5.1.0(esbuild@0.27.2):
+    dependencies:
+      esbuild: 0.27.2
+      load-tsconfig: 0.2.5
+
+  bytes@3.1.2: {}
+
+  c8@10.1.3:
+    dependencies:
+      '@bcoe/v8-coverage': 1.0.2
+      '@istanbuljs/schema': 0.1.3
+      find-up: 5.0.0
+      foreground-child: 3.3.1
+      istanbul-lib-coverage: 3.2.2
+      istanbul-lib-report: 3.0.1
+      istanbul-reports: 3.2.0
+      test-exclude: 7.0.1
+      v8-to-istanbul: 9.3.0
+      yargs: 17.7.2
+      yargs-parser: 21.1.1
+
+  cac@6.7.14: {}
+
+  cacheable-lookup@7.0.0: {}
+
+  cacheable-request@10.2.14:
+    dependencies:
+      '@types/http-cache-semantics': 4.0.4
+      get-stream: 6.0.1
+      http-cache-semantics: 4.1.1
+      keyv: 4.5.4
+      mimic-response: 4.0.0
+      normalize-url: 8.0.1
+      responselike: 3.0.0
+
+  call-bind-apply-helpers@1.0.2:
+    dependencies:
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+
+  call-bind@1.0.8:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-define-property: 1.0.1
+      get-intrinsic: 1.3.0
+      set-function-length: 1.2.2
+
+  call-bound@1.0.4:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      get-intrinsic: 1.3.0
+
+  callsites@3.1.0: {}
+
+  camelcase-css@2.0.1: {}
+
+  camelcase@6.3.0: {}
+
+  ccount@2.0.1: {}
+
+  chai@4.5.0:
+    dependencies:
+      assertion-error: 1.1.0
+      check-error: 1.0.3
+      deep-eql: 4.1.4
+      get-func-name: 2.0.2
+      loupe: 2.3.7
+      pathval: 1.1.1
+      type-detect: 4.1.0
+
+  chai@6.2.1: {}
+
+  chalk@4.1.2:
+    dependencies:
+      ansi-styles: 4.3.0
+      supports-color: 7.2.0
+
+  chalk@5.4.1: {}
+
+  character-entities-html4@2.1.0: {}
+
+  character-entities-legacy@3.0.0: {}
+
+  character-entities@2.0.2: {}
+
+  character-reference-invalid@2.0.1: {}
+
+  chardet@0.7.0: {}
+
+  check-error@1.0.3:
+    dependencies:
+      get-func-name: 2.0.2
+
+  chokidar@3.6.0:
+    dependencies:
+      anymatch: 3.1.3
+      braces: 3.0.3
+      glob-parent: 5.1.2
+      is-binary-path: 2.1.0
+      is-glob: 4.0.3
+      normalize-path: 3.0.0
+      readdirp: 3.6.0
+    optionalDependencies:
+      fsevents: 2.3.3
+
+  chokidar@4.0.3:
+    dependencies:
+      readdirp: 4.1.2
+
+  chownr@2.0.0: {}
+
+  chrome-launcher@1.2.0:
+    dependencies:
+      '@types/node': 20.17.32
+      escape-string-regexp: 4.0.0
+      is-wsl: 2.2.0
+      lighthouse-logger: 2.0.2
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
+  chromium-bidi@0.6.3(devtools-protocol@0.0.1312386):
+    dependencies:
+      devtools-protocol: 0.0.1312386
+      mitt: 3.0.1
+      urlpattern-polyfill: 10.0.0
+      zod: 3.23.8
+
+  ci-info@3.9.0: {}
+
+  clean-stack@4.2.0:
+    dependencies:
+      escape-string-regexp: 5.0.0
+
+  cli-boxes@3.0.0: {}
+
+  cli-cursor@4.0.0:
+    dependencies:
+      restore-cursor: 4.0.0
+
+  cli-progress@3.12.0:
+    dependencies:
+      string-width: 4.2.3
+
+  cli-spinners@2.9.2: {}
+
+  cli-truncate@4.0.0:
+    dependencies:
+      slice-ansi: 5.0.0
+      string-width: 7.2.0
+
+  cli-width@4.1.0: {}
+
+  cliui@8.0.1:
+    dependencies:
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+      wrap-ansi: 7.0.0
+
+  cliui@9.0.1:
+    dependencies:
+      string-width: 7.2.0
+      strip-ansi: 7.1.0
+      wrap-ansi: 9.0.0
+
+  code-excerpt@4.0.0:
+    dependencies:
+      convert-to-spaces: 2.0.1
+
+  collapse-white-space@2.1.0: {}
+
+  color-convert@2.0.1:
+    dependencies:
+      color-name: 1.1.4
+
+  color-name@1.1.4: {}
+
+  color-string@1.9.1:
+    dependencies:
+      color-name: 1.1.4
+      simple-swizzle: 0.2.2
+
+  color@4.2.3:
+    dependencies:
+      color-convert: 2.0.1
+      color-string: 1.9.1
+
+  colorette@2.0.20: {}
+
+  combined-stream@1.0.8:
+    dependencies:
+      delayed-stream: 1.0.0
+
+  comma-separated-tokens@2.0.3: {}
+
+  commander@12.1.0: {}
+
+  commander@4.1.1: {}
+
+  commander@8.3.0: {}
+
+  commander@9.5.0: {}
+
+  concat-map@0.0.1: {}
+
+  confbox@0.1.8: {}
+
+  consola@3.4.2: {}
+
+  console-table-printer@2.12.1:
+    dependencies:
+      simple-wcswidth: 1.0.1
+
+  content-disposition@0.5.4:
+    dependencies:
+      safe-buffer: 5.2.1
+
+  content-disposition@1.0.0:
+    dependencies:
+      safe-buffer: 5.2.1
+
+  content-type@1.0.5: {}
+
+  convert-source-map@2.0.0: {}
+
+  convert-to-spaces@2.0.1: {}
+
+  cookie-signature@1.0.6: {}
+
+  cookie-signature@1.2.2: {}
+
+  cookie@0.7.1: {}
+
+  cookie@0.7.2: {}
+
+  cookie@1.1.1: {}
+
+  cors@2.8.5:
+    dependencies:
+      object-assign: 4.1.1
+      vary: 1.1.2
+
+  cosmiconfig@9.0.0(typescript@5.9.3):
+    dependencies:
+      env-paths: 2.2.1
+      import-fresh: 3.3.1
+      js-yaml: 4.1.0
+      parse-json: 5.2.0
+    optionalDependencies:
+      typescript: 5.9.3
+
+  cross-spawn@7.0.6:
+    dependencies:
+      path-key: 3.1.1
+      shebang-command: 2.0.0
+      which: 2.0.2
+
+  cssesc@3.0.0: {}
+
+  cssstyle@4.6.0:
+    dependencies:
+      '@asamuzakjp/css-color': 3.2.0
+      rrweb-cssom: 0.8.0
+
+  csstype@3.2.3: {}
+
+  ctrf@0.0.17:
+    dependencies:
+      ajv: 8.17.1
+      ajv-formats: 3.0.1(ajv@8.17.1)
+      glob: 11.1.0
+      typescript: 5.8.3
+      yargs: 18.0.0
+
+  data-uri-to-buffer@4.0.1:
+    optional: true
+
+  data-uri-to-buffer@6.0.2: {}
+
+  data-urls@5.0.0:
+    dependencies:
+      whatwg-mimetype: 4.0.0
+      whatwg-url: 14.2.0
+
+  data-view-buffer@1.0.2:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-data-view: 1.0.2
+
+  data-view-byte-length@1.0.2:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-data-view: 1.0.2
+
+  data-view-byte-offset@1.0.1:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-data-view: 1.0.2
+
+  dataloader@1.4.0: {}
+
+  dateformat@4.6.3: {}
+
+  debug@2.6.9:
+    dependencies:
+      ms: 2.0.0
+
+  debug@4.3.7:
+    dependencies:
+      ms: 2.1.3
+
+  debug@4.4.3:
+    dependencies:
+      ms: 2.1.3
+
+  decamelize@1.2.0: {}
+
+  decimal.js@10.6.0: {}
+
+  decode-named-character-reference@1.1.0:
+    dependencies:
+      character-entities: 2.0.2
+
+  decompress-response@6.0.0:
+    dependencies:
+      mimic-response: 3.1.0
+
+  deep-eql@4.1.4:
+    dependencies:
+      type-detect: 4.1.0
+
+  deep-is@0.1.4: {}
+
+  deepmerge@4.3.1: {}
+
+  defer-to-connect@2.0.1: {}
+
+  define-data-property@1.1.4:
+    dependencies:
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
+      gopd: 1.2.0
+
+  define-lazy-prop@2.0.0: {}
+
+  define-properties@1.2.1:
+    dependencies:
+      define-data-property: 1.1.4
+      has-property-descriptors: 1.0.2
+      object-keys: 1.1.1
+
+  degenerator@5.0.1:
+    dependencies:
+      ast-types: 0.13.4
+      escodegen: 2.1.0
+      esprima: 4.0.1
+
+  delayed-stream@1.0.0: {}
+
+  depd@2.0.0: {}
+
+  dependency-graph@0.11.0: {}
+
+  dequal@2.0.3: {}
+
+  destroy@1.2.0: {}
+
+  detect-indent@6.1.0: {}
+
+  detect-libc@2.1.2: {}
+
+  detect-port@1.6.1:
+    dependencies:
+      address: 1.2.2
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
+  devlop@1.1.0:
+    dependencies:
+      dequal: 2.0.3
+
+  devtools-protocol@0.0.1312386: {}
+
+  devtools-protocol@0.0.1464554: {}
+
+  didyoumean@1.2.2: {}
+
+  diff-sequences@29.6.3: {}
+
+  dir-glob@3.0.1:
+    dependencies:
+      path-type: 4.0.0
+
+  dlv@1.1.3: {}
+
+  dns-packet@5.6.1:
+    dependencies:
+      '@leichtgewicht/ip-codec': 2.0.5
+
+  dns-socket@4.2.2:
+    dependencies:
+      dns-packet: 5.6.1
+
+  dotenv@16.4.5: {}
+
+  dotenv@17.3.1: {}
+
+  dotenv@8.6.0: {}
+
+  dunder-proto@1.0.1:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-errors: 1.3.0
+      gopd: 1.2.0
+
+  eastasianwidth@0.2.0: {}
+
+  ecdsa-sig-formatter@1.0.11:
+    dependencies:
+      safe-buffer: 5.2.1
+
+  ee-first@1.1.1: {}
+
+  emoji-regex@10.4.0: {}
+
+  emoji-regex@8.0.0: {}
+
+  emoji-regex@9.2.2: {}
+
+  encodeurl@1.0.2: {}
+
+  encodeurl@2.0.0: {}
+
+  end-of-stream@1.4.4:
+    dependencies:
+      once: 1.4.0
+
+  engine.io-parser@5.2.3: {}
+
+  engine.io@6.6.4(bufferutil@4.0.9):
+    dependencies:
+      '@types/cors': 2.8.17
+      '@types/node': 20.17.32
+      accepts: 1.3.8
+      base64id: 2.0.0
+      cookie: 0.7.2
+      cors: 2.8.5
+      debug: 4.3.7
+      engine.io-parser: 5.2.3
+      ws: 8.17.1(bufferutil@4.0.9)
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  enquirer@2.4.1:
+    dependencies:
+      ansi-colors: 4.1.3
+      strip-ansi: 6.0.1
+
+  entities@6.0.0: {}
+
+  env-paths@2.2.1: {}
+
+  environment@1.1.0: {}
+
+  error-ex@1.3.2:
+    dependencies:
+      is-arrayish: 0.2.1
+
+  es-abstract@1.23.9:
+    dependencies:
+      array-buffer-byte-length: 1.0.2
+      arraybuffer.prototype.slice: 1.0.4
+      available-typed-arrays: 1.0.7
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      data-view-buffer: 1.0.2
+      data-view-byte-length: 1.0.2
+      data-view-byte-offset: 1.0.1
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.1
+      es-set-tostringtag: 2.1.0
+      es-to-primitive: 1.3.0
+      function.prototype.name: 1.1.8
+      get-intrinsic: 1.3.0
+      get-proto: 1.0.1
+      get-symbol-description: 1.1.0
+      globalthis: 1.0.4
+      gopd: 1.2.0
+      has-property-descriptors: 1.0.2
+      has-proto: 1.2.0
+      has-symbols: 1.1.0
+      hasown: 2.0.2
+      internal-slot: 1.1.0
+      is-array-buffer: 3.0.5
+      is-callable: 1.2.7
+      is-data-view: 1.0.2
+      is-regex: 1.2.1
+      is-shared-array-buffer: 1.0.4
+      is-string: 1.1.1
+      is-typed-array: 1.1.15
+      is-weakref: 1.1.1
+      math-intrinsics: 1.1.0
+      object-inspect: 1.13.4
+      object-keys: 1.1.1
+      object.assign: 4.1.7
+      own-keys: 1.0.1
+      regexp.prototype.flags: 1.5.4
+      safe-array-concat: 1.1.3
+      safe-push-apply: 1.0.0
+      safe-regex-test: 1.1.0
+      set-proto: 1.0.0
+      string.prototype.trim: 1.2.10
+      string.prototype.trimend: 1.0.9
+      string.prototype.trimstart: 1.0.8
+      typed-array-buffer: 1.0.3
+      typed-array-byte-length: 1.0.3
+      typed-array-byte-offset: 1.0.4
+      typed-array-length: 1.0.7
+      unbox-primitive: 1.1.0
+      which-typed-array: 1.1.19
+
+  es-aggregate-error@1.0.13:
+    dependencies:
+      define-data-property: 1.1.4
+      define-properties: 1.2.1
+      es-abstract: 1.23.9
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+      globalthis: 1.0.4
+      has-property-descriptors: 1.0.2
+      set-function-name: 2.0.2
+
+  es-define-property@1.0.1: {}
+
+  es-errors@1.3.0: {}
+
+  es-module-lexer@1.7.0: {}
+
+  es-object-atoms@1.1.1:
+    dependencies:
+      es-errors: 1.3.0
+
+  es-set-tostringtag@2.1.0:
+    dependencies:
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      has-tostringtag: 1.0.2
+      hasown: 2.0.2
+
+  es-to-primitive@1.3.0:
+    dependencies:
+      is-callable: 1.2.7
+      is-date-object: 1.1.0
+      is-symbol: 1.1.1
+
+  es-toolkit@1.39.10: {}
+
+  esast-util-from-estree@2.0.0:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      devlop: 1.1.0
+      estree-util-visit: 2.0.0
+      unist-util-position-from-estree: 2.0.0
+
+  esast-util-from-js@2.0.1:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      acorn: 8.16.0
+      esast-util-from-estree: 2.0.0
+      vfile-message: 4.0.2
+
+  esbuild@0.21.5:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.21.5
+      '@esbuild/android-arm': 0.21.5
+      '@esbuild/android-arm64': 0.21.5
+      '@esbuild/android-x64': 0.21.5
+      '@esbuild/darwin-arm64': 0.21.5
+      '@esbuild/darwin-x64': 0.21.5
+      '@esbuild/freebsd-arm64': 0.21.5
+      '@esbuild/freebsd-x64': 0.21.5
+      '@esbuild/linux-arm': 0.21.5
+      '@esbuild/linux-arm64': 0.21.5
+      '@esbuild/linux-ia32': 0.21.5
+      '@esbuild/linux-loong64': 0.21.5
+      '@esbuild/linux-mips64el': 0.21.5
+      '@esbuild/linux-ppc64': 0.21.5
+      '@esbuild/linux-riscv64': 0.21.5
+      '@esbuild/linux-s390x': 0.21.5
+      '@esbuild/linux-x64': 0.21.5
+      '@esbuild/netbsd-x64': 0.21.5
+      '@esbuild/openbsd-x64': 0.21.5
+      '@esbuild/sunos-x64': 0.21.5
+      '@esbuild/win32-arm64': 0.21.5
+      '@esbuild/win32-ia32': 0.21.5
+      '@esbuild/win32-x64': 0.21.5
+
+  esbuild@0.25.11:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.25.11
+      '@esbuild/android-arm': 0.25.11
+      '@esbuild/android-arm64': 0.25.11
+      '@esbuild/android-x64': 0.25.11
+      '@esbuild/darwin-arm64': 0.25.11
+      '@esbuild/darwin-x64': 0.25.11
+      '@esbuild/freebsd-arm64': 0.25.11
+      '@esbuild/freebsd-x64': 0.25.11
+      '@esbuild/linux-arm': 0.25.11
+      '@esbuild/linux-arm64': 0.25.11
+      '@esbuild/linux-ia32': 0.25.11
+      '@esbuild/linux-loong64': 0.25.11
+      '@esbuild/linux-mips64el': 0.25.11
+      '@esbuild/linux-ppc64': 0.25.11
+      '@esbuild/linux-riscv64': 0.25.11
+      '@esbuild/linux-s390x': 0.25.11
+      '@esbuild/linux-x64': 0.25.11
+      '@esbuild/netbsd-arm64': 0.25.11
+      '@esbuild/netbsd-x64': 0.25.11
+      '@esbuild/openbsd-arm64': 0.25.11
+      '@esbuild/openbsd-x64': 0.25.11
+      '@esbuild/openharmony-arm64': 0.25.11
+      '@esbuild/sunos-x64': 0.25.11
+      '@esbuild/win32-arm64': 0.25.11
+      '@esbuild/win32-ia32': 0.25.11
+      '@esbuild/win32-x64': 0.25.11
+
+  esbuild@0.27.2:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.27.2
+      '@esbuild/android-arm': 0.27.2
+      '@esbuild/android-arm64': 0.27.2
+      '@esbuild/android-x64': 0.27.2
+      '@esbuild/darwin-arm64': 0.27.2
+      '@esbuild/darwin-x64': 0.27.2
+      '@esbuild/freebsd-arm64': 0.27.2
+      '@esbuild/freebsd-x64': 0.27.2
+      '@esbuild/linux-arm': 0.27.2
+      '@esbuild/linux-arm64': 0.27.2
+      '@esbuild/linux-ia32': 0.27.2
+      '@esbuild/linux-loong64': 0.27.2
+      '@esbuild/linux-mips64el': 0.27.2
+      '@esbuild/linux-ppc64': 0.27.2
+      '@esbuild/linux-riscv64': 0.27.2
+      '@esbuild/linux-s390x': 0.27.2
+      '@esbuild/linux-x64': 0.27.2
+      '@esbuild/netbsd-arm64': 0.27.2
+      '@esbuild/netbsd-x64': 0.27.2
+      '@esbuild/openbsd-arm64': 0.27.2
+      '@esbuild/openbsd-x64': 0.27.2
+      '@esbuild/openharmony-arm64': 0.27.2
+      '@esbuild/sunos-x64': 0.27.2
+      '@esbuild/win32-arm64': 0.27.2
+      '@esbuild/win32-ia32': 0.27.2
+      '@esbuild/win32-x64': 0.27.2
+
+  escalade@3.2.0: {}
+
+  escape-html@1.0.3: {}
+
+  escape-string-regexp@2.0.0: {}
+
+  escape-string-regexp@4.0.0: {}
+
+  escape-string-regexp@5.0.0: {}
+
+  escodegen@2.1.0:
+    dependencies:
+      esprima: 4.0.1
+      estraverse: 5.3.0
+      esutils: 2.0.3
+    optionalDependencies:
+      source-map: 0.6.1
+
+  eslint-plugin-security@3.0.1:
+    dependencies:
+      safe-regex: 2.1.1
+
+  eslint-scope@8.4.0:
+    dependencies:
+      esrecurse: 4.3.0
+      estraverse: 5.3.0
+
+  eslint-scope@9.1.1:
+    dependencies:
+      '@types/esrecurse': 4.3.1
+      '@types/estree': 1.0.8
+      esrecurse: 4.3.0
+      estraverse: 5.3.0
+
+  eslint-visitor-keys@3.4.3: {}
+
+  eslint-visitor-keys@4.2.1: {}
+
+  eslint-visitor-keys@5.0.1: {}
+
+  eslint@10.0.2(jiti@1.21.7):
+    dependencies:
+      '@eslint-community/eslint-utils': 4.9.1(eslint@10.0.2(jiti@1.21.7))
+      '@eslint-community/regexpp': 4.12.2
+      '@eslint/config-array': 0.23.2
+      '@eslint/config-helpers': 0.5.2
+      '@eslint/core': 1.1.0
+      '@eslint/plugin-kit': 0.6.0
+      '@humanfs/node': 0.16.6
+      '@humanwhocodes/module-importer': 1.0.1
+      '@humanwhocodes/retry': 0.4.2
+      '@types/estree': 1.0.8
+      ajv: 6.14.0
+      cross-spawn: 7.0.6
+      debug: 4.4.3
+      escape-string-regexp: 4.0.0
+      eslint-scope: 9.1.1
+      eslint-visitor-keys: 5.0.1
+      espree: 11.1.1
+      esquery: 1.7.0
+      esutils: 2.0.3
+      fast-deep-equal: 3.1.3
+      file-entry-cache: 8.0.0
+      find-up: 5.0.0
+      glob-parent: 6.0.2
+      ignore: 5.3.2
+      imurmurhash: 0.1.4
+      is-glob: 4.0.3
+      json-stable-stringify-without-jsonify: 1.0.1
+      minimatch: 10.2.2
+      natural-compare: 1.4.0
+      optionator: 0.9.4
+    optionalDependencies:
+      jiti: 1.21.7
+    transitivePeerDependencies:
+      - supports-color
+
+  eslint@9.39.4(jiti@1.21.7):
+    dependencies:
+      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.4(jiti@1.21.7))
+      '@eslint-community/regexpp': 4.12.2
+      '@eslint/config-array': 0.21.2
+      '@eslint/config-helpers': 0.4.2
+      '@eslint/core': 0.17.0
+      '@eslint/eslintrc': 3.3.5
+      '@eslint/js': 9.39.4
+      '@eslint/plugin-kit': 0.4.1
+      '@humanfs/node': 0.16.6
+      '@humanwhocodes/module-importer': 1.0.1
+      '@humanwhocodes/retry': 0.4.2
+      '@types/estree': 1.0.8
+      ajv: 6.14.0
+      chalk: 4.1.2
+      cross-spawn: 7.0.6
+      debug: 4.4.3
+      escape-string-regexp: 4.0.0
+      eslint-scope: 8.4.0
+      eslint-visitor-keys: 4.2.1
+      espree: 10.4.0
+      esquery: 1.7.0
+      esutils: 2.0.3
+      fast-deep-equal: 3.1.3
+      file-entry-cache: 8.0.0
+      find-up: 5.0.0
+      glob-parent: 6.0.2
+      ignore: 5.3.2
+      imurmurhash: 0.1.4
+      is-glob: 4.0.3
+      json-stable-stringify-without-jsonify: 1.0.1
+      lodash.merge: 4.6.2
+      minimatch: 3.1.5
+      natural-compare: 1.4.0
+      optionator: 0.9.4
+    optionalDependencies:
+      jiti: 1.21.7
+    transitivePeerDependencies:
+      - supports-color
+
+  espree@10.4.0:
+    dependencies:
+      acorn: 8.16.0
+      acorn-jsx: 5.3.2(acorn@8.16.0)
+      eslint-visitor-keys: 4.2.1
+
+  espree@11.1.1:
+    dependencies:
+      acorn: 8.16.0
+      acorn-jsx: 5.3.2(acorn@8.16.0)
+      eslint-visitor-keys: 5.0.1
+
+  esprima@4.0.1: {}
+
+  esquery@1.7.0:
+    dependencies:
+      estraverse: 5.3.0
+
+  esrecurse@4.3.0:
+    dependencies:
+      estraverse: 5.3.0
+
+  estraverse@5.3.0: {}
+
+  estree-util-attach-comments@3.0.0:
+    dependencies:
+      '@types/estree': 1.0.8
+
+  estree-util-build-jsx@3.0.1:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      devlop: 1.1.0
+      estree-util-is-identifier-name: 3.0.0
+      estree-walker: 3.0.3
+
+  estree-util-is-identifier-name@3.0.0: {}
+
+  estree-util-scope@1.0.0:
+    dependencies:
+      '@types/estree': 1.0.8
+      devlop: 1.1.0
+
+  estree-util-to-js@2.0.0:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      astring: 1.9.0
+      source-map: 0.7.4
+
+  estree-util-visit@2.0.0:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/unist': 3.0.3
+
+  estree-walker@3.0.3:
+    dependencies:
+      '@types/estree': 1.0.8
+
+  esutils@2.0.3: {}
+
+  etag@1.8.1: {}
+
+  event-target-shim@5.0.1: {}
+
+  eventemitter3@4.0.7: {}
+
+  events@3.3.0: {}
+
+  eventsource-parser@1.1.2: {}
+
+  eventsource-parser@3.0.6: {}
+
+  eventsource@3.0.7:
+    dependencies:
+      eventsource-parser: 3.0.6
+
+  execa@8.0.1:
+    dependencies:
+      cross-spawn: 7.0.6
+      get-stream: 8.0.1
+      human-signals: 5.0.0
+      is-stream: 3.0.0
+      merge-stream: 2.0.0
+      npm-run-path: 5.3.0
+      onetime: 6.0.0
+      signal-exit: 4.1.0
+      strip-final-newline: 3.0.0
+
+  expect-type@1.2.2: {}
+
+  express-rate-limit@7.5.1(express@5.1.0):
+    dependencies:
+      express: 5.1.0
+
+  express@4.21.2:
+    dependencies:
+      accepts: 1.3.8
+      array-flatten: 1.1.1
+      body-parser: 1.20.3
+      content-disposition: 0.5.4
+      content-type: 1.0.5
+      cookie: 0.7.1
+      cookie-signature: 1.0.6
+      debug: 2.6.9
+      depd: 2.0.0
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      etag: 1.8.1
+      finalhandler: 1.3.1
+      fresh: 0.5.2
+      http-errors: 2.0.0
+      merge-descriptors: 1.0.3
+      methods: 1.1.2
+      on-finished: 2.4.1
+      parseurl: 1.3.3
+      path-to-regexp: 0.1.12
+      proxy-addr: 2.0.7
+      qs: 6.13.0
+      range-parser: 1.2.1
+      safe-buffer: 5.2.1
+      send: 0.19.0
+      serve-static: 1.16.2
+      setprototypeof: 1.2.0
+      statuses: 2.0.1
+      type-is: 1.6.18
+      utils-merge: 1.0.1
+      vary: 1.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  express@5.1.0:
+    dependencies:
+      accepts: 2.0.0
+      body-parser: 2.2.0
+      content-disposition: 1.0.0
+      content-type: 1.0.5
+      cookie: 0.7.2
+      cookie-signature: 1.2.2
+      debug: 4.4.3
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      etag: 1.8.1
+      finalhandler: 2.1.0
+      fresh: 2.0.0
+      http-errors: 2.0.0
+      merge-descriptors: 2.0.0
+      mime-types: 3.0.1
+      on-finished: 2.4.1
+      once: 1.4.0
+      parseurl: 1.3.3
+      proxy-addr: 2.0.7
+      qs: 6.14.0
+      range-parser: 1.2.1
+      router: 2.2.0
+      send: 1.2.0
+      serve-static: 2.2.0
+      statuses: 2.0.1
+      type-is: 2.0.1
+      vary: 1.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  extend-shallow@2.0.1:
+    dependencies:
+      is-extendable: 0.1.1
+
+  extend@3.0.2: {}
+
+  extendable-error@0.1.7: {}
+
+  external-editor@3.1.0:
+    dependencies:
+      chardet: 0.7.0
+      iconv-lite: 0.4.24
+      tmp: 0.0.33
+
+  extract-zip@2.0.1:
+    dependencies:
+      debug: 4.4.3
+      get-stream: 5.2.0
+      yauzl: 2.10.0
+    optionalDependencies:
+      '@types/yauzl': 2.10.3
+    transitivePeerDependencies:
+      - supports-color
+
+  fast-copy@3.0.2: {}
+
+  fast-decode-uri-component@1.0.1: {}
+
+  fast-deep-equal@3.1.3: {}
+
+  fast-fifo@1.3.2: {}
+
+  fast-glob@3.3.3:
+    dependencies:
+      '@nodelib/fs.stat': 2.0.5
+      '@nodelib/fs.walk': 1.2.8
+      glob-parent: 5.1.2
+      merge2: 1.4.1
+      micromatch: 4.0.8
+
+  fast-json-stable-stringify@2.1.0: {}
+
+  fast-json-stringify@6.1.1:
+    dependencies:
+      '@fastify/merge-json-schemas': 0.2.1
+      ajv: 8.17.1
+      ajv-formats: 3.0.1(ajv@8.17.1)
+      fast-uri: 3.0.6
+      json-schema-ref-resolver: 3.0.0
+      rfdc: 1.4.1
+
+  fast-levenshtein@2.0.6: {}
+
+  fast-memoize@2.5.2: {}
+
+  fast-querystring@1.1.2:
+    dependencies:
+      fast-decode-uri-component: 1.0.1
+
+  fast-safe-stringify@2.1.1: {}
+
+  fast-uri@3.0.6: {}
+
+  fastify-metrics@12.1.0(fastify@5.6.2):
+    dependencies:
+      fastify: 5.6.2
+      fastify-plugin: 5.1.0
+      prom-client: 15.1.3
+
+  fastify-plugin@4.5.1: {}
+
+  fastify-plugin@5.1.0: {}
+
+  fastify-zod-openapi@5.5.0(@fastify/swagger-ui@5.2.3)(@fastify/swagger@9.6.1)(fastify@5.6.2)(zod@4.2.1):
+    dependencies:
+      '@fastify/error': 4.2.0
+      fast-json-stringify: 6.1.1
+      fastify: 5.6.2
+      fastify-plugin: 5.1.0
+      zod: 4.2.1
+      zod-openapi: 5.4.5(zod@4.2.1)
+    optionalDependencies:
+      '@fastify/swagger': 9.6.1
+      '@fastify/swagger-ui': 5.2.3
+
+  fastify@5.6.2:
+    dependencies:
+      '@fastify/ajv-compiler': 4.0.5
+      '@fastify/error': 4.2.0
+      '@fastify/fast-json-stringify-compiler': 5.0.3
+      '@fastify/proxy-addr': 5.1.0
+      abstract-logging: 2.0.1
+      avvio: 9.1.0
+      fast-json-stringify: 6.1.1
+      find-my-way: 9.3.0
+      light-my-request: 6.6.0
+      pino: 10.1.0
+      process-warning: 5.0.0
+      rfdc: 1.4.1
+      secure-json-parse: 4.1.0
+      semver: 7.7.3
+      toad-cache: 3.7.0
+
+  fastq@1.19.1:
+    dependencies:
+      reusify: 1.1.0
+
+  fault@2.0.1:
+    dependencies:
+      format: 0.2.2
+
+  favicons@7.2.0:
+    dependencies:
+      escape-html: 1.0.3
+      sharp: 0.33.5
+      xml2js: 0.6.2
+
+  fd-slicer@1.1.0:
+    dependencies:
+      pend: 1.2.0
+
+  fdir@6.5.0(picomatch@4.0.3):
+    optionalDependencies:
+      picomatch: 4.0.3
+
+  fetch-blob@3.2.0:
+    dependencies:
+      node-domexception: 1.0.0
+      web-streams-polyfill: 3.3.3
+    optional: true
+
+  fetch-cookie@3.1.0:
+    dependencies:
+      set-cookie-parser: 2.7.1
+      tough-cookie: 5.1.2
+
+  file-entry-cache@8.0.0:
+    dependencies:
+      flat-cache: 4.0.1
+
+  fill-range@7.1.1:
+    dependencies:
+      to-regex-range: 5.0.1
+
+  finalhandler@1.3.1:
+    dependencies:
+      debug: 2.6.9
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      on-finished: 2.4.1
+      parseurl: 1.3.3
+      statuses: 2.0.1
+      unpipe: 1.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  finalhandler@2.1.0:
+    dependencies:
+      debug: 4.4.3
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      on-finished: 2.4.1
+      parseurl: 1.3.3
+      statuses: 2.0.1
+    transitivePeerDependencies:
+      - supports-color
+
+  find-my-way@9.3.0:
+    dependencies:
+      fast-deep-equal: 3.1.3
+      fast-querystring: 1.1.2
+      safe-regex2: 5.0.0
+
+  find-up@4.1.0:
+    dependencies:
+      locate-path: 5.0.0
+      path-exists: 4.0.0
+
+  find-up@5.0.0:
+    dependencies:
+      locate-path: 6.0.0
+      path-exists: 4.0.0
+
+  fix-dts-default-cjs-exports@1.0.1:
+    dependencies:
+      magic-string: 0.30.21
+      mlly: 1.8.1
+      rollup: 4.53.2
+
+  flat-cache@4.0.1:
+    dependencies:
+      flatted: 3.3.3
+      keyv: 4.5.4
+
+  flatted@3.3.3: {}
+
+  follow-redirects@1.15.9: {}
+
+  for-each@0.3.5:
+    dependencies:
+      is-callable: 1.2.7
+
+  foreground-child@3.3.1:
+    dependencies:
+      cross-spawn: 7.0.6
+      signal-exit: 4.1.0
+
+  form-data-encoder@1.7.2: {}
+
+  form-data-encoder@2.1.4: {}
+
+  form-data@4.0.2:
+    dependencies:
+      asynckit: 0.4.0
+      combined-stream: 1.0.8
+      es-set-tostringtag: 2.1.0
+      mime-types: 2.1.35
+
+  format@0.2.2: {}
+
+  formdata-node@4.4.1:
+    dependencies:
+      node-domexception: 1.0.0
+      web-streams-polyfill: 4.0.0-beta.3
+
+  formdata-polyfill@4.0.10:
+    dependencies:
+      fetch-blob: 3.2.0
+    optional: true
+
+  forwarded@0.2.0: {}
+
+  fresh@0.5.2: {}
+
+  fresh@2.0.0: {}
+
+  fs-extra@11.3.0:
+    dependencies:
+      graceful-fs: 4.2.11
+      jsonfile: 6.1.0
+      universalify: 2.0.1
+
+  fs-extra@7.0.1:
+    dependencies:
+      graceful-fs: 4.2.11
+      jsonfile: 4.0.0
+      universalify: 0.1.2
+
+  fs-extra@8.1.0:
+    dependencies:
+      graceful-fs: 4.2.11
+      jsonfile: 4.0.0
+      universalify: 0.1.2
+
+  fs-minipass@2.1.0:
+    dependencies:
+      minipass: 3.3.6
+
+  fsevents@2.3.2:
+    optional: true
+
+  fsevents@2.3.3:
+    optional: true
+
+  function-bind@1.1.2: {}
+
+  function.prototype.name@1.1.8:
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      define-properties: 1.2.1
+      functions-have-names: 1.2.3
+      hasown: 2.0.2
+      is-callable: 1.2.7
+
+  functions-have-names@1.2.3: {}
+
+  gaxios@6.7.1:
+    dependencies:
+      extend: 3.0.2
+      https-proxy-agent: 7.0.6
+      is-stream: 2.0.1
+      node-fetch: 2.7.0
+      uuid: 9.0.1
+    transitivePeerDependencies:
+      - encoding
+      - supports-color
+
+  gaxios@7.1.3:
+    dependencies:
+      extend: 3.0.2
+      https-proxy-agent: 7.0.6
+      node-fetch: 3.3.2
+      rimraf: 5.0.10
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
+  gcd@0.0.1: {}
+
+  gcp-metadata@6.1.1:
+    dependencies:
+      gaxios: 6.7.1
+      google-logging-utils: 0.0.2
+      json-bigint: 1.0.0
+    transitivePeerDependencies:
+      - encoding
+      - supports-color
+
+  gcp-metadata@8.1.2:
+    dependencies:
+      gaxios: 7.1.3
+      google-logging-utils: 1.1.3
+      json-bigint: 1.0.0
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
+  get-caller-file@2.0.5: {}
+
+  get-east-asian-width@1.3.0: {}
+
+  get-func-name@2.0.2: {}
+
+  get-intrinsic@1.3.0:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.1
+      function-bind: 1.1.2
+      get-proto: 1.0.1
+      gopd: 1.2.0
+      has-symbols: 1.1.0
+      hasown: 2.0.2
+      math-intrinsics: 1.1.0
+
+  get-proto@1.0.1:
+    dependencies:
+      dunder-proto: 1.0.1
+      es-object-atoms: 1.1.1
+
+  get-stream@5.2.0:
+    dependencies:
+      pump: 3.0.2
+
+  get-stream@6.0.1: {}
+
+  get-stream@8.0.1: {}
+
+  get-symbol-description@1.1.0:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+
+  get-tsconfig@4.10.0:
+    dependencies:
+      resolve-pkg-maps: 1.0.0
+
+  get-uri@6.0.4:
+    dependencies:
+      basic-ftp: 5.0.5
+      data-uri-to-buffer: 6.0.2
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
+  glob-parent@5.1.2:
+    dependencies:
+      is-glob: 4.0.3
+
+  glob-parent@6.0.2:
+    dependencies:
+      is-glob: 4.0.3
+
+  glob@10.4.5:
+    dependencies:
+      foreground-child: 3.3.1
+      jackspeak: 3.4.3
+      minimatch: 9.0.5
+      minipass: 7.1.2
+      package-json-from-dist: 1.0.1
+      path-scurry: 1.11.1
+
+  glob@11.1.0:
+    dependencies:
+      foreground-child: 3.3.1
+      jackspeak: 4.1.1
+      minimatch: 10.1.1
+      minipass: 7.1.2
+      package-json-from-dist: 1.0.1
+      path-scurry: 2.0.1
+
+  globals@14.0.0: {}
+
+  globals@15.15.0: {}
+
+  globalthis@1.0.4:
+    dependencies:
+      define-properties: 1.2.1
+      gopd: 1.2.0
+
+  globby@11.1.0:
+    dependencies:
+      array-union: 2.1.0
+      dir-glob: 3.0.1
+      fast-glob: 3.3.3
+      ignore: 5.3.2
+      merge2: 1.4.1
+      slash: 3.0.0
+
+  google-auth-library@10.5.0:
+    dependencies:
+      base64-js: 1.5.1
+      ecdsa-sig-formatter: 1.0.11
+      gaxios: 7.1.3
+      gcp-metadata: 8.1.2
+      google-logging-utils: 1.1.3
+      gtoken: 8.0.0
+      jws: 4.0.0
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
+  google-auth-library@9.15.1:
+    dependencies:
+      base64-js: 1.5.1
+      ecdsa-sig-formatter: 1.0.11
+      gaxios: 6.7.1
+      gcp-metadata: 6.1.1
+      gtoken: 7.1.0
+      jws: 4.0.0
+    transitivePeerDependencies:
+      - encoding
+      - supports-color
+
+  google-logging-utils@0.0.2: {}
+
+  google-logging-utils@1.1.3:
+    optional: true
+
+  gopd@1.2.0: {}
+
+  got@12.6.1:
+    dependencies:
+      '@sindresorhus/is': 5.6.0
+      '@szmarczak/http-timer': 5.0.1
+      cacheable-lookup: 7.0.0
+      cacheable-request: 10.2.14
+      decompress-response: 6.0.0
+      form-data-encoder: 2.1.4
+      get-stream: 6.0.1
+      http2-wrapper: 2.2.1
+      lowercase-keys: 3.0.0
+      p-cancelable: 3.0.0
+      responselike: 3.0.0
+
+  got@13.0.0:
+    dependencies:
+      '@sindresorhus/is': 5.6.0
+      '@szmarczak/http-timer': 5.0.1
+      cacheable-lookup: 7.0.0
+      cacheable-request: 10.2.14
+      decompress-response: 6.0.0
+      form-data-encoder: 2.1.4
+      get-stream: 6.0.1
+      http2-wrapper: 2.2.1
+      lowercase-keys: 3.0.0
+      p-cancelable: 3.0.0
+      responselike: 3.0.0
+
+  graceful-fs@4.2.11: {}
+
+  gray-matter@4.0.3:
+    dependencies:
+      js-yaml: 3.14.1
+      kind-of: 6.0.3
+      section-matter: 1.0.0
+      strip-bom-string: 1.0.0
+
+  gtoken@7.1.0:
+    dependencies:
+      gaxios: 6.7.1
+      jws: 4.0.0
+    transitivePeerDependencies:
+      - encoding
+      - supports-color
+
+  gtoken@8.0.0:
+    dependencies:
+      gaxios: 7.1.3
+      jws: 4.0.0
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
+  has-bigints@1.1.0: {}
+
+  has-flag@4.0.0: {}
+
+  has-property-descriptors@1.0.2:
+    dependencies:
+      es-define-property: 1.0.1
+
+  has-proto@1.2.0:
+    dependencies:
+      dunder-proto: 1.0.1
+
+  has-symbols@1.1.0: {}
+
+  has-tostringtag@1.0.2:
+    dependencies:
+      has-symbols: 1.1.0
+
+  hasown@2.0.2:
+    dependencies:
+      function-bind: 1.1.2
+
+  hast-util-embedded@3.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+      hast-util-is-element: 3.0.0
+
+  hast-util-from-dom@5.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      hastscript: 9.0.1
+      web-namespaces: 2.0.1
+
+  hast-util-from-html-isomorphic@2.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+      hast-util-from-dom: 5.0.1
+      hast-util-from-html: 2.0.3
+      unist-util-remove-position: 5.0.0
+
+  hast-util-from-html@2.0.3:
+    dependencies:
+      '@types/hast': 3.0.4
+      devlop: 1.1.0
+      hast-util-from-parse5: 8.0.3
+      parse5: 7.3.0
+      vfile: 6.0.3
+      vfile-message: 4.0.2
+
+  hast-util-from-parse5@8.0.3:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      devlop: 1.1.0
+      hastscript: 9.0.1
+      property-information: 7.0.0
+      vfile: 6.0.3
+      vfile-location: 5.0.3
+      web-namespaces: 2.0.1
+
+  hast-util-has-property@3.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+
+  hast-util-is-body-ok-link@3.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+
+  hast-util-is-element@3.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+
+  hast-util-minify-whitespace@1.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      hast-util-embedded: 3.0.0
+      hast-util-is-element: 3.0.0
+      hast-util-whitespace: 3.0.0
+      unist-util-is: 6.0.0
+
+  hast-util-parse-selector@4.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+
+  hast-util-phrasing@3.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      hast-util-embedded: 3.0.0
+      hast-util-has-property: 3.0.0
+      hast-util-is-body-ok-link: 3.0.1
+      hast-util-is-element: 3.0.0
+
+  hast-util-to-estree@3.1.3:
+    dependencies:
+      '@types/estree': 1.0.8
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      comma-separated-tokens: 2.0.3
+      devlop: 1.1.0
+      estree-util-attach-comments: 3.0.0
+      estree-util-is-identifier-name: 3.0.0
+      hast-util-whitespace: 3.0.0
+      mdast-util-mdx-expression: 2.0.1
+      mdast-util-mdx-jsx: 3.2.0
+      mdast-util-mdxjs-esm: 2.0.1
+      property-information: 7.0.0
+      space-separated-tokens: 2.0.2
+      style-to-js: 1.1.16
+      unist-util-position: 5.0.0
+      zwitch: 2.0.4
+    transitivePeerDependencies:
+      - supports-color
+
+  hast-util-to-html@9.0.5:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      ccount: 2.0.1
+      comma-separated-tokens: 2.0.3
+      hast-util-whitespace: 3.0.0
+      html-void-elements: 3.0.0
+      mdast-util-to-hast: 13.2.0
+      property-information: 7.0.0
+      space-separated-tokens: 2.0.2
+      stringify-entities: 4.0.4
+      zwitch: 2.0.4
+
+  hast-util-to-jsx-runtime@2.3.6:
+    dependencies:
+      '@types/estree': 1.0.8
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      comma-separated-tokens: 2.0.3
+      devlop: 1.1.0
+      estree-util-is-identifier-name: 3.0.0
+      hast-util-whitespace: 3.0.0
+      mdast-util-mdx-expression: 2.0.1
+      mdast-util-mdx-jsx: 3.2.0
+      mdast-util-mdxjs-esm: 2.0.1
+      property-information: 7.0.0
+      space-separated-tokens: 2.0.2
+      style-to-js: 1.1.16
+      unist-util-position: 5.0.0
+      vfile-message: 4.0.2
+    transitivePeerDependencies:
+      - supports-color
+
+  hast-util-to-mdast@10.1.2:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      '@ungap/structured-clone': 1.3.0
+      hast-util-phrasing: 3.0.1
+      hast-util-to-html: 9.0.5
+      hast-util-to-text: 4.0.2
+      hast-util-whitespace: 3.0.0
+      mdast-util-phrasing: 4.1.0
+      mdast-util-to-hast: 13.2.0
+      mdast-util-to-string: 4.0.0
+      rehype-minify-whitespace: 6.0.2
+      trim-trailing-lines: 2.1.0
+      unist-util-position: 5.0.0
+      unist-util-visit: 5.0.0
+
+  hast-util-to-string@3.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+
+  hast-util-to-text@4.0.2:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      hast-util-is-element: 3.0.0
+      unist-util-find-after: 5.0.0
+
+  hast-util-whitespace@3.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+
+  hastscript@9.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      comma-separated-tokens: 2.0.3
+      hast-util-parse-selector: 4.0.0
+      property-information: 7.0.0
+      space-separated-tokens: 2.0.2
+
+  help-me@5.0.0: {}
+
+  html-encoding-sniffer@4.0.0:
+    dependencies:
+      whatwg-encoding: 3.1.1
+
+  html-escaper@2.0.2: {}
+
+  html-void-elements@3.0.0: {}
+
+  http-cache-semantics@4.1.1: {}
+
+  http-errors@2.0.0:
+    dependencies:
+      depd: 2.0.0
+      inherits: 2.0.4
+      setprototypeof: 1.2.0
+      statuses: 2.0.1
+      toidentifier: 1.0.1
+
+  http-proxy-agent@7.0.2:
+    dependencies:
+      agent-base: 7.1.3
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
+  http-status-codes@2.3.0: {}
+
+  http2-wrapper@2.2.1:
+    dependencies:
+      quick-lru: 5.1.1
+      resolve-alpn: 1.2.1
+
+  https-proxy-agent@7.0.6:
+    dependencies:
+      agent-base: 7.1.3
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
+  human-id@4.1.1: {}
+
+  human-signals@5.0.0: {}
+
+  humanize-ms@1.2.1:
+    dependencies:
+      ms: 2.1.3
+
+  iconv-lite@0.4.24:
+    dependencies:
+      safer-buffer: 2.1.2
+
+  iconv-lite@0.6.3:
+    dependencies:
+      safer-buffer: 2.1.2
+
+  ieee754@1.2.1: {}
+
+  ignore@5.3.2: {}
+
+  ignore@7.0.5: {}
+
+  immer@9.0.21: {}
+
+  import-fresh@3.3.1:
+    dependencies:
+      parent-module: 1.0.1
+      resolve-from: 4.0.0
+
+  imurmurhash@0.1.4: {}
+
+  indent-string@5.0.0: {}
+
+  inherits@2.0.4: {}
+
+  ink-spinner@5.0.0(ink@5.2.1(@types/react@19.1.3)(bufferutil@4.0.9)(react@18.3.1))(react@18.3.1):
+    dependencies:
+      cli-spinners: 2.9.2
+      ink: 5.2.1(@types/react@19.1.3)(bufferutil@4.0.9)(react@18.3.1)
+      react: 18.3.1
+
+  ink@5.2.1(@types/react@19.1.3)(bufferutil@4.0.9)(react@18.3.1):
+    dependencies:
+      '@alcalzone/ansi-tokenize': 0.1.3
+      ansi-escapes: 7.0.0
+      ansi-styles: 6.2.1
+      auto-bind: 5.0.1
+      chalk: 5.4.1
+      cli-boxes: 3.0.0
+      cli-cursor: 4.0.0
+      cli-truncate: 4.0.0
+      code-excerpt: 4.0.0
+      es-toolkit: 1.39.10
+      indent-string: 5.0.0
+      is-in-ci: 1.0.0
+      patch-console: 2.0.0
+      react: 18.3.1
+      react-reconciler: 0.29.2(react@18.3.1)
+      scheduler: 0.23.2
+      signal-exit: 3.0.7
+      slice-ansi: 7.1.0
+      stack-utils: 2.0.6
+      string-width: 7.2.0
+      type-fest: 4.41.0
+      widest-line: 5.0.0
+      wrap-ansi: 9.0.0
+      ws: 8.18.3(bufferutil@4.0.9)
+      yoga-layout: 3.2.1
+    optionalDependencies:
+      '@types/react': 19.1.3
+    transitivePeerDependencies:
+      - bufferutil
+      - utf-8-validate
+
+  inline-style-parser@0.2.4: {}
+
+  inquirer@12.6.0(@types/node@22.13.1):
+    dependencies:
+      '@inquirer/core': 10.1.10(@types/node@22.13.1)
+      '@inquirer/prompts': 7.5.0(@types/node@22.13.1)
+      '@inquirer/type': 3.0.6(@types/node@22.13.1)
+      ansi-escapes: 4.3.2
+      mute-stream: 2.0.0
+      run-async: 3.0.0
+      rxjs: 7.8.2
+    optionalDependencies:
+      '@types/node': 22.13.1
+
+  internal-slot@1.1.0:
+    dependencies:
+      es-errors: 1.3.0
+      hasown: 2.0.2
+      side-channel: 1.1.0
+
+  ip-address@9.0.5:
+    dependencies:
+      jsbn: 1.1.0
+      sprintf-js: 1.1.3
+
+  ip-regex@4.3.0: {}
+
+  ipaddr.js@1.9.1: {}
+
+  ipaddr.js@2.3.0: {}
+
+  is-alphabetical@2.0.1: {}
+
+  is-alphanumerical@2.0.1:
+    dependencies:
+      is-alphabetical: 2.0.1
+      is-decimal: 2.0.1
+
+  is-array-buffer@3.0.5:
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      get-intrinsic: 1.3.0
+
+  is-arrayish@0.2.1: {}
+
+  is-arrayish@0.3.2: {}
+
+  is-async-function@2.1.1:
+    dependencies:
+      async-function: 1.0.0
+      call-bound: 1.0.4
+      get-proto: 1.0.1
+      has-tostringtag: 1.0.2
+      safe-regex-test: 1.1.0
+
+  is-bigint@1.1.0:
+    dependencies:
+      has-bigints: 1.1.0
+
+  is-binary-path@2.1.0:
+    dependencies:
+      binary-extensions: 2.3.0
+
+  is-boolean-object@1.2.2:
+    dependencies:
+      call-bound: 1.0.4
+      has-tostringtag: 1.0.2
+
+  is-callable@1.2.7: {}
+
+  is-core-module@2.16.1:
+    dependencies:
+      hasown: 2.0.2
+
+  is-data-view@1.0.2:
+    dependencies:
+      call-bound: 1.0.4
+      get-intrinsic: 1.3.0
+      is-typed-array: 1.1.15
+
+  is-date-object@1.1.0:
+    dependencies:
+      call-bound: 1.0.4
+      has-tostringtag: 1.0.2
+
+  is-decimal@2.0.1: {}
+
+  is-docker@2.2.1: {}
+
+  is-extendable@0.1.1: {}
+
+  is-extglob@2.1.1: {}
+
+  is-finalizationregistry@1.1.1:
+    dependencies:
+      call-bound: 1.0.4
+
+  is-fullwidth-code-point@3.0.0: {}
+
+  is-fullwidth-code-point@4.0.0: {}
+
+  is-fullwidth-code-point@5.0.0:
+    dependencies:
+      get-east-asian-width: 1.3.0
+
+  is-generator-function@1.1.0:
+    dependencies:
+      call-bound: 1.0.4
+      get-proto: 1.0.1
+      has-tostringtag: 1.0.2
+      safe-regex-test: 1.1.0
+
+  is-glob@4.0.3:
+    dependencies:
+      is-extglob: 2.1.1
+
+  is-hexadecimal@2.0.1: {}
+
+  is-in-ci@1.0.0: {}
+
+  is-ip@3.1.0:
+    dependencies:
+      ip-regex: 4.3.0
+
+  is-map@2.0.3: {}
+
+  is-number-object@1.1.1:
+    dependencies:
+      call-bound: 1.0.4
+      has-tostringtag: 1.0.2
+
+  is-number@7.0.0: {}
+
+  is-online@10.0.0:
+    dependencies:
+      got: 12.6.1
+      p-any: 4.0.0
+      p-timeout: 5.1.0
+      public-ip: 5.0.0
+
+  is-plain-obj@4.1.0: {}
+
+  is-potential-custom-element-name@1.0.1: {}
+
+  is-promise@4.0.0: {}
+
+  is-regex@1.2.1:
+    dependencies:
+      call-bound: 1.0.4
+      gopd: 1.2.0
+      has-tostringtag: 1.0.2
+      hasown: 2.0.2
+
+  is-set@2.0.3: {}
+
+  is-shared-array-buffer@1.0.4:
+    dependencies:
+      call-bound: 1.0.4
+
+  is-stream@2.0.1: {}
+
+  is-stream@3.0.0: {}
+
+  is-string@1.1.1:
+    dependencies:
+      call-bound: 1.0.4
+      has-tostringtag: 1.0.2
+
+  is-subdir@1.2.0:
+    dependencies:
+      better-path-resolve: 1.0.0
+
+  is-symbol@1.1.1:
+    dependencies:
+      call-bound: 1.0.4
+      has-symbols: 1.1.0
+      safe-regex-test: 1.1.0
+
+  is-typed-array@1.1.15:
+    dependencies:
+      which-typed-array: 1.1.19
+
+  is-weakmap@2.0.2: {}
+
+  is-weakref@1.1.1:
+    dependencies:
+      call-bound: 1.0.4
+
+  is-weakset@2.0.4:
+    dependencies:
+      call-bound: 1.0.4
+      get-intrinsic: 1.3.0
+
+  is-windows@1.0.2: {}
+
+  is-wsl@2.2.0:
+    dependencies:
+      is-docker: 2.2.1
+
+  isarray@2.0.5: {}
+
+  isexe@2.0.0: {}
+
+  istanbul-lib-coverage@3.2.2: {}
+
+  istanbul-lib-report@3.0.1:
+    dependencies:
+      istanbul-lib-coverage: 3.2.2
+      make-dir: 4.0.0
+      supports-color: 7.2.0
+
+  istanbul-reports@3.2.0:
+    dependencies:
+      html-escaper: 2.0.2
+      istanbul-lib-report: 3.0.1
+
+  jackspeak@3.4.3:
+    dependencies:
+      '@isaacs/cliui': 8.0.2
+    optionalDependencies:
+      '@pkgjs/parseargs': 0.11.0
+
+  jackspeak@4.1.1:
+    dependencies:
+      '@isaacs/cliui': 8.0.2
+
+  jiti@1.21.7: {}
+
+  joycon@3.1.1: {}
+
+  js-tiktoken@1.0.20:
+    dependencies:
+      base64-js: 1.5.1
+
+  js-tokens@10.0.0: {}
+
+  js-tokens@4.0.0: {}
+
+  js-tokens@9.0.1: {}
+
+  js-yaml@3.14.1:
+    dependencies:
+      argparse: 1.0.10
+      esprima: 4.0.1
+
+  js-yaml@4.1.0:
+    dependencies:
+      argparse: 2.0.1
+
+  js-yaml@4.1.1:
+    dependencies:
+      argparse: 2.0.1
+
+  jsbn@1.1.0: {}
+
+  jsdom@24.1.3(bufferutil@4.0.9):
+    dependencies:
+      cssstyle: 4.6.0
+      data-urls: 5.0.0
+      decimal.js: 10.6.0
+      form-data: 4.0.2
+      html-encoding-sniffer: 4.0.0
+      http-proxy-agent: 7.0.2
+      https-proxy-agent: 7.0.6
+      is-potential-custom-element-name: 1.0.1
+      nwsapi: 2.2.23
+      parse5: 7.3.0
+      rrweb-cssom: 0.7.1
+      saxes: 6.0.0
+      symbol-tree: 3.2.4
+      tough-cookie: 4.1.4
+      w3c-xmlserializer: 5.0.0
+      webidl-conversions: 7.0.0
+      whatwg-encoding: 3.1.1
+      whatwg-mimetype: 4.0.0
+      whatwg-url: 14.2.0
+      ws: 8.18.3(bufferutil@4.0.9)
+      xml-name-validator: 5.0.0
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  jsep@1.4.0: {}
+
+  json-bigint@1.0.0:
+    dependencies:
+      bignumber.js: 9.3.0
+
+  json-buffer@3.0.1: {}
+
+  json-parse-even-better-errors@2.3.1: {}
+
+  json-schema-ref-resolver@3.0.0:
+    dependencies:
+      dequal: 2.0.3
+
+  json-schema-resolver@3.0.0:
+    dependencies:
+      debug: 4.4.3
+      fast-uri: 3.0.6
+      rfdc: 1.4.1
+    transitivePeerDependencies:
+      - supports-color
+
+  json-schema-traverse@0.4.1: {}
+
+  json-schema-traverse@1.0.0: {}
+
+  json-schema@0.4.0: {}
+
+  json-stable-stringify-without-jsonify@1.0.1: {}
+
+  jsonc-parser@2.2.1: {}
+
+  jsonfile@4.0.0:
+    optionalDependencies:
+      graceful-fs: 4.2.11
+
+  jsonfile@6.1.0:
+    dependencies:
+      universalify: 2.0.1
+    optionalDependencies:
+      graceful-fs: 4.2.11
+
+  jsonpath-plus@10.3.0:
+    dependencies:
+      '@jsep-plugin/assignment': 1.3.0(jsep@1.4.0)
+      '@jsep-plugin/regex': 1.0.4(jsep@1.4.0)
+      jsep: 1.4.0
+
+  jsonpointer@5.0.1: {}
+
+  junit-to-ctrf@0.0.14:
+    dependencies:
+      ctrf: 0.0.17
+      fs-extra: 11.3.0
+      glob: 11.1.0
+      typescript: 5.8.3
+      xml2js: 0.6.2
+      yargs: 18.0.0
+
+  jwa@2.0.1:
+    dependencies:
+      buffer-equal-constant-time: 1.0.1
+      ecdsa-sig-formatter: 1.0.11
+      safe-buffer: 5.2.1
+
+  jws@4.0.0:
+    dependencies:
+      jwa: 2.0.1
+      safe-buffer: 5.2.1
+
+  katex@0.16.22:
+    dependencies:
+      commander: 8.3.0
+
+  keyv@4.5.4:
+    dependencies:
+      json-buffer: 3.0.1
+
+  kind-of@6.0.3: {}
+
+  langsmith@0.3.23(openai@4.87.1(ws@8.18.3(bufferutil@4.0.9))(zod@4.2.1)):
+    dependencies:
+      '@types/uuid': 10.0.0
+      chalk: 4.1.2
+      console-table-printer: 2.12.1
+      p-queue: 6.6.2
+      p-retry: 4.6.2
+      semver: 7.7.3
+      uuid: 10.0.0
+    optionalDependencies:
+      openai: 4.87.1(ws@8.18.3(bufferutil@4.0.9))(zod@4.2.1)
+
+  lcm@0.0.3:
+    dependencies:
+      gcd: 0.0.1
+
+  leven@3.1.0: {}
+
+  leven@4.0.0: {}
+
+  levn@0.4.1:
+    dependencies:
+      prelude-ls: 1.2.1
+      type-check: 0.4.0
+
+  light-my-request@6.6.0:
+    dependencies:
+      cookie: 1.1.1
+      process-warning: 4.0.1
+      set-cookie-parser: 2.7.1
+
+  lighthouse-logger@2.0.2:
+    dependencies:
+      debug: 4.4.3
+      marky: 1.3.0
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
+  lilconfig@3.1.3: {}
+
+  lines-and-columns@1.2.4: {}
+
+  load-tsconfig@0.2.5: {}
+
+  local-pkg@0.5.1:
+    dependencies:
+      mlly: 1.8.1
+      pkg-types: 1.3.1
+
+  locate-path@5.0.0:
+    dependencies:
+      p-locate: 4.1.0
+
+  locate-path@6.0.0:
+    dependencies:
+      p-locate: 5.0.0
+
+  lodash.merge@4.6.2: {}
+
+  lodash.startcase@4.4.0: {}
+
+  lodash.topath@4.5.2: {}
+
+  lodash@4.17.21: {}
+
+  longest-streak@3.1.0: {}
+
+  loose-envify@1.4.0:
+    dependencies:
+      js-tokens: 4.0.0
+
+  loupe@2.3.7:
+    dependencies:
+      get-func-name: 2.0.2
+
+  lowercase-keys@3.0.0: {}
+
+  lru-cache@10.4.3: {}
+
+  lru-cache@11.2.4: {}
+
+  lru-cache@7.18.3: {}
+
+  magic-string@0.30.21:
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
+
+  magicast@0.5.2:
+    dependencies:
+      '@babel/parser': 7.29.0
+      '@babel/types': 7.29.0
+      source-map-js: 1.2.1
+
+  make-dir@4.0.0:
+    dependencies:
+      semver: 7.7.3
+
+  markdown-extensions@2.0.0: {}
+
+  markdown-table@3.0.4: {}
+
+  marky@1.3.0:
+    optional: true
+
+  math-intrinsics@1.1.0: {}
+
+  mdast-util-find-and-replace@3.0.2:
+    dependencies:
+      '@types/mdast': 4.0.4
+      escape-string-regexp: 5.0.0
+      unist-util-is: 6.0.0
+      unist-util-visit-parents: 6.0.1
+
+  mdast-util-from-markdown@2.0.2:
+    dependencies:
+      '@types/mdast': 4.0.4
+      '@types/unist': 3.0.3
+      decode-named-character-reference: 1.1.0
+      devlop: 1.1.0
+      mdast-util-to-string: 4.0.0
+      micromark: 4.0.2
+      micromark-util-decode-numeric-character-reference: 2.0.2
+      micromark-util-decode-string: 2.0.1
+      micromark-util-normalize-identifier: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+      unist-util-stringify-position: 4.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-frontmatter@2.0.1:
+    dependencies:
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      escape-string-regexp: 5.0.0
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+      micromark-extension-frontmatter: 2.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-autolink-literal@2.0.1:
+    dependencies:
+      '@types/mdast': 4.0.4
+      ccount: 2.0.1
+      devlop: 1.1.0
+      mdast-util-find-and-replace: 3.0.2
+      micromark-util-character: 2.1.1
+
+  mdast-util-gfm-footnote@2.1.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+      micromark-util-normalize-identifier: 2.0.1
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-strikethrough@2.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-table@2.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      markdown-table: 3.0.4
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-task-list-item@2.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm@3.1.0:
+    dependencies:
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-gfm-autolink-literal: 2.0.1
+      mdast-util-gfm-footnote: 2.1.0
+      mdast-util-gfm-strikethrough: 2.0.0
+      mdast-util-gfm-table: 2.0.0
+      mdast-util-gfm-task-list-item: 2.0.0
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-math@3.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      longest-streak: 3.1.0
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+      unist-util-remove-position: 5.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdx-expression@2.0.1:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdx-jsx@3.2.0:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      '@types/unist': 3.0.3
+      ccount: 2.0.1
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+      parse-entities: 4.0.2
+      stringify-entities: 4.0.4
+      unist-util-stringify-position: 4.0.0
+      vfile-message: 4.0.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdx@3.0.0:
+    dependencies:
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-mdx-expression: 2.0.1
+      mdast-util-mdx-jsx: 3.2.0
+      mdast-util-mdxjs-esm: 2.0.1
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdxjs-esm@2.0.1:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.2
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-phrasing@4.1.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      unist-util-is: 6.0.0
+
+  mdast-util-to-hast@13.2.0:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      '@ungap/structured-clone': 1.3.0
+      devlop: 1.1.0
+      micromark-util-sanitize-uri: 2.0.1
+      trim-lines: 3.0.1
+      unist-util-position: 5.0.0
+      unist-util-visit: 5.0.0
+      vfile: 6.0.3
+
+  mdast-util-to-markdown@2.1.2:
+    dependencies:
+      '@types/mdast': 4.0.4
+      '@types/unist': 3.0.3
+      longest-streak: 3.1.0
+      mdast-util-phrasing: 4.1.0
+      mdast-util-to-string: 4.0.0
+      micromark-util-classify-character: 2.0.1
+      micromark-util-decode-string: 2.0.1
+      unist-util-visit: 5.0.0
+      zwitch: 2.0.4
+
+  mdast-util-to-string@4.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+
+  mdast@3.0.0: {}
+
+  media-typer@0.3.0: {}
+
+  media-typer@1.1.0: {}
+
+  merge-descriptors@1.0.3: {}
+
+  merge-descriptors@2.0.0: {}
+
+  merge-stream@2.0.0: {}
+
+  merge2@1.4.1: {}
+
+  methods@1.1.2: {}
+
+  micromark-core-commonmark@2.0.3:
+    dependencies:
+      decode-named-character-reference: 1.1.0
+      devlop: 1.1.0
+      micromark-factory-destination: 2.0.1
+      micromark-factory-label: 2.0.1
+      micromark-factory-space: 2.0.1
+      micromark-factory-title: 2.0.1
+      micromark-factory-whitespace: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-chunked: 2.0.1
+      micromark-util-classify-character: 2.0.1
+      micromark-util-html-tag-name: 2.0.1
+      micromark-util-normalize-identifier: 2.0.1
+      micromark-util-resolve-all: 2.0.1
+      micromark-util-subtokenize: 2.1.0
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-frontmatter@2.0.0:
+    dependencies:
+      fault: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-autolink-literal@2.1.0:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-sanitize-uri: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-footnote@2.1.0:
+    dependencies:
+      devlop: 1.1.0
+      micromark-core-commonmark: 2.0.3
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-normalize-identifier: 2.0.1
+      micromark-util-sanitize-uri: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-strikethrough@2.1.0:
+    dependencies:
+      devlop: 1.1.0
+      micromark-util-chunked: 2.0.1
+      micromark-util-classify-character: 2.0.1
+      micromark-util-resolve-all: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-table@2.1.1:
+    dependencies:
+      devlop: 1.1.0
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-tagfilter@2.0.0:
+    dependencies:
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-task-list-item@2.1.0:
+    dependencies:
+      devlop: 1.1.0
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm@3.0.0:
+    dependencies:
+      micromark-extension-gfm-autolink-literal: 2.1.0
+      micromark-extension-gfm-footnote: 2.1.0
+      micromark-extension-gfm-strikethrough: 2.1.0
+      micromark-extension-gfm-table: 2.1.1
+      micromark-extension-gfm-tagfilter: 2.0.0
+      micromark-extension-gfm-task-list-item: 2.1.0
+      micromark-util-combine-extensions: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-math@3.1.0:
+    dependencies:
+      '@types/katex': 0.16.7
+      devlop: 1.1.0
+      katex: 0.16.22
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-mdx-expression@3.0.1:
+    dependencies:
+      '@types/estree': 1.0.8
+      devlop: 1.1.0
+      micromark-factory-mdx-expression: 2.0.3
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-events-to-acorn: 2.0.3
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-mdx-jsx@3.0.2:
+    dependencies:
+      '@types/estree': 1.0.8
+      devlop: 1.1.0
+      estree-util-is-identifier-name: 3.0.0
+      micromark-factory-mdx-expression: 2.0.3
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-events-to-acorn: 2.0.3
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+      vfile-message: 4.0.2
+
+  micromark-extension-mdx-md@2.0.0:
+    dependencies:
+      micromark-util-types: 2.0.2
+
+  micromark-extension-mdxjs-esm@3.0.0:
+    dependencies:
+      '@types/estree': 1.0.8
+      devlop: 1.1.0
+      micromark-core-commonmark: 2.0.3
+      micromark-util-character: 2.1.1
+      micromark-util-events-to-acorn: 2.0.3
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+      unist-util-position-from-estree: 2.0.0
+      vfile-message: 4.0.2
+
+  micromark-extension-mdxjs@3.0.0:
+    dependencies:
+      acorn: 8.15.0
+      acorn-jsx: 5.3.2(acorn@8.15.0)
+      micromark-extension-mdx-expression: 3.0.1
+      micromark-extension-mdx-jsx: 3.0.2
+      micromark-extension-mdx-md: 2.0.0
+      micromark-extension-mdxjs-esm: 3.0.0
+      micromark-util-combine-extensions: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-factory-destination@2.0.1:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-factory-label@2.0.1:
+    dependencies:
+      devlop: 1.1.0
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-factory-mdx-expression@2.0.3:
+    dependencies:
+      '@types/estree': 1.0.8
+      devlop: 1.1.0
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-events-to-acorn: 2.0.3
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+      unist-util-position-from-estree: 2.0.0
+      vfile-message: 4.0.2
+
+  micromark-factory-space@2.0.1:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-types: 2.0.2
+
+  micromark-factory-title@2.0.1:
+    dependencies:
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-factory-whitespace@2.0.1:
+    dependencies:
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-util-character@2.1.1:
+    dependencies:
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-util-chunked@2.0.1:
+    dependencies:
+      micromark-util-symbol: 2.0.1
+
+  micromark-util-classify-character@2.0.1:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-util-combine-extensions@2.0.1:
+    dependencies:
+      micromark-util-chunked: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-util-decode-numeric-character-reference@2.0.2:
+    dependencies:
+      micromark-util-symbol: 2.0.1
+
+  micromark-util-decode-string@2.0.1:
+    dependencies:
+      decode-named-character-reference: 1.1.0
+      micromark-util-character: 2.1.1
+      micromark-util-decode-numeric-character-reference: 2.0.2
+      micromark-util-symbol: 2.0.1
+
+  micromark-util-encode@2.0.1: {}
+
+  micromark-util-events-to-acorn@2.0.3:
+    dependencies:
+      '@types/estree': 1.0.8
+      '@types/unist': 3.0.3
+      devlop: 1.1.0
+      estree-util-visit: 2.0.0
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+      vfile-message: 4.0.2
+
+  micromark-util-html-tag-name@2.0.1: {}
+
+  micromark-util-normalize-identifier@2.0.1:
+    dependencies:
+      micromark-util-symbol: 2.0.1
+
+  micromark-util-resolve-all@2.0.1:
+    dependencies:
+      micromark-util-types: 2.0.2
+
+  micromark-util-sanitize-uri@2.0.1:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-encode: 2.0.1
+      micromark-util-symbol: 2.0.1
+
+  micromark-util-subtokenize@2.1.0:
+    dependencies:
+      devlop: 1.1.0
+      micromark-util-chunked: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-util-symbol@2.0.1: {}
+
+  micromark-util-types@2.0.2: {}
+
+  micromark@4.0.2:
+    dependencies:
+      '@types/debug': 4.1.12
+      debug: 4.4.3
+      decode-named-character-reference: 1.1.0
+      devlop: 1.1.0
+      micromark-core-commonmark: 2.0.3
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-chunked: 2.0.1
+      micromark-util-combine-extensions: 2.0.1
+      micromark-util-decode-numeric-character-reference: 2.0.2
+      micromark-util-encode: 2.0.1
+      micromark-util-normalize-identifier: 2.0.1
+      micromark-util-resolve-all: 2.0.1
+      micromark-util-sanitize-uri: 2.0.1
+      micromark-util-subtokenize: 2.1.0
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+    transitivePeerDependencies:
+      - supports-color
+
+  micromatch@4.0.8:
+    dependencies:
+      braces: 3.0.3
+      picomatch: 2.3.1
+
+  mime-db@1.52.0: {}
+
+  mime-db@1.54.0: {}
+
+  mime-types@2.1.35:
+    dependencies:
+      mime-db: 1.52.0
+
+  mime-types@3.0.1:
+    dependencies:
+      mime-db: 1.54.0
+
+  mime@1.6.0: {}
+
+  mime@3.0.0: {}
+
+  mimic-fn@2.1.0: {}
+
+  mimic-fn@4.0.0: {}
+
+  mimic-response@3.1.0: {}
+
+  mimic-response@4.0.0: {}
+
+  minimatch@10.1.1:
+    dependencies:
+      '@isaacs/brace-expansion': 5.0.0
+
+  minimatch@10.2.2:
+    dependencies:
+      brace-expansion: 5.0.3
+
+  minimatch@3.1.2:
+    dependencies:
+      brace-expansion: 1.1.11
+
+  minimatch@3.1.5:
+    dependencies:
+      brace-expansion: 1.1.11
+
+  minimatch@9.0.5:
+    dependencies:
+      brace-expansion: 2.0.1
+
+  minimist@1.2.8: {}
+
+  minipass@3.3.6:
+    dependencies:
+      yallist: 4.0.0
+
+  minipass@5.0.0: {}
+
+  minipass@7.1.2: {}
+
+  minizlib@2.1.2:
+    dependencies:
+      minipass: 3.3.6
+      yallist: 4.0.0
+
+  mintlify@4.2.78(@types/node@22.13.1)(@types/react@19.1.3)(bufferutil@4.0.9)(react-dom@18.3.1(react@18.3.1))(typescript@5.9.3):
+    dependencies:
+      '@mintlify/cli': 4.0.682(@types/node@22.13.1)(@types/react@19.1.3)(bufferutil@4.0.9)(react-dom@18.3.1(react@18.3.1))(typescript@5.9.3)
+    transitivePeerDependencies:
+      - '@types/node'
+      - '@types/react'
+      - bare-buffer
+      - bufferutil
+      - debug
+      - encoding
+      - react-devtools-core
+      - react-dom
+      - supports-color
+      - ts-node
+      - typescript
+      - utf-8-validate
+
+  mitt@3.0.1: {}
+
+  mkdirp@1.0.4: {}
+
+  mlly@1.8.1:
+    dependencies:
+      acorn: 8.16.0
+      pathe: 2.0.3
+      pkg-types: 1.3.1
+      ufo: 1.6.3
+
+  mri@1.2.0: {}
+
+  ms@2.0.0: {}
+
+  ms@2.1.3: {}
+
+  mustache@4.2.0: {}
+
+  mute-stream@2.0.0: {}
+
+  mylas@2.1.14: {}
+
+  mz@2.7.0:
+    dependencies:
+      any-promise: 1.3.0
+      object-assign: 4.1.1
+      thenify-all: 1.6.0
+
+  nanoid@3.3.11: {}
+
+  natural-compare@1.4.0: {}
+
+  negotiator@0.6.3: {}
+
+  negotiator@1.0.0: {}
+
+  neotraverse@0.6.18: {}
+
+  netmask@2.0.2: {}
+
+  next-mdx-remote-client@1.1.1(@types/react@19.1.3)(acorn@8.15.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1):
+    dependencies:
+      '@babel/code-frame': 7.27.1
+      '@mdx-js/mdx': 3.1.0(acorn@8.15.0)
+      '@mdx-js/react': 3.1.0(@types/react@19.1.3)(react@18.3.1)
+      react: 18.3.1
+      react-dom: 18.3.1(react@18.3.1)
+      remark-mdx-remove-esm: 1.1.0
+      serialize-error: 12.0.0
+      vfile: 6.0.3
+      vfile-matter: 5.0.1
+    transitivePeerDependencies:
+      - '@types/react'
+      - acorn
+      - supports-color
+
+  nimma@0.2.3:
+    dependencies:
+      '@jsep-plugin/regex': 1.0.4(jsep@1.4.0)
+      '@jsep-plugin/ternary': 1.1.4(jsep@1.4.0)
+      astring: 1.9.0
+      jsep: 1.4.0
+    optionalDependencies:
+      jsonpath-plus: 10.3.0
+      lodash.topath: 4.5.2
+
+  nlcst-to-string@4.0.0:
+    dependencies:
+      '@types/nlcst': 2.0.3
+
+  node-domexception@1.0.0: {}
+
+  node-fetch@2.6.7:
+    dependencies:
+      whatwg-url: 5.0.0
+
+  node-fetch@2.7.0:
+    dependencies:
+      whatwg-url: 5.0.0
+
+  node-fetch@3.3.2:
+    dependencies:
+      data-uri-to-buffer: 4.0.1
+      fetch-blob: 3.2.0
+      formdata-polyfill: 4.0.10
+    optional: true
+
+  node-gyp-build@4.8.4:
+    optional: true
+
+  normalize-path@3.0.0: {}
+
+  normalize-url@8.0.1: {}
+
+  npm-run-path@5.3.0:
+    dependencies:
+      path-key: 4.0.0
+
+  nwsapi@2.2.23: {}
+
+  object-assign@4.1.1: {}
+
+  object-hash@3.0.0: {}
+
+  object-inspect@1.13.4: {}
+
+  object-keys@1.1.1: {}
+
+  object.assign@4.1.7:
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      define-properties: 1.2.1
+      es-object-atoms: 1.1.1
+      has-symbols: 1.1.0
+      object-keys: 1.1.1
+
+  obug@2.1.1: {}
+
+  ollama-ai-provider-v2@1.5.0(zod@4.2.1):
+    dependencies:
+      '@ai-sdk/provider': 2.0.1
+      '@ai-sdk/provider-utils': 3.0.21(zod@4.2.1)
+      zod: 4.2.1
+    optional: true
+
+  on-exit-leak-free@2.1.2: {}
+
+  on-finished@2.4.1:
+    dependencies:
+      ee-first: 1.1.1
+
+  once@1.4.0:
+    dependencies:
+      wrappy: 1.0.2
+
+  onetime@5.1.2:
+    dependencies:
+      mimic-fn: 2.1.0
+
+  onetime@6.0.0:
+    dependencies:
+      mimic-fn: 4.0.0
+
+  oniguruma-parser@0.12.1: {}
+
+  oniguruma-to-es@4.3.3:
+    dependencies:
+      oniguruma-parser: 0.12.1
+      regex: 6.0.1
+      regex-recursion: 6.0.2
+
+  open@8.4.2:
+    dependencies:
+      define-lazy-prop: 2.0.0
+      is-docker: 2.2.1
+      is-wsl: 2.2.0
+
+  openai@4.87.1(ws@8.18.3(bufferutil@4.0.9))(zod@4.2.1):
+    dependencies:
+      '@types/node': 18.19.87
+      '@types/node-fetch': 2.6.12
+      abort-controller: 3.0.0
+      agentkeepalive: 4.6.0
+      form-data-encoder: 1.7.2
+      formdata-node: 4.4.1
+      node-fetch: 2.7.0
+    optionalDependencies:
+      ws: 8.18.3(bufferutil@4.0.9)
+      zod: 4.2.1
+    transitivePeerDependencies:
+      - encoding
+
+  openai@4.96.2(ws@8.18.3(bufferutil@4.0.9))(zod@3.25.76):
+    dependencies:
+      '@types/node': 18.19.87
+      '@types/node-fetch': 2.6.12
+      abort-controller: 3.0.0
+      agentkeepalive: 4.6.0
+      form-data-encoder: 1.7.2
+      formdata-node: 4.4.1
+      node-fetch: 2.7.0
+    optionalDependencies:
+      ws: 8.18.3(bufferutil@4.0.9)
+      zod: 3.25.76
+    transitivePeerDependencies:
+      - encoding
+
+  openapi-types@12.1.3: {}
+
+  optionator@0.9.4:
+    dependencies:
+      deep-is: 0.1.4
+      fast-levenshtein: 2.0.6
+      levn: 0.4.1
+      prelude-ls: 1.2.1
+      type-check: 0.4.0
+      word-wrap: 1.2.5
+
+  os-tmpdir@1.0.2: {}
+
+  outdent@0.5.0: {}
+
+  own-keys@1.0.1:
+    dependencies:
+      get-intrinsic: 1.3.0
+      object-keys: 1.1.1
+      safe-push-apply: 1.0.0
+
+  p-any@4.0.0:
+    dependencies:
+      p-cancelable: 3.0.0
+      p-some: 6.0.0
+
+  p-cancelable@3.0.0: {}
+
+  p-filter@2.1.0:
+    dependencies:
+      p-map: 2.1.0
+
+  p-finally@1.0.0: {}
+
+  p-limit@2.3.0:
+    dependencies:
+      p-try: 2.2.0
+
+  p-limit@3.1.0:
+    dependencies:
+      yocto-queue: 0.1.0
+
+  p-limit@5.0.0:
+    dependencies:
+      yocto-queue: 1.2.2
+
+  p-locate@4.1.0:
+    dependencies:
+      p-limit: 2.3.0
+
+  p-locate@5.0.0:
+    dependencies:
+      p-limit: 3.1.0
+
+  p-map@2.1.0: {}
+
+  p-queue@6.6.2:
+    dependencies:
+      eventemitter3: 4.0.7
+      p-timeout: 3.2.0
+
+  p-retry@4.6.2:
+    dependencies:
+      '@types/retry': 0.12.0
+      retry: 0.13.1
+
+  p-some@6.0.0:
+    dependencies:
+      aggregate-error: 4.0.1
+      p-cancelable: 3.0.0
+
+  p-timeout@3.2.0:
+    dependencies:
+      p-finally: 1.0.0
+
+  p-timeout@5.1.0: {}
+
+  p-try@2.2.0: {}
+
+  pac-proxy-agent@7.2.0:
+    dependencies:
+      '@tootallnate/quickjs-emscripten': 0.23.0
+      agent-base: 7.1.3
+      debug: 4.4.3
+      get-uri: 6.0.4
+      http-proxy-agent: 7.0.2
+      https-proxy-agent: 7.0.6
+      pac-resolver: 7.0.1
+      socks-proxy-agent: 8.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  pac-resolver@7.0.1:
+    dependencies:
+      degenerator: 5.0.1
+      netmask: 2.0.2
+
+  package-json-from-dist@1.0.1: {}
+
+  package-manager-detector@0.2.11:
+    dependencies:
+      quansync: 0.2.10
+
+  parent-module@1.0.1:
+    dependencies:
+      callsites: 3.1.0
+
+  parse-entities@4.0.2:
+    dependencies:
+      '@types/unist': 2.0.11
+      character-entities-legacy: 3.0.0
+      character-reference-invalid: 2.0.1
+      decode-named-character-reference: 1.1.0
+      is-alphanumerical: 2.0.1
+      is-decimal: 2.0.1
+      is-hexadecimal: 2.0.1
+
+  parse-json@5.2.0:
+    dependencies:
+      '@babel/code-frame': 7.27.1
+      error-ex: 1.3.2
+      json-parse-even-better-errors: 2.3.1
+      lines-and-columns: 1.2.4
+
+  parse-latin@7.0.0:
+    dependencies:
+      '@types/nlcst': 2.0.3
+      '@types/unist': 3.0.3
+      nlcst-to-string: 4.0.0
+      unist-util-modify-children: 4.0.0
+      unist-util-visit-children: 3.0.0
+      vfile: 6.0.3
+
+  parse5@7.3.0:
+    dependencies:
+      entities: 6.0.0
+
+  parseurl@1.3.3: {}
+
+  patch-console@2.0.0: {}
+
+  patchright-core@1.55.2:
+    optional: true
+
+  path-exists@4.0.0: {}
+
+  path-key@3.1.1: {}
+
+  path-key@4.0.0: {}
+
+  path-parse@1.0.7: {}
+
+  path-scurry@1.11.1:
+    dependencies:
+      lru-cache: 10.4.3
+      minipass: 7.1.2
+
+  path-scurry@2.0.1:
+    dependencies:
+      lru-cache: 11.2.4
+      minipass: 7.1.2
+
+  path-to-regexp@0.1.12: {}
+
+  path-to-regexp@8.2.0: {}
+
+  path-type@4.0.0: {}
+
+  pathe@1.1.2: {}
+
+  pathe@2.0.3: {}
+
+  pathval@1.1.1: {}
+
+  pend@1.2.0: {}
+
+  picocolors@1.1.1: {}
+
+  picomatch@2.3.1: {}
+
+  picomatch@4.0.3: {}
+
+  pify@2.3.0: {}
+
+  pify@4.0.1: {}
+
+  pino-abstract-transport@2.0.0:
+    dependencies:
+      split2: 4.2.0
+
+  pino-pretty@11.3.0:
+    dependencies:
+      colorette: 2.0.20
+      dateformat: 4.6.3
+      fast-copy: 3.0.2
+      fast-safe-stringify: 2.1.1
+      help-me: 5.0.0
+      joycon: 3.1.1
+      minimist: 1.2.8
+      on-exit-leak-free: 2.1.2
+      pino-abstract-transport: 2.0.0
+      pump: 3.0.2
+      readable-stream: 4.7.0
+      secure-json-parse: 2.7.0
+      sonic-boom: 4.2.0
+      strip-json-comments: 3.1.1
+
+  pino-pretty@13.0.0:
+    dependencies:
+      colorette: 2.0.20
+      dateformat: 4.6.3
+      fast-copy: 3.0.2
+      fast-safe-stringify: 2.1.1
+      help-me: 5.0.0
+      joycon: 3.1.1
+      minimist: 1.2.8
+      on-exit-leak-free: 2.1.2
+      pino-abstract-transport: 2.0.0
+      pump: 3.0.2
+      secure-json-parse: 2.7.0
+      sonic-boom: 4.2.0
+      strip-json-comments: 3.1.1
+
+  pino-std-serializers@7.0.0: {}
+
+  pino@10.1.0:
+    dependencies:
+      '@pinojs/redact': 0.4.0
+      atomic-sleep: 1.0.0
+      on-exit-leak-free: 2.1.2
+      pino-abstract-transport: 2.0.0
+      pino-std-serializers: 7.0.0
+      process-warning: 5.0.0
+      quick-format-unescaped: 4.0.4
+      real-require: 0.2.0
+      safe-stable-stringify: 2.5.0
+      sonic-boom: 4.2.0
+      thread-stream: 3.1.0
+
+  pino@9.14.0:
+    dependencies:
+      '@pinojs/redact': 0.4.0
+      atomic-sleep: 1.0.0
+      on-exit-leak-free: 2.1.2
+      pino-abstract-transport: 2.0.0
+      pino-std-serializers: 7.0.0
+      process-warning: 5.0.0
+      quick-format-unescaped: 4.0.4
+      real-require: 0.2.0
+      safe-stable-stringify: 2.5.0
+      sonic-boom: 4.2.0
+      thread-stream: 3.1.0
+
+  pirates@4.0.7: {}
+
+  pkce-challenge@5.0.0: {}
+
+  pkg-types@1.3.1:
+    dependencies:
+      confbox: 0.1.8
+      mlly: 1.8.1
+      pathe: 2.0.3
+
+  playwright-core@1.52.0: {}
+
+  playwright-core@1.54.2: {}
+
+  playwright@1.52.0:
+    dependencies:
+      playwright-core: 1.52.0
+    optionalDependencies:
+      fsevents: 2.3.2
+
+  playwright@1.54.2:
+    dependencies:
+      playwright-core: 1.54.2
+    optionalDependencies:
+      fsevents: 2.3.2
+
+  plimit-lit@1.6.1:
+    dependencies:
+      queue-lit: 1.5.2
+
+  pluralize@8.0.0: {}
+
+  pony-cause@1.1.1: {}
+
+  possible-typed-array-names@1.1.0: {}
+
+  postcss-import@15.1.0(postcss@8.5.6):
+    dependencies:
+      postcss: 8.5.6
+      postcss-value-parser: 4.2.0
+      read-cache: 1.0.0
+      resolve: 1.22.10
+
+  postcss-js@4.0.1(postcss@8.5.6):
+    dependencies:
+      camelcase-css: 2.0.1
+      postcss: 8.5.6
+
+  postcss-load-config@4.0.2(postcss@8.5.6):
+    dependencies:
+      lilconfig: 3.1.3
+      yaml: 2.7.1
+    optionalDependencies:
+      postcss: 8.5.6
+
+  postcss-load-config@6.0.1(jiti@1.21.7)(postcss@8.5.6)(tsx@4.19.4)(yaml@2.7.1):
+    dependencies:
+      lilconfig: 3.1.3
+    optionalDependencies:
+      jiti: 1.21.7
+      postcss: 8.5.6
+      tsx: 4.19.4
+      yaml: 2.7.1
+
+  postcss-nested@6.2.0(postcss@8.5.6):
+    dependencies:
+      postcss: 8.5.6
+      postcss-selector-parser: 6.1.2
+
+  postcss-selector-parser@6.1.2:
+    dependencies:
+      cssesc: 3.0.0
+      util-deprecate: 1.0.2
+
+  postcss-value-parser@4.2.0: {}
+
+  postcss@8.5.6:
+    dependencies:
+      nanoid: 3.3.11
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
+  postject@1.0.0-alpha.6:
+    dependencies:
+      commander: 9.5.0
+
+  prelude-ls@1.2.1: {}
+
+  prettier@2.8.8: {}
+
+  prettier@3.5.3: {}
+
+  pretty-format@29.7.0:
+    dependencies:
+      '@jest/schemas': 29.6.3
+      ansi-styles: 5.2.0
+      react-is: 18.3.1
+
+  process-warning@4.0.1: {}
+
+  process-warning@5.0.0: {}
+
+  process@0.11.10: {}
+
+  progress@2.0.3: {}
+
+  prom-client@15.1.3:
+    dependencies:
+      '@opentelemetry/api': 1.9.0
+      tdigest: 0.1.2
+
+  property-information@7.0.0: {}
+
+  proxy-addr@2.0.7:
+    dependencies:
+      forwarded: 0.2.0
+      ipaddr.js: 1.9.1
+
+  proxy-agent@6.5.0:
+    dependencies:
+      agent-base: 7.1.3
+      debug: 4.4.3
+      http-proxy-agent: 7.0.2
+      https-proxy-agent: 7.0.6
+      lru-cache: 7.18.3
+      pac-proxy-agent: 7.2.0
+      proxy-from-env: 1.1.0
+      socks-proxy-agent: 8.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  proxy-from-env@1.1.0: {}
+
+  psl@1.15.0:
+    dependencies:
+      punycode: 2.3.1
+
+  public-ip@5.0.0:
+    dependencies:
+      dns-socket: 4.2.2
+      got: 12.6.1
+      is-ip: 3.1.0
+
+  pump@3.0.2:
+    dependencies:
+      end-of-stream: 1.4.4
+      once: 1.4.0
+
+  punycode@2.3.1: {}
+
+  puppeteer-core@22.15.0(bufferutil@4.0.9):
+    dependencies:
+      '@puppeteer/browsers': 2.3.0
+      chromium-bidi: 0.6.3(devtools-protocol@0.0.1312386)
+      debug: 4.4.3
+      devtools-protocol: 0.0.1312386
+      ws: 8.18.3(bufferutil@4.0.9)
+    transitivePeerDependencies:
+      - bare-buffer
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  puppeteer@22.15.0(bufferutil@4.0.9)(typescript@5.9.3):
+    dependencies:
+      '@puppeteer/browsers': 2.3.0
+      cosmiconfig: 9.0.0(typescript@5.9.3)
+      devtools-protocol: 0.0.1312386
+      puppeteer-core: 22.15.0(bufferutil@4.0.9)
+    transitivePeerDependencies:
+      - bare-buffer
+      - bufferutil
+      - supports-color
+      - typescript
+      - utf-8-validate
+
+  qs@6.13.0:
+    dependencies:
+      side-channel: 1.1.0
+
+  qs@6.14.0:
+    dependencies:
+      side-channel: 1.1.0
+
+  quansync@0.2.10: {}
+
+  querystringify@2.2.0: {}
+
+  queue-lit@1.5.2: {}
+
+  queue-microtask@1.2.3: {}
+
+  quick-format-unescaped@4.0.4: {}
+
+  quick-lru@5.1.1: {}
+
+  range-parser@1.2.1: {}
+
+  raw-body@2.5.2:
+    dependencies:
+      bytes: 3.1.2
+      http-errors: 2.0.0
+      iconv-lite: 0.4.24
+      unpipe: 1.0.0
+
+  raw-body@3.0.0:
+    dependencies:
+      bytes: 3.1.2
+      http-errors: 2.0.0
+      iconv-lite: 0.6.3
+      unpipe: 1.0.0
+
+  react-dom@18.3.1(react@18.3.1):
+    dependencies:
+      loose-envify: 1.4.0
+      react: 18.3.1
+      scheduler: 0.23.2
+
+  react-is@18.3.1: {}
+
+  react-reconciler@0.29.2(react@18.3.1):
+    dependencies:
+      loose-envify: 1.4.0
+      react: 18.3.1
+      scheduler: 0.23.2
+
+  react@18.3.1:
+    dependencies:
+      loose-envify: 1.4.0
+
+  read-cache@1.0.0:
+    dependencies:
+      pify: 2.3.0
+
+  read-yaml-file@1.1.0:
+    dependencies:
+      graceful-fs: 4.2.11
+      js-yaml: 3.14.1
+      pify: 4.0.1
+      strip-bom: 3.0.0
+
+  readable-stream@4.7.0:
+    dependencies:
+      abort-controller: 3.0.0
+      buffer: 6.0.3
+      events: 3.3.0
+      process: 0.11.10
+      string_decoder: 1.3.0
+
+  readdirp@3.6.0:
+    dependencies:
+      picomatch: 2.3.1
+
+  readdirp@4.1.2: {}
+
+  real-require@0.2.0: {}
+
+  recma-build-jsx@1.0.0:
+    dependencies:
+      '@types/estree': 1.0.8
+      estree-util-build-jsx: 3.0.1
+      vfile: 6.0.3
+
+  recma-jsx@1.0.0(acorn@8.15.0):
+    dependencies:
+      acorn-jsx: 5.3.2(acorn@8.15.0)
+      estree-util-to-js: 2.0.0
+      recma-parse: 1.0.0
+      recma-stringify: 1.0.0
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - acorn
+
+  recma-parse@1.0.0:
+    dependencies:
+      '@types/estree': 1.0.8
+      esast-util-from-js: 2.0.1
+      unified: 11.0.5
+      vfile: 6.0.3
+
+  recma-stringify@1.0.0:
+    dependencies:
+      '@types/estree': 1.0.8
+      estree-util-to-js: 2.0.0
+      unified: 11.0.5
+      vfile: 6.0.3
+
+  reflect.getprototypeof@1.0.10:
+    dependencies:
+      call-bind: 1.0.8
+      define-properties: 1.2.1
+      es-abstract: 1.23.9
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.1
+      get-intrinsic: 1.3.0
+      get-proto: 1.0.1
+      which-builtin-type: 1.2.1
+
+  regex-recursion@6.0.2:
+    dependencies:
+      regex-utilities: 2.3.0
+
+  regex-utilities@2.3.0: {}
+
+  regex@6.0.1:
+    dependencies:
+      regex-utilities: 2.3.0
+
+  regexp-tree@0.1.27: {}
+
+  regexp.prototype.flags@1.5.4:
+    dependencies:
+      call-bind: 1.0.8
+      define-properties: 1.2.1
+      es-errors: 1.3.0
+      get-proto: 1.0.1
+      gopd: 1.2.0
+      set-function-name: 2.0.2
+
+  rehype-katex@7.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/katex': 0.16.7
+      hast-util-from-html-isomorphic: 2.0.0
+      hast-util-to-text: 4.0.2
+      katex: 0.16.22
+      unist-util-visit-parents: 6.0.1
+      vfile: 6.0.3
+
+  rehype-minify-whitespace@6.0.2:
+    dependencies:
+      '@types/hast': 3.0.4
+      hast-util-minify-whitespace: 1.0.1
+
+  rehype-parse@9.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      hast-util-from-html: 2.0.3
+      unified: 11.0.5
+
+  rehype-recma@1.0.0:
+    dependencies:
+      '@types/estree': 1.0.8
+      '@types/hast': 3.0.4
+      hast-util-to-estree: 3.1.3
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-frontmatter@5.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-frontmatter: 2.0.1
+      micromark-extension-frontmatter: 2.0.0
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-gfm@4.0.1:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-gfm: 3.1.0
+      micromark-extension-gfm: 3.0.0
+      remark-parse: 11.0.0
+      remark-stringify: 11.0.0
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-math@6.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-math: 3.0.0
+      micromark-extension-math: 3.1.0
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-mdx-remove-esm@1.1.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-mdxjs-esm: 2.0.1
+      unist-util-remove: 4.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-mdx@3.1.0:
+    dependencies:
+      mdast-util-mdx: 3.0.0
+      micromark-extension-mdxjs: 3.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-parse@11.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-from-markdown: 2.0.2
+      micromark-util-types: 2.0.2
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-rehype@11.1.2:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      mdast-util-to-hast: 13.2.0
+      unified: 11.0.5
+      vfile: 6.0.3
+
+  remark-smartypants@3.0.2:
+    dependencies:
+      retext: 9.0.0
+      retext-smartypants: 6.2.0
+      unified: 11.0.5
+      unist-util-visit: 5.0.0
+
+  remark-stringify@11.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-to-markdown: 2.1.2
+      unified: 11.0.5
+
+  remark@15.0.1:
+    dependencies:
+      '@types/mdast': 4.0.4
+      remark-parse: 11.0.0
+      remark-stringify: 11.0.0
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  require-directory@2.1.1: {}
+
+  require-from-string@2.0.2: {}
+
+  requires-port@1.0.0: {}
+
+  resolve-alpn@1.2.1: {}
+
+  resolve-from@4.0.0: {}
+
+  resolve-from@5.0.0: {}
+
+  resolve-pkg-maps@1.0.0: {}
+
+  resolve@1.22.10:
+    dependencies:
+      is-core-module: 2.16.1
+      path-parse: 1.0.7
+      supports-preserve-symlinks-flag: 1.0.0
+
+  responselike@3.0.0:
+    dependencies:
+      lowercase-keys: 3.0.0
+
+  restore-cursor@4.0.0:
+    dependencies:
+      onetime: 5.1.2
+      signal-exit: 3.0.7
+
+  ret@0.5.0: {}
+
+  retext-latin@4.0.0:
+    dependencies:
+      '@types/nlcst': 2.0.3
+      parse-latin: 7.0.0
+      unified: 11.0.5
+
+  retext-smartypants@6.2.0:
+    dependencies:
+      '@types/nlcst': 2.0.3
+      nlcst-to-string: 4.0.0
+      unist-util-visit: 5.0.0
+
+  retext-stringify@4.0.0:
+    dependencies:
+      '@types/nlcst': 2.0.3
+      nlcst-to-string: 4.0.0
+      unified: 11.0.5
+
+  retext@9.0.0:
+    dependencies:
+      '@types/nlcst': 2.0.3
+      retext-latin: 4.0.0
+      retext-stringify: 4.0.0
+      unified: 11.0.5
+
+  retry@0.13.1: {}
+
+  reusify@1.1.0: {}
+
+  rfdc@1.4.1: {}
+
+  rimraf@5.0.10:
+    dependencies:
+      glob: 10.4.5
+    optional: true
+
+  rollup@4.53.2:
+    dependencies:
+      '@types/estree': 1.0.8
+    optionalDependencies:
+      '@rollup/rollup-android-arm-eabi': 4.53.2
+      '@rollup/rollup-android-arm64': 4.53.2
+      '@rollup/rollup-darwin-arm64': 4.53.2
+      '@rollup/rollup-darwin-x64': 4.53.2
+      '@rollup/rollup-freebsd-arm64': 4.53.2
+      '@rollup/rollup-freebsd-x64': 4.53.2
+      '@rollup/rollup-linux-arm-gnueabihf': 4.53.2
+      '@rollup/rollup-linux-arm-musleabihf': 4.53.2
+      '@rollup/rollup-linux-arm64-gnu': 4.53.2
+      '@rollup/rollup-linux-arm64-musl': 4.53.2
+      '@rollup/rollup-linux-loong64-gnu': 4.53.2
+      '@rollup/rollup-linux-ppc64-gnu': 4.53.2
+      '@rollup/rollup-linux-riscv64-gnu': 4.53.2
+      '@rollup/rollup-linux-riscv64-musl': 4.53.2
+      '@rollup/rollup-linux-s390x-gnu': 4.53.2
+      '@rollup/rollup-linux-x64-gnu': 4.53.2
+      '@rollup/rollup-linux-x64-musl': 4.53.2
+      '@rollup/rollup-openharmony-arm64': 4.53.2
+      '@rollup/rollup-win32-arm64-msvc': 4.53.2
+      '@rollup/rollup-win32-ia32-msvc': 4.53.2
+      '@rollup/rollup-win32-x64-gnu': 4.53.2
+      '@rollup/rollup-win32-x64-msvc': 4.53.2
+      fsevents: 2.3.3
+
+  router@2.2.0:
+    dependencies:
+      debug: 4.4.3
+      depd: 2.0.0
+      is-promise: 4.0.0
+      parseurl: 1.3.3
+      path-to-regexp: 8.2.0
+    transitivePeerDependencies:
+      - supports-color
+
+  rrweb-cssom@0.7.1: {}
+
+  rrweb-cssom@0.8.0: {}
+
+  run-async@3.0.0: {}
+
+  run-parallel@1.2.0:
+    dependencies:
+      queue-microtask: 1.2.3
+
+  rxjs@7.8.2:
+    dependencies:
+      tslib: 2.8.1
+
+  safe-array-concat@1.1.3:
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      get-intrinsic: 1.3.0
+      has-symbols: 1.1.0
+      isarray: 2.0.5
+
+  safe-buffer@5.2.1: {}
+
+  safe-push-apply@1.0.0:
+    dependencies:
+      es-errors: 1.3.0
+      isarray: 2.0.5
+
+  safe-regex-test@1.1.0:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-regex: 1.2.1
+
+  safe-regex2@5.0.0:
+    dependencies:
+      ret: 0.5.0
+
+  safe-regex@2.1.1:
+    dependencies:
+      regexp-tree: 0.1.27
+
+  safe-stable-stringify@1.1.1: {}
+
+  safe-stable-stringify@2.5.0: {}
+
+  safer-buffer@2.1.2: {}
+
+  sax@1.4.1: {}
+
+  saxes@6.0.0:
+    dependencies:
+      xmlchars: 2.2.0
+
+  scheduler@0.23.2:
+    dependencies:
+      loose-envify: 1.4.0
+
+  section-matter@1.0.0:
+    dependencies:
+      extend-shallow: 2.0.1
+      kind-of: 6.0.3
+
+  secure-json-parse@2.7.0: {}
+
+  secure-json-parse@4.1.0: {}
+
+  semver@7.7.3: {}
+
+  send@0.19.0:
+    dependencies:
+      debug: 2.6.9
+      depd: 2.0.0
+      destroy: 1.2.0
+      encodeurl: 1.0.2
+      escape-html: 1.0.3
+      etag: 1.8.1
+      fresh: 0.5.2
+      http-errors: 2.0.0
+      mime: 1.6.0
+      ms: 2.1.3
+      on-finished: 2.4.1
+      range-parser: 1.2.1
+      statuses: 2.0.1
+    transitivePeerDependencies:
+      - supports-color
+
+  send@1.2.0:
+    dependencies:
+      debug: 4.4.3
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      etag: 1.8.1
+      fresh: 2.0.0
+      http-errors: 2.0.0
+      mime-types: 3.0.1
+      ms: 2.1.3
+      on-finished: 2.4.1
+      range-parser: 1.2.1
+      statuses: 2.0.1
+    transitivePeerDependencies:
+      - supports-color
+
+  serialize-error@12.0.0:
+    dependencies:
+      type-fest: 4.41.0
+
+  serve-static@1.16.2:
+    dependencies:
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      parseurl: 1.3.3
+      send: 0.19.0
+    transitivePeerDependencies:
+      - supports-color
+
+  serve-static@2.2.0:
+    dependencies:
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      parseurl: 1.3.3
+      send: 1.2.0
+    transitivePeerDependencies:
+      - supports-color
+
+  set-cookie-parser@2.7.1: {}
+
+  set-function-length@1.2.2:
+    dependencies:
+      define-data-property: 1.1.4
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+      get-intrinsic: 1.3.0
+      gopd: 1.2.0
+      has-property-descriptors: 1.0.2
+
+  set-function-name@2.0.2:
+    dependencies:
+      define-data-property: 1.1.4
+      es-errors: 1.3.0
+      functions-have-names: 1.2.3
+      has-property-descriptors: 1.0.2
+
+  set-proto@1.0.0:
+    dependencies:
+      dunder-proto: 1.0.1
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.1
+
+  setprototypeof@1.2.0: {}
+
+  sharp@0.33.5:
+    dependencies:
+      color: 4.2.3
+      detect-libc: 2.1.2
+      semver: 7.7.3
+    optionalDependencies:
+      '@img/sharp-darwin-arm64': 0.33.5
+      '@img/sharp-darwin-x64': 0.33.5
+      '@img/sharp-libvips-darwin-arm64': 1.0.4
+      '@img/sharp-libvips-darwin-x64': 1.0.4
+      '@img/sharp-libvips-linux-arm': 1.0.5
+      '@img/sharp-libvips-linux-arm64': 1.0.4
+      '@img/sharp-libvips-linux-s390x': 1.0.4
+      '@img/sharp-libvips-linux-x64': 1.0.4
+      '@img/sharp-libvips-linuxmusl-arm64': 1.0.4
+      '@img/sharp-libvips-linuxmusl-x64': 1.0.4
+      '@img/sharp-linux-arm': 0.33.5
+      '@img/sharp-linux-arm64': 0.33.5
+      '@img/sharp-linux-s390x': 0.33.5
+      '@img/sharp-linux-x64': 0.33.5
+      '@img/sharp-linuxmusl-arm64': 0.33.5
+      '@img/sharp-linuxmusl-x64': 0.33.5
+      '@img/sharp-wasm32': 0.33.5
+      '@img/sharp-win32-ia32': 0.33.5
+      '@img/sharp-win32-x64': 0.33.5
+
+  sharp@0.34.5:
+    dependencies:
+      '@img/colour': 1.0.0
+      detect-libc: 2.1.2
+      semver: 7.7.3
+    optionalDependencies:
+      '@img/sharp-darwin-arm64': 0.34.5
+      '@img/sharp-darwin-x64': 0.34.5
+      '@img/sharp-libvips-darwin-arm64': 1.2.4
+      '@img/sharp-libvips-darwin-x64': 1.2.4
+      '@img/sharp-libvips-linux-arm': 1.2.4
+      '@img/sharp-libvips-linux-arm64': 1.2.4
+      '@img/sharp-libvips-linux-ppc64': 1.2.4
+      '@img/sharp-libvips-linux-riscv64': 1.2.4
+      '@img/sharp-libvips-linux-s390x': 1.2.4
+      '@img/sharp-libvips-linux-x64': 1.2.4
+      '@img/sharp-libvips-linuxmusl-arm64': 1.2.4
+      '@img/sharp-libvips-linuxmusl-x64': 1.2.4
+      '@img/sharp-linux-arm': 0.34.5
+      '@img/sharp-linux-arm64': 0.34.5
+      '@img/sharp-linux-ppc64': 0.34.5
+      '@img/sharp-linux-riscv64': 0.34.5
+      '@img/sharp-linux-s390x': 0.34.5
+      '@img/sharp-linux-x64': 0.34.5
+      '@img/sharp-linuxmusl-arm64': 0.34.5
+      '@img/sharp-linuxmusl-x64': 0.34.5
+      '@img/sharp-wasm32': 0.34.5
+      '@img/sharp-win32-arm64': 0.34.5
+      '@img/sharp-win32-ia32': 0.34.5
+      '@img/sharp-win32-x64': 0.34.5
+
+  shebang-command@2.0.0:
+    dependencies:
+      shebang-regex: 3.0.0
+
+  shebang-regex@3.0.0: {}
+
+  shiki@3.11.0:
+    dependencies:
+      '@shikijs/core': 3.11.0
+      '@shikijs/engine-javascript': 3.11.0
+      '@shikijs/engine-oniguruma': 3.11.0
+      '@shikijs/langs': 3.11.0
+      '@shikijs/themes': 3.11.0
+      '@shikijs/types': 3.11.0
+      '@shikijs/vscode-textmate': 10.0.2
+      '@types/hast': 3.0.4
+
+  side-channel-list@1.0.0:
+    dependencies:
+      es-errors: 1.3.0
+      object-inspect: 1.13.4
+
+  side-channel-map@1.0.1:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      object-inspect: 1.13.4
+
+  side-channel-weakmap@1.0.2:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      object-inspect: 1.13.4
+      side-channel-map: 1.0.1
+
+  side-channel@1.1.0:
+    dependencies:
+      es-errors: 1.3.0
+      object-inspect: 1.13.4
+      side-channel-list: 1.0.0
+      side-channel-map: 1.0.1
+      side-channel-weakmap: 1.0.2
+
+  siginfo@2.0.0: {}
+
+  signal-exit@3.0.7: {}
+
+  signal-exit@4.1.0: {}
+
+  simple-eval@1.0.1:
+    dependencies:
+      jsep: 1.4.0
+
+  simple-git@3.27.0:
+    dependencies:
+      '@kwsites/file-exists': 1.1.1
+      '@kwsites/promise-deferred': 1.1.1
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
+  simple-swizzle@0.2.2:
+    dependencies:
+      is-arrayish: 0.3.2
+
+  simple-wcswidth@1.0.1: {}
+
+  slash@3.0.0: {}
+
+  slice-ansi@5.0.0:
+    dependencies:
+      ansi-styles: 6.2.1
+      is-fullwidth-code-point: 4.0.0
+
+  slice-ansi@7.1.0:
+    dependencies:
+      ansi-styles: 6.2.1
+      is-fullwidth-code-point: 5.0.0
+
+  slugify@1.6.6: {}
+
+  smart-buffer@4.2.0: {}
+
+  socket.io-adapter@2.5.5(bufferutil@4.0.9):
+    dependencies:
+      debug: 4.3.7
+      ws: 8.17.1(bufferutil@4.0.9)
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  socket.io-parser@4.2.4:
+    dependencies:
+      '@socket.io/component-emitter': 3.1.2
+      debug: 4.3.7
+    transitivePeerDependencies:
+      - supports-color
+
+  socket.io@4.8.1(bufferutil@4.0.9):
+    dependencies:
+      accepts: 1.3.8
+      base64id: 2.0.0
+      cors: 2.8.5
+      debug: 4.3.7
+      engine.io: 6.6.4(bufferutil@4.0.9)
+      socket.io-adapter: 2.5.5(bufferutil@4.0.9)
+      socket.io-parser: 4.2.4
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  socks-proxy-agent@8.0.5:
+    dependencies:
+      agent-base: 7.1.3
+      debug: 4.4.3
+      socks: 2.8.4
+    transitivePeerDependencies:
+      - supports-color
+
+  socks@2.8.4:
+    dependencies:
+      ip-address: 9.0.5
+      smart-buffer: 4.2.0
+
+  sonic-boom@4.2.0:
+    dependencies:
+      atomic-sleep: 1.0.0
+
+  source-map-js@1.2.1: {}
+
+  source-map@0.6.1:
+    optional: true
+
+  source-map@0.7.4: {}
+
+  source-map@0.7.6: {}
+
+  space-separated-tokens@2.0.2: {}
+
+  spawndamnit@3.0.1:
+    dependencies:
+      cross-spawn: 7.0.6
+      signal-exit: 4.1.0
+
+  split2@4.2.0: {}
+
+  sprintf-js@1.0.3: {}
+
+  sprintf-js@1.1.3: {}
+
+  stack-utils@2.0.6:
+    dependencies:
+      escape-string-regexp: 2.0.0
+
+  stackback@0.0.2: {}
+
+  statuses@2.0.1: {}
+
+  std-env@3.10.0: {}
+
+  streamx@2.22.0:
+    dependencies:
+      fast-fifo: 1.3.2
+      text-decoder: 1.2.3
+    optionalDependencies:
+      bare-events: 2.5.4
+
+  string-comparison@1.3.0: {}
+
+  string-width@4.2.3:
+    dependencies:
+      emoji-regex: 8.0.0
+      is-fullwidth-code-point: 3.0.0
+      strip-ansi: 6.0.1
+
+  string-width@5.1.2:
+    dependencies:
+      eastasianwidth: 0.2.0
+      emoji-regex: 9.2.2
+      strip-ansi: 7.1.0
+
+  string-width@7.2.0:
+    dependencies:
+      emoji-regex: 10.4.0
+      get-east-asian-width: 1.3.0
+      strip-ansi: 7.1.0
+
+  string.prototype.trim@1.2.10:
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      define-data-property: 1.1.4
+      define-properties: 1.2.1
+      es-abstract: 1.23.9
+      es-object-atoms: 1.1.1
+      has-property-descriptors: 1.0.2
+
+  string.prototype.trimend@1.0.9:
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      define-properties: 1.2.1
+      es-object-atoms: 1.1.1
+
+  string.prototype.trimstart@1.0.8:
+    dependencies:
+      call-bind: 1.0.8
+      define-properties: 1.2.1
+      es-object-atoms: 1.1.1
+
+  string_decoder@1.3.0:
+    dependencies:
+      safe-buffer: 5.2.1
+
+  stringify-entities@4.0.4:
+    dependencies:
+      character-entities-html4: 2.1.0
+      character-entities-legacy: 3.0.0
+
+  strip-ansi@6.0.1:
+    dependencies:
+      ansi-regex: 5.0.1
+
+  strip-ansi@7.1.0:
+    dependencies:
+      ansi-regex: 6.1.0
+
+  strip-bom-string@1.0.0: {}
+
+  strip-bom@3.0.0: {}
+
+  strip-final-newline@3.0.0: {}
+
+  strip-json-comments@3.1.1: {}
+
+  strip-literal@2.1.1:
+    dependencies:
+      js-tokens: 9.0.1
+
+  style-to-js@1.1.16:
+    dependencies:
+      style-to-object: 1.0.8
+
+  style-to-object@1.0.8:
+    dependencies:
+      inline-style-parser: 0.2.4
+
+  sucrase@3.35.0:
+    dependencies:
+      '@jridgewell/gen-mapping': 0.3.8
+      commander: 4.1.1
+      glob: 10.4.5
+      lines-and-columns: 1.2.4
+      mz: 2.7.0
+      pirates: 4.0.7
+      ts-interface-checker: 0.1.13
+
+  supports-color@7.2.0:
+    dependencies:
+      has-flag: 4.0.0
+
+  supports-preserve-symlinks-flag@1.0.0: {}
+
+  symbol-tree@3.2.4: {}
+
+  tailwindcss@3.4.17:
+    dependencies:
+      '@alloc/quick-lru': 5.2.0
+      arg: 5.0.2
+      chokidar: 3.6.0
+      didyoumean: 1.2.2
+      dlv: 1.1.3
+      fast-glob: 3.3.3
+      glob-parent: 6.0.2
+      is-glob: 4.0.3
+      jiti: 1.21.7
+      lilconfig: 3.1.3
+      micromatch: 4.0.8
+      normalize-path: 3.0.0
+      object-hash: 3.0.0
+      picocolors: 1.1.1
+      postcss: 8.5.6
+      postcss-import: 15.1.0(postcss@8.5.6)
+      postcss-js: 4.0.1(postcss@8.5.6)
+      postcss-load-config: 4.0.2(postcss@8.5.6)
+      postcss-nested: 6.2.0(postcss@8.5.6)
+      postcss-selector-parser: 6.1.2
+      resolve: 1.22.10
+      sucrase: 3.35.0
+    transitivePeerDependencies:
+      - ts-node
+
+  tar-fs@3.1.0:
+    dependencies:
+      pump: 3.0.2
+      tar-stream: 3.1.7
+    optionalDependencies:
+      bare-fs: 4.1.4
+      bare-path: 3.0.0
+    transitivePeerDependencies:
+      - bare-buffer
+
+  tar-stream@3.1.7:
+    dependencies:
+      b4a: 1.6.7
+      fast-fifo: 1.3.2
+      streamx: 2.22.0
+
+  tar@6.2.1:
+    dependencies:
+      chownr: 2.0.0
+      fs-minipass: 2.1.0
+      minipass: 5.0.0
+      minizlib: 2.1.2
+      mkdirp: 1.0.4
+      yallist: 4.0.0
+
+  tdigest@0.1.2:
+    dependencies:
+      bintrees: 1.0.2
+
+  term-size@2.2.1: {}
+
+  test-exclude@7.0.1:
+    dependencies:
+      '@istanbuljs/schema': 0.1.3
+      glob: 10.4.5
+      minimatch: 9.0.5
+
+  text-decoder@1.2.3:
+    dependencies:
+      b4a: 1.6.7
+
+  thenify-all@1.6.0:
+    dependencies:
+      thenify: 3.3.1
+
+  thenify@3.3.1:
+    dependencies:
+      any-promise: 1.3.0
+
+  thread-stream@3.1.0:
+    dependencies:
+      real-require: 0.2.0
+
+  through@2.3.8: {}
+
+  tinybench@2.9.0: {}
+
+  tinyexec@0.3.2: {}
+
+  tinyglobby@0.2.15:
+    dependencies:
+      fdir: 6.5.0(picomatch@4.0.3)
+      picomatch: 4.0.3
+
+  tinypool@0.8.4: {}
+
+  tinyrainbow@3.0.3: {}
+
+  tinyspy@2.2.1: {}
+
+  tldts-core@6.1.86: {}
+
+  tldts@6.1.86:
+    dependencies:
+      tldts-core: 6.1.86
+
+  tmp@0.0.33:
+    dependencies:
+      os-tmpdir: 1.0.2
+
+  to-regex-range@5.0.1:
+    dependencies:
+      is-number: 7.0.0
+
+  toad-cache@3.7.0: {}
+
+  toidentifier@1.0.1: {}
+
+  tough-cookie@4.1.4:
+    dependencies:
+      psl: 1.15.0
+      punycode: 2.3.1
+      universalify: 0.2.0
+      url-parse: 1.5.10
+
+  tough-cookie@5.1.2:
+    dependencies:
+      tldts: 6.1.86
+
+  tr46@0.0.3: {}
+
+  tr46@5.1.1:
+    dependencies:
+      punycode: 2.3.1
+
+  tree-kill@1.2.2: {}
+
+  trim-lines@3.0.1: {}
+
+  trim-trailing-lines@2.1.0: {}
+
+  trough@2.2.0: {}
+
+  ts-api-utils@2.4.0(typescript@5.8.3):
+    dependencies:
+      typescript: 5.8.3
+
+  ts-interface-checker@0.1.13: {}
+
+  tsc-alias@1.8.16:
+    dependencies:
+      chokidar: 3.6.0
+      commander: 9.5.0
+      get-tsconfig: 4.10.0
+      globby: 11.1.0
+      mylas: 2.1.14
+      normalize-path: 3.0.0
+      plimit-lit: 1.6.1
+
+  tslib@1.14.1: {}
+
+  tslib@2.8.1: {}
+
+  tsup@8.5.1(jiti@1.21.7)(postcss@8.5.6)(tsx@4.19.4)(typescript@5.8.3)(yaml@2.7.1):
+    dependencies:
+      bundle-require: 5.1.0(esbuild@0.27.2)
+      cac: 6.7.14
+      chokidar: 4.0.3
+      consola: 3.4.2
+      debug: 4.4.3
+      esbuild: 0.27.2
+      fix-dts-default-cjs-exports: 1.0.1
+      joycon: 3.1.1
+      picocolors: 1.1.1
+      postcss-load-config: 6.0.1(jiti@1.21.7)(postcss@8.5.6)(tsx@4.19.4)(yaml@2.7.1)
+      resolve-from: 5.0.0
+      rollup: 4.53.2
+      source-map: 0.7.6
+      sucrase: 3.35.0
+      tinyexec: 0.3.2
+      tinyglobby: 0.2.15
+      tree-kill: 1.2.2
+    optionalDependencies:
+      postcss: 8.5.6
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - jiti
+      - supports-color
+      - tsx
+      - yaml
+
+  tsx@4.19.4:
+    dependencies:
+      esbuild: 0.25.11
+      get-tsconfig: 4.10.0
+    optionalDependencies:
+      fsevents: 2.3.3
+
+  turbo-darwin-64@2.8.10:
+    optional: true
+
+  turbo-darwin-arm64@2.8.10:
+    optional: true
+
+  turbo-linux-64@2.8.10:
+    optional: true
+
+  turbo-linux-arm64@2.8.10:
+    optional: true
+
+  turbo-windows-64@2.8.10:
+    optional: true
+
+  turbo-windows-arm64@2.8.10:
+    optional: true
+
+  turbo@2.8.10:
+    optionalDependencies:
+      turbo-darwin-64: 2.8.10
+      turbo-darwin-arm64: 2.8.10
+      turbo-linux-64: 2.8.10
+      turbo-linux-arm64: 2.8.10
+      turbo-windows-64: 2.8.10
+      turbo-windows-arm64: 2.8.10
+
+  type-check@0.4.0:
+    dependencies:
+      prelude-ls: 1.2.1
+
+  type-detect@4.1.0: {}
+
+  type-fest@0.21.3: {}
+
+  type-fest@4.41.0: {}
+
+  type-is@1.6.18:
+    dependencies:
+      media-typer: 0.3.0
+      mime-types: 2.1.35
+
+  type-is@2.0.1:
+    dependencies:
+      content-type: 1.0.5
+      media-typer: 1.1.0
+      mime-types: 3.0.1
+
+  typed-array-buffer@1.0.3:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-typed-array: 1.1.15
+
+  typed-array-byte-length@1.0.3:
+    dependencies:
+      call-bind: 1.0.8
+      for-each: 0.3.5
+      gopd: 1.2.0
+      has-proto: 1.2.0
+      is-typed-array: 1.1.15
+
+  typed-array-byte-offset@1.0.4:
+    dependencies:
+      available-typed-arrays: 1.0.7
+      call-bind: 1.0.8
+      for-each: 0.3.5
+      gopd: 1.2.0
+      has-proto: 1.2.0
+      is-typed-array: 1.1.15
+      reflect.getprototypeof: 1.0.10
+
+  typed-array-length@1.0.7:
+    dependencies:
+      call-bind: 1.0.8
+      for-each: 0.3.5
+      gopd: 1.2.0
+      is-typed-array: 1.1.15
+      possible-typed-array-names: 1.1.0
+      reflect.getprototypeof: 1.0.10
+
+  typescript-eslint@8.56.1(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3):
+    dependencies:
+      '@typescript-eslint/eslint-plugin': 8.56.1(@typescript-eslint/parser@8.56.1(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3))(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3)
+      '@typescript-eslint/parser': 8.56.1(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3)
+      '@typescript-eslint/typescript-estree': 8.56.1(typescript@5.8.3)
+      '@typescript-eslint/utils': 8.56.1(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3)
+      eslint: 10.0.2(jiti@1.21.7)
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  typescript-eslint@8.56.1(eslint@9.39.4(jiti@1.21.7))(typescript@5.8.3):
+    dependencies:
+      '@typescript-eslint/eslint-plugin': 8.56.1(@typescript-eslint/parser@8.56.1(eslint@10.0.2(jiti@1.21.7))(typescript@5.8.3))(eslint@9.39.4(jiti@1.21.7))(typescript@5.8.3)
+      '@typescript-eslint/parser': 8.56.1(eslint@9.39.4(jiti@1.21.7))(typescript@5.8.3)
+      '@typescript-eslint/typescript-estree': 8.56.1(typescript@5.8.3)
+      '@typescript-eslint/utils': 8.56.1(eslint@9.39.4(jiti@1.21.7))(typescript@5.8.3)
+      eslint: 9.39.4(jiti@1.21.7)
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  typescript@5.8.3: {}
+
+  typescript@5.9.3:
+    optional: true
+
+  ufo@1.6.3: {}
+
+  unbox-primitive@1.1.0:
+    dependencies:
+      call-bound: 1.0.4
+      has-bigints: 1.1.0
+      has-symbols: 1.1.0
+      which-boxed-primitive: 1.1.1
+
+  unbzip2-stream@1.4.3:
+    dependencies:
+      buffer: 5.7.1
+      through: 2.3.8
+
+  undici-types@5.26.5: {}
+
+  undici-types@6.19.8: {}
+
+  undici-types@6.20.0: {}
+
+  unified@11.0.5:
+    dependencies:
+      '@types/unist': 3.0.3
+      bail: 2.0.2
+      devlop: 1.1.0
+      extend: 3.0.2
+      is-plain-obj: 4.1.0
+      trough: 2.2.0
+      vfile: 6.0.3
+
+  unist-builder@4.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-find-after@5.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-is: 6.0.0
+
+  unist-util-is@5.2.1:
+    dependencies:
+      '@types/unist': 2.0.11
+
+  unist-util-is@6.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-map@4.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-modify-children@4.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+      array-iterate: 2.0.1
+
+  unist-util-position-from-estree@2.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-position@5.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-remove-position@5.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-visit: 5.0.0
+
+  unist-util-remove@4.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-is: 6.0.0
+      unist-util-visit-parents: 6.0.1
+
+  unist-util-stringify-position@4.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-visit-children@3.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-visit-parents@5.1.3:
+    dependencies:
+      '@types/unist': 2.0.11
+      unist-util-is: 5.2.1
+
+  unist-util-visit-parents@6.0.1:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-is: 6.0.0
+
+  unist-util-visit@4.1.2:
+    dependencies:
+      '@types/unist': 2.0.11
+      unist-util-is: 5.2.1
+      unist-util-visit-parents: 5.1.3
+
+  unist-util-visit@5.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-is: 6.0.0
+      unist-util-visit-parents: 6.0.1
+
+  universalify@0.1.2: {}
+
+  universalify@0.2.0: {}
+
+  universalify@2.0.1: {}
+
+  unpipe@1.0.0: {}
+
+  uri-js@4.4.1:
+    dependencies:
+      punycode: 2.3.1
+
+  urijs@1.19.11: {}
+
+  url-parse@1.5.10:
+    dependencies:
+      querystringify: 2.2.0
+      requires-port: 1.0.0
+
+  urlpattern-polyfill@10.0.0: {}
+
+  util-deprecate@1.0.2: {}
+
+  utility-types@3.11.0: {}
+
+  utils-merge@1.0.1: {}
+
+  uuid@10.0.0: {}
+
+  uuid@11.1.0: {}
+
+  uuid@9.0.1: {}
+
+  v8-to-istanbul@9.3.0:
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.31
+      '@types/istanbul-lib-coverage': 2.0.6
+      convert-source-map: 2.0.0
+
+  vary@1.1.2: {}
+
+  vfile-location@5.0.3:
+    dependencies:
+      '@types/unist': 3.0.3
+      vfile: 6.0.3
+
+  vfile-matter@5.0.1:
+    dependencies:
+      vfile: 6.0.3
+      yaml: 2.7.1
+
+  vfile-message@4.0.2:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-stringify-position: 4.0.0
+
+  vfile@6.0.3:
+    dependencies:
+      '@types/unist': 3.0.3
+      vfile-message: 4.0.2
+
+  vite-node@1.6.1(@types/node@20.17.32):
+    dependencies:
+      cac: 6.7.14
+      debug: 4.4.3
+      pathe: 1.1.2
+      picocolors: 1.1.1
+      vite: 5.4.21(@types/node@20.17.32)
+    transitivePeerDependencies:
+      - '@types/node'
+      - less
+      - lightningcss
+      - sass
+      - sass-embedded
+      - stylus
+      - sugarss
+      - supports-color
+      - terser
+
+  vite@5.4.21(@types/node@20.17.32):
+    dependencies:
+      esbuild: 0.21.5
+      postcss: 8.5.6
+      rollup: 4.53.2
+    optionalDependencies:
+      '@types/node': 20.17.32
+      fsevents: 2.3.3
+
+  vite@7.2.2(@types/node@20.17.32)(jiti@1.21.7)(tsx@4.19.4)(yaml@2.7.1):
+    dependencies:
+      esbuild: 0.25.11
+      fdir: 6.5.0(picomatch@4.0.3)
+      picomatch: 4.0.3
+      postcss: 8.5.6
+      rollup: 4.53.2
+      tinyglobby: 0.2.15
+    optionalDependencies:
+      '@types/node': 20.17.32
+      fsevents: 2.3.3
+      jiti: 1.21.7
+      tsx: 4.19.4
+      yaml: 2.7.1
+
+  vite@7.2.2(@types/node@22.13.1)(jiti@1.21.7)(tsx@4.19.4)(yaml@2.7.1):
+    dependencies:
+      esbuild: 0.25.11
+      fdir: 6.5.0(picomatch@4.0.3)
+      picomatch: 4.0.3
+      postcss: 8.5.6
+      rollup: 4.53.2
+      tinyglobby: 0.2.15
+    optionalDependencies:
+      '@types/node': 22.13.1
+      fsevents: 2.3.3
+      jiti: 1.21.7
+      tsx: 4.19.4
+      yaml: 2.7.1
+
+  vitest@1.6.1(@types/node@20.17.32)(jsdom@24.1.3(bufferutil@4.0.9)):
+    dependencies:
+      '@vitest/expect': 1.6.1
+      '@vitest/runner': 1.6.1
+      '@vitest/snapshot': 1.6.1
+      '@vitest/spy': 1.6.1
+      '@vitest/utils': 1.6.1
+      acorn-walk: 8.3.5
+      chai: 4.5.0
+      debug: 4.4.3
+      execa: 8.0.1
+      local-pkg: 0.5.1
+      magic-string: 0.30.21
+      pathe: 1.1.2
+      picocolors: 1.1.1
+      std-env: 3.10.0
+      strip-literal: 2.1.1
+      tinybench: 2.9.0
+      tinypool: 0.8.4
+      vite: 5.4.21(@types/node@20.17.32)
+      vite-node: 1.6.1(@types/node@20.17.32)
+      why-is-node-running: 2.3.0
+    optionalDependencies:
+      '@types/node': 20.17.32
+      jsdom: 24.1.3(bufferutil@4.0.9)
+    transitivePeerDependencies:
+      - less
+      - lightningcss
+      - sass
+      - sass-embedded
+      - stylus
+      - sugarss
+      - supports-color
+      - terser
+
+  vitest@4.0.8(@types/debug@4.1.12)(@types/node@20.17.32)(jiti@1.21.7)(jsdom@24.1.3(bufferutil@4.0.9))(tsx@4.19.4)(yaml@2.7.1):
+    dependencies:
+      '@vitest/expect': 4.0.8
+      '@vitest/mocker': 4.0.8(vite@7.2.2(@types/node@20.17.32)(jiti@1.21.7)(tsx@4.19.4)(yaml@2.7.1))
+      '@vitest/pretty-format': 4.0.8
+      '@vitest/runner': 4.0.8
+      '@vitest/snapshot': 4.0.8
+      '@vitest/spy': 4.0.8
+      '@vitest/utils': 4.0.8
+      debug: 4.4.3
+      es-module-lexer: 1.7.0
+      expect-type: 1.2.2
+      magic-string: 0.30.21
+      pathe: 2.0.3
+      picomatch: 4.0.3
+      std-env: 3.10.0
+      tinybench: 2.9.0
+      tinyexec: 0.3.2
+      tinyglobby: 0.2.15
+      tinyrainbow: 3.0.3
+      vite: 7.2.2(@types/node@20.17.32)(jiti@1.21.7)(tsx@4.19.4)(yaml@2.7.1)
+      why-is-node-running: 2.3.0
+    optionalDependencies:
+      '@types/debug': 4.1.12
+      '@types/node': 20.17.32
+      jsdom: 24.1.3(bufferutil@4.0.9)
+    transitivePeerDependencies:
+      - jiti
+      - less
+      - lightningcss
+      - msw
+      - sass
+      - sass-embedded
+      - stylus
+      - sugarss
+      - supports-color
+      - terser
+      - tsx
+      - yaml
+
+  vitest@4.0.8(@types/debug@4.1.12)(@types/node@22.13.1)(jiti@1.21.7)(jsdom@24.1.3(bufferutil@4.0.9))(tsx@4.19.4)(yaml@2.7.1):
+    dependencies:
+      '@vitest/expect': 4.0.8
+      '@vitest/mocker': 4.0.8(vite@7.2.2(@types/node@22.13.1)(jiti@1.21.7)(tsx@4.19.4)(yaml@2.7.1))
+      '@vitest/pretty-format': 4.0.8
+      '@vitest/runner': 4.0.8
+      '@vitest/snapshot': 4.0.8
+      '@vitest/spy': 4.0.8
+      '@vitest/utils': 4.0.8
+      debug: 4.4.3
+      es-module-lexer: 1.7.0
+      expect-type: 1.2.2
+      magic-string: 0.30.21
+      pathe: 2.0.3
+      picomatch: 4.0.3
+      std-env: 3.10.0
+      tinybench: 2.9.0
+      tinyexec: 0.3.2
+      tinyglobby: 0.2.15
+      tinyrainbow: 3.0.3
+      vite: 7.2.2(@types/node@22.13.1)(jiti@1.21.7)(tsx@4.19.4)(yaml@2.7.1)
+      why-is-node-running: 2.3.0
+    optionalDependencies:
+      '@types/debug': 4.1.12
+      '@types/node': 22.13.1
+      jsdom: 24.1.3(bufferutil@4.0.9)
+    transitivePeerDependencies:
+      - jiti
+      - less
+      - lightningcss
+      - msw
+      - sass
+      - sass-embedded
+      - stylus
+      - sugarss
+      - supports-color
+      - terser
+      - tsx
+      - yaml
+
+  w3c-xmlserializer@5.0.0:
+    dependencies:
+      xml-name-validator: 5.0.0
+
+  web-namespaces@2.0.1: {}
+
+  web-streams-polyfill@3.3.3:
+    optional: true
+
+  web-streams-polyfill@4.0.0-beta.3: {}
+
+  webidl-conversions@3.0.1: {}
+
+  webidl-conversions@7.0.0: {}
+
+  whatwg-encoding@3.1.1:
+    dependencies:
+      iconv-lite: 0.6.3
+
+  whatwg-mimetype@4.0.0: {}
+
+  whatwg-url@14.2.0:
+    dependencies:
+      tr46: 5.1.1
+      webidl-conversions: 7.0.0
+
+  whatwg-url@5.0.0:
+    dependencies:
+      tr46: 0.0.3
+      webidl-conversions: 3.0.1
+
+  which-boxed-primitive@1.1.1:
+    dependencies:
+      is-bigint: 1.1.0
+      is-boolean-object: 1.2.2
+      is-number-object: 1.1.1
+      is-string: 1.1.1
+      is-symbol: 1.1.1
+
+  which-builtin-type@1.2.1:
+    dependencies:
+      call-bound: 1.0.4
+      function.prototype.name: 1.1.8
+      has-tostringtag: 1.0.2
+      is-async-function: 2.1.1
+      is-date-object: 1.1.0
+      is-finalizationregistry: 1.1.1
+      is-generator-function: 1.1.0
+      is-regex: 1.2.1
+      is-weakref: 1.1.1
+      isarray: 2.0.5
+      which-boxed-primitive: 1.1.1
+      which-collection: 1.0.2
+      which-typed-array: 1.1.19
+
+  which-collection@1.0.2:
+    dependencies:
+      is-map: 2.0.3
+      is-set: 2.0.3
+      is-weakmap: 2.0.2
+      is-weakset: 2.0.4
+
+  which-typed-array@1.1.19:
+    dependencies:
+      available-typed-arrays: 1.0.7
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      for-each: 0.3.5
+      get-proto: 1.0.1
+      gopd: 1.2.0
+      has-tostringtag: 1.0.2
+
+  which@2.0.2:
+    dependencies:
+      isexe: 2.0.0
+
+  why-is-node-running@2.3.0:
+    dependencies:
+      siginfo: 2.0.0
+      stackback: 0.0.2
+
+  widest-line@5.0.0:
+    dependencies:
+      string-width: 7.2.0
+
+  word-wrap@1.2.5: {}
+
+  wrap-ansi@6.2.0:
+    dependencies:
+      ansi-styles: 4.3.0
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+
+  wrap-ansi@7.0.0:
+    dependencies:
+      ansi-styles: 4.3.0
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+
+  wrap-ansi@8.1.0:
+    dependencies:
+      ansi-styles: 6.2.1
+      string-width: 5.1.2
+      strip-ansi: 7.1.0
+
+  wrap-ansi@9.0.0:
+    dependencies:
+      ansi-styles: 6.2.1
+      string-width: 7.2.0
+      strip-ansi: 7.1.0
+
+  wrappy@1.0.2: {}
+
+  ws@8.17.1(bufferutil@4.0.9):
+    optionalDependencies:
+      bufferutil: 4.0.9
+
+  ws@8.18.3(bufferutil@4.0.9):
+    optionalDependencies:
+      bufferutil: 4.0.9
+
+  xml-name-validator@5.0.0: {}
+
+  xml2js@0.6.2:
+    dependencies:
+      sax: 1.4.1
+      xmlbuilder: 11.0.1
+
+  xmlbuilder@11.0.1: {}
+
+  xmlchars@2.2.0: {}
+
+  y18n@5.0.8: {}
+
+  yallist@4.0.0: {}
+
+  yaml@2.7.1: {}
+
+  yargs-parser@21.1.1: {}
+
+  yargs-parser@22.0.0: {}
+
+  yargs@17.7.2:
+    dependencies:
+      cliui: 8.0.1
+      escalade: 3.2.0
+      get-caller-file: 2.0.5
+      require-directory: 2.1.1
+      string-width: 4.2.3
+      y18n: 5.0.8
+      yargs-parser: 21.1.1
+
+  yargs@18.0.0:
+    dependencies:
+      cliui: 9.0.1
+      escalade: 3.2.0
+      get-caller-file: 2.0.5
+      string-width: 7.2.0
+      y18n: 5.0.8
+      yargs-parser: 22.0.0
+
+  yauzl@2.10.0:
+    dependencies:
+      buffer-crc32: 0.2.13
+      fd-slicer: 1.1.0
+
+  yocto-queue@0.1.0: {}
+
+  yocto-queue@1.2.2: {}
+
+  yoctocolors-cjs@2.1.2: {}
+
+  yoga-layout@3.2.1: {}
+
+  zod-openapi@5.4.5(zod@4.2.1):
+    dependencies:
+      zod: 4.2.1
+
+  zod-to-json-schema@3.25.0(zod@3.25.76):
+    dependencies:
+      zod: 3.25.76
+
+  zod-to-json-schema@3.25.0(zod@4.2.1):
+    dependencies:
+      zod: 4.2.1
+
+  zod@3.23.8: {}
+
+  zod@3.25.76: {}
+
+  zod@4.2.1: {}
+
+  zwitch@2.0.4: {}
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
new file mode 100644
index 000000000..a84a85f5e
--- /dev/null
+++ b/pnpm-workspace.yaml
@@ -0,0 +1,7 @@
+packages:
+  - "packages/core"
+  - "packages/cli"
+  - "packages/evals"
+  - "packages/docs"
+  - "packages/server-v3"
+  - "packages/server-v4"
diff --git a/stagehand.config.ts b/stagehand.config.ts
deleted file mode 100644
index 4c901799b..000000000
--- a/stagehand.config.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import type { ConstructorParams } from "@/dist";
-import dotenv from "dotenv";
-dotenv.config();
-
-const StagehandConfig: ConstructorParams = {
-  verbose: 2 /* Verbosity level for logging: 0 = silent, 1 = info, 2 = all */,
-  domSettleTimeoutMs: 30_000 /* Timeout for DOM to settle in milliseconds */,
-
-  //   LLM configuration
-  modelName: "gpt-4o" /* Name of the model to use */,
-  modelClientOptions: {
-    apiKey: process.env.OPENAI_API_KEY,
-  } /* Configuration options for the model client */,
-
-  // Browser configuration
-  env:
-    process.env.BROWSERBASE_API_KEY && process.env.BROWSERBASE_PROJECT_ID
-      ? "BROWSERBASE"
-      : "LOCAL",
-  apiKey: process.env.BROWSERBASE_API_KEY /* API key for authentication */,
-  projectId: process.env.BROWSERBASE_PROJECT_ID /* Project identifier */,
-  browserbaseSessionID:
-    undefined /* Session ID for resuming Browserbase sessions */,
-  browserbaseSessionCreateParams: {
-    projectId: process.env.BROWSERBASE_PROJECT_ID!,
-    browserSettings: {
-      blockAds: true,
-      viewport: {
-        width: 1024,
-        height: 768,
-      },
-    },
-  },
-  localBrowserLaunchOptions: {
-    headless: false,
-    viewport: {
-      width: 1024,
-      height: 768,
-    },
-  } /* Configuration options for the local browser */,
-};
-export default StagehandConfig;
diff --git a/stainless.yml b/stainless.yml
new file mode 100644
index 000000000..0270ad4d4
--- /dev/null
+++ b/stainless.yml
@@ -0,0 +1,284 @@
+# yaml-language-server: $schema=https://app.stainless.com/config-internal.schema.json
+
+##########################################################################
+############ DO NOT EDIT THIS FILE IN THE STAINLESS STUDIO UI ############
+############ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ############
+############ ONLY EDIT IN browserbase/stagehand/stainless.yml ############
+##########################################################################
+
+edition: 2025-10-10
+
+organization:
+  name: stagehand
+  docs: https://docs.stagehand.dev
+  contact: ""
+
+targets:
+  python:
+    edition: python.2025-11-20
+    package_name: stagehand
+    project_name: stagehand
+    production_repo: browserbase/stagehand-python
+    publish:
+      pypi: true
+  go:
+    edition: go.2025-10-08
+    package_name: stagehand
+    production_repo: browserbase/stagehand-go
+    options:
+      enable_v2: true
+  java:
+    edition: java.2025-10-08
+    reverse_domain: com.browserbase.api
+    package_name: stagehand
+    production_repo: browserbase/stagehand-java
+    publish:
+      maven:
+        sonatype_platform: portal
+  kotlin:
+    edition: kotlin.2025-10-08
+    reverse_domain: com.browserbase.api
+    package_name: stagehand
+    production_repo: browserbase/stagehand-kotlin
+    publish:
+      maven:
+        sonatype_platform: portal
+  ruby:
+    edition: ruby.2025-10-08
+    gem_name: stagehand
+    production_repo: browserbase/stagehand-ruby
+    publish:
+      rubygems: false
+  typescript:
+    edition: typescript.2025-10-10
+    package_name: stagehand-sdk
+    production_repo: null
+    publish:
+      npm: false
+    options:
+      mcp_server: false
+  php:
+    edition: php.2025-10-08
+    package_name: stagehand
+    production_repo: browserbase/stagehand-php
+    composer_package_name: browserbase/stagehand
+    publish:
+      packagist: true
+  csharp:
+    edition: csharp.2025-10-08
+    package_name: stagehand
+    production_repo: browserbase/stagehand-net
+    publish:
+      nuget: true
+  # cli:
+  #   edition: cli.2025-10-08
+  #   binary_name: stagehand
+  #   production_repo: browserbase/stagehand-cli
+
+# `environments` are a map of the name of the environment (e.g. "sandbox",
+# "production") to the corresponding url to use.
+environments:
+  production: https://api.stagehand.browserbase.com
+  # dev: https://api.stagehand.dev.browserbase.com
+  # local: http://stagehand-api.localhost
+
+# OpenAPI transforms applied by Stainless during SDK generation.
+# This keeps the generated `packages/server-v3/openapi.v3.yaml` faithful to the Fastify+Zod source,
+# while still producing a Stainless-compatible spec for codegen.
+openapi:
+  code_samples: mintlify
+  transforms:
+    # Stainless doesn't support `propertyNames` (emitted by some JSON Schema generators).
+    - command: remove
+      reason: Remove unsupported JSON Schema keyword
+      args:
+        target: "$..propertyNames"
+
+    # Empty-schema `additionalProperties: {}` is equivalent to `true`, and avoids Stainless issues.
+    - command: update
+      reason: Treat record value schema as any
+      args:
+        target: "$.components.schemas.BrowserbaseSessionCreateParams.properties.userMetadata.additionalProperties"
+        value: true
+    - command: update
+      reason: Treat record value schema as any
+      args:
+        target: "$.components.schemas.BrowserbaseSessionCreateParamsOutput.properties.userMetadata.additionalProperties"
+        value: true
+    - command: update
+      reason: Treat record value schema as any
+      args:
+        target: "$.components.schemas.ExtractRequest.properties.schema.additionalProperties"
+        value: true
+    - command: update
+      reason: Treat record value schema as any
+      args:
+        target: "$.components.schemas.AgentResultData.properties.metadata.additionalProperties"
+        value: true
+    - command: update
+      reason: Treat record value schema as any
+      args:
+        target: "$.components.schemas.AgentResultDataOutput.properties.metadata.additionalProperties"
+        value: true
+    - command: update
+      reason: Treat passthrough schema as any
+      args:
+        target: "$.components.schemas.AgentAction.additionalProperties"
+        value: true
+
+    # Add a stable title to help Stainless infer a consistent name for this anonymous array schema.
+    - command: merge
+      reason: Improve name inference for anonymous arrays
+      args:
+        target: '$.components.schemas.BrowserbaseSessionCreateParams.properties.proxies.anyOf[?(@.type == "array")]'
+        value:
+          title: ProxyConfigList
+    - command: merge
+      reason: Improve name inference for anonymous arrays
+      args:
+        target: '$.components.schemas.BrowserbaseSessionCreateParamsOutput.properties.proxies.anyOf[?(@.type == "array")]'
+        value:
+          title: ProxyConfigList
+
+    # `result` is intentionally untyped and should be treated as `any` in Stainless.
+    - command: merge
+      reason: Treat StreamEventSystemData.result as any
+      args:
+        target: "$.components.schemas.StreamEventSystemData.properties.result"
+        value:
+          x-stainless-any: true
+    - command: merge
+      reason: Treat StreamEventSystemDataOutput.result as any
+      args:
+        target: "$.components.schemas.StreamEventSystemDataOutput.properties.result"
+        value:
+          x-stainless-any: true
+
+# `resources` define the structure and organization for your API, such as how
+# methods and models are grouped together and accessed. See the [configuration
+# guide] for more information.
+#
+# [configuration guide]: https://www.stainless.com/docs/guides/configure#resources
+resources:
+  sessions:
+    models:
+      action: "#/components/schemas/Action"
+      model_config: "#/components/schemas/ModelConfig"
+      stream_event: "#/components/schemas/StreamEvent"
+    methods:
+      start: post /v1/sessions/start
+      act:
+        endpoint: post /v1/sessions/{id}/act
+        type: http
+        streaming:
+          param_discriminator: streamResponse
+          stream_event_model: sessions.stream_event
+          params_type_name: streamResponse
+      extract:
+        endpoint: post /v1/sessions/{id}/extract
+        type: http
+        streaming:
+          param_discriminator: streamResponse
+          stream_event_model: sessions.stream_event
+          params_type_name: streamResponse
+      observe:
+        endpoint: post /v1/sessions/{id}/observe
+        type: http
+        streaming:
+          param_discriminator: streamResponse
+          stream_event_model: sessions.stream_event
+          params_type_name: streamResponse
+      execute:
+        endpoint: post /v1/sessions/{id}/agentExecute
+        type: http
+        streaming:
+          param_discriminator: streamResponse
+          stream_event_model: sessions.stream_event
+          params_type_name: streamResponse
+      navigate: post /v1/sessions/{id}/navigate
+      replay: get /v1/sessions/{id}/replay
+      end: post /v1/sessions/{id}/end
+
+streaming:
+  on_event:
+    - data_starts_with: '{"data":{"status":"finished"'
+      handle: done
+    - data_starts_with: error
+      handle: error
+    - event_type: null
+      handle: yield
+
+settings:
+  # All generated integration tests that hit the prism mock http server are marked
+  # as skipped. Removing this setting or setting it to false enables tests, but
+  # doing so may result in test failures due to bugs in the test server.
+  #
+  # [prism mock http server]: https://stoplight.io/open-source/prism
+  disable_mock_tests: true
+  license: MIT
+
+# `client_settings` define settings for the API client, such as extra constructor
+# arguments (used for authentication), retry behavior, idempotency, etc.
+client_settings:
+  opts:
+    BROWSERBASE_API_KEY:
+      type: string
+      read_env: BROWSERBASE_API_KEY
+      description: Your [Browserbase API Key](https://www.browserbase.com/settings)
+      nullable: false
+      auth:
+        security_scheme: BBApiKeyAuth
+    BROWSERBASE_PROJECT_ID:
+      type: string
+      read_env: BROWSERBASE_PROJECT_ID
+      description: Your [Browserbase Project ID](https://www.browserbase.com/settings)
+      nullable: false
+      auth:
+        security_scheme: BBProjectIdAuth
+    MODEL_API_KEY:
+      type: string
+      read_env: MODEL_API_KEY
+      description: Your LLM provider API key (e.g. OPENAI_API_KEY, ANTHROPIC_API_KEY, etc.)
+      nullable: false
+      auth:
+        security_scheme: LLMModelApiKeyAuth
+
+security_schemes:
+  BBApiKeyAuth:
+    type: apiKey
+    in: header
+    name: x-bb-api-key
+  BBProjectIdAuth:
+    type: apiKey
+    in: header
+    name: x-bb-project-id
+  LLMModelApiKeyAuth:
+    type: apiKey
+    in: header
+    name: x-model-api-key
+
+security:
+  - BBApiKeyAuth: []
+    BBProjectIdAuth: []
+    LLMModelApiKeyAuth: []
+
+# `readme` is used to configure the code snippets that will be rendered in the
+# README.md of various SDKs.
+readme:
+  example_requests:
+    default:
+      type: request
+      endpoint: post /v1/sessions/start
+      params:
+        modelName: "openai/gpt-5-nano"
+    headline:
+      type: request
+      endpoint: post /v1/sessions/{id}/act
+      params:
+        input: "click the first link on the page"
+        id: "00000000-your-session-id-000000000000"
+
+diagnostics:
+  ignored:
+    Ruby/NameNotAllowed: true
+    Ruby/NameShadowedBuiltin: true
diff --git a/tsconfig.base.json b/tsconfig.base.json
new file mode 100644
index 000000000..4694aa9e5
--- /dev/null
+++ b/tsconfig.base.json
@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "noImplicitAny": true,
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "sourceMap": true,
+    "inlineSources": true,
+    "declaration": true,
+    "skipLibCheck": true
+  }
+}
diff --git a/tsconfig.json b/tsconfig.json
index d97b9cb50..66f98b818 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,20 +1,12 @@
 {
+  "extends": "./tsconfig.base.json",
   "compilerOptions": {
-    "module": "commonjs",
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "target": "es6",
-    "noImplicitAny": true,
-    "moduleResolution": "node",
-    "sourceMap": true,
     "outDir": "dist",
     "baseUrl": ".",
     "paths": {
-      "*": ["node_modules/*", "lib/types/*"],
+      "*": ["node_modules/*", "packages/core/lib/types/*"],
       "@/*": ["./*"]
-    },
-    "skipLibCheck": true,
-    "declaration": true
+    }
   },
   "exclude": ["node_modules", "dist", ".eslintrc.cjs"]
 }
diff --git a/turbo.json b/turbo.json
new file mode 100644
index 000000000..9c350e89a
--- /dev/null
+++ b/turbo.json
@@ -0,0 +1,548 @@
+{
+  "$schema": "https://v2-8-10.turborepo.dev/schema.json",
+  "globalEnv": [
+    "CI"
+  ],
+  "globalDependencies": [
+    ".github/workflows/ci.yml",
+    "package.json",
+    "packages/*/package.json",
+    "tsconfig.json",
+    "tsconfig.base.json",
+    "eslint.config.mjs",
+    ".prettierrc",
+    ".prettierignore"
+  ],
+  "tasks": {
+    "build": {
+      "dependsOn": ["^build"],
+      "outputs": [
+        "dist/**"
+      ],
+      "inputs": [
+        "**/*.ts",
+        "**/*.js",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "!dist/**"
+      ]
+    },
+    "@browserbasehq/stagehand#build": {
+      "dependsOn": [
+        "^build",
+        "gen-version",
+        "build-dom-scripts:dom",
+        "build-dom-scripts:locator",
+        "build-dom-scripts:screenshot",
+        "build-dom-scripts:a11y"
+      ],
+      "outputs": [
+        "dist/**"
+      ],
+      "inputs": [
+        "**/*.ts",
+        "**/*.js",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "!lib/version.ts",
+        "!lib/dom/build/**",
+        "!lib/v3/dom/build/**",
+        "!dist/**"
+      ]
+    },
+    "@browserbasehq/stagehand-server-v3#build": {
+      "dependsOn": ["^build"],
+      "outputs": [
+        "dist/**",
+        "openapi.v3.yaml"
+      ],
+      "inputs": [
+        "**/*.ts",
+        "**/*.js",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "!dist/**",
+        "!openapi.v3.yaml"
+      ]
+    },
+    "@browserbasehq/stagehand-server-v4#build": {
+      "dependsOn": ["^build"],
+      "outputs": [
+        "dist/**",
+        "openapi.v4.yaml"
+      ],
+      "inputs": [
+        "**/*.ts",
+        "**/*.js",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "!dist/**",
+        "!openapi.v4.yaml"
+      ]
+    },
+    "@browserbasehq/stagehand-server-v4#gen:openapi": {
+      "dependsOn": ["^build:esm"],
+      "outputs": ["openapi.v4.yaml"],
+      "inputs": [
+        "src/**/*.ts",
+        "scripts/gen-openapi.ts",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "!openapi.v4.yaml"
+      ]
+    },
+    "@browserbasehq/stagehand#build:esm": {
+      "dependsOn": [
+        "^build:esm",
+        "gen-version",
+        "build-dom-scripts:dom",
+        "build-dom-scripts:locator",
+        "build-dom-scripts:screenshot",
+        "build-dom-scripts:a11y"
+      ],
+      "outputs": [
+        "dist/esm/**"
+      ],
+      "inputs": [
+        "**/*.ts",
+        "**/*.js",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "!lib/version.ts",
+        "!lib/dom/build/**",
+        "!lib/v3/dom/build/**",
+        "!dist/**"
+      ]
+    },
+    "@browserbasehq/stagehand#build:cjs": {
+      "dependsOn": [
+        "^build:cjs",
+        "gen-version",
+        "build-dom-scripts:dom",
+        "build-dom-scripts:locator",
+        "build-dom-scripts:screenshot",
+        "build-dom-scripts:a11y"
+      ],
+      "outputs": [
+        "dist/cjs/**"
+      ],
+      "inputs": [
+        "**/*.ts",
+        "**/*.js",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "!lib/version.ts",
+        "!lib/dom/build/**",
+        "!lib/v3/dom/build/**",
+        "!dist/**"
+      ]
+    },
+    "gen-version": {
+      "outputs": ["lib/version.ts"],
+      "inputs": [
+        "scripts/gen-version.ts",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "!lib/version.ts"
+      ]
+    },
+    "build-dom-scripts:dom": {
+      "outputs": [
+        "lib/v3/dom/build/v3-index.js",
+        "lib/v3/dom/build/scriptV3Content.ts",
+        "lib/v3/dom/build/rerender-index.js",
+        "lib/v3/dom/build/reRenderScriptContent.ts"
+      ],
+      "inputs": [
+        "lib/v3/dom/genDomScripts.ts",
+        "lib/v3/dom/**/*.ts",
+        "!lib/v3/dom/build/**",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json"
+      ]
+    },
+    "build-dom-scripts:locator": {
+      "outputs": [
+        "lib/v3/dom/build/locatorScripts.generated.ts"
+      ],
+      "inputs": [
+        "lib/v3/dom/genLocatorScripts.ts",
+        "lib/v3/dom/locatorScripts/**/*.ts",
+        "!lib/v3/dom/build/**",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json"
+      ]
+    },
+    "build-dom-scripts:screenshot": {
+      "outputs": [
+        "lib/v3/dom/build/screenshotScripts.generated.ts"
+      ],
+      "inputs": [
+        "lib/v3/dom/genScreenshotScripts.ts",
+        "lib/v3/dom/screenshotScripts/**/*.ts",
+        "!lib/v3/dom/build/**",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json"
+      ]
+    },
+    "build-dom-scripts:a11y": {
+      "outputs": [
+        "lib/v3/dom/build/a11yScripts.generated.ts"
+      ],
+      "inputs": [
+        "lib/v3/dom/genA11yScripts.ts",
+        "lib/v3/dom/a11yScripts/**/*.ts",
+        "!lib/v3/dom/build/**",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json"
+      ]
+    },
+    "build:esm": {
+      "dependsOn": ["^build:esm"],
+      "outputs": [
+        "dist/esm/**"
+      ],
+      "inputs": [
+        "**/*.ts",
+        "**/*.js",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "!dist/esm/**"
+      ]
+    },
+    "build:esm-tests": {
+      "dependsOn": ["^build:esm"],
+      "outputs": ["dist/tests/**"],
+      "inputs": [
+        "test/**/*.ts",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "!dist/tests/**"
+      ]
+    },
+    "build:server:dist": {
+      "dependsOn": ["^build:esm"],
+      "outputs": [
+        "dist/lib/**",
+        "dist/routes/**",
+        "dist/types/**",
+        "dist/*.js",
+        "dist/*.js.map",
+        "dist/*.d.ts"
+      ],
+      "inputs": [
+        "src/**/*.ts",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "!dist/lib/**",
+        "!dist/routes/**",
+        "!dist/types/**",
+        "!dist/*.js",
+        "!dist/*.js.map",
+        "!dist/*.d.ts"
+      ]
+    },
+    "gen:openapi": {
+      "dependsOn": ["^build:esm"],
+      "outputs": ["openapi.v3.yaml"],
+      "inputs": [
+        "src/**/*.ts",
+        "scripts/gen-openapi.ts",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "!openapi.v3.yaml"
+      ]
+    },
+    "build:sea:esm": {
+      "dependsOn": ["^build:esm"],
+      "outputs": [
+        "dist/sea/**",
+        "dist/app.mjs"
+      ],
+      "env": [
+        "SEA_BUILD_MODE",
+        "SEA_TARGET_PLATFORM",
+        "SEA_TARGET_ARCH",
+        "SEA_BINARY_NAME"
+      ],
+      "inputs": [
+        "src/**/*.ts",
+        "scripts/**/*.ts",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "!dist/sea/**",
+        "!dist/app.mjs"
+      ]
+    },
+    "build:sea:cjs": {
+      "dependsOn": ["^build:cjs"],
+      "outputs": ["dist/sea/**"],
+      "env": [
+        "SEA_BUILD_MODE",
+        "SEA_TARGET_PLATFORM",
+        "SEA_TARGET_ARCH",
+        "SEA_BINARY_NAME"
+      ],
+      "inputs": [
+        "src/**/*.ts",
+        "scripts/**/*.ts",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "!dist/sea/**"
+      ]
+    },
+    "build:cjs": {
+      "dependsOn": ["^build:cjs"],
+      "outputs": [
+        "dist/cjs/**"
+      ],
+      "inputs": [
+        "**/*.ts",
+        "**/*.js",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "!dist/cjs/**"
+      ]
+    },
+    "build:cli": {
+      "dependsOn": ["^build:esm"],
+      "outputs": ["dist/cli/**"],
+      "inputs": [
+        "cli.ts",
+        "evals.config.json",
+        "scripts/**",
+        "!dist/cli/**"
+      ]
+    },
+    "lint": {
+      "dependsOn": ["^build"],
+      "outputs": [],
+      "inputs": [
+        "**/*.ts",
+        "**/*.tsx",
+        "**/*.js",
+        "**/*.jsx",
+        "**/*.mjs",
+        "**/*.cjs",
+        "**/*.mts",
+        "**/*.cts",
+        "**/*.md",
+        "**/*.mdx",
+        "**/*.yml",
+        "**/*.yaml",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "!dist/**",
+        "!node_modules/**",
+        "!.turbo/**"
+      ]
+    },
+    "format": {
+      "outputs": [],
+      "cache": false
+    },
+    "test": {
+      "dependsOn": [],
+      "outputs": [],
+      "inputs": [
+        "**/*.spec.ts",
+        "**/*.test.ts"
+      ]
+    },
+    "test:core": {
+      "dependsOn": ["build:esm"],
+      "outputs": [],
+      "cache": false,
+      "env": [
+        "VITEST_CONSOLE_REPORTER"
+      ],
+      "inputs": [
+        "tests/**/*.ts",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json"
+      ]
+    },
+    "test:e2e": {
+      "dependsOn": ["build:esm"],
+      "outputs": [
+        "playwright-report/**",
+        "test-results/**"
+      ],
+      "cache": false,
+      "env": [
+        "BB_API_KEY",
+        "BB_PROJECT_ID",
+        "BROWSERBASE_REGION",
+        "BROWSERBASE_SESSION_LIMIT_PER_E2E_TEST",
+        "IFRAME_CHILD_FRAME_TIMEOUT_MS",
+        "IFRAME_DEBUG",
+        "IFRAME_POPUP_TIMEOUT_MS",
+        "IFRAME_POPUP_URL_TIMEOUT_MS",
+        "KEEP_ALIVE_ACTION_EXIT_TIMEOUT_MS",
+        "KEEP_ALIVE_BB_INFO_TIMEOUT_MS",
+        "KEEP_ALIVE_BB_TIMEOUT_MS",
+        "KEEP_ALIVE_DEBUG",
+        "KEEP_ALIVE_LOCAL_INFO_TIMEOUT_MS",
+        "KEEP_ALIVE_LOCAL_TIMEOUT_MS",
+        "KEEP_ALIVE_STAY_OPEN_MS",
+        "KEEP_ALIVE_VIEW_MS",
+        "LOCAL_SESSION_LIMIT_PER_E2E_TEST",
+        "PLAYWRIGHT_CONSOLE_REPORTER",
+        "STAGEHAND_BROWSER_TARGET",
+        "STAGEHAND_API_URL"
+      ],
+      "passThroughEnv": [
+        "ANTHROPIC_API_KEY",
+        "BROWSERBASE_API_KEY",
+        "BROWSERBASE_CDP_CONNECT_MAX_MS",
+        "BROWSERBASE_PROJECT_ID",
+        "BROWSERBASE_SESSION_CREATE_MAX_MS",
+        "CHROME_PATH",
+        "CTRF_JUNIT_PATH",
+        "GEMINI_API_KEY",
+        "GOOGLE_GENERATIVE_AI_API_KEY",
+        "HEADLESS",
+        "LLM_MAX_MS",
+        "NODE_OPTIONS",
+        "NODE_V8_COVERAGE",
+        "OPENAI_API_KEY",
+        "STAGEHAND_SERVER_TARGET"
+      ],
+      "inputs": [
+        "lib/v3/tests/**/*.ts",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "!playwright-report/**",
+        "!test-results/**"
+      ]
+    },
+    "test:evals": {
+      "dependsOn": ["build:esm", "build:cli"],
+      "outputs": [],
+      "cache": false,
+      "env": [
+        "AGENT_EVAL_MAX_STEPS",
+        "BRAINTRUST_API_KEY",
+        "EVAL_AGENT_MODELS",
+        "EVAL_AGENT_MODELS_CUA",
+        "EVAL_CATEGORIES",
+        "EVAL_DATASET",
+        "EVAL_ENV",
+        "EVAL_GAIA_FILE",
+        "EVAL_GAIA_LEVEL",
+        "EVAL_GAIA_LIMIT",
+        "EVAL_GAIA_SAMPLE",
+        "EVAL_MAX_CONCURRENCY",
+        "EVAL_MAX_K",
+        "EVAL_MODELS",
+        "EVAL_ONLINEMIND2WEB_LIMIT",
+        "EVAL_ONLINEMIND2WEB_SAMPLE",
+        "EVAL_PROVIDER",
+        "EVAL_TRIAL_COUNT",
+        "EVAL_WEBVOYAGER_LIMIT",
+        "EVAL_WEBVOYAGER_SAMPLE",
+        "OP_AUTO_ENV_DISABLE",
+        "OP_ENV_FILE",
+        "STAGEHAND_BROWSER_TARGET",
+        "USE_API"
+      ],
+      "passThroughEnv": [
+        "ANTHROPIC_API_KEY",
+        "BROWSERBASE_API_KEY",
+        "BROWSERBASE_CDP_CONNECT_MAX_MS",
+        "BROWSERBASE_PROJECT_ID",
+        "BROWSERBASE_SESSION_CREATE_MAX_MS",
+        "CHROME_PATH",
+        "CTRF_JUNIT_PATH",
+        "GEMINI_API_KEY",
+        "GOOGLE_GENERATIVE_AI_API_KEY",
+        "HEADLESS",
+        "LLM_MAX_MS",
+        "NODE_OPTIONS",
+        "NODE_V8_COVERAGE",
+        "OPENAI_API_KEY",
+        "STAGEHAND_SERVER_TARGET"
+      ],
+      "inputs": [
+        "scripts/**",
+        "cli.ts",
+        "evals.config.json",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json"
+      ]
+    },
+    "test:server": {
+      "dependsOn": ["build:sea:esm", "build:esm-tests"],
+      "outputs": [],
+      "cache": false,
+      "env": [
+        "BB_ENV",
+        "NODE_ENV",
+        "NODE_TEST_CONSOLE_REPORTER",
+        "NODE_TEST_REPORTER",
+        "NODE_TEST_REPORTER_DESTINATION",
+        "SEA_BINARY_NAME",
+        "STAGEHAND_BASE_URL",
+        "STAGEHAND_SEA_CACHE_DIR",
+        "STAGEHAND_TEST_LOCAL_CONNECT_TIMEOUT_MS"
+      ],
+      "passThroughEnv": [
+        "ANTHROPIC_API_KEY",
+        "BROWSERBASE_API_KEY",
+        "BROWSERBASE_CDP_CONNECT_MAX_MS",
+        "BROWSERBASE_PROJECT_ID",
+        "BROWSERBASE_SESSION_CREATE_MAX_MS",
+        "CHROME_PATH",
+        "CTRF_JUNIT_PATH",
+        "GEMINI_API_KEY",
+        "GOOGLE_GENERATIVE_AI_API_KEY",
+        "HEADLESS",
+        "LLM_MAX_MS",
+        "NODE_OPTIONS",
+        "NODE_V8_COVERAGE",
+        "OPENAI_API_KEY",
+        "STAGEHAND_BROWSER_TARGET",
+        "STAGEHAND_SERVER_TARGET"
+      ],
+      "inputs": [
+        "test/**/*.ts",
+        "scripts/**",
+        "src/**/*.ts",
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.*.json"
+      ]
+    },
+    "docs": {
+      "persistent": true,
+      "cache": false
+    },
+    "dev": {
+      "persistent": true,
+      "cache": false
+    }
+  }
+}
diff --git a/types/act.ts b/types/act.ts
deleted file mode 100644
index bdccf4299..000000000
--- a/types/act.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import { LLMClient } from "../lib/llm/LLMClient";
-import { Locator } from "@playwright/test";
-import { Logger } from "@/types/log";
-import { StagehandPage } from "@/lib/StagehandPage";
-
-// WARNING: This is NOT to be confused with the ActParams type used in `page.act()`.
-// This is the type for the parameters passed to the `act` command in `inference.ts`.
-// page.act() params/result types are defined in `types/stagehand.ts`.
-export interface ActCommandParams {
-  action: string;
-  steps?: string;
-  domElements: string;
-  llmClient: LLMClient;
-  retries?: number;
-  logger: (message: { category?: string; message: string }) => void;
-  requestId: string;
-  variables?: Record<string, string>;
-  userProvidedInstructions?: string;
-}
-
-// WARNING: This is NOT to be confused with the ActResult type used in `page.act()`.
-// This is the type for the result of the `act` command in `inference.ts`.
-// page.act() params/result types are defined in `types/stagehand.ts`.
-export interface ActCommandResult {
-  method: string;
-  element: number;
-  args: unknown[];
-  completed: boolean;
-  step: string;
-  why?: string;
-}
-
-// We can use this enum to list the actions supported in performPlaywrightMethod
-export enum SupportedPlaywrightAction {
-  CLICK = "click",
-  FILL = "fill",
-  TYPE = "type",
-  PRESS = "press",
-  SCROLL = "scrollTo",
-  NEXT_CHUNK = "nextChunk",
-  PREV_CHUNK = "prevChunk",
-}
-
-/**
- * A context object to hold all parameters that might be needed by
- * any of the methods in the `methodHandlerMap`
- */
-export interface MethodHandlerContext {
-  method: string;
-  locator: Locator;
-  xpath: string;
-  args: unknown[];
-  logger: Logger;
-  stagehandPage: StagehandPage;
-  initialUrl: string;
-  domSettleTimeoutMs?: number;
-}
diff --git a/types/agent.ts b/types/agent.ts
deleted file mode 100644
index 8cc062012..000000000
--- a/types/agent.ts
+++ /dev/null
@@ -1,141 +0,0 @@
-import { LogLine } from "./log";
-
-export interface AgentAction {
-  type: string;
-  [key: string]: unknown;
-}
-
-export interface AgentResult {
-  success: boolean;
-  message: string;
-  actions: AgentAction[];
-  completed: boolean;
-  metadata?: Record<string, unknown>;
-}
-
-export interface AgentOptions {
-  maxSteps?: number;
-  autoScreenshot?: boolean;
-  waitBetweenActions?: number;
-  context?: string;
-}
-
-export interface AgentExecuteOptions extends AgentOptions {
-  instruction: string;
-}
-
-export type AgentProviderType = "openai" | "anthropic";
-
-export interface AgentClientOptions {
-  apiKey: string;
-  organization?: string;
-  baseURL?: string;
-  defaultMaxSteps?: number;
-  [key: string]: unknown;
-}
-
-export type AgentType = "openai" | "anthropic";
-
-export interface AgentExecutionOptions {
-  options: AgentExecuteOptions;
-  logger: (message: LogLine) => void;
-  retries?: number;
-}
-
-export interface AgentHandlerOptions {
-  modelName: string;
-  clientOptions?: Record<string, unknown>;
-  userProvidedInstructions?: string;
-  agentType: AgentType;
-}
-
-export interface ActionExecutionResult {
-  success: boolean;
-  error?: string;
-  data?: unknown;
-}
-
-// Anthropic types:
-
-export interface ToolUseItem extends ResponseItem {
-  type: "tool_use";
-  id: string; // This is the correct property name from Anthropic's API
-  name: string; // Name of the tool being used
-  input: Record<string, unknown>;
-}
-
-export interface AnthropicMessage {
-  role: string;
-  content: string | Array<AnthropicContentBlock>;
-}
-
-export interface AnthropicContentBlock {
-  type: string;
-  [key: string]: unknown;
-}
-
-export interface AnthropicTextBlock extends AnthropicContentBlock {
-  type: "text";
-  text: string;
-}
-
-export interface AnthropicToolResult {
-  type: "tool_result";
-  tool_use_id: string;
-  content: string | Array<AnthropicContentBlock>;
-}
-
-// OpenAI types:
-
-export interface ResponseItem {
-  type: string;
-  id: string;
-  [key: string]: unknown;
-}
-
-export interface ComputerCallItem extends ResponseItem {
-  type: "computer_call";
-  call_id: string;
-  action: {
-    type: string;
-    [key: string]: unknown;
-  };
-  pending_safety_checks?: Array<{
-    id: string;
-    code: string;
-    message: string;
-  }>;
-}
-
-export interface FunctionCallItem extends ResponseItem {
-  type: "function_call";
-  call_id: string;
-  name: string;
-  arguments: string;
-}
-
-export type ResponseInputItem =
-  | { role: string; content: string }
-  | {
-      type: "computer_call_output";
-      call_id: string;
-      output:
-        | {
-            type: "input_image";
-            image_url: string;
-            current_url?: string;
-            error?: string;
-            [key: string]: unknown;
-          }
-        | string;
-      acknowledged_safety_checks?: Array<{
-        id: string;
-        code: string;
-        message: string;
-      }>;
-    }
-  | {
-      type: "function_call_output";
-      call_id: string;
-      output: string;
-    };
diff --git a/types/api.ts b/types/api.ts
deleted file mode 100644
index 14cc43f9e..000000000
--- a/types/api.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import Browserbase from "@browserbasehq/sdk";
-import { LogLine } from "./log";
-
-export interface StagehandAPIConstructorParams {
-  apiKey: string;
-  projectId: string;
-  logger: (message: LogLine) => void;
-}
-
-export interface ExecuteActionParams {
-  method: "act" | "extract" | "observe" | "navigate" | "end" | "agentExecute";
-  args?: unknown;
-  params?: unknown;
-}
-
-export interface StartSessionParams {
-  modelName: string;
-  modelApiKey: string;
-  domSettleTimeoutMs: number;
-  verbose: number;
-  debugDom: boolean;
-  systemPrompt?: string;
-  browserbaseSessionCreateParams?: Browserbase.Sessions.SessionCreateParams;
-  selfHeal?: boolean;
-  waitForCaptchaSolves?: boolean;
-  actionTimeoutMs?: number;
-  browserbaseSessionID?: string;
-}
-
-export interface StartSessionResult {
-  sessionId: string;
-}
-
-export interface SuccessResponse<T> {
-  success: true;
-  data: T;
-}
-
-export interface ErrorResponse {
-  success: false;
-  message: string;
-}
-
-export type ApiResponse<T> = SuccessResponse<T> | ErrorResponse;
diff --git a/types/browser.ts b/types/browser.ts
deleted file mode 100644
index 3a7779668..000000000
--- a/types/browser.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import { Browser, BrowserContext } from "./page";
-
-export interface BrowserResult {
-  env: "LOCAL" | "BROWSERBASE";
-  browser?: Browser;
-  context: BrowserContext;
-  debugUrl?: string;
-  sessionUrl?: string;
-  contextPath?: string;
-  sessionId?: string;
-}
diff --git a/types/context.ts b/types/context.ts
deleted file mode 100644
index 2c8976554..000000000
--- a/types/context.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import type { BrowserContext as PlaywrightContext } from "@playwright/test";
-import { Page } from "../types/page";
-
-export interface AXNode {
-  role?: { value: string };
-  name?: { value: string };
-  description?: { value: string };
-  value?: { value: string };
-  nodeId: string;
-  backendDOMNodeId?: number;
-  parentId?: string;
-  childIds?: string[];
-  properties?: {
-    name: string;
-    value: {
-      type: string;
-      value?: string;
-    };
-  }[];
-}
-
-export type AccessibilityNode = {
-  role: string;
-  name?: string;
-  description?: string;
-  value?: string;
-  children?: AccessibilityNode[];
-  childIds?: string[];
-  parentId?: string;
-  nodeId?: string;
-  backendDOMNodeId?: number;
-  properties?: {
-    name: string;
-    value: {
-      type: string;
-      value?: string;
-    };
-  }[];
-};
-
-export interface TreeResult {
-  tree: AccessibilityNode[];
-  simplified: string;
-  iframes?: AccessibilityNode[];
-  idToUrl: Record<string, string>;
-}
-
-export interface EnhancedContext
-  extends Omit<PlaywrightContext, "newPage" | "pages"> {
-  newPage(): Promise<Page>;
-  pages(): Page[];
-}
diff --git a/types/inference.ts b/types/inference.ts
deleted file mode 100644
index b36e4d6c1..000000000
--- a/types/inference.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import { LLMClient } from "../lib/llm/LLMClient";
-import { LLMProvider } from "../lib/llm/LLMProvider";
-
-export interface VerifyActCompletionParams {
-  goal: string;
-  steps: string;
-  llmProvider: LLMProvider;
-  llmClient: LLMClient;
-  domElements?: string;
-  logger: (message: { category?: string; message: string }) => void;
-  requestId: string;
-}
diff --git a/types/llm.ts b/types/llm.ts
deleted file mode 100644
index f383b97ea..000000000
--- a/types/llm.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-export interface LLMTool {
-  type: "function";
-  name: string;
-  description: string;
-  parameters: Record<string, unknown>;
-}
diff --git a/types/model.ts b/types/model.ts
deleted file mode 100644
index 00f304eb8..000000000
--- a/types/model.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import type { ClientOptions as AnthropicClientOptions } from "@anthropic-ai/sdk";
-import type { ClientOptions as OpenAIClientOptions } from "openai";
-import { z } from "zod";
-
-export const AvailableModelSchema = z.enum([
-  "gpt-4o",
-  "gpt-4o-mini",
-  "gpt-4o-2024-08-06",
-  "gpt-4.5-preview",
-  "claude-3-5-sonnet-latest",
-  "claude-3-5-sonnet-20241022",
-  "claude-3-5-sonnet-20240620",
-  "claude-3-7-sonnet-latest",
-  "claude-3-7-sonnet-20250219",
-  "o1-mini",
-  "o1-preview",
-  "o3-mini",
-  "cerebras-llama-3.3-70b",
-  "cerebras-llama-3.1-8b",
-  "groq-llama-3.3-70b-versatile",
-  "groq-llama-3.3-70b-specdec",
-  "gemini-1.5-flash",
-  "gemini-1.5-pro",
-  "gemini-1.5-flash-8b",
-  "gemini-2.0-flash-lite",
-  "gemini-2.0-flash",
-  "gemini-2.5-flash-preview-04-17",
-  "gemini-2.5-pro-preview-03-25",
-]);
-
-export type AvailableModel = z.infer<typeof AvailableModelSchema>;
-
-export type ModelProvider =
-  | "openai"
-  | "anthropic"
-  | "cerebras"
-  | "groq"
-  | "google";
-
-export type ClientOptions = OpenAIClientOptions | AnthropicClientOptions;
-
-export interface AnthropicJsonSchemaObject {
-  definitions?: {
-    MySchema?: { properties?: Record<string, unknown>; required?: string[] };
-  };
-  properties?: Record<string, unknown>;
-  required?: string[];
-}
diff --git a/types/operator.ts b/types/operator.ts
deleted file mode 100644
index 08ee870f3..000000000
--- a/types/operator.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import { z } from "zod";
-
-export const operatorResponseSchema = z.object({
-  reasoning: z
-    .string()
-    .describe(
-      "The reasoning for the step taken. If this step's method is `close`, the goal was to extract data, and the task was successful, state the data that was extracted.",
-    ),
-  method: z.enum([
-    "act",
-    "extract",
-    "goto",
-    "close",
-    "wait",
-    "navback",
-    "refresh",
-  ])
-    .describe(`The action to perform on the page based off of the goal and the current state of the page.
-      goto: Navigate to a specific URL.
-      act: Perform an action on the page.  
-      extract: Extract data from the page.
-      close: The task is complete, close the browser.
-      wait: Wait for a period of time.
-      navback: Navigate back to the previous page. Do not navigate back if you are already on the first page.
-      refresh: Refresh the page.`),
-  parameters: z
-    .string()
-    .describe(
-      `The parameter for the action. Only pass in a parameter for the following methods:
-        - act: The action to perform. e.g. "click on the submit button" or "type [email] into the email input field and press enter"
-        - extract: The data to extract. e.g. "the title of the article". If you want to extract all of the text on the page, leave this undefined.
-        - wait: The amount of time to wait in milliseconds.
-        - goto: The URL to navigate to. e.g. "https://www.google.com"
-        The other methods do not require a parameter.`,
-    )
-    .optional(),
-  taskComplete: z
-    .boolean()
-    .describe(
-      "Whether the task is complete. If true, the task is complete and no more steps are needed. If you chose to close the task because the goal is not achievable, set this to false.",
-    ),
-});
-
-export type OperatorResponse = z.infer<typeof operatorResponseSchema>;
-
-export const operatorSummarySchema = z.object({
-  answer: z.string().describe("The final answer to the original instruction."),
-});
-
-export type OperatorSummary = z.infer<typeof operatorSummarySchema>;
diff --git a/types/page.ts b/types/page.ts
deleted file mode 100644
index 3d5706012..000000000
--- a/types/page.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import type {
-  Browser as PlaywrightBrowser,
-  BrowserContext as PlaywrightContext,
-  Page as PlaywrightPage,
-} from "@playwright/test";
-import { z } from "zod";
-import type {
-  ActOptions,
-  ActResult,
-  ExtractOptions,
-  ExtractResult,
-  ObserveOptions,
-  ObserveResult,
-} from "./stagehand";
-
-export const defaultExtractSchema = z.object({
-  extraction: z.string(),
-});
-
-export const pageTextSchema = z.object({
-  page_text: z.string(),
-});
-
-export interface Page extends Omit<PlaywrightPage, "on"> {
-  act(action: string): Promise<ActResult>;
-  act(options: ActOptions): Promise<ActResult>;
-  act(observation: ObserveResult): Promise<ActResult>;
-
-  extract(
-    instruction: string,
-  ): Promise<ExtractResult<typeof defaultExtractSchema>>;
-  extract<T extends z.AnyZodObject>(
-    options: ExtractOptions<T>,
-  ): Promise<ExtractResult<T>>;
-  extract(): Promise<ExtractResult<typeof pageTextSchema>>;
-
-  observe(): Promise<ObserveResult[]>;
-  observe(instruction: string): Promise<ObserveResult[]>;
-  observe(options?: ObserveOptions): Promise<ObserveResult[]>;
-
-  on: {
-    (event: "popup", listener: (page: Page) => unknown): Page;
-  } & PlaywrightPage["on"];
-}
-
-// Empty type for now, but will be used in the future
-export type BrowserContext = PlaywrightContext;
-
-// Empty type for now, but will be used in the future
-export type Browser = PlaywrightBrowser;
diff --git a/types/playwright.ts b/types/playwright.ts
deleted file mode 100644
index bb623576b..000000000
--- a/types/playwright.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-export class PlaywrightCommandException extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "PlaywrightCommandException";
-  }
-}
-
-export class PlaywrightCommandMethodNotSupportedException extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "PlaywrightCommandMethodNotSupportedException";
-  }
-}
-
-export interface GotoOptions {
-  timeout?: number;
-  waitUntil?: "load" | "domcontentloaded" | "networkidle" | "commit";
-  referer?: string;
-}
diff --git a/types/stagehand.ts b/types/stagehand.ts
deleted file mode 100644
index 7fdc49a1d..000000000
--- a/types/stagehand.ts
+++ /dev/null
@@ -1,290 +0,0 @@
-import Browserbase from "@browserbasehq/sdk";
-import { z } from "zod";
-import { LLMProvider } from "../lib/llm/LLMProvider";
-import { LogLine } from "./log";
-import { AvailableModel, ClientOptions } from "./model";
-import { LLMClient } from "../lib/llm/LLMClient";
-import { Cookie } from "@playwright/test";
-import { AgentProviderType } from "./agent";
-
-export interface ConstructorParams {
-  /**
-   * The environment to use for Stagehand
-   */
-  env: "LOCAL" | "BROWSERBASE";
-  /**
-   * Your Browserbase API key
-   */
-  apiKey?: string;
-  /**
-   * Your Browserbase project ID
-   */
-  projectId?: string;
-  /**
-   * The verbosity of the Stagehand logger
-   * 0 - No logs
-   * 1 - Only errors
-   * 2 - All logs
-   */
-  verbose?: 0 | 1 | 2;
-  /**
-   * The LLM provider to use for Stagehand
-   * See
-   */
-  llmProvider?: LLMProvider;
-  /**
-   * The logger to use for Stagehand
-   */
-  logger?: (message: LogLine) => void | Promise<void>;
-  /**
-   * The timeout to use for the DOM to settle
-   * @default 10000
-   */
-  domSettleTimeoutMs?: number;
-  /**
-   * The parameters to use for creating a Browserbase session
-   * See https://docs.browserbase.com/reference/api/create-a-session
-   */
-  browserbaseSessionCreateParams?: Browserbase.Sessions.SessionCreateParams;
-  /**
-   * Enable caching of LLM responses
-   * @default true
-   */
-  enableCaching?: boolean;
-  /**
-   * The ID of a Browserbase session to resume
-   */
-  browserbaseSessionID?: string;
-  /**
-   * The model to use for Stagehand
-   */
-  modelName?: AvailableModel;
-  /**
-   * The LLM client to use for Stagehand
-   */
-  llmClient?: LLMClient;
-  /**
-   * The parameters to use for the LLM client
-   * Useful for parameterizing LLM API Keys
-   */
-  modelClientOptions?: ClientOptions;
-  /**
-   * Customize the Stagehand system prompt
-   */
-  systemPrompt?: string;
-  /**
-   * Offload Stagehand method calls to the Stagehand API.
-   * Must have a valid API key to use
-   */
-  useAPI?: boolean;
-  /**
-   * Wait for captchas to be solved after navigation when using Browserbase environment.
-   *
-   * @default false
-   */
-  waitForCaptchaSolves?: boolean;
-  /**
-   * The parameters to use for launching a local browser
-   */
-  localBrowserLaunchOptions?: LocalBrowserLaunchOptions;
-  /**
-   * Log the inference to a file
-   */
-  logInferenceToFile?: boolean;
-  selfHeal?: boolean;
-  /**
-   * Disable Pino (helpful for Next.js or test environments)
-   */
-  disablePino?: boolean;
-}
-
-export interface InitResult {
-  debugUrl: string;
-  sessionUrl: string;
-  sessionId: string;
-}
-
-export interface ActOptions {
-  action: string;
-  modelName?: AvailableModel;
-  modelClientOptions?: ClientOptions;
-  variables?: Record<string, string>;
-  domSettleTimeoutMs?: number;
-  timeoutMs?: number;
-}
-
-export interface ActResult {
-  success: boolean;
-  message: string;
-  action: string;
-}
-
-export interface ExtractOptions<T extends z.AnyZodObject> {
-  instruction?: string;
-  schema?: T;
-  modelName?: AvailableModel;
-  modelClientOptions?: ClientOptions;
-  domSettleTimeoutMs?: number;
-  useTextExtract?: boolean;
-  selector?: string;
-}
-
-export type ExtractResult<T extends z.AnyZodObject> = z.infer<T>;
-
-export interface ObserveOptions {
-  instruction?: string;
-  modelName?: AvailableModel;
-  modelClientOptions?: ClientOptions;
-  domSettleTimeoutMs?: number;
-  returnAction?: boolean;
-  onlyVisible?: boolean;
-  drawOverlay?: boolean;
-}
-
-export interface ObserveResult {
-  selector: string;
-  description: string;
-  backendNodeId?: number;
-  method?: string;
-  arguments?: string[];
-}
-
-export interface LocalBrowserLaunchOptions {
-  args?: string[];
-  chromiumSandbox?: boolean;
-  devtools?: boolean;
-  env?: Record<string, string | number | boolean>;
-  executablePath?: string;
-  handleSIGHUP?: boolean;
-  handleSIGINT?: boolean;
-  handleSIGTERM?: boolean;
-  headless?: boolean;
-  ignoreDefaultArgs?: boolean | Array<string>;
-  proxy?: {
-    server: string;
-    bypass?: string;
-    username?: string;
-    password?: string;
-  };
-  tracesDir?: string;
-  userDataDir?: string;
-  acceptDownloads?: boolean;
-  downloadsPath?: string;
-  extraHTTPHeaders?: Record<string, string>;
-  geolocation?: { latitude: number; longitude: number; accuracy?: number };
-  hasTouch?: boolean;
-  ignoreHTTPSErrors?: boolean;
-  locale?: string;
-  permissions?: Array<string>;
-  recordHar?: {
-    omitContent?: boolean;
-    content?: "omit" | "embed" | "attach";
-    path: string;
-    mode?: "full" | "minimal";
-    urlFilter?: string | RegExp;
-  };
-  recordVideo?: { dir: string; size?: { width: number; height: number } };
-  viewport?: { width: number; height: number };
-  deviceScaleFactor?: number;
-  timezoneId?: string;
-  bypassCSP?: boolean;
-  cookies?: Cookie[];
-  cdpUrl?: string;
-}
-
-export interface StagehandMetrics {
-  actPromptTokens: number;
-  actCompletionTokens: number;
-  actInferenceTimeMs: number;
-  extractPromptTokens: number;
-  extractCompletionTokens: number;
-  extractInferenceTimeMs: number;
-  observePromptTokens: number;
-  observeCompletionTokens: number;
-  observeInferenceTimeMs: number;
-  totalPromptTokens: number;
-  totalCompletionTokens: number;
-  totalInferenceTimeMs: number;
-}
-
-/**
- * Options for executing a task with an agent
- */
-export interface AgentExecuteParams {
-  /**
-   * The instruction to execute with the agent
-   */
-  instruction: string;
-  /**
-   * Maximum number of steps the agent can take to complete the task
-   * @default 10
-   */
-  maxSteps?: number;
-  /**
-   * Take a screenshot automatically before each agent step
-   * @default true
-   */
-  autoScreenshot?: boolean;
-  /**
-   * Wait time in milliseconds between agent actions
-   * @default 0
-   */
-  waitBetweenActions?: number;
-  /**
-   * Additional context to provide to the agent
-   */
-  context?: string;
-}
-
-/**
- * Configuration for agent functionality
- */
-export interface AgentConfig {
-  /**
-   * The provider to use for agent functionality
-   */
-  provider?: AgentProviderType;
-  /**
-   * The model to use for agent functionality
-   */
-  model?: string;
-  /**
-   * Custom instructions to provide to the agent
-   */
-  instructions?: string;
-  /**
-   * Additional options to pass to the agent client
-   */
-  options?: Record<string, unknown>;
-}
-
-export enum StagehandFunctionName {
-  ACT = "ACT",
-  EXTRACT = "EXTRACT",
-  OBSERVE = "OBSERVE",
-}
-
-export interface HistoryEntry {
-  method: "act" | "extract" | "observe" | "navigate";
-  parameters: unknown;
-  result: unknown;
-  timestamp: string;
-}
-
-/**
- * Represents a path through a Zod schema from the root object down to a
- * particular field. The `segments` array describes the chain of keys/indices.
- *
- * - **String** segments indicate object property names.
- * - **Number** segments indicate array indices.
- *
- * For example, `["users", 0, "homepage"]` might describe reaching
- * the `homepage` field in `schema.users[0].homepage`.
- */
-export interface ZodPathSegments {
-  /**
-   * The ordered list of keys/indices leading from the schema root
-   * to the targeted field.
-   */
-  segments: Array<string | number>;
-}
diff --git a/types/stagehandErrors.ts b/types/stagehandErrors.ts
deleted file mode 100644
index 83b2bd269..000000000
--- a/types/stagehandErrors.ts
+++ /dev/null
@@ -1,149 +0,0 @@
-export class StagehandError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = this.constructor.name;
-  }
-}
-
-export class StagehandDefaultError extends StagehandError {
-  constructor(error?: unknown) {
-    if (error instanceof Error || error instanceof StagehandError) {
-      super(
-        `\nHey! We're sorry you ran into an error. \nIf you need help, please open a Github issue or reach out to us on Slack: https://stagehand.dev/slack\n\nFull error:\n${error.message}`,
-      );
-    }
-  }
-}
-
-export class StagehandEnvironmentError extends StagehandError {
-  constructor(
-    currentEnvironment: string,
-    requiredEnvironment: string,
-    feature: string,
-  ) {
-    super(
-      `You seem to be setting the current environment to ${currentEnvironment}.` +
-        `Ensure the environment is set to ${requiredEnvironment} if you want to use ${feature}.`,
-    );
-  }
-}
-
-export class MissingEnvironmentVariableError extends StagehandError {
-  constructor(missingEnvironmentVariable: string, feature: string) {
-    super(
-      `${missingEnvironmentVariable} is required to use ${feature}.` +
-        `Please set ${missingEnvironmentVariable} in your environment.`,
-    );
-  }
-}
-
-export class UnsupportedModelError extends StagehandError {
-  constructor(supportedModels: string[], feature?: string) {
-    super(
-      feature
-        ? `${feature} requires one of the following models: ${supportedModels}`
-        : `please use one of the supported models: ${supportedModels}`,
-    );
-  }
-}
-
-export class UnsupportedModelProviderError extends StagehandError {
-  constructor(supportedProviders: string[], feature?: string) {
-    super(
-      feature
-        ? `${feature} requires one of the following model providers: ${supportedProviders}`
-        : `please use one of the supported model providers: ${supportedProviders}`,
-    );
-  }
-}
-
-export class StagehandNotInitializedError extends StagehandError {
-  constructor(prop: string) {
-    super(
-      `You seem to be calling \`${prop}\` on a page in an uninitialized \`Stagehand\` object. ` +
-        `Ensure you are running \`await stagehand.init()\` on the Stagehand object before ` +
-        `referencing the \`page\` object.`,
-    );
-  }
-}
-
-export class BrowserbaseSessionNotFoundError extends StagehandError {
-  constructor() {
-    super("No Browserbase session ID found");
-  }
-}
-
-export class CaptchaTimeoutError extends StagehandError {
-  constructor() {
-    super("Captcha timeout");
-  }
-}
-
-export class MissingLLMConfigurationError extends StagehandError {
-  constructor() {
-    super(
-      "No LLM API key or LLM Client configured. An LLM API key or a custom LLM Client " +
-        "is required to use act, extract, or observe.",
-    );
-  }
-}
-
-export class HandlerNotInitializedError extends StagehandError {
-  constructor(handlerType: string) {
-    super(`${handlerType} handler not initialized`);
-  }
-}
-
-export class StagehandNotImplementedError extends StagehandError {
-  constructor(message: string) {
-    super(`NotImplementedError: ${message}`);
-  }
-}
-
-export class StagehandDeprecationError extends StagehandError {
-  constructor(message: string) {
-    super(`DeprecationError: ${message}`);
-  }
-}
-
-export class StagehandInvalidArgumentError extends StagehandError {
-  constructor(message: string) {
-    super(`InvalidArgumentError: ${message}`);
-  }
-}
-
-export class StagehandElementNotFoundError extends StagehandError {
-  constructor(xpaths: string[]) {
-    super(`Could not find an element for the given xPath(s): ${xpaths}`);
-  }
-}
-
-export class AgentScreenshotProviderError extends StagehandError {
-  constructor(message: string) {
-    super(`ScreenshotProviderError: ${message}`);
-  }
-}
-
-export class StagehandMissingArgumentError extends StagehandError {
-  constructor(message: string) {
-    super(`MissingArgumentError: ${message}`);
-  }
-}
-
-export class CreateChatCompletionResponseError extends StagehandError {
-  constructor(message: string) {
-    super(`CreateChatCompletionResponseError: ${message}`);
-  }
-}
-
-export class StagehandEvalError extends StagehandError {
-  constructor(message: string) {
-    super(`StagehandEvalError: ${message}`);
-  }
-}
-
-export class StagehandDomProcessError extends StagehandError {
-  constructor(message: string) {
-    super(`Error Processing Dom: ${message}`);
-  }
-}
diff --git a/types/textannotation.ts b/types/textannotation.ts
deleted file mode 100644
index 1ce823666..000000000
--- a/types/textannotation.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-export type TextAnnotation = {
-  text: string;
-  bottom_left: { x: number; y: number };
-  bottom_left_normalized: { x: number; y: number };
-  width: number;
-  height: number;
-};